Merge branch 'LWRP' into lw/api-refactor-v1

# Conflicts: # ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs
6 年前 · 63a6fe03
--- a/.gitignore
+++ b/.gitignore
 Library/*
 obj/*
 Temp/*
+.vs
+.vscode
+.idea
 .DS_Store
 *.aspx
 *.browser
 *.sublime-workspace
 *.suo
 *.userprefs
+.npmrc
+ShaderGraph/DebugOutput.meta
+ShaderGraph/DebugOutput/**
+ShaderGraph/Testing/IntegrationTests/.Failed
--- a/.gitmodules
+++ b/.gitmodules
 	path = PostProcessing
 	url = https://github.com/Unity-Technologies/PostProcessing
 	branch = v2
-[submodule "ShaderGraph"]
-	path = ShaderGraph
-	url = https://github.com/Unity-Technologies/ShaderGraph
-url=https://github.com/Unity-Technologies/UTF_Core.git
+	url = https://github.com/Unity-Technologies/UTF_Core.git
-url=https://github.com/Unity-Technologies/UTF_Tests_HDRP.git
+	url = https://github.com/Unity-Technologies/UTF_Tests_HDRP.git
--- a/ImageTemplates/FailStamp.png.meta
+++ b/ImageTemplates/FailStamp.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/001_SimpleCube.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/001_SimpleCube.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/002_Camera_Clip.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/002_Camera_Clip.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/003_Camera_Ortho.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/003_Camera_Ortho.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/004_Camera_TargetTexture.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/004_Camera_TargetTexture.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/005_LitBakedEmission.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/005_LitBakedEmission.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/006_LitShaderLightProbes.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/006_LitShaderLightProbes.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/007_LitShaderMaps.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/007_LitShaderMaps.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/008_LitShaderReflection.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/008_LitShaderReflection.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/009_LightweightShading.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/009_LightweightShading.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/010_MultiplePointLights.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/010_MultiplePointLights.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/011_UnlitSprites.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/011_UnlitSprites.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/012_PBS_EnvironmentBRDF_Spheres.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/016_Lighting_Scene_Directional.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/016_Lighting_Scene_Directional.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/017_Lighting_Scene_DirectionalBaked.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/017_Lighting_Scene_DirectionalBaked.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/018_Lighting_Scene_DirectionalBakedIndirect.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/018_Lighting_Scene_DirectionalBakedIndirect.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/019_Lighting_Scene_PointLights.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/019_Lighting_Scene_PointLights.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/020_Lighting_BasicDirectional.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/020_Lighting_BasicDirectional.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/021_Lighting_BasicPoint.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/021_Lighting_BasicPoint.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/022_Lighting_BasicSpot.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/022_Lighting_BasicSpot.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/023_Lighting_Mixed.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/023_Lighting_Mixed.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/024_Shader_PBRvalidation_Specular.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/024_Shader_PBRvalidation_Specular.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/025_Shader_PBRvalidation_Metallic.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/025_Shader_PBRvalidation_Metallic.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/026_Shader_PBRscene.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/026_Shader_PBRscene.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/027_PostProcessing.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/027_PostProcessing.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/028_PostProcessing_Custom.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/028_PostProcessing_Custom.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/029_Particles.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/029_Particles.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/031_Shader_GlossyEnvironmentSky.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/031_Shader_GlossyEnvironmentSky.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/032_Shader_GlossyEnvironmentColor.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/032_Shader_GlossyEnvironmentColor.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/033_Shader_HighlightsEnvironmentGradientSH.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/033_Shader_HighlightsEnvironmentGradientSH.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/034_Shader_HighlightsEnvironmentGradientBaked.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/034_Shader_HighlightsEnvironmentGradientBaked.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/035_Shader_TerrainShaders.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/035_Shader_TerrainShaders.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/036_Lighting_Scene_DirectionalBakedDirectional.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/036_Lighting_Scene_DirectionalBakedDirectional.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/037_Particles.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/037_Particles.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/038_Lighting_DirectionalCookie.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/038_Lighting_DirectionalCookie.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/039_Lighting_SpotCookie.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/039_Lighting_SpotCookie.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/040_UpgradeScene.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/040_UpgradeScene.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/041_Lighting_BasicArea.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/041_Lighting_BasicArea.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/042_Lighting_Scene_VertexLighting.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/042_Lighting_Scene_VertexLighting.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/043_Lighting_Mixed_ShadowMask.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/043_Lighting_Mixed_ShadowMask.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/ImageTemplates/LightweightPipeline/Scenes/044_ReflectionProbe.unity.png.meta
+++ b/ImageTemplates/LightweightPipeline/Scenes/044_ReflectionProbe.unity.png.meta
 TextureImporter:
  fileIDToRecycleName: {}
  externalObjects: {}
-  serializedVersion: 5
+  serializedVersion: 6
  mipmaps:
    mipMapMode: 0
    enableMipMap: 1
    heightScale: 0.25
    normalMapFilter: 0
  isReadable: 0
+  streamingMipmaps: 0
+  streamingMipmapsPriority: 0
  grayScaleToAlpha: 0
  generateCubemap: 6
  cubemapConvolution: 0
--- a/LICENSE.md
+++ b/LICENSE.md
-**Unity Companion Package License v1.0 ("_License_")**
-
-Copyright © 2017 Unity Technologies ApS ("**_Unity_**")
-
-Unity hereby grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available with this License ("**_Software_**"), subject to the following terms and conditions:
-
-1. *Unity Companion Use Only*. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity development engine software license ("**_Engine License_**"). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted.
-
-1. *No Modification of Engine License*. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
-
-1. *Ownership & Grant Back to You*. 
-
-    3.1. You own your content. In this License, "derivative works" means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); “derivative works” of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
-
-    3.2. Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity. 
-
-    3.3. You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
-
-1. *Trademarks*. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates ("**_Trademarks_**"). Descriptive uses of Trademarks are permitted; see, for example, Unity’s Branding Usage Guidelines at [https://unity3d.com/public-relations/brand](https://unity3d.com/public-relations/brand).
-
-1. *Notices & Third-Party Rights*. This License, including the copyright notice above, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity "third-party notices" or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
-
-1. *DISCLAIMER, LIMITATION OF LIABILITY*. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-1. *USE IS ACCEPTANCE and License Versions*. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License. 
-
-1. *Use in Compliance with Law and Termination*. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
+Copyright © 2018 Unity Technologies ApS
-1. *Severability*. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
+Licensed under the Unity Companion License for Unity-dependent projects--see [Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License). 
-1. *Governing Law and Venue*. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License ("**_Dispute_**"). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute.
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
--- a/ScriptableRenderPipeline/Core/CoreRP/CoreResources/EncodeBC6H.compute
+++ b/ScriptableRenderPipeline/Core/CoreRP/CoreResources/EncodeBC6H.compute
 #include "CoreRP/ShaderLibrary/BC6H.hlsl"
 #include "CoreRP/ShaderLibrary/Sampling/Sampling.hlsl"

-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

 TextureCube<float4> _Source;
 RWTexture2DArray<uint4> _Target;
--- a/ScriptableRenderPipeline/Core/CoreRP/CoreResources/GPUCopy.compute
+++ b/ScriptableRenderPipeline/Core/CoreRP/CoreResources/GPUCopy.compute
 // Autogenerated file. Do not edit by hand

-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
 #include "../ShaderLibrary/Common.hlsl"

 CBUFFER_START (UnityCBuffer)
--- a/ScriptableRenderPipeline/Core/CoreRP/CoreResources/TexturePadding.compute
+++ b/ScriptableRenderPipeline/Core/CoreRP/CoreResources/TexturePadding.compute
 #pragma kernel KMainTop                 KERNEL_NAME=KMainTop        DIRECTION=DIRECTION_TOP
 #pragma kernel KMainRight               KERNEL_NAME=KMainRight      DIRECTION=DIRECTION_RIGHT

-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

 // ------------------------------------------------
 // Texture buffers
--- a/ScriptableRenderPipeline/Core/CoreRP/Debugging/DebugManager.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Debugging/DebugManager.cs

    public sealed partial class DebugManager
    {
+#if UNITY_EDITOR
+        // HACK: Make debug windows work correctly with FrameSettings in Editor
+        public static bool renderPipelineIsRecreated = false;
+#endif
+
        static readonly DebugManager s_Instance = new DebugManager();
        public static DebugManager instance { get { return s_Instance; } }

--- a/ScriptableRenderPipeline/Core/CoreRP/Editor/CoreEditorDrawers.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Editor/CoreEditorDrawers.cs
            AnimBoolGetter m_IsExpanded;
            string m_Title;
            FoldoutOption m_Options;
-            bool m_Animate;

            bool animate { get { return (m_Options & FoldoutOption.Animate) != 0; } }
            bool indent { get { return (m_Options & FoldoutOption.Indent) != 0; } }
--- a/ScriptableRenderPipeline/Core/CoreRP/Editor/Debugging/DebugWindow.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Editor/Debugging/DebugWindow.cs
            DebugManager.instance.onSetDirty -= MarkDirty;
            Undo.ClearUndo(m_Settings);

+            DestroyWidgetStates();
+        }
+
+        public void DestroyWidgetStates()
+        {
            if (m_WidgetStates != null)
            {
                // Clear all the states from memory

        void Update()
        {
+            // HACK: Make debug windows work correctly with FrameSettings in Editor
+            // When we manipulate the framesettings on HDRenderPipelineAsset, the debug windows is not
+            // refresh, it keep the old state of the runtime framesettings in memory and thus overwrite
+            // our freshly edited value. To ensure debug windows is aware of framesettings change we need to
+            // destroy its internal widget state.
+            if (DebugManager.renderPipelineIsRecreated)
+            {
+                DestroyWidgetStates();
+                DebugManager.renderPipelineIsRecreated = false;
+            }
+            // END HACK
+
            int treeState = DebugManager.instance.GetState();

            if (m_DebugTreeState != treeState || m_IsDirty)
--- a/ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/Drawers/ColorParameterDrawer.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/Drawers/ColorParameterDrawer.cs
                return false;

            var o = parameter.GetObjectRef<ColorParameter>();
-            value.colorValue = EditorGUILayout.ColorField(title, value.colorValue, o.showEyeDropper, o.showAlpha, o.showAlpha);
+            value.colorValue = EditorGUILayout.ColorField(title, value.colorValue, o.showEyeDropper, o.showAlpha, o.hdr);
            return true;
        }
    }
--- a/ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeComponentListEditor.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeComponentListEditor.cs
 {
    public sealed class VolumeComponentListEditor
    {
+        public VolumeProfile asset { get; private set; }
+
-        VolumeProfile m_Asset;
        SerializedObject m_SerializedObject;
        SerializedProperty m_ComponentsProperty;

            Assert.IsNotNull(asset);
            Assert.IsNotNull(serializedObject);

-            m_Asset = asset;
+            this.asset = asset;
            m_SerializedObject = serializedObject;
            m_ComponentsProperty = serializedObject.Find((VolumeProfile x) => x.components);
            Assert.IsNotNull(m_ComponentsProperty);

        void OnUndoRedoPerformed()
        {
-            m_Asset.isDirty = true;
+            asset.isDirty = true;

            // Dumb hack to make sure the serialized object is up to date on undo (else there'll be
            // a state mismatch when this class is used in a GameObject inspector).
            m_Editors.Clear();

            // Recreate editors for existing settings, if any
-            for (int i = 0; i < m_Asset.components.Count; i++)
-                CreateEditor(m_Asset.components[i], m_ComponentsProperty.GetArrayElementAtIndex(i));
+            var components = asset.components;
+            for (int i = 0; i < components.Count; i++)
+                CreateEditor(components[i], m_ComponentsProperty.GetArrayElementAtIndex(i));
        }

        public void Clear()

        public void OnGUI()
        {
-            if (m_Asset == null)
+            if (asset == null)
-            if (m_Asset.isDirty)
+            if (asset.isDirty)
-                m_Asset.isDirty = false;
+                asset.isDirty = false;
-                || AssetDatabase.IsOpenForEdit(m_Asset, StatusQueryOptions.UseCachedIfPossible);
+                || AssetDatabase.IsOpenForEdit(asset, StatusQueryOptions.UseCachedIfPossible);

            using (new EditorGUI.DisabledScope(!isEditable))
            {
                    {
                        var r = hscope.rect;
                        var pos = new Vector2(r.x + r.width / 2f, r.yMax + 18f);
-                        FilterWindow.Show(pos, new VolumeComponentProvider(m_Asset, this));
+                        FilterWindow.Show(pos, new VolumeComponentProvider(asset, this));
                    }
                }
            }
            Undo.RegisterCreatedObjectUndo(component, "Add Volume Component");

            // Store this new effect as a subasset so we can reference it safely afterwards
-            AssetDatabase.AddObjectToAsset(component, m_Asset);
+            // Only when we're not dealing with an instantiated asset
+            if (EditorUtility.IsPersistent(asset))
+                AssetDatabase.AddObjectToAsset(component, asset);

            // Grow the list first, then add - that's how serialized lists work in Unity
            m_ComponentsProperty.arraySize++;
            // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
-            AssetDatabase.SaveAssets();
+            if (EditorUtility.IsPersistent(asset))
+            {
+                EditorUtility.SetDirty(asset);
+                AssetDatabase.SaveAssets();
+            }

            // Create & store the internal editor object for this effect
            CreateEditor(component, componentProp, forceOpen: true);
            Undo.DestroyObjectImmediate(component);

            // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
+            EditorUtility.SetDirty(asset);
            AssetDatabase.SaveAssets();
        }

            Undo.RegisterCreatedObjectUndo(newComponent, "Reset Volume Component");

            // Store this new effect as a subasset so we can reference it safely afterwards
-            AssetDatabase.AddObjectToAsset(newComponent, m_Asset);
+            AssetDatabase.AddObjectToAsset(newComponent, asset);

            // Put it in the reserved space
            property.objectReferenceValue = newComponent;
            Undo.DestroyObjectImmediate(prevComponent);

            // Force save / refresh
-            EditorUtility.SetDirty(m_Asset);
+            EditorUtility.SetDirty(asset);
            AssetDatabase.SaveAssets();
        }

--- a/ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeEditor.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeEditor.cs
            get { return target as Volume; }
        }

+        VolumeProfile profileRef
+        {
+            get { return actualTarget.HasInstantiatedProfile() ? actualTarget.profile : actualTarget.sharedProfile; }
+        }
+
        void OnEnable()
        {
            var o = new PropertyFetcher<Volume>(serializedObject);
            var buttonNewRect = new Rect(fieldRect.xMax, lineRect.y, buttonWidth, lineRect.height);
            var buttonCopyRect = new Rect(buttonNewRect.xMax, lineRect.y, buttonWidth, lineRect.height);

-            EditorGUI.PrefixLabel(labelRect, CoreEditorUtils.GetContent("Profile|A reference to a profile asset."));
+            EditorGUI.PrefixLabel(labelRect, CoreEditorUtils.GetContent(actualTarget.HasInstantiatedProfile() ? "Profile (Instance)|A copy of a profile asset." : "Profile|A reference to a profile asset."));
-                var profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, m_Profile.objectReferenceValue, typeof(VolumeProfile), false);
+                VolumeProfile profile = null;
+
+                if (actualTarget.HasInstantiatedProfile())
+                    profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, actualTarget.profile, typeof(VolumeProfile), false);
+                else
+                    profile = (VolumeProfile)EditorGUI.ObjectField(fieldRect, m_Profile.objectReferenceValue, typeof(VolumeProfile), false);
+
+                    if (actualTarget.HasInstantiatedProfile()) // Clear the instantiated profile, from now on we're using shared again
+                        actualTarget.profile = null;
                }

                EditorGUI.EndProperty();
                    var scene = actualTarget.gameObject.scene;
                    var asset = VolumeProfileFactory.CreateVolumeProfile(scene, targetName);
                    m_Profile.objectReferenceValue = asset;
+                    actualTarget.profile = null; // Make sure we're not using an instantiated profile anymore
-                if (showCopy && GUI.Button(buttonCopyRect, CoreEditorUtils.GetContent("Clone|Create a new profile and copy the content of the currently assigned profile."), EditorStyles.miniButtonRight))
+                if (showCopy && GUI.Button(buttonCopyRect, CoreEditorUtils.GetContent(actualTarget.HasInstantiatedProfile() ? "Save|Save the instantiated profile" : "Clone|Create a new profile and copy the content of the currently assigned profile."), EditorStyles.miniButtonRight))
-                    var origin = (VolumeProfile)m_Profile.objectReferenceValue;
-                    var path = AssetDatabase.GetAssetPath(origin);
+                    var origin = profileRef;
+                    var path = AssetDatabase.GetAssetPath(m_Profile.objectReferenceValue);
                    path = AssetDatabase.GenerateUniqueAssetPath(path);

                    var asset = Instantiate(origin);
                    AssetDatabase.Refresh();

                    m_Profile.objectReferenceValue = asset;
+                    actualTarget.profile = null; // Make sure we're not using an instantiated profile anymore
                    assetHasChanged = true;
                }
            }
-            if (m_Profile.objectReferenceValue == null)
+            if (m_Profile.objectReferenceValue == null && !actualTarget.HasInstantiatedProfile())
            {
                if (assetHasChanged)
                    m_ComponentList.Clear(); // Asset wasn't null before, do some cleanup
-                if (assetHasChanged)
-                    RefreshEffectListEditor((VolumeProfile)m_Profile.objectReferenceValue);
+                if (assetHasChanged || profileRef != m_ComponentList.asset)
+                    RefreshEffectListEditor(profileRef);

                if (!multiEdit)
                {
--- a/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/BSDF.hlsl
+++ b/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/BSDF.hlsl

 // Conversion FO/IOR

+TEMPLATE_2_REAL(IorToFresnel0, transmittedIor, incidentIor, return Sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor)) )
-real IorToFresnel0(real transmittedIor, real incidentIor = 1.0)
+real IorToFresnel0(real transmittedIor)
-    return Sq((transmittedIor - incidentIor) / (transmittedIor + incidentIor));
+    return IorToFresnel0(transmittedIor, 1.0);
-// Note: Don't handle the case fresnel0 == 1
-real Fresnel0ToIor(real fresnel0)
-{
-    real sqrtF0 = sqrt(fresnel0);
-    return (1.0 + sqrtF0) / (1.0 - sqrtF0);
-}
+// Note: We don't handle the case fresnel0 == 1
+//real Fresnel0ToIor(real fresnel0)
+//{
+//    real sqrtF0 = sqrt(fresnel0);
+//    return (1.0 + sqrtF0) / (1.0 - sqrtF0);
+//}
+TEMPLATE_1_REAL(Fresnel0ToIor, fresnel0, return ((1.0 + sqrt(fresnel0)) / (1.0 - sqrt(fresnel0))) )

 // This function is a coarse approximation of computing fresnel0 for a different top than air (here clear coat of IOR 1.5) when we only have fresnel0 with air interface
 // This function is equivalent to IorToFresnel0(Fresnel0ToIor(fresnel0), 1.5)
 {
    real3 nf0 = Sq(n + 1.0) * f0 - Sq(f0 - 1.0);
    return nf0 / (1.0 - f0);
+}
+
+// same as regular refract except there is not the test for total internal reflection + the vector is flipped for processing
+real3 CoatRefract(real3 X, real3 N, real ieta)
+{
+    real XdotN = saturate(dot(N, X));
+    return ieta * X + (sqrt(1 + ieta * ieta * (XdotN * XdotN - 1)) - ieta * XdotN) * N;
 }

 //-----------------------------------------------------------------------------
--- a/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl
+++ b/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl
 #include "API/Metal.hlsl"
 #elif defined(SHADER_API_VULKAN)
 #include "API/Vulkan.hlsl"
+#elif defined(SHADER_API_SWITCH)
+#include "API/Switch.hlsl"
 #elif defined(SHADER_API_GLCORE)
 #include "API/GLCore.hlsl"
 #elif defined(SHADER_API_GLES3)
--- a/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/CommonMaterial.hlsl
+++ b/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/CommonMaterial.hlsl
    roughnessB = roughness * (1 - anisotropy);
 }

+void ConvertRoughnessToAnisotropy(real roughnessT, real roughnessB, out real anisotropy)
+{
+    anisotropy = ((roughnessT - roughnessB) / (roughnessT + roughnessB + 0.0001));
+}
+
 // Same as ConvertAnisotropyToRoughness but
 // roughnessT and roughnessB are clamped, and are meant to be used with punctual and directional lights.
 void ConvertAnisotropyToClampRoughness(real perceptualRoughness, real anisotropy, out real roughnessT, out real roughnessB)
    return sqrt(2.0 / (variance + 2.0));
 }

-// same as regular refract except there is not the test for total internal reflection + the vector is flipped for processing
-real3 CoatRefract(real3 X, real3 N, real ieta)
+// ----------------------------------------------------------------------------
+// Helper for Disney parametrization
+// ----------------------------------------------------------------------------
+
+float3 ComputeDiffuseColor(float3 baseColor, float metallic)
+{
+    return baseColor * (1.0 - metallic);
+}
+
+float3 ComputeFresnel0(float3 baseColor, float metallic, float dielectricF0)
-    real XdotN = saturate(dot(N, X));
-    return ieta * X + (sqrt(1 + ieta * ieta * (XdotN * XdotN - 1)) - ieta * XdotN) * N;
+    return lerp(dielectricF0.xxx, baseColor, metallic);
-// Parallax mapping
+// Helper for normal blending
 // ----------------------------------------------------------------------------

 // ref https://www.gamedev.net/topic/678043-how-to-blend-world-space-normals/#entry5287707
    return normalize(real3(n1.xy * n2.z + n2.xy * n1.z, n1.z * n2.z));
 }

+// ----------------------------------------------------------------------------
+// Helper for triplanar
+// ----------------------------------------------------------------------------
+
 // Ref: http://http.developer.nvidia.com/GPUGems3/gpugems3_ch01.html / http://www.slideshare.net/icastano/cascades-demo-secrets
 real3 ComputeTriplanarWeights(real3 normal)
 {
    uvZY = float2(position.z, position.y);
 }

+// ----------------------------------------------------------------------------
+// Helper for detail map operation
+// ----------------------------------------------------------------------------
+
 real LerpWhiteTo(real b, real t)
 {
    real oneMinusT = 1.0 - t;
    real oneMinusT = 1.0 - t;
    return real3(oneMinusT, oneMinusT, oneMinusT) + b * t;
 }
-

 #endif // UNITY_COMMON_MATERIAL_INCLUDED
--- a/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/GeometricTools.hlsl
+++ b/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/GeometricTools.hlsl
 // This simplified version assume that we care about the result only when we are inside the box
 float IntersectRayAABBSimple(float3 start, float3 dir, float3 boxMin, float3 boxMax)
 {
-    float3 invDir = 1.0 / dir;
+    float3 invDir = rcp(dir);

    // Find the ray intersection with box plane
    float3 rbmin = (boxMin - start) * invDir;
--- a/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/UnityInstancing.hlsl
+++ b/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/UnityInstancing.hlsl
    #define UNITY_SUPPORT_INSTANCING
 #endif

-#if defined(SHADER_API_D3D11)
+#if defined(SHADER_API_D3D11) || defined(SHADER_API_GLCORE) || defined(SHADER_API_GLES3)
    #define UNITY_SUPPORT_STEREO_INSTANCING
 #endif

 // - UNITY_TRANSFER_VERTEX_OUTPUT_STEREO    Copy stero target from input struct to output struct. Used in vertex shader.
 // - UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX
 #ifdef UNITY_STEREO_INSTANCING_ENABLED
+#if defined(SHADER_API_GLES3) || defined(SHADER_API_GLCORE)
+    #define DEFAULT_UNITY_VERTEX_OUTPUT_STEREO                          uint stereoTargetEyeIndexSV : SV_RenderTargetArrayIndex; uint stereoTargetEyeIndex : BLENDINDICES0;
+    #define DEFAULT_UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output)       output.stereoTargetEyeIndexSV = unity_StereoEyeIndex; output.stereoTargetEyeIndex = unity_StereoEyeIndex;
+#else
+#endif
    #define DEFAULT_UNITY_TRANSFER_VERTEX_OUTPUT_STEREO(input, output)  output.stereoTargetEyeIndex = input.stereoTargetEyeIndex;
    #define DEFAULT_UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input) unity_StereoEyeIndex = input.stereoTargetEyeIndex;
 #elif defined(UNITY_STEREO_MULTIVIEW_ENABLED)
    void UnitySetupInstanceID(uint inputInstanceID)
    {
        #ifdef UNITY_STEREO_INSTANCING_ENABLED
-            // stereo eye index is automatically figured out from the instance ID
-            unity_StereoEyeIndex = inputInstanceID & 0x01;
-            unity_InstanceID = unity_BaseInstanceID + (inputInstanceID >> 1);
+            #if defined(SHADER_API_GLES3)
+                // We must calculate the stereo eye index differently for GLES3
+                // because otherwise,  the unity shader compiler will emit a bitfieldInsert function.
+                // bitfieldInsert requires support for glsl version 400 or later.  Therefore the
+                // generated glsl code will fail to compile on lower end devices.  By changing the
+                // way we calculate the stereo eye index,  we can help the shader compiler to avoid
+                // emitting the bitfieldInsert function and thereby increase the number of devices we
+                // can run stereo instancing on.
+                unity_StereoEyeIndex = round(fmod(inputInstanceID, 2.0));
+                unity_InstanceID = unity_BaseInstanceID + (inputInstanceID >> 1);
+            #else
+                // stereo eye index is automatically figured out from the instance ID
+                unity_StereoEyeIndex = inputInstanceID & 0x01;
+                unity_InstanceID = unity_BaseInstanceID + (inputInstanceID >> 1);
+            #endif
        #else
            unity_InstanceID = inputInstanceID + unity_BaseInstanceID;
        #endif
            UNITY_DEFINE_INSTANCED_PROP(float4x4, unity_WorldToObjectArray)
        #endif
        #if defined(UNITY_USE_LODFADE_ARRAY) && defined(UNITY_INSTANCING_SUPPORT_FLEXIBLE_ARRAY_SIZE)
-            UNITY_DEFINE_INSTANCED_PROP(float, unity_LODFadeArray)
-            // the quantized fade value (unity_LODFade.y) is automatically used for cross-fading instances
-            #define unity_LODFade UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_LODFadeArray).xxxx
+            UNITY_DEFINE_INSTANCED_PROP(float2, unity_LODFadeArray)
+            #define unity_LODFade UNITY_ACCESS_INSTANCED_PROP(unity_Builtins0, unity_LODFadeArray).xyxx
        #endif
    UNITY_INSTANCING_BUFFER_END(unity_Builtins0)

        #endif
        #if defined(UNITY_USE_LODFADE_ARRAY) && !defined(UNITY_INSTANCING_SUPPORT_FLEXIBLE_ARRAY_SIZE)
-            UNITY_DEFINE_INSTANCED_PROP(float, unity_LODFadeArray)
-            // the quantized fade value (unity_LODFade.y) is automatically used for cross-fading instances
-            #define unity_LODFade UNITY_ACCESS_INSTANCED_PROP(unity_Builtins1, unity_LODFadeArray).xxxx
+            UNITY_DEFINE_INSTANCED_PROP(float2, unity_LODFadeArray)
+            #define unity_LODFade UNITY_ACCESS_INSTANCED_PROP(unity_Builtins1, unity_LODFadeArray).xyxx
        #endif
    UNITY_INSTANCING_BUFFER_END(unity_Builtins1)

--- a/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/VolumeRendering.hlsl
+++ b/ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/VolumeRendering.hlsl
    return INV_FOUR_PI;
 }

-real HenyeyGreensteinPhasePartConstant(real asymmetry)
+real HenyeyGreensteinPhasePartConstant(real anisotropy)
-    real g = asymmetry;
+    real g = anisotropy;
-real HenyeyGreensteinPhasePartVarying(real asymmetry, real cosTheta)
+real HenyeyGreensteinPhasePartVarying(real anisotropy, real cosTheta)
-    real g = asymmetry;
+    real g = anisotropy;
-real HenyeyGreensteinPhaseFunction(real asymmetry, real cosTheta)
+real HenyeyGreensteinPhaseFunction(real anisotropy, real cosTheta)
-    return HenyeyGreensteinPhasePartConstant(asymmetry) *
-           HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+    return HenyeyGreensteinPhasePartConstant(anisotropy) *
+           HenyeyGreensteinPhasePartVarying(anisotropy, cosTheta);
-real CornetteShanksPhasePartConstant(real asymmetry)
+real CornetteShanksPhasePartConstant(real anisotropy)
-    real g = asymmetry;
+    real g = anisotropy;
-real CornetteShanksPhasePartVarying(real asymmetry, real cosTheta)
+real CornetteShanksPhasePartVarying(real anisotropy, real cosTheta)
-    real g = asymmetry;
+    real g = anisotropy;
    real f = rsqrt(1 + g * g - 2 * g * cosTheta); // x^(-1/2)
    real h = (1 + cosTheta * cosTheta);

 // A better approximation of the Mie phase function.
 // Ref: Henyey–Greenstein and Mie phase functions in Monte Carlo radiative transfer computations
-real CornetteShanksPhaseFunction(real asymmetry, real cosTheta)
+real CornetteShanksPhaseFunction(real anisotropy, real cosTheta)
-    return CornetteShanksPhasePartConstant(asymmetry) *
-           CornetteShanksPhasePartVarying(asymmetry, cosTheta);
+    return CornetteShanksPhasePartConstant(anisotropy) *
+           CornetteShanksPhasePartVarying(anisotropy, cosTheta);
 }

 // Samples the interval of homogeneous participating medium using the closed-form tracking approach
--- a/ScriptableRenderPipeline/Core/CoreRP/Shadow/DebugDisplayShadowMap.shader
+++ b/ScriptableRenderPipeline/Core/CoreRP/Shadow/DebugDisplayShadowMap.shader
 {
    HLSLINCLUDE
        #pragma target 4.5
-        #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+        #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

        #include "CoreRP/ShaderLibrary/Common.hlsl"

--- a/ScriptableRenderPipeline/Core/CoreRP/Shadow/Shadow.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Shadow/Shadow.cs
            m_Shadowmap.hideFlags   = HideFlags.DontSaveInEditor | HideFlags.DontSaveInBuild;
            m_Shadowmap.dimension   = TextureDimension.Tex2DArray;
            m_Shadowmap.volumeDepth = (int) m_Slices;
-            m_Shadowmap.name = CoreUtils.GetRenderTargetAutoName(shadowmap.width, shadowmap.height, shadowmap.format, "Shadow", mips : shadowmap.useMipMap);
+            m_Shadowmap.name = CoreUtils.GetRenderTargetAutoName(shadowmap.width, shadowmap.height, 1, shadowmap.format, "Shadow", mips : shadowmap.useMipMap);

            m_ShadowmapId = new RenderTargetIdentifier( m_Shadowmap );
        }
                int requestIdx        = shadowRequests[i];
                VisibleLight vl       = lights[requestIdx];
                int facecount         = 0;
-                GPUShadowType shadowType = GPUShadowType.Point;
+                GPUShadowType shadowType = GetShadowLightType( vl.light );
-                bool    add             = (distToCam < asd.shadowFadeDistance || vl.lightType == LightType.Directional) && m_ShadowSettings.enabled;
+                bool    add             = shadowType != GPUShadowType.Unknown && (distToCam < asd.shadowFadeDistance || vl.lightType == LightType.Directional) && m_ShadowSettings.enabled;

                if( add )
                {
                            add = --m_MaxShadows[(int)GPUShadowType.Directional, 0] >= 0;
-                            shadowType = GPUShadowType.Directional;
-                            shadowType = GPUShadowType.Point;
-                            shadowType = GPUShadowType.Spot;
                            facecount = 1;
                            break;
                    }
--- a/ScriptableRenderPipeline/Core/CoreRP/Shadow/ShadowBlurMoments.compute
+++ b/ScriptableRenderPipeline/Core/CoreRP/Shadow/ShadowBlurMoments.compute
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "CoreRP/ShaderLibrary/Shadow/ShadowMoments.hlsl"

-#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

 #if MAX_MSAA > 1
 Texture2DMS<float> depthTex;
--- a/ScriptableRenderPipeline/Core/CoreRP/Shadow/ShadowClear.shader
+++ b/ScriptableRenderPipeline/Core/CoreRP/Shadow/ShadowClear.shader
 {
    HLSLINCLUDE
        #pragma target 4.5
-        #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+        #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

        #include "CoreRP/ShaderLibrary/Common.hlsl"
    ENDHLSL
--- a/ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.RTHandle.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.RTHandle.cs
            {
                get
                {
-                    if(!useScaling)
+                    if (!useScaling)
                    {
                        return m_EnableMSAA ? m_RTs[(int)RTCategory.MSAA] : m_RTs[(int)RTCategory.Regular];
                    }
                        useDynamicScale = refRT.useDynamicScale,
                        vrUsage = refRT.vrUsage,
                        memorylessMode = refRT.memorylessMode,
-                        name = CoreUtils.GetRenderTargetAutoName(refRT.width, refRT.height, refRT.format, m_Name, mips : refRT.useMipMap)
+                        name = CoreUtils.GetRenderTargetAutoName(refRT.width, refRT.height, refRT.volumeDepth, refRT.format, m_Name, mips : refRT.useMipMap)
                    };
                    newRT.Create();

--- a/ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandleSystem.cs
        public void DemandResize(RTHandle rth)
        {
            Assert.IsTrue(m_ResizeOnDemandRTs.Contains(rth), string.Format("The RTHandle {0} is not an resize on demand handle in this RTHandleSystem. Please call SwitchToResizeOnDemand(rth, true) before resizing on demand.", rth));
-            
+
            for (int i = 0, c = (int)RTCategory.Count; i < c; ++i)
            {
                if (rth.m_RTs[i] == null)
                    rt.height = scaledSize.y;

                    rt.name = CoreUtils.GetRenderTargetAutoName(
-                        rt.width, 
-                        rt.height, 
-                        rt.format, 
-                        rth.m_Name, 
-                        mips: rt.useMipMap, 
-                        enableMSAA : enableMSAA, 
+                        rt.width,
+                        rt.height,
+                        rt.volumeDepth,
+                        rt.format,
+                        rth.m_Name,
+                        mips: rt.useMipMap,
+                        enableMSAA : enableMSAA,
                        msaaSamples: m_ScaledRTCurrentMSAASamples
                    );
                    rt.Create();
            {
                var rth = m_AutoSizedRTsArray[i];
                rth.referenceSize = maxSize;
-                
+
                var rt = rth.m_RTs[(int)category];

                // This can happen if you create a RTH for MSAA. By default we only create the MSAA version of the target.
                    if (category == RTCategory.MSAA)
                        rt.antiAliasing = (int)m_ScaledRTCurrentMSAASamples;

-                    rt.name = CoreUtils.GetRenderTargetAutoName(rt.width, rt.height, rt.format, rth.m_Name, mips: rt.useMipMap, enableMSAA : category == RTCategory.MSAA, msaaSamples: m_ScaledRTCurrentMSAASamples);
+                    rt.name = CoreUtils.GetRenderTargetAutoName(rt.width, rt.height, rt.volumeDepth, rt.format, rth.m_Name, mips: rt.useMipMap, enableMSAA : category == RTCategory.MSAA, msaaSamples: m_ScaledRTCurrentMSAASamples);
                    rt.Create();
                }
            }
                useDynamicScale = useDynamicScale,
                vrUsage = vrUsage,
                memorylessMode = memoryless,
-                name = CoreUtils.GetRenderTargetAutoName(width, height, colorFormat, name, mips: useMipMap, enableMSAA: enableMSAA, msaaSamples: msaaSamples)
+                name = CoreUtils.GetRenderTargetAutoName(width, height, slices, colorFormat, name, mips: useMipMap, enableMSAA: enableMSAA, msaaSamples: msaaSamples)
            };
            rt.Create();

            newRT.m_Name = name;

            newRT.referenceSize = new Vector2Int(width, height);
-            
+
            return newRT;
        }

        // Since MSAA cannot be changed on the fly for a given RenderTexture, a separate instance will be created if the user requires it. This instance will be the one used after the next call of SetReferenceSize if MSAA is required.
        public RTHandle Alloc(
                Vector2 scaleFactor,
+                int slices = 1,
                DepthBits depthBufferBits = DepthBits.None,
                RenderTextureFormat colorFormat = RenderTextureFormat.Default,
                FilterMode filterMode = FilterMode.Point,

            var rth = AllocAutoSizedRenderTexture(width,
                height,
-                1,
+                slices,
                depthBufferBits,
                colorFormat,
                filterMode,
        //
        public RTHandle Alloc(
                ScaleFunc scaleFunc,
+                int slices = 1,
                DepthBits depthBufferBits = DepthBits.None,
                RenderTextureFormat colorFormat = RenderTextureFormat.Default,
                FilterMode filterMode = FilterMode.Point,

            var rth = AllocAutoSizedRenderTexture(width,
                height,
-                1,
+                slices,
                depthBufferBits,
                colorFormat,
                filterMode,
                useDynamicScale = useDynamicScale,
                vrUsage = vrUsage,
                memorylessMode = memoryless,
-                name = CoreUtils.GetRenderTargetAutoName(width, height, colorFormat, name, mips : useMipMap, enableMSAA: allocForMSAA, msaaSamples : m_ScaledRTCurrentMSAASamples)
+                name = CoreUtils.GetRenderTargetAutoName(width, height, slices, colorFormat, name, mips : useMipMap, enableMSAA: allocForMSAA, msaaSamples : m_ScaledRTCurrentMSAASamples)
            };
            rt.Create();

--- a/ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandles.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Textures/RTHandles.cs
-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine.Rendering;

 namespace UnityEngine.Experimental.Rendering
        public static int maxHeight { get { return s_DefaultInstance.maxHeight; } }

        public static RTHandleSystem.RTHandle Alloc(
-            int width, 
-            int height, 
-            int slices = 1, 
-            DepthBits depthBufferBits = DepthBits.None, 
-            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
-            FilterMode filterMode = FilterMode.Point, 
-            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
-            TextureDimension dimension = TextureDimension.Tex2D, 
-            bool sRGB = true, 
-            bool enableRandomWrite = false, 
-            bool useMipMap = false, 
-            bool autoGenerateMips = true, 
-            int anisoLevel = 1, 
-            float mipMapBias = 0, 
-            MSAASamples msaaSamples = MSAASamples.None, 
-            bool bindTextureMS = false, 
-            bool useDynamicScale = false, 
-            VRTextureUsage vrUsage = VRTextureUsage.None, 
-            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            int width,
+            int height,
+            int slices = 1,
+            DepthBits depthBufferBits = DepthBits.None,
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+            FilterMode filterMode = FilterMode.Point,
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+            TextureDimension dimension = TextureDimension.Tex2D,
+            bool sRGB = true,
+            bool enableRandomWrite = false,
+            bool useMipMap = false,
+            bool autoGenerateMips = true,
+            int anisoLevel = 1,
+            float mipMapBias = 0,
+            MSAASamples msaaSamples = MSAASamples.None,
+            bool bindTextureMS = false,
+            bool useDynamicScale = false,
+            VRTextureUsage vrUsage = VRTextureUsage.None,
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
            string name = ""
        )
        {
        }

        public static RTHandleSystem.RTHandle Alloc(
-            Vector2 scaleFactor, 
-            DepthBits depthBufferBits = DepthBits.None, 
-            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
-            FilterMode filterMode = FilterMode.Point, 
-            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
-            TextureDimension dimension = TextureDimension.Tex2D, 
-            bool sRGB = true, 
-            bool enableRandomWrite = false, 
-            bool useMipMap = false, 
-            bool autoGenerateMips = true, 
-            int anisoLevel = 1, 
-            float mipMapBias = 0, 
-            bool enableMSAA = false, 
-            bool bindTextureMS = false, 
-            bool useDynamicScale = false, 
-            VRTextureUsage vrUsage = VRTextureUsage.None, 
-            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            Vector2 scaleFactor,
+            int slices = 1,
+            DepthBits depthBufferBits = DepthBits.None,
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+            FilterMode filterMode = FilterMode.Point,
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+            TextureDimension dimension = TextureDimension.Tex2D,
+            bool sRGB = true,
+            bool enableRandomWrite = false,
+            bool useMipMap = false,
+            bool autoGenerateMips = true,
+            int anisoLevel = 1,
+            float mipMapBias = 0,
+            bool enableMSAA = false,
+            bool bindTextureMS = false,
+            bool useDynamicScale = false,
+            VRTextureUsage vrUsage = VRTextureUsage.None,
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
+                slices,
                depthBufferBits,
                colorFormat,
                filterMode,
        }

        public static RTHandleSystem.RTHandle Alloc(
-            ScaleFunc scaleFunc, 
-            DepthBits depthBufferBits = DepthBits.None, 
-            RenderTextureFormat colorFormat = RenderTextureFormat.Default, 
-            FilterMode filterMode = FilterMode.Point, 
-            TextureWrapMode wrapMode = TextureWrapMode.Repeat, 
-            TextureDimension dimension = TextureDimension.Tex2D, 
-            bool sRGB = true, 
-            bool enableRandomWrite = false, 
+            ScaleFunc scaleFunc,
+            int slices = 1,
+            DepthBits depthBufferBits = DepthBits.None,
+            RenderTextureFormat colorFormat = RenderTextureFormat.Default,
+            FilterMode filterMode = FilterMode.Point,
+            TextureWrapMode wrapMode = TextureWrapMode.Repeat,
+            TextureDimension dimension = TextureDimension.Tex2D,
+            bool sRGB = true,
+            bool enableRandomWrite = false,
-            bool autoGenerateMips = true, 
-            int anisoLevel = 1, 
-            float mipMapBias = 0, 
-            bool enableMSAA = false, 
-            bool bindTextureMS = false, 
-            bool useDynamicScale = false, 
-            VRTextureUsage vrUsage = VRTextureUsage.None, 
-            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None, 
+            bool autoGenerateMips = true,
+            int anisoLevel = 1,
+            float mipMapBias = 0,
+            bool enableMSAA = false,
+            bool bindTextureMS = false,
+            bool useDynamicScale = false,
+            VRTextureUsage vrUsage = VRTextureUsage.None,
+            RenderTextureMemoryless memoryless = RenderTextureMemoryless.None,
+                slices,
                depthBufferBits,
                colorFormat,
                filterMode,
        }

        public static void Initialize(
-            int width, 
-            int height, 
-            bool scaledRTsupportsMSAA, 
+            int width,
+            int height,
+            bool scaledRTsupportsMSAA,
            MSAASamples scaledRTMSAASamples
        )
        {
        }

        public static void ResetReferenceSize(
-            int width, 
-            int height, 
-            bool msaa, 
+            int width,
+            int height,
+            bool msaa,
            MSAASamples msaaSamples
        )
        {
        }

        public static void SetReferenceSize(
-            int width, 
-            int height, 
-            bool msaa, 
+            int width,
+            int height,
+            bool msaa,
            MSAASamples msaaSamples
        )
        {
--- a/ScriptableRenderPipeline/Core/CoreRP/Textures/TextureCache.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Textures/TextureCache.cs
                for (int m = 0; m < m_NumPanoMipLevels; m++)
                {
                    m_StagingRTs[m] = new RenderTexture(Mathf.Max(1, panoWidthTop >> m), Mathf.Max(1, panoHeightTop >> m), 0, RenderTextureFormat.ARGBHalf) { hideFlags = HideFlags.HideAndDontSave };
-                    m_StagingRTs[m].name = CoreUtils.GetRenderTargetAutoName(Mathf.Max(1, panoWidthTop >> m), Mathf.Max(1, panoHeightTop >> m), RenderTextureFormat.ARGBHalf, String.Format("PanaCache{0}", m));
+                    m_StagingRTs[m].name = CoreUtils.GetRenderTargetAutoName(Mathf.Max(1, panoWidthTop >> m), Mathf.Max(1, panoHeightTop >> m), 1, RenderTextureFormat.ARGBHalf, String.Format("PanaCache{0}", m));
                }

                if (m_CubeBlitMaterial)
--- a/ScriptableRenderPipeline/Core/CoreRP/Utilities/CoreUtils.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Utilities/CoreUtils.cs
            SetRenderTarget(cmd, colorBuffer, colorLoadAction, colorStoreAction, depthBuffer, depthLoadAction, depthStoreAction, clearFlag, clearColorAllBlack);
        }

-        public static string GetRenderTargetAutoName(int width, int height, RenderTextureFormat format, string name = "", bool mips = false, bool enableMSAA = false, MSAASamples msaaSamples = MSAASamples.None)
+        public static string GetRenderTargetAutoName(int width, int height, int depth, RenderTextureFormat format, string name, bool mips = false, bool enableMSAA = false, MSAASamples msaaSamples = MSAASamples.None)
-            string temp;
+            string result = string.Format("{0}_{1}x{2}", name, width, height);
+
+            if (depth > 1)
+                result = string.Format("{0}x{1}", result, depth);
+
+            if (mips)
+                result = string.Format("{0}_{1}", result, "Mips");
+
+            result = string.Format("{0}_{1}", result, format);
+
-                temp = string.Format("{0}x{1}_{2}{3}_{4}", width, height, format, mips ? "_Mips"  : "", msaaSamples.ToString());
-            else
-                temp = string.Format("{0}x{1}_{2}{3}", width, height, format, mips ? "_Mips" : "");
-
-            temp = String.Format("{0}_{1}", name == "" ? "RenderTarget" : name, temp);
+                result = string.Format("{0}_{1}", result, msaaSamples.ToString());
-            return temp;
+            return result;
        }

        public static string GetTextureAutoName(int width, int height, TextureFormat format, TextureDimension dim = TextureDimension.None, string name = "", bool mips = false, int depth = 0)
-                temp = string.Format("{0}x{1}_{2}{3}", width, height, format, mips ? "_Mips" : "");
+                temp = string.Format("{0}x{1}{2}_{3}", width, height, mips ? "_Mips" : "", format);
-                temp = string.Format("{0}x{1}x{2}_{3}{4}", width, height, depth, format, mips ? "_Mips" : "");
+                temp = string.Format("{0}x{1}x{2}{3}_{4}", width, height, depth, mips ? "_Mips" : "", format);
            temp = String.Format("{0}_{1}_{2}", name == "" ? "Texture" : name, (dim == TextureDimension.None) ? "" : dim.ToString(), temp);

            return temp;
--- a/ScriptableRenderPipeline/Core/CoreRP/Volume/Volume.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Volume/Volume.cs
            }
        }

+        public bool HasInstantiatedProfile()
+        {
+            return m_InternalProfile != null;
+        }
+
        // Needed for state tracking (see the comments in Update)
        int m_PreviousLayer;
        float m_PreviousPriority;
--- a/ScriptableRenderPipeline/Core/CoreRP/Volume/VolumeManager.cs
+++ b/ScriptableRenderPipeline/Core/CoreRP/Volume/VolumeManager.cs
    public sealed class VolumeManager
    {
        //>>> System.Lazy<T> is broken in Unity (legacy runtime) so we'll have to do it ourselves :|
-        static volatile VolumeManager s_Instance;
-        static object s_LockObj = new UnityObject();
+        static readonly VolumeManager s_Instance = new VolumeManager();
+        public static VolumeManager instance { get { return s_Instance; } }
-        public static VolumeManager instance
-        {
-            get
-            {
-                // Double-lock checking
-                if (s_Instance == null)
-                {
-                    lock (s_LockObj) // Lock on a separate object to avoid deadlocks
-                    {
-                        if (s_Instance == null)
-                            s_Instance = new VolumeManager();
-                    }
-                }
-
-                return s_Instance;
-            }
-        }
+        // Explicit static constructor to tell the C# compiler not to mark type as beforefieldinit
+        static VolumeManager() { }
        //<<<

        // Internal stack
--- a/ScriptableRenderPipeline/Core/LICENSE.md
+++ b/ScriptableRenderPipeline/Core/LICENSE.md
-**Unity Companion Package License v1.0 ("_License_")**
-
-Copyright © 2017 Unity Technologies ApS ("**_Unity_**")
-
-Unity hereby grants to you a worldwide, non-exclusive, no-charge, and royalty-free copyright license to reproduce, prepare derivative works of, publicly display, publicly perform, sublicense, and distribute the software that is made available with this License ("**_Software_**"), subject to the following terms and conditions:
-
-1. *Unity Companion Use Only*. Exercise of the license granted herein is limited to exercise for the creation, use, and/or distribution of applications, software, or other content pursuant to a valid Unity development engine software license ("**_Engine License_**"). That means while use of the Software is not limited to use in the software licensed under the Engine License, the Software may not be used for any purpose other than the creation, use, and/or distribution of Engine License-dependent applications, software, or other content. No other exercise of the license granted herein is permitted.
-
-1. *No Modification of Engine License*. Neither this License nor any exercise of the license granted herein modifies the Engine License in any way.
-
-1. *Ownership & Grant Back to You*. 
-
-    3.1. You own your content. In this License, "derivative works" means derivatives of the Software itself--works derived only from the Software by you under this License (for example, modifying the code of the Software itself to improve its efficacy); “derivative works” of the Software do not include, for example, games, apps, or content that you create using the Software. You keep all right, title, and interest to your own content.
-
-    3.2. Unity owns its content. While you keep all right, title, and interest to your own content per the above, as between Unity and you, Unity will own all right, title, and interest to all intellectual property rights (including patent, trademark, and copyright) in the Software and derivative works of the Software, and you hereby assign and agree to assign all such rights in those derivative works to Unity. 
-
-    3.3. You have a license to those derivative works. Subject to this License, Unity grants to you the same worldwide, non-exclusive, no-charge, and royalty-free copyright license to derivative works of the Software you create as is granted to you for the Software under this License.
-
-1. *Trademarks*. You are not granted any right or license under this License to use any trademarks, service marks, trade names, products names, or branding of Unity or its affiliates ("**_Trademarks_**"). Descriptive uses of Trademarks are permitted; see, for example, Unity’s Branding Usage Guidelines at [https://unity3d.com/public-relations/brand](https://unity3d.com/public-relations/brand).
-
-1. *Notices & Third-Party Rights*. This License, including the copyright notice above, must be provided in all substantial portions of the Software and derivative works thereof (or, if that is impracticable, in any other location where such notices are customarily placed). Further, if the Software is accompanied by a Unity "third-party notices" or similar file, you acknowledge and agree that software identified in that file is governed by those separate license terms.
-
-1. *DISCLAIMER, LIMITATION OF LIABILITY*. THE SOFTWARE AND ANY DERIVATIVE WORKS THEREOF IS PROVIDED ON AN "AS IS" BASIS, AND IS PROVIDED WITHOUT WARRANTY OF ANY KIND, WHETHER EXPRESS OR IMPLIED, INCLUDING ANY WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE, AND/OR NONINFRINGEMENT. IN NO EVENT SHALL ANY COPYRIGHT HOLDER OR AUTHOR BE LIABLE FOR ANY CLAIM, DAMAGES (WHETHER DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL, INCLUDING PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES, LOSS OF USE, DATA, OR PROFITS, AND BUSINESS INTERRUPTION), OR OTHER LIABILITY WHATSOEVER, WHETHER IN AN ACTION OF CONTRACT, TORT, OR OTHERWISE, ARISING FROM OR OUT OF, OR IN CONNECTION WITH, THE SOFTWARE OR ANY DERIVATIVE WORKS THEREOF OR THE USE OF OR OTHER DEALINGS IN SAME, EVEN WHERE ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-1. *USE IS ACCEPTANCE and License Versions*. Your receipt and use of the Software constitutes your acceptance of this License and its terms and conditions. Software released by Unity under this License may be modified or updated and the License with it; upon any such modification or update, you will comply with the terms of the updated License for any use of any of the Software under the updated License. 
-
-1. *Use in Compliance with Law and Termination*. Your exercise of the license granted herein will at all times be in compliance with applicable law and will not infringe any proprietary rights (including intellectual property rights); this License will terminate immediately on any breach by you of this License.
+Render Pipeline Core copyright © 2018 Unity Technologies ApS
-1. *Severability*. If any provision of this License is held to be unenforceable or invalid, that provision will be enforced to the maximum extent possible and the other provisions will remain in full force and effect.
+Licensed under the Unity Companion License for Unity-dependent projects--see [Unity Companion License](http://www.unity3d.com/legal/licenses/Unity_Companion_License). 
-1. *Governing Law and Venue*. This License is governed by and construed in accordance with the laws of Denmark, except for its conflict of laws rules; the United Nations Convention on Contracts for the International Sale of Goods will not apply. If you reside (or your principal place of business is) within the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the state and federal courts located in San Francisco County, California concerning any dispute arising out of this License ("**_Dispute_**"). If you reside (or your principal place of business is) outside the United States, you and Unity agree to submit to the personal and exclusive jurisdiction of and venue in the courts located in Copenhagen, Denmark concerning any Dispute.
+Unless expressly provided otherwise, the Software under this license is made available strictly on an “AS IS” BASIS WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED. Please review the license for details on these and other terms and conditions.
--- a/ScriptableRenderPipeline/HDRenderPipeline/CHANGELOG.md
+++ b/ScriptableRenderPipeline/HDRenderPipeline/CHANGELOG.md
 - Disable per-object culling that was executed in C++ in HD whereas it was not used (Optimization)
 - Enable texture streaming debugging (was not working before 2018.2)

+### Changed, Removals and deprecations
+- Removed GlobalLightLoopSettings.maxPlanarReflectionProbes and instead use value of GlobalLightLoopSettings.planarReflectionProbeCacheSize
+
- Configure the volumetric lighting code path to be on by default
+- Configure the VolumetricLightingSystem code path to be on by default
+- Add 3D texture support for DensityVolumes
+- Add a better mapping of roughness to mipmap for planar reflection
+- The VolumetricLightingSystem now uses RTHandles, which allows to save memory by sharing buffers between different cameras (history buffers are not shared), and reduce reallocation frequency by reallocating buffers only if the rendering resolution increases (and suballocating within existing buffers if the rendering resolution decreases)
+- Add a Volumetric Dimmer slider to lights to control the intensity of the scattered volumetric lighting
+- Add UV tiling and offset support for decals.
+- Rename _MainDepthTexture to _CameraDepthTexture
+- The VolumetricLightingController has been moved to the Interpolation Volume framework and now functions similarly to the VolumetricFog settings
+- Update of UI of cookie, CubeCookie, Reflection probe and planar reflection probe to combo box
+- Allow enabling/disabling shadows for area lights when they are set to baked.
+- Hide applyRangeAttenuation and FadeDistance for directional shadow as they are not used
- Fix the bug preventing decals from coexisting with density volumes 
+- Fix the bug preventing decals from coexisting with density volumes
+- Fix issue with alpha tested geometry using planar/triplanar mapping not render correctly or flickering (due to being wrongly alpha tested in depth prepass)
+- Fix meta pass with triplanar (was not handling correctly the normal)
+- Fix preview when a planar reflection is present
+- Fix Camera preview, it is now a Preview cameraType (was a SceneView)
+- Fix handling unknown GPUShadowTypes in the shadow manager.
+- Fix area light shapes sent as point lights to the baking backends when they are set to baked.
+- Fix unnecessary division by PI for baked area lights.
+- Fix line lights sent to the lightmappers. The backends don't support this light type.
+- Fix issue with shadow mask framesettings not correctly taken into account when shadow mask is enabled for lighting.
+- Fix directional light and shadow mask transition, they are now matching making smooth transition

 ## [2018.1.0f2]

--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDAdditionalCameraData.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDAdditionalCameraData.cs
        public Color backgroundColorHDR = new Color(0.025f, 0.07f, 0.19f, 0.0f);
        public bool clearDepth = true;

-        public RenderingPath    renderingPath;
+        public RenderingPath renderingPath;
-        public LayerMask        volumeLayerMask = -1;
+        public LayerMask volumeLayerMask = -1;

        // Physical parameters
        public float aperture = 8f;
        // we create a runtime copy (m_ActiveFrameSettings that is used, and any parametrization is done on serialized frameSettings)
        [SerializeField]
        [FormerlySerializedAs("serializedFrameSettings")]
-        FrameSettings    m_FrameSettings = new FrameSettings(); // Serialize frameSettings
+        FrameSettings m_FrameSettings = new FrameSettings(); // Serialize frameSettings

        // Not serialized, visible only in the debug windows
        FrameSettings m_FrameSettingsRuntime = new FrameSettings();
        // Use for debug windows
        // When camera name change we need to update the name in DebugWindows.
        // This is the purpose of this class
-        bool    m_IsDebugRegistered = false;
-        string  m_CameraRegisterName;
+        bool m_IsDebugRegistered = false;
+        string m_CameraRegisterName;
+
+        // When we are a preview, there is no way inside Unity to make a disctinctoin between camera preview and material preview.
+        // This property allow to say that we are an editor camera preview when the type is preview.
+        public bool isEditorCameraPreview { get; set; }

        // This is the function use outside to access FrameSettings. It return the current state of FrameSettings for the camera
        // taking into account the customization via the debug menu
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs
        public Vector4   projectionParams;
        public Vector4   screenParams;

+        public VolumetricLightingSystem.VBufferParameters[] vBufferParams; // Double-buffered
+
        public PostProcessRenderContext postprocessRenderContext;

        public Matrix4x4[] viewMatrixStereo;
        // This is the size actually used for this camera (as it can be altered by VR for example)
        int m_ActualWidth;
        int m_ActualHeight;
-        // This is the scale and bias of the camera viewport compared to the reference size of our Render Targets (RHandle.maxSize)
-        Vector2 m_CameraScaleBias;
+        // This is the scale of the camera viewport compared to the reference size of our Render Targets (RTHandle.maxSize)
+        Vector2 m_ViewportScaleCurrentFrame;
+        Vector2 m_ViewportScalePreviousFrame;
+        FrameSettings m_frameSettings;
-        public Vector2 scaleBias { get { return m_CameraScaleBias; } }
+        public Vector2 viewportScale { get { return m_ViewportScaleCurrentFrame; } }
+        public Vector4 doubleBufferedViewportScale { get { return new Vector4(m_ViewportScaleCurrentFrame.x, m_ViewportScaleCurrentFrame.y, m_ViewportScalePreviousFrame.x, m_ViewportScalePreviousFrame.y); } }
+
+        public FrameSettings frameSettings { get { return m_frameSettings; } }

        public Matrix4x4 viewProjMatrix
        {
            projMatrixStereo = new Matrix4x4[2];

            postprocessRenderContext = new PostProcessRenderContext();
+
+
-        public void Update(PostProcessLayer postProcessLayer, FrameSettings frameSettings)
+        // Pass all the systems that may want to update per-camera data here.
+        // That way you will never update an HDCamera and forget to update the dependent system.
+        public void Update(FrameSettings currentFrameSettings, PostProcessLayer postProcessLayer, VolumetricLightingSystem vlSys)
+            m_frameSettings = currentFrameSettings;
+
-                frameSettings.enablePostprocess;
+                m_frameSettings.enablePostprocess;

            var nonJitteredCameraProj = camera.projectionMatrix;
            var cameraProj = taaEnabled
            m_ActualHeight = camera.pixelHeight;
            var screenWidth = m_ActualWidth;
            var screenHeight = m_ActualHeight;
-            if (frameSettings.enableStereo)
+#if !UNITY_SWITCH
+            if (m_frameSettings.enableStereo)
            {
                screenWidth = XRSettings.eyeTextureWidth;
                screenHeight = XRSettings.eyeTextureHeight;

                ConfigureStereoMatrices();
            }
+#endif
-            RTHandles.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, m_msaaSamples);
-            m_HistoryRTSystem.SetReferenceSize(m_ActualWidth, m_ActualHeight, frameSettings.enableMSAA, m_msaaSamples);
+            RTHandles.SetReferenceSize(m_ActualWidth, m_ActualHeight, m_frameSettings.enableMSAA, m_msaaSamples);
+            m_HistoryRTSystem.SetReferenceSize(m_ActualWidth, m_ActualHeight, m_frameSettings.enableMSAA, m_msaaSamples);
-            m_CameraScaleBias.x = (float)m_ActualWidth / maxWidth;
-            m_CameraScaleBias.y = (float)m_ActualHeight / maxHeight;
+            m_ViewportScalePreviousFrame = m_ViewportScaleCurrentFrame; // Double-buffer
+            m_ViewportScaleCurrentFrame.x = (float)m_ActualWidth / maxWidth;
+            m_ViewportScaleCurrentFrame.y = (float)m_ActualHeight / maxHeight;
+
+            if (vlSys != null)
+            {
+                vlSys.UpdatePerCameraData(this);
+            }
-        public void UpdateStereoDependentState(FrameSettings frameSettings, ref ScriptableCullingParameters cullingParams)
+        public void UpdateStereoDependentState(ref ScriptableCullingParameters cullingParams)
-            if (!frameSettings.enableStereo)
+            if (!m_frameSettings.enableStereo)
                return;

            // What constants in UnityPerPass need updating for stereo considerations?
            isFirstFrame = true;
        }

-        // Grab the HDCamera tied to a given Camera and update it.
-        public static HDCamera Get(Camera camera, PostProcessLayer postProcessLayer, FrameSettings frameSettings)
+        // Will return NULL if the camera does not exist.
+        public static HDCamera Get(Camera camera)
+        {
+            HDCamera hdCamera;
+
+            if (!s_Cameras.TryGetValue(camera, out hdCamera))
+            {
+                hdCamera = null;
+            }
+
+            return hdCamera;
+        }
+
+        // Pass all the systems that may want to initialize per-camera data here.
+        // That way you will never create an HDCamera and forget to initialize the data.
+        public static HDCamera Create(Camera camera, VolumetricLightingSystem vlSys)
-            HDCamera hdcam;
+            HDCamera hdCamera = new HDCamera(camera);
+            s_Cameras.Add(camera, hdCamera);
-            if (!s_Cameras.TryGetValue(camera, out hdcam))
+            if (vlSys != null)
-                hdcam = new HDCamera(camera);
-                s_Cameras.Add(camera, hdcam);
+                // Have to perform a NULL check here because the Reflection System internally allocates HDCameras.
+                vlSys.InitializePerCameraData(hdCamera);
-            hdcam.Update(postProcessLayer, frameSettings);
-            return hdcam;
+            return hdCamera;
        }

        public static void ClearAll()
            s_Cleanup.Clear();
        }

-        // Look for any camera that hasn't been used in the last frame and remove them for the pool.
+        // Look for any camera that hasn't been used in the last frame and remove them from the pool.
        public static void CleanUnused()
        {
            int frameCheck = Time.frameCount - 1;
            cmd.SetGlobalVector(HDShaderIDs._WorldSpaceCameraPos,       worldSpaceCameraPos);
            cmd.SetGlobalFloat( HDShaderIDs._DetViewMatrix,             detViewMatrix);
            cmd.SetGlobalVector(HDShaderIDs._ScreenSize,                screenSize);
-            cmd.SetGlobalVector(HDShaderIDs._ScreenToTargetScale,       scaleBias);
+            cmd.SetGlobalVector(HDShaderIDs._ScreenToTargetScale,       doubleBufferedViewportScale);
            cmd.SetGlobalVector(HDShaderIDs._ZBufferParams,             zBufferParams);
            cmd.SetGlobalVector(HDShaderIDs._ProjectionParams,          projectionParams);
            cmd.SetGlobalVector(HDShaderIDs.unity_OrthoParams,          unity_OrthoParams);
        // Allocate buffers frames and return current frame
        public RTHandleSystem.RTHandle AllocHistoryFrameRT(int id, Func<string, int, RTHandleSystem, RTHandleSystem.RTHandle> allocator)
        {
-            m_HistoryRTSystem.AllocBuffer(id, (rts, i) => allocator(camera.name, i, rts), 2);
+            const int bufferCount = 2; // Hard-coded for now. Will have to see if this is enough...
+            m_HistoryRTSystem.AllocBuffer(id, (rts, i) => allocator(camera.name, i, rts), bufferCount);
            return m_HistoryRTSystem.GetFrameRT(id, 0);
        }

--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCameraFrameHistoryType.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCameraFrameHistoryType.cs
 {
    public enum HDCameraFrameHistoryType
    {
-        DepthPyramid,
-        ColorPyramid
+        DepthPyramid       = 0,
+        ColorPyramid       = 1,
+        VolumetricLighting = 2,
+        Count              = 3 // Keep this last
    }
 }
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugColorPicker.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugColorPicker.shader

            HLSLPROGRAM
            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

            #pragma vertex Vert
            #pragma fragment Frag
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplayLatlong.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplayLatlong.shader

            HLSLPROGRAM
            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

            #pragma vertex Vert
            #pragma fragment Frag
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugFullScreen.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugFullScreen.shader

            HLSLPROGRAM
            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

            #pragma vertex Vert
            #pragma fragment Frag
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewMaterialGBuffer.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewMaterialGBuffer.shader

            HLSLPROGRAM
            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

            #pragma vertex Vert
            #pragma fragment Frag
            float4 Frag(Varyings input) : SV_Target
            {
                // input.positionCS is SV_Position
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, input.positionCS.xy).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, input.positionCS.xy).x;
                PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V);

                BSDFData bsdfData;
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewTiles.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugViewTiles.shader

            HLSLPROGRAM
            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

            #pragma vertex Vert
            #pragma fragment Frag
            float4 Frag(Varyings input) : SV_Target
            {
                // positionCS is SV_Position
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, input.positionCS.xy).x;
+                float depth = LOAD_TEXTURE2D(_CameraDepthTexture, input.positionCS.xy).x;
                PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_V, uint2(input.positionCS.xy) / GetTileSize());

                int2 pixelCoord = posInput.positionSS.xy;
                int maxLights = 32;
                if (tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxLights + 3)
                {
-                    float depthMouse = LOAD_TEXTURE2D(_MainDepthTexture, _MousePixelCoord.xy).x;
+                    float depthMouse = LOAD_TEXTURE2D(_CameraDepthTexture, _MousePixelCoord.xy).x;
                    PositionInputs mousePosInput = GetPositionInput(_MousePixelCoord.xy, _ScreenSize.zw, depthMouse, UNITY_MATRIX_I_VP, UNITY_MATRIX_V, mouseTileCoord);

                    uint category = (LIGHTCATEGORY_COUNT - 1) - tileCoord.y;
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalProjectorComponent.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalProjectorComponent.cs
        public Material m_Material = null;
 		public float m_DrawDistance = 1000.0f;
        public float m_FadeScale = 0.9f;
+        public Vector2 m_UVScale = new Vector2(1,1);
+        public Vector2 m_UVBias = new Vector2(0,0);
        private Material m_OldMaterial = null;
        private DecalSystem.DecalHandle m_Handle = null;


            if(m_Handle != null)
                DecalSystem.instance.RemoveDecal(m_Handle);
-            m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, m_Material);
+            Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
+            m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Material);
        }

        public void OnDisable()
            {
                if( m_Handle != null)
                    DecalSystem.instance.RemoveDecal(m_Handle);
-                m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, m_Material);
+                Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
+                m_Handle = DecalSystem.instance.AddDecal(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Material);
                m_OldMaterial = m_Material;

                // notify the editor that material has changed so it can update the shader foldout
            {
                if (transform.hasChanged == true)
                {
-                    DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, m_Handle);
+                    Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
+                    DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Handle);
                    transform.hasChanged = false;
                }
            }
        {
            DrawGizmo(true);
            // if this object is selected there is a chance the transform was changed so update culling info
-            DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, m_Handle);
+            Vector4 uvScaleBias = new Vector4(m_UVScale.x, m_UVScale.y, m_UVBias.x, m_UVBias.y);
+            DecalSystem.instance.UpdateCachedData(transform, m_DrawDistance, m_FadeScale, uvScaleBias, m_Handle);
        }

        public void OnDrawGizmos()
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs
                return res;
            }

-            public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, DecalHandle handle) 
+            public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, DecalHandle handle) 
            {
                int index = handle.m_Index;
                m_CachedDecalToWorld[index] = transform.localToWorldMatrix;
                    ? drawDistance
                    : instance.DrawDistance;
                m_CachedDrawDistances[index].y = fadeScale;
+                m_CachedUVScaleBias[index] = uvScaleBias;
-            public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, int materialID)
+            public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, int materialID)
            {
                // increase array size if no space left
                if (m_DecalsCount == m_Handles.Length)
                    Matrix4x4[] newCachedTransforms = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
                    Matrix4x4[] newCachedNormalToWorld = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
                    Vector2[] newCachedDrawDistances = new Vector2[m_DecalsCount + kDecalBlockSize];
+                    Vector4[] newCachedUVScaleBias = new Vector4[m_DecalsCount + kDecalBlockSize];
                    m_ResultIndices = new int[m_DecalsCount + kDecalBlockSize];

                    m_Handles.CopyTo(newHandles, 0);
                    m_CachedDrawDistances.CopyTo(newCachedDrawDistances, 0);
+                    m_CachedUVScaleBias.CopyTo(newCachedUVScaleBias, 0);

                    m_Handles = newHandles;
                    m_BoundingSpheres = newSpheres;
+                    m_CachedUVScaleBias = newCachedUVScaleBias;
-                UpdateCachedData(transform, drawDistance, fadeScale, decalHandle);
+                UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, decalHandle);
                m_DecalsCount++;
                return decalHandle;
            }
                m_CachedDecalToWorld[removeAtIndex] = m_CachedDecalToWorld[m_DecalsCount - 1];
                m_CachedNormalToWorld[removeAtIndex] = m_CachedNormalToWorld[m_DecalsCount - 1];
                m_CachedDrawDistances[removeAtIndex] = m_CachedDrawDistances[m_DecalsCount - 1];
+                m_CachedUVScaleBias[removeAtIndex] = m_CachedUVScaleBias[m_DecalsCount - 1];
                m_DecalsCount--;
                handle.m_Index = kInvalidIndex;
            }
                        normalToWorldBatch[instanceCount] = m_CachedNormalToWorld[decalIndex];
                        float fadeFactor = Mathf.Clamp((cullDistance - distanceToDecal) / (cullDistance * (1.0f - m_CachedDrawDistances[decalIndex].y)), 0.0f, 1.0f);
                        normalToWorldBatch[instanceCount].m03 = fadeFactor * m_Blend;   // vector3 rotation matrix so bottom row and last column can be used for other data to save space
+                        normalToWorldBatch[instanceCount].SetRow(3, m_CachedUVScaleBias[decalIndex]);

                        // clustered forward data
                        m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse;
            private Matrix4x4[] m_CachedDecalToWorld = new Matrix4x4[kDecalBlockSize];
            private Matrix4x4[] m_CachedNormalToWorld = new Matrix4x4[kDecalBlockSize];
 			private Vector2[] m_CachedDrawDistances = new Vector2[kDecalBlockSize]; // x - draw distance, y - fade scale
+            private Vector4[] m_CachedUVScaleBias = new Vector4[kDecalBlockSize]; // xy - scale, zw bias
            private Material m_Material;
            private float m_Blend = 0;

        }

-        public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Material material)
+        public DecalHandle AddDecal(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, Material material)
        {			
            DecalSet decalSet = null;
            int key = material.GetInstanceID();
                m_DecalSets.Add(key, decalSet);
            }
-            return decalSet.AddDecal(transform, drawDistance, fadeScale, key);
+            return decalSet.AddDecal(transform, drawDistance, fadeScale, uvScaleBias, key);
        }

        public void RemoveDecal(DecalHandle handle)
            }
        }

-        public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, DecalHandle handle)
+        public void UpdateCachedData(Transform transform, float drawDistance, float fadeScale, Vector4 uvScaleBias, DecalHandle handle)
        {
            if(!DecalHandle.IsValid(handle))
                return;
            if (m_DecalSets.TryGetValue(key, out decalSet))
            {
-                decalSet.UpdateCachedData(transform, drawDistance, fadeScale, handle);
+                decalSet.UpdateCachedData(transform, drawDistance, fadeScale, uvScaleBias, handle);
            }
        }

--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/BuildPlayer/HDRPCustomBuildProcessor.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/BuildPlayer/HDRPCustomBuildProcessor.cs
 using UnityEditor.Build;
 using UnityEditor.Build.Reporting;
 using UnityEngine;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;

 class HDRPCustomBuildProcessor : IPreprocessBuildWithReport
 {
    {
+        // Don't execute the preprocess if we are not HDRenderPipeline
+        HDRenderPipeline hdrp = RenderPipelineManager.currentPipeline as HDRenderPipeline;
+        if (hdrp == null)
+            return;
+
        // Note: If you add new platform in this function, think about adding support in IsSupportedPlatform() function in HDRenderPipeline.cs

        // If platform is supported all good
            report.summary.platform == BuildTarget.StandaloneLinuxUniversal ||
            report.summary.platform == BuildTarget.StandaloneOSX ||
            report.summary.platform == BuildTarget.XboxOne ||
-            report.summary.platform == BuildTarget.PS4 /* ||
-            report.summary.platform == BuildTarget.Switch */)
+            report.summary.platform == BuildTarget.PS4 ||
+            report.summary.platform == BuildTarget.Switch)
        {
            return ;
        }
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/BuildPlayer/HDRPVariantStripper.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/BuildPlayer/HDRPVariantStripper.cs
-using System.Collections;
+using System.Collections;
 using System.Collections.Generic;
 using UnityEditor.Build;
 using UnityEditor.Rendering;
        ShaderKeyword m_TileLighting;
        ShaderKeyword m_ClusterLighting;

-        ShaderKeyword m_FeatureSSS;
+        //ShaderKeyword m_FeatureSSS;

        public HDRPVariantStripper()
        {
            m_TileLighting = new ShaderKeyword("USE_FPTL_LIGHTLIST");
            m_ClusterLighting = new ShaderKeyword("USE_CLUSTERED_LIGHTLIST");

-            m_FeatureSSS = new ShaderKeyword("_MATERIAL_FEATURE_SUBSURFACE_SCATTERING");
+            //m_FeatureSSS = new ShaderKeyword("_MATERIAL_FEATURE_SUBSURFACE_SCATTERING");
        }

        bool LitShaderStripper(Shader shader, ShaderSnippetData snippet, ShaderCompilerData inputData)
        public int callbackOrder { get { return 0; } }
        public void OnProcessShader(Shader shader, ShaderSnippetData snippet, IList<ShaderCompilerData> inputData)
        {
+            // This test will also return if we are not using HDRenderPipelineAsset
            if (m_CurrentHDRPAsset == null || !m_CurrentHDRPAsset.allowShaderVariantStripping)
                return;

--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/HDCameraEditor.Handlers.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/HDCameraEditor.Handlers.cs
-using System;
+using System;
 using System.Reflection;
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
            EditorUtility.CopySerialized(cameraData, m_PreviewAdditionalCameraData);
            var layer = c.GetComponent<PostProcessLayer>() ?? ComponentSingleton<PostProcessLayer>.instance;
            EditorUtility.CopySerialized(layer, m_PreviewPostProcessLayer);
-            m_PreviewCamera.cameraType = CameraType.SceneView; // This is required else if we use Preview the image is flipped... (Unity...)
-
-            // We need to call UpdateDirtyFrameSettings to update the dirty flags that was set in the CopySerialized call
-            m_PreviewAdditionalCameraData.UpdateDirtyFrameSettings(true, cameraData.GetFrameSettings());
-            // And then to copy the runtime frame settings
-            // So this includes the runtime frame settings properly
-            cameraData.GetFrameSettings().CopyTo(m_PreviewAdditionalCameraData.GetFrameSettings());
-            m_PreviewHDCamera.Update(m_PreviewPostProcessLayer, m_PreviewAdditionalCameraData.GetFrameSettings());

            var previewTexture = GetPreviewTextureWithSize((int)previewSize.x, (int)previewSize.y);
            m_PreviewCamera.targetTexture = previewTexture;
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/HDCameraEditor.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/HDCameraEditor.cs
        Camera m_PreviewCamera;
        HDAdditionalCameraData m_PreviewAdditionalCameraData;
        PostProcessLayer m_PreviewPostProcessLayer;
-        HDCamera m_PreviewHDCamera;

        void OnEnable()
        {
            m_PreviewCamera.enabled = false;
            m_PreviewCamera.cameraType = CameraType.Preview; // Must be init before adding HDAdditionalCameraData
            m_PreviewAdditionalCameraData = m_PreviewCamera.gameObject.AddComponent<HDAdditionalCameraData>();
+            // Say that we are a camera editor preview and not just a regular preview
+            m_PreviewAdditionalCameraData.isEditorCameraPreview = true;
-            m_PreviewHDCamera = new HDCamera(m_PreviewCamera);
-            m_PreviewHDCamera.Update(m_PreviewPostProcessLayer, m_PreviewAdditionalCameraData.GetFrameSettings());
        }

        void OnDisable()
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.Styles.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.Styles.cs
-using System;
+using System;
 using System.Linq;
 using UnityEngine;

            public readonly GUIContent affectDiffuse = new GUIContent("Affect Diffuse", "This will disable diffuse lighting for this light. Doesn't save performance, diffuse lighting is still computed.");
            public readonly GUIContent affectSpecular = new GUIContent("Affect Specular", "This will disable specular lighting for this light. Doesn't save performance, specular lighting is still computed.");
            public readonly GUIContent lightDimmer = new GUIContent("Dimmer", "Aim to be used with script, timeline or animation. It allows dimming one or multiple lights of heterogeneous intensity easily (without needing to know the intensity of each light).");
+            public readonly GUIContent volumetricDimmer = new GUIContent("Volumetric Dimmer", "Allows to reduce the intensity of the scattered volumetric lighting.");
            public readonly GUIContent fadeDistance = new GUIContent("Fade Distance", "The distance at which the light will smoothly fade before being culled to minimize popping.");
            public readonly GUIContent spotInnerPercent = new GUIContent("Inner Percent", "Controls size of the angular attenuation in percent of the base angle of the Spot light's cone.");
            public readonly GUIContent spotLightShape = new GUIContent("Shape", "The shape use for the spotlight. Has an impact on the cookie transformation and light angular attenuation.");
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/HDLightEditor.cs
            public SerializedProperty shapeRadius;
            public SerializedProperty maxSmoothness;
            public SerializedProperty applyRangeAttenuation;
+            public SerializedProperty volumetricDimmer;

            // Editor stuff
            public SerializedProperty useOldInspector;
                enableSpotReflector = o.Find(x => x.enableSpotReflector),
                spotInnerPercent = o.Find(x => x.m_InnerSpotPercent),
                lightDimmer = o.Find(x => x.lightDimmer),
+                volumetricDimmer = o.Find(x => x.volumetricDimmer),
-                spotLightShape = o.Find(x => x.spotLightShape),              
+                spotLightShape = o.Find(x => x.spotLightShape),
                shapeWidth = o.Find(x => x.shapeWidth),
                shapeHeight = o.Find(x => x.shapeHeight),
                aspectRatio = o.Find(x => x.aspectRatio),

        void DrawFeatures()
        {
-            bool disabledScope = settings.isCompletelyBaked
-                || m_LightShape == LightShape.Line
-                || m_LightShape == LightShape.Rectangle;
+            bool disabledScope = m_LightShape == LightShape.Line || (m_LightShape == LightShape.Rectangle && settings.isRealtime);

            using (new EditorGUI.DisabledScope(disabledScope))
            {
                    m_AdditionalLightData.shapeHeight.floatValue = Mathf.Max(m_AdditionalLightData.shapeHeight.floatValue, k_MinAreaWidth);
                    settings.areaSizeX.floatValue = m_AdditionalLightData.shapeWidth.floatValue;
                    settings.areaSizeY.floatValue = m_AdditionalLightData.shapeHeight.floatValue;
-                    settings.shadowsType.enumValueIndex = (int)LightShadows.None;
+                    if (settings.isRealtime)
+                        settings.shadowsType.enumValueIndex = (int)LightShadows.None;
                    break;

                case LightShape.Line:
                EditorGUI.indentLevel++;
                EditorGUILayout.PropertyField(m_AdditionalLightData.affectDiffuse, s_Styles.affectDiffuse);
                EditorGUILayout.PropertyField(m_AdditionalLightData.affectSpecular, s_Styles.affectSpecular);
-                EditorGUILayout.PropertyField(m_AdditionalLightData.fadeDistance, s_Styles.fadeDistance);
+                if (m_LightShape != LightShape.Directional)
+                    EditorGUILayout.PropertyField(m_AdditionalLightData.fadeDistance, s_Styles.fadeDistance);
-                EditorGUILayout.PropertyField(m_AdditionalLightData.applyRangeAttenuation, s_Styles.applyRangeAttenuation);
+                EditorGUILayout.PropertyField(m_AdditionalLightData.volumetricDimmer, s_Styles.volumetricDimmer);
+                if (m_LightShape != LightShape.Directional)
+                    EditorGUILayout.PropertyField(m_AdditionalLightData.applyRangeAttenuation, s_Styles.applyRangeAttenuation);
                EditorGUI.indentLevel--;
            }

--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Handles.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeEditor.Handles.cs
        [DrawGizmo(GizmoType.Selected)]
        static void DrawSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
        {
+            var e = GetEditorFor(reflectionProbe);
+            if (e == null || !e.sceneViewEditing)
+                return;
+
            var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();

            Gizmos_Influence(reflectionProbe, reflectionData, null, false);
        [DrawGizmo(GizmoType.NonSelected)]
        static void DrawNonSelectedGizmo(ReflectionProbe reflectionProbe, GizmoType gizmoType)
        {
+            var e = GetEditorFor(reflectionProbe);
+            if (e == null || !e.sceneViewEditing)
+                return;
+                
            var reflectionData = reflectionProbe.GetComponent<HDAdditionalReflectionData>();
            if (reflectionData != null)
                HDReflectionProbeEditorUtility.ChangeVisibility(reflectionProbe, false);
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/HDReflectionProbeUI.Drawers.cs
        public static readonly CED.IDrawer[] Inspector;

        public static readonly CED.IDrawer SectionPrimarySettings = CED.Group(
-        
+
            CED.Action(Drawer_ReflectionProbeMode),
            CED.FadeGroup((s, p, o, i) => s.IsSectionExpandedMode((ReflectionProbeMode)i),
                FadeOption.Indent,
        static void Drawer_CaptureSettings(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor owner)
        {
            var renderPipelineAsset = (HDRenderPipelineAsset)GraphicsSettings.renderPipelineAsset;
-            p.resolution.intValue = renderPipelineAsset.GetRenderPipelineSettings().lightLoopSettings.reflectionCubemapSize;
+            p.resolution.intValue = (int)renderPipelineAsset.GetRenderPipelineSettings().lightLoopSettings.reflectionCubemapSize;
            EditorGUILayout.LabelField(CoreEditorUtils.GetContent("Resolution"), CoreEditorUtils.GetContent(p.resolution.intValue.ToString()));

            EditorGUILayout.PropertyField(p.shadowDistance, CoreEditorUtils.GetContent("Shadow Distance"));
            EditorGUI.showMixedValue = false;
            if (EditorGUI.EndChangeCheck())
                s.SetShapeTarget(p.influenceShape.intValue);
+
+            if (p.proxyVolumeComponent.objectReferenceValue != null)
+            {
+                var proxy = (ReflectionProxyVolumeComponent)p.proxyVolumeComponent.objectReferenceValue;
+                if ((int)proxy.proxyVolume.shapeType != p.influenceShape.enumValueIndex)
+                    EditorGUILayout.HelpBox(
+                        "Proxy volume and influence volume have different shape types, this is not supported.",
+                        MessageType.Error,
+                        true
+                    );
+            }
        }

        static void Drawer_IntensityMultiplier(HDReflectionProbeUI s, SerializedHDReflectionProbe p, Editor owner)
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Lighting/Reflection/PlanarReflectionProbeUI.Drawers.cs
                    (s, d, o) => d.influenceVolume,
                    InfluenceVolumeUI.SectionFoldoutShape
                ),
+                CED.Action(Drawer_DifferentShapeError),
                SectionFoldoutInfluenceSettings,
                SectionFoldoutCaptureSettings,
                CED.Select(
        {
            // EditorGUILayout.PropertyField(d.captureMirrorPlaneLocalPosition, _.GetContent("Plane Position"));
            // EditorGUILayout.PropertyField(d.captureMirrorPlaneLocalNormal, _.GetContent("Plane Normal"));
+        }
+
+        static void Drawer_DifferentShapeError(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
+        {
+            var proxy = d.proxyVolumeReference.objectReferenceValue as ReflectionProxyVolumeComponent;
+            if (proxy != null && (int)proxy.proxyVolume.shapeType != d.influenceVolume.shapeType.enumValueIndex)
+            {
+                EditorGUILayout.HelpBox(
+                    "Proxy volume and influence volume have different shape types, this is not supported.",
+                    MessageType.Error,
+                    true
+                );
+            }
        }

        static void Drawer_SectionCaptureSettings(PlanarReflectionProbeUI s, SerializedPlanarReflectionProbe d, Editor o)
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Decal/DecalProjectorComponentEditor.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Decal/DecalProjectorComponentEditor.cs
        private SerializedProperty m_MaterialProperty;
        private SerializedProperty m_DrawDistanceProperty;
        private SerializedProperty m_FadeScaleProperty;
+        private SerializedProperty m_UVScaleProperty;
+        private SerializedProperty m_UVBiasProperty;

        public class DecalBoundsHandle :  BoxBoundsHandle
        {
            m_MaterialProperty = serializedObject.FindProperty("m_Material");
            m_DrawDistanceProperty = serializedObject.FindProperty("m_DrawDistance");
            m_FadeScaleProperty = serializedObject.FindProperty("m_FadeScale");
+            m_UVScaleProperty = serializedObject.FindProperty("m_UVScale");
+            m_UVBiasProperty = serializedObject.FindProperty("m_UVBias");
        }

 		private void OnDisable()
            EditorGUILayout.PropertyField(m_MaterialProperty);
            EditorGUILayout.PropertyField(m_DrawDistanceProperty);
            EditorGUILayout.Slider(m_FadeScaleProperty, 0.0f, 1.0f, new GUIContent("Fade scale"));
+            EditorGUILayout.PropertyField(m_UVScaleProperty);
+            EditorGUILayout.PropertyField(m_UVBiasProperty);
            if (EditorGUI.EndChangeCheck())
            {
                serializedObject.ApplyModifiedProperties();
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/DiffusionProfile/DrawDiffusionProfile.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/DiffusionProfile/DrawDiffusionProfile.shader

            HLSLPROGRAM
            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

            #pragma vertex Vert
            #pragma fragment Frag
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/DiffusionProfile/DrawTransmittanceGraph.shader
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/DiffusionProfile/DrawTransmittanceGraph.shader

            HLSLPROGRAM
            #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 xboxone vulkan metal
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch

            #pragma vertex Vert
            #pragma fragment Frag
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/BaseMaterialUI.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/BaseMaterialUI.cs
            public abstract void OnFindProperty(MaterialProperty[] props);

            public abstract void OnGUI();
+
+            internal abstract string ToShaderPropertiesStringInternal();
        }

        public class GroupProperty : BaseProperty
            private readonly BaseProperty[] m_ChildProperties;
-
-            public bool Foldout = false;
+            private readonly Property m_Show;
-            public GroupProperty(BaseMaterialGUI parent, BaseProperty[] childProperties, Func<object, bool> isVisible = null)
-                : this(parent, string.Empty, childProperties, isVisible)
+            public GroupProperty(BaseMaterialGUI parent, string groupName, BaseProperty[] childProperties, Func<object, bool> isVisible = null)
+                : this(parent, groupName, string.Empty, childProperties, isVisible)
-            public GroupProperty(BaseMaterialGUI parent, string groupTitle, BaseProperty[] childProperties, Func<object, bool> isVisible = null)
+            public GroupProperty(BaseMaterialGUI parent, string groupName, string groupTitle, BaseProperty[] childProperties, Func<object, bool> isVisible = null)
+                m_Show = new Property(parent, groupName + "Show", "", false);
+
                m_Title = groupTitle;
                m_ChildProperties = childProperties;
            }
+                m_Show.OnFindProperty(props);
+
                foreach (var c in m_ChildProperties)
                {
                    c.OnFindProperty(props);
                {
                    if (!string.IsNullOrEmpty(m_Title))
                    {
-                        Foldout = EditorGUILayout.Foldout(Foldout, m_Title);
+                        m_Show.BoolValue = EditorGUILayout.Foldout(m_Show.BoolValue, m_Title);
-                    else
+                    else if (m_Show.IsValid)
-                        Foldout = true;
+                        m_Show.BoolValue = true;
-                    if (Foldout)
+                    if (!m_Show.IsValid || m_Show.BoolValue)
                    {
                        EditorGUI.indentLevel++;

                    }
                }
            }
+
+            internal override string ToShaderPropertiesStringInternal()
+            {
+                string outputString = string.Empty;
+
+                foreach (var c in m_ChildProperties)
+                {
+                    outputString += c.ToShaderPropertiesStringInternal() + "\n";
+                }
+
+                return outputString;
+            }
-         
+
-            protected MaterialProperty m_MaterialProperty = null;
+            public MaterialProperty m_MaterialProperty = null;

            protected readonly GUIContent m_GuiContent = null;

            {
                get { return m_MaterialProperty != null; }
            }
-        
+
            public float FloatValue
            {
                get { return m_MaterialProperty.floatValue; }
            public bool BoolValue
            {
-                get { return Math.Abs(m_MaterialProperty.floatValue) > 0.0f; }
+                get { return m_MaterialProperty == null || Math.Abs(m_MaterialProperty.floatValue) > 0.0f; }
                set { m_MaterialProperty.floatValue = value ? 1.0f : 0.0f; }
            }

                set { m_MaterialProperty.vectorValue = value; }
            }

-            public Property(BaseMaterialGUI parent, string propertyName, string guiText, bool isMandatory = true)
-                : this(parent, propertyName, guiText, string.Empty, isMandatory)
+            public Property(BaseMaterialGUI parent, string propertyName, string guiText, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : this(parent, propertyName, guiText, string.Empty, isMandatory, isVisible)
-            public Property(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true)
-                : base(parent)
+            public Property(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, isVisible)
            {
                m_GuiContent = new GUIContent(guiText, toolTip);
                PropertyName = propertyName;
                    Parent.m_MaterialEditor.ShaderProperty(m_MaterialProperty, m_GuiContent);
                }
            }
+
+            internal override string ToShaderPropertiesStringInternal()
+            {
+                if (IsValid
+                    && (IsVisible == null || IsVisible(this)))
+                {
+                    switch (m_MaterialProperty.type)
+                    {
+                        case MaterialProperty.PropType.Color:
+                            return string.Format("{0}(\"{1}\", Color) = (1, 1, 1, 1)", PropertyName, PropertyText);
+
+                        case MaterialProperty.PropType.Vector:
+                            return string.Format("{0}(\"{1}\", Vector) = (0, 0, 0, 0)", PropertyName, PropertyText);
+
+                        case MaterialProperty.PropType.Float:
+                            return string.Format("{0}(\"{1}\", Float) = 0.0", PropertyName, PropertyText);
+
+                        case MaterialProperty.PropType.Range:
+                            return string.Format("{0}(\"{1}\", Range({2:0.0###}, {3:0.0###})) = 0", PropertyName, PropertyText, m_MaterialProperty.rangeLimits.x, m_MaterialProperty.rangeLimits.y);
+
+                        case MaterialProperty.PropType.Texture:
+                            return string.Format("{0}(\"{1}\", 2D) = \"white\" {{}}", PropertyName, PropertyText);
+
+                        default:
+                            // Unknown type... default to outputting a float.
+                            return string.Format("{0}(\"{1}\", Float) = 0.0", PropertyName, PropertyText);
+                    }
+                }
+                else
+                {
+                    // Material property is not loaded, default to outputting a float.
+                    return string.Format("{0}(\"{1}\", Float) = 0.0", PropertyName, PropertyText);
+                }
+            }
        }

        public class ComboProperty : Property

-            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string[] options, bool isMandatory = true)
-                : base(parent, propertyName, guiText, isMandatory)
+            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string[] options, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, isMandatory, isVisible)
-            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, string[] options, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, string[] options, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
-            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string[] options, int[] values, bool isMandatory = true)
-                : base(parent, propertyName, guiText, isMandatory)
+            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string[] options, int[] values, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, isMandatory, isVisible)
-            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, string[] options, int[] values, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public ComboProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, string[] options, int[] values, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
            {
                m_Options = options;
                m_Values = values;

        public class DiffusionProfileProperty : Property
        {
-            public DiffusionProfileProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public DiffusionProfileProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
            {
            }


            private MaterialProperty m_ExtraProperty;

-            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string guiText, bool isMandatory = true)
-                : base(parent, propertyName, guiText, isMandatory)
+            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string guiText, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, isMandatory, isVisible)
-            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string guiText, string toolTip, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
-            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string extraPropertyName, string guiText, string toolTip, bool isMandatory = true)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public TextureOneLineProperty(BaseMaterialGUI parent, string propertyName, string extraPropertyName, string guiText, string toolTip, bool isMandatory = true, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
            {
                ExtraPropertyName = extraPropertyName;
            }
                    Parent.m_MaterialEditor.TexturePropertySingleLine(m_GuiContent, m_MaterialProperty, m_ExtraProperty);
                }
            }
+
+            internal override string ToShaderPropertiesStringInternal()
+            {
+                return string.Format("{0}(\"{1}\", 2D) = \"white\" {{}}\n" +
+                                     "{2}(\"{3}\", Float) = 0.0",
+                                     PropertyName, PropertyText,
+                                     ExtraPropertyName, ExtraPropertyName);
+            }
        }

        public class TextureProperty : Property
                A,
            }

+            public enum PlanarSpace
+            {
+                World,
+                Local
+            }
+
+            public enum NormalSpace
+            {
+                Tangent,
+                Object
+            }
+
            public enum UVMapping
            {
                UV0,
                Triplanar,
            }

+            public Property m_Show;
+
+            public Property m_ConstantProperty;
+
-            public Property m_LocalOrWorldProperty;
+            public ComboProperty m_LocalOrWorldProperty;
-            public ComboProperty m_TilingProperty;
+            public ComboProperty m_NormalSpaceProperty;

            public Property m_ChannelProperty;


-            public bool Foldout = false;
+            public string m_ConstantPropertyName;
+
+            public bool m_IsNormalMap;
-            public TextureProperty(BaseMaterialGUI parent, string propertyName, string constantPropertyName, string guiText, bool isMandatory = true, bool isNormalMap = false)
-                : this(parent, propertyName, constantPropertyName, guiText, string.Empty, isMandatory, isNormalMap)
+            public TextureProperty(BaseMaterialGUI parent, string propertyName, string constantPropertyName, string guiText, bool useConstantAsTint, bool isMandatory = true, bool isNormalMap = false, Func<object, bool> isVisible = null)
+                : this(parent, propertyName, constantPropertyName, guiText, string.Empty, useConstantAsTint, isMandatory, isNormalMap, isVisible)
-            public TextureProperty(BaseMaterialGUI parent, string propertyName, string constantPropertyName, string guiText, string toolTip, bool isMandatory = true, bool isNormalMap = false)
-                : base(parent, propertyName, guiText, toolTip, isMandatory)
+            public TextureProperty(BaseMaterialGUI parent, string propertyName, string constantPropertyName, string guiText, string toolTip, bool useConstantAsTint, bool isMandatory = true, bool isNormalMap = false, Func<object, bool> isVisible = null)
+                : base(parent, propertyName, guiText, toolTip, isMandatory, isVisible)
-                m_TextureProperty = new TextureOneLineProperty(parent, propertyName, constantPropertyName, guiText, toolTip, isMandatory);
+                m_IsNormalMap = isNormalMap;
+
+                m_ConstantPropertyName = constantPropertyName;
+
+                m_Show = new Property(parent, propertyName + "Show", "", isMandatory);
+
+                if (useConstantAsTint == false)
+                {
+                    m_ConstantProperty = new Property(parent, constantPropertyName, guiText, toolTip, isMandatory);
+                }
+
+                m_TextureProperty = new TextureOneLineProperty(parent, propertyName, useConstantAsTint ? constantPropertyName : string.Empty, guiText, toolTip, isMandatory);
-                m_LocalOrWorldProperty = new Property(parent, propertyName + "LocalOrWorld", "Local Space", "Whether Planar or Triplanar is using Local or World space.", false);
+                m_LocalOrWorldProperty = new ComboProperty(parent, propertyName + "UVLocal", "Local or world", Enum.GetNames(typeof(PlanarSpace)), false);
+
+                m_NormalSpaceProperty = new ComboProperty(parent, propertyName + "ObjSpace", "Normal space", Enum.GetNames(typeof(NormalSpace)), false);
-                m_TilingProperty = new ComboProperty(parent, propertyName + "Tiling", "Tiling", Enum.GetNames(typeof(Tiling)), false);
-                m_ChannelProperty = new Property(parent, propertyName + "Channel", "Channel", false);
+                m_ChannelProperty = new ComboProperty(parent, propertyName + "Channel", "Channel", Enum.GetNames(typeof(Channel)), false);

                m_RemapProperty = new Property(parent, constantPropertyName + "Remap", "Remapping", "Defines the range to remap/scale the values in texture", false);
                m_InvertRemapProperty = new Property(parent, constantPropertyName + "RemapInverted", "Invert Remapping", "Whether the mapping values are inverted.", false);
            {
                base.OnFindProperty(props);

+                m_Show.OnFindProperty(props);
+                if (m_ConstantProperty != null)
+                {
+                    m_ConstantProperty.OnFindProperty(props);
+                }
-                m_TilingProperty.OnFindProperty(props);
+                m_NormalSpaceProperty.OnFindProperty(props);
                m_ChannelProperty.OnFindProperty(props);
                m_RemapProperty.OnFindProperty(props);
                m_InvertRemapProperty.OnFindProperty(props);
            {
-                if (m_TextureProperty.IsValid
-                    && (IsVisible == null || IsVisible(this)))
+                if ((IsVisible == null || IsVisible(this))
+                    && m_Show.IsValid
+                    && m_TextureProperty.IsValid)
-                    Foldout = EditorGUILayout.Foldout(Foldout, PropertyText);
-                    if (Foldout)
+                    m_Show.BoolValue = EditorGUILayout.Foldout(m_Show.BoolValue, PropertyText);
+
+                    if (m_Show.BoolValue)
+                        if (m_ConstantProperty != null && m_ConstantProperty.IsValid
+                            && m_TextureProperty.TextureValue == null)
+                        {
+                            m_ConstantProperty.OnGUI();
+                        }

                        m_TextureProperty.OnGUI();

-                            m_LocalOrWorldProperty.OnGUI();
-                            m_TilingProperty.OnGUI();
-                            m_LocalOrWorldProperty.OnGUI();
+
+                            Parent.m_MaterialEditor.TextureScaleOffsetProperty(m_TextureProperty.m_MaterialProperty);
+
+                            if (m_UvSetProperty.FloatValue >= (float)UVMapping.PlanarXY)
+                            {
+                                m_LocalOrWorldProperty.OnGUI();
+                            }
+
+                            if (m_IsNormalMap)
+                            {
+                                m_NormalSpaceProperty.OnGUI();
+                            }

                            if (m_RemapProperty.IsValid)
                            {
-                                EditorGUILayout.MinMaxSlider(m_RemapProperty.PropertyText, ref remap.x, ref remap.y,
-                                    0.0f, 1.0f);
+                                EditorGUILayout.MinMaxSlider(m_RemapProperty.PropertyText, ref remap.x, ref remap.y, 0.0f, 1.0f);
-                                m_InvertRemapProperty.OnGUI();
+                                if (m_InvertRemapProperty.IsValid)
+                                {
+                                    m_InvertRemapProperty.OnGUI();
+                                }
                            }
                        }

            }
-        }
+
+            internal override string ToShaderPropertiesStringInternal()
+            {
+                string constantName = m_ConstantPropertyName.StartsWith("_")
+                    ? m_ConstantPropertyName.Substring(1)
+                    : m_ConstantPropertyName;
+
+                return string.Format(
+                    "[HideInInspector] {0}MapShow(\"{1} Show\", Float) = 0\n" +
+                    "{0}(\"{1}\", Range(0.0, 1.0)) = 0\n" +
+                    "{2}(\"{1} Map\", 2D) = " + (m_IsNormalMap ? "\"bump\"" : "\"white\"") + " {{ }}\n" +
+                    "{0}UseMap(\"{1} Use Map\", Float) = 0\n" +
+                    (m_IsNormalMap ? "{0}ObjSpace(\"{1} Object Space\", Float) = 0\n" : "") +
+                    "{2}UV(\"{1} Map UV\", Float) = 0.0\n" +
+                    "{2}UVLocal(\"{1} Map UV Local\", Float) = 0.0\n" +
+                    "{2}Channel(\"{1} Map Channel\", Float) = 0.0\n" +
+                    "{2}ChannelMask(\"{1} Map Channel Mask\", Vector) = (1, 0, 0, 0)\n" +
+                    "{0}Remap(\"{1} Remap\", Vector) = (0, 1, 0, 0)\n" +
+                    "[ToggleUI] {0}RemapInverted(\"Invert {1} Remap\", Float) = 0.0\n" +
+                    "[HideInInspector] {0}Range(\"{1} Range\", Vector) = (0, 1, 0, 0)\n",
+                    m_ConstantPropertyName, constantName, PropertyName);
+            }
+    }
        #endregion
    }
 }
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/StackLitUI.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/StackLit/StackLitUI.cs
 using UnityEngine;
 using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+        protected static class StylesStackLit
+        {
+            public static GUIContent useLocalPlanarMapping = new GUIContent("Use Local Planar Mapping", "Use local space for planar/triplanar mapping instead of world space");
+        };
+
        #region Strings

        protected const string k_DoubleSidedNormalMode = "_DoubleSidedNormalMode";
        // Base
        protected const string k_BaseColor = "_BaseColor";
        protected const string k_BaseColorMap = "_BaseColorMap";
+        protected const string k_BaseColorMapUV = "_BaseColorMapUV";
-        protected const string k_MetallicRemapMin = "_MetallicRemap";
+        protected const string k_MetallicMapUV = "_MetallicMapUV";
-        protected const string k_Smoothness1 = "_SmoothnessA";
-        protected const string k_Smoothness1Map = "_SmoothnessAMap";
-        protected const string k_Smoothness1RemapMin = "_SmoothnessARemap";
+        protected const string k_DielectricIor = "_DielectricIor";
+
+        protected const string k_SmoothnessA = "_SmoothnessA";
+        protected const string k_SmoothnessAMap = "_SmoothnessAMap";
+        protected const string k_SmoothnessAMapUV = "_SmoothnessAMapUV";
+        protected const string k_NormalMapUV = "_NormalMapUV";
+        protected const string k_AmbientOcclusion = "_AmbientOcclusion";
+        protected const string k_AmbientOcclusionMap = "_AmbientOcclusionMap";
+        protected const string k_AmbientOcclusionMapUV = "_AmbientOcclusionMapUV";
+
+        protected const string k_EmissiveColorMapUV = "_EmissiveColorMapUV";
+        // Coat
+        protected const string k_EnableCoat = "_EnableCoat";
+        protected const string k_CoatSmoothness = "_CoatSmoothness";
+        protected const string k_CoatSmoothnessMap = "_CoatSmoothnessMap";
+        protected const string k_CoatSmoothnessMapUV = "_CoatSmoothnessMapUV";
+        protected const string k_CoatIor = "_CoatIor";
+        protected const string k_CoatThickness = "_CoatThickness";
+        protected const string k_CoatExtinction = "_CoatExtinction";
+        protected const string k_EnableCoatNormalMap = "_EnableCoatNormalMap";
+        protected const string k_CoatNormalMap = "_CoatNormalMap";
+        protected const string k_CoatNormalMapUV = "_CoatNormalMapUV";
+        protected const string k_CoatNormalScale = "_CoatNormalScale";
+
-        protected const string k_DiffusionProfileName = "_DiffusionProfile";
-        protected const string k_SubsurfaceMaskName = "_SubsurfaceMask";
+        protected const string k_EnableSubsurfaceScattering = "_EnableSubsurfaceScattering";
+        protected const string k_DiffusionProfile = "_DiffusionProfile";
+        protected const string k_SubsurfaceMask = "_SubsurfaceMask";
+        protected const string k_SubsurfaceMaskMapUV = "_SubsurfaceMaskMapUV";
-        protected const string k_ThicknessName = "_Thickness";
-        protected const string k_ThicknessMapName = "_ThicknessMap";
-        protected const string k_ThicknessRemapName = "_ThicknessRemap";
+        // Translucency
+        protected const string k_EnableTransmission = "_EnableTransmission";
+        protected const string k_Thickness = "_Thickness";
+        protected const string k_ThicknessMap = "_ThicknessMap";
+        protected const string k_ThicknessMapUV = "_ThicknessMapUV";
-        protected const string k_Smoothness2 = "_SmoothnessB";
-        protected const string k_Smoothness2Map = "_SmoothnessBMap";
-        protected const string k_SmoothnessRemap2Min = "_SmoothnessBRemap";
+        protected const string k_EnableDualSpecularLobe = "_EnableDualSpecularLobe";
+        protected const string k_SmoothnessB = "_SmoothnessB";
+        protected const string k_SmoothnessBMap = "_SmoothnessBMap";
+        protected const string k_SmoothnessBMapUV = "_SmoothnessBMapUV";
-        //// transparency params
-        //protected MaterialProperty transmissionEnable = null;
-        //protected const string kTransmissionEnable = "_TransmissionEnable";
+        // Anisotropy
+        protected const string k_EnableAnisotropy = "_EnableAnisotropy";
+        protected const string k_Anisotropy = "_Anisotropy";
+        protected const string k_AnisotropyMap = "_AnisotropyMap";
+        protected const string k_AnisotropyMapUV = "_AnisotropyMapUV";
+
+        // Iridescence
+        protected const string k_EnableIridescence = "_EnableIridescence";
+        protected const string k_IridescenceIor = "_IridescenceIor";
+        protected const string k_IridescenceThickness = "_IridescenceThickness";
+        protected const string k_IridescenceThicknessMap = "_IridescenceThicknessMap";
+        protected const string k_IridescenceThicknessMapUV = "_IridescenceThicknessMapUV";
+
+        // Stencil is use to control lighting mode (regular, split lighting)
+        protected const string kStencilRef = "_StencilRef";
+        protected const string kStencilWriteMask = "_StencilWriteMask";
+        protected const string kStencilRefMV = "_StencilRefMV";
+        protected const string kStencilWriteMaskMV = "_StencilWriteMaskMV";
+
+        protected const string k_SpecularAntiAliasingEnabled = "_SpecularAntiAliasingEnabled";
+        protected const string k_NormalCurvatureToRoughnessEnabled = "_NormalCurvatureToRoughnessEnabled";
-        //protected MaterialProperty ior = null;
-        //protected const string kIor = "_Ior";
-        //protected MaterialProperty transmittanceColor = null;
-        //protected const string kTransmittanceColor = "_TransmittanceColor";
-        //protected MaterialProperty transmittanceColorMap = null;
-        //protected const string kTransmittanceColorMap = "_TransmittanceColorMap";
-        //protected MaterialProperty atDistance = null;
-        //protected const string kATDistance = "_ATDistance";
-        //protected MaterialProperty thicknessMultiplier = null;
-        //protected const string kThicknessMultiplier = "_ThicknessMultiplier";
-        //protected MaterialProperty refractionModel = null;
-        //protected const string kRefractionModel = "_RefractionModel";
-        //protected MaterialProperty refractionSSRayModel = null;
-        //protected const string kRefractionSSRayModel = "_RefractionSSRayModel";
        #endregion

        // Add the properties into an array.
+        private Property EnableSSS;
+        private Property EnableTransmission;
+        private Property EnableCoat;
+        private Property EnableCoatNormalMap;
+        private Property EnableAnisotropy;
+        private Property EnableDualSpecularLobe;
+        private Property EnableIridescence;
+
+        private Property EnableSpecularAA;
+        private Property EnableNormalCurvatureToRoughness;
+
-            _baseMaterialProperties = new GroupProperty(this, new BaseProperty[]
+            _baseMaterialProperties = new GroupProperty(this, "_BaseMaterial", new BaseProperty[]
-                new Property(this, k_DoubleSidedNormalMode, "Normal mode", "This will modify the normal base on the selected mode. Mirror: Mirror the normal with vertex normal plane, Flip: Flip the normal.", false), 
+                new Property(this, k_DoubleSidedNormalMode, "Normal mode", "This will modify the normal base on the selected mode. Mirror: Mirror the normal with vertex normal plane, Flip: Flip the normal.", false),
-            _materialProperties = new GroupProperty(this, new BaseProperty[]
+            //
+            EnableSSS = new Property(this, k_EnableSubsurfaceScattering, "Enable Subsurface Scattering", "Enable Subsurface Scattering", true);
+            EnableTransmission = new Property(this, k_EnableTransmission, "Enable Transmission", "Enable Transmission", true);
+            EnableCoat = new Property(this, k_EnableCoat, "Enable Coat", "Enable coat layer with true vertical physically based BSDF mixing", true);
+            EnableCoatNormalMap = new Property(this, k_EnableCoatNormalMap, "Enable Coat Normal Map", "Enable separate top coat normal map", true);
+            EnableAnisotropy = new Property(this, k_EnableAnisotropy, "Enable Anisotropy", "Enable anisotropy, correct anisotropy for punctual light but very coarse approximated for reflection", true);
+            EnableDualSpecularLobe = new Property(this, k_EnableDualSpecularLobe, "Enable Dual Specular Lobe", "Enable a second specular lobe, aim to simulate a mix of a narrow and a haze lobe that better match measured material", true);
+            EnableIridescence = new Property(this, k_EnableIridescence, "Enable Iridescence", "Enable physically based iridescence layer", true);
+
+            EnableSpecularAA = new Property(this, k_SpecularAntiAliasingEnabled, k_SpecularAntiAliasingEnabled, k_SpecularAntiAliasingEnabled, true);
+            EnableNormalCurvatureToRoughness = new Property(this, k_NormalCurvatureToRoughnessEnabled, k_NormalCurvatureToRoughnessEnabled, k_NormalCurvatureToRoughnessEnabled, true);
+
+            // All material properties
+            _materialProperties = new GroupProperty(this, "_Material", new BaseProperty[]
-                new GroupProperty(this, "Standard", new BaseProperty[]
+                new GroupProperty(this, "_MaterialFeatures", "Material Features", new BaseProperty[]
-                    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Base Color + Opacity", "Albedo (RGB) and Opacity (A)", false),
-                    new TextureProperty(this, k_MetallicMap, k_Metallic, "Metallic", "Metallic", false), 
-                    new TextureProperty(this, k_Smoothness1Map, k_Smoothness1, "Smoothness", "Smoothness", false),
-                    // TODO: Special case for normal maps.
-                    new TextureProperty(this, k_NormalMap, k_NormalScale, "Normal TODO", "Normal Map", false, true),
-
-                    //new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Dielectric IoR", "Index of Refraction for Dielectric", false),
+                    EnableDualSpecularLobe,
+                    EnableAnisotropy,
+                    EnableCoat,
+                    EnableCoatNormalMap,
+                    EnableIridescence,
+                    EnableSSS,
+                    EnableTransmission
-                new GroupProperty(this, "Emissive", new BaseProperty[]
+                new GroupProperty(this, "_Standard", "Standard", new BaseProperty[]
-                    new TextureProperty(this, k_EmissiveColorMap, k_EmissiveColor, "Emissive Color", "Emissive", false),
-                    new Property(this, k_EmissiveIntensity, "Emissive Intensity", "Emissive", false),
-                    new Property(this, k_AlbedoAffectEmissive, "Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo.", false),
+                    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Base Color + Opacity", "Albedo (RGB) and Opacity (A)", true, false),
+                    new TextureProperty(this, k_MetallicMap, k_Metallic, "Metallic", "Metallic", false, false),
+                    new Property(this, k_DielectricIor, "DieletricIor", "IOR use for dielectric material (i.e non metallic material)", false),
+                    new TextureProperty(this, k_SmoothnessAMap, k_SmoothnessA, "Smoothness", "Smoothness", false, false),
+                    new TextureProperty(this, k_NormalMap, k_NormalScale, "Normal", "Normal Map", true, false, true),
+                    new TextureProperty(this, k_AmbientOcclusionMap, k_AmbientOcclusion, "AmbientOcclusion", "AmbientOcclusion Map", false, false),
-                //new GroupProperty(this, "Coat", new BaseProperty[]
-                //{
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "SmoothnessCoat", "smoothnessCoat", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Index Of Refraction", "iorCoat", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Normal", "normal Coat", false),
-                //}),
+                new GroupProperty(this, "_DualSpecularLobe", "Dual Specular Lobe", new BaseProperty[]
+                {
+                    new TextureProperty(this, k_SmoothnessBMap, k_SmoothnessB, "Smoothness B", "Smoothness B", false, false),
+                    new Property(this, k_LobeMix, "Lobe Mix", "Lobe Mix", false),
+                }, _ => EnableDualSpecularLobe.BoolValue == true),
-                new GroupProperty(this, "Sub-Surface Scattering", new BaseProperty[]
+                new GroupProperty(this, "_Anisotropy", "Anisotropy", new BaseProperty[]
-                    new DiffusionProfileProperty(this, k_DiffusionProfileName, "Diffusion Profile", "A profile determines the shape of the SSS/transmission filter.", false),
-                    new TextureProperty(this, k_SubsurfaceMaskName, "Subsurface mask map (R)", "Determines the strength of the subsurface scattering effect.", false),
-                }/*, _ => _materialId == MaterialId.SubSurfaceScattering*/),
+                    new Property(this, k_Anisotropy, "Anisotropy", "Anisotropy of base layer", false),
+                    // TODO: Tangent map and rotation
+                }, _ => EnableAnisotropy.BoolValue == true),
+
+                new GroupProperty(this, "_Coat", "Coat", new BaseProperty[]
+                {
+                    new TextureProperty(this, k_CoatSmoothnessMap, k_CoatSmoothness, "Coat smoothness", "Coat smoothness", false),
+                    new TextureProperty(this, k_CoatNormalMap, k_CoatNormalScale, "Coat Normal Map", "Coat Normal Map", true, false, true,  _ => EnableCoatNormalMap.BoolValue == true),
+                    new Property(this, "_CoatIor", "Coat IOR", "Index of refraction", false),
+                    new Property(this, "_CoatThickness", "Coat Thickness", "Coat thickness", false),
+                    new Property(this, "_CoatExtinction", "Coat Absorption", "Coat absorption tint (the thicker the coat, the more that color is removed)", false),
+                }, _ =>EnableCoat.BoolValue == true),
-                new GroupProperty(this, "Second Specular Lobe", new BaseProperty[]
+                new GroupProperty(this, "_Iridescence", "Iridescence", new BaseProperty[]
-                    new TextureProperty(this, k_Smoothness2Map, k_Smoothness2, "Smoothness2", "Smoothness2", false),
-                    new Property(this, k_LobeMix, "Lobe Mix", "Lobe Mix", false), 
-                }),
+                    new Property(this, "_IridescenceIor", "IOR", "Index of refraction of iridescence layer", false),
+                    new Property(this, "_IridescenceThickness", "Thickness", "Iridescence thickness (Remap to 0..3000nm)", false),
+                }, _ => EnableIridescence.BoolValue == true),
-                //new GroupProperty(this, "Anisotropy", new BaseProperty[]
-                //{
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Anisotropy Strength", "anisotropy strength", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Rotation", "rotation", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Tangent", "tangent", false),
-                //}),
+                new GroupProperty(this, "_SSS", "Sub-Surface Scattering", new BaseProperty[]
+                {
+                    new DiffusionProfileProperty(this, k_DiffusionProfile, "Diffusion Profile", "A profile determines the shape of the SSS/transmission filter.", false),
+                    new TextureProperty(this, k_SubsurfaceMaskMap, k_SubsurfaceMask, "Subsurface mask map (R)", "Determines the strength of the subsurface scattering effect.", false, false),
+                }, _ => EnableSSS.BoolValue == true ),
-                new GroupProperty(this, "Transmission", new BaseProperty[]
+                new GroupProperty(this, "_Transmission", "Transmission", new BaseProperty[]
-                    new DiffusionProfileProperty(this, k_DiffusionProfileName, "Diffusion Profile", "A profile determines the shape of the SSS/transmission filter.", false),
-                    new TextureProperty(this, k_ThicknessName, "Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.", false),
+                    new DiffusionProfileProperty(this, k_DiffusionProfile, "Diffusion Profile", "A profile determines the shape of the SSS/transmission filter.", false, _ => EnableSSS.BoolValue == false),
+                    new TextureProperty(this, k_ThicknessMap, k_Thickness, "Thickness", "If subsurface scattering is enabled, low values allow some light to be transmitted through the object.", false),
+                }, _ => EnableTransmission.BoolValue == true),
+
+                new GroupProperty(this, "_Emissive", "Emissive", new BaseProperty[]
+                {
+                    new TextureProperty(this, k_EmissiveColorMap, k_EmissiveColor, "Emissive Color", "Emissive", true, false),
+                    new Property(this, k_EmissiveIntensity, "Emissive Intensity", "Emissive", false),
+                    new Property(this, k_AlbedoAffectEmissive, "Albedo Affect Emissive", "Specifies whether or not the emissive color is multiplied by the albedo.", false),
-                //new GroupProperty(this, "Iridescence", new BaseProperty[]
-                //{
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Index of Refraction", "Index of Refraction for Iridescence", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Thickness", "Thickness", false),
-                //}),
+                new GroupProperty(this, "_Debug", "Debug", new BaseProperty[]
+                {
+                    new Property(this, "_VlayerRecomputePerLight", "Vlayer Recompute Per Light", "", false),
+                    new Property(this, "_VlayerUseRefractedAnglesForBase", "Vlayer Use Refracted Angles For Base", "", false),
+                    new Property(this, "_DebugEnable", "Debug Enable", "Switch to a debug version of the shader", false),
+                    new Property(this, "_DebugEnvLobeMask", "DebugEnvLobeMask", "xyz is Environments Lobe 0 1 2 Enable, w is Enable VLayering", false),
+                    new Property(this, "_DebugLobeMask", "DebugLobeMask", "xyz is Analytical Lobe 0 1 2 Enable", false),
+                    new Property(this, "_DebugAniso", "DebugAniso", "x is Hack Enable, y is factor", false),
-                //new GroupProperty(this, "Glint", new BaseProperty[]
-                //{
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Density", "Density:", false),
-                //    new TextureProperty(this, k_BaseColorMap, k_BaseColor, "Tint", "Tint", false),
-                //}),
+                    EnableSpecularAA,
+                    new Property(this, "_SpecularAntiAliasingScreenSpaceVariance", "Specular Aliasing Enable", "Specular Aliasing Enable", false, _ => EnableSpecularAA.BoolValue == true),
+                    new Property(this, "_SpecularAntiAliasingThreshold", "Specular Aliasing Enable", "Specular Aliasing Enable", false, _ => EnableSpecularAA.BoolValue == true),
+
+                    EnableNormalCurvatureToRoughness,
+                    new Property(this, "_NormalCurvatureToRoughnessScale", "Normal Curvature To Roughness Scale", "Normal Curvature To Roughness Scale", false, _ => EnableNormalCurvatureToRoughness.BoolValue == true),
+                    new Property(this, "_NormalCurvatureToRoughnessBias", "Normal Curvature To Roughness Bias", "Normal Curvature To Roughness Bias", false, _ => EnableNormalCurvatureToRoughness.BoolValue == true),
+                    new Property(this, "_NormalCurvatureToRoughnessExponent", "Normal Curvature To Roughness Exponent", "Normal Curvature To Roughness Exponent", false, _ => EnableNormalCurvatureToRoughness.BoolValue == true),
+
+                }),
            });
        }

        {
            //base.FindMaterialProperties(props);
            _materialProperties.OnFindProperty(props);
-            }
+        }

        protected override void BaseMaterialPropertiesGUI()
        {

        protected override void MaterialPropertiesGUI(Material material)
        {
+            //if (GUILayout.Button("Generate All Properties"))
+            //{
+            //    Debug.Log(_materialProperties.ToShaderPropertiesStringInternal());
+            //}
+
            _materialProperties.OnGUI();
        }

            SetupMaterialKeywordsAndPass(material);
        }

+        protected static void SetupTextureMaterialProperty(Material material, string basePropertyName)
+        {
+            // TODO: Caution this can generate a lot of garbage collection call ?
+            string useMapPropertyName = basePropertyName + "UseMap";
+            string mapPropertyName = basePropertyName + "Map";
+            string remapPropertyName = basePropertyName + "Remap";
+            string invertPropertyName = basePropertyName + "RemapInverted";
+            string rangePropertyName = basePropertyName + "Range";
+            string channelPropertyName = basePropertyName + "MapChannel";
+            string channelMaskPropertyName = basePropertyName + "MapChannelMask";
+
+            if (material.GetTexture(mapPropertyName))
+            {
+                Vector4 rangeVector = material.GetVector(remapPropertyName);
+                if (material.HasProperty(invertPropertyName) && material.GetFloat(invertPropertyName) > 0.0f)
+                {
+                    float s = rangeVector.x;
+                    rangeVector.x = rangeVector.y;
+                    rangeVector.y = s;
+                }
+
+                material.SetFloat(useMapPropertyName, 1.0f);
+                material.SetVector(rangePropertyName, rangeVector);
+
+                int channel = (int)material.GetFloat(channelPropertyName);
+                switch (channel)
+                {
+                case 0:
+                    material.SetVector(channelMaskPropertyName, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
+                    break;
+                case 1:
+                    material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
+                    break;
+                case 2:
+                    material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 0.0f, 1.0f, 0.0f));
+                    break;
+                case 3:
+                    material.SetVector(channelMaskPropertyName, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+                    break;
+                }
+            }
+            else
+            {
+                material.SetFloat(useMapPropertyName, 0.0f);
+                material.SetVector(rangePropertyName, new Vector4(0.0f, 1.0f, 0.0f, 0.0f));
+                material.SetVector(channelMaskPropertyName, new Vector4(1.0f, 0.0f, 0.0f, 0.0f));
+            }
+        }
+
-        static public void SetupMaterialKeywordsAndPass(Material material)
+        public static void SetupMaterialKeywordsAndPass(Material material)
        {
            //TODO see BaseLitUI.cs:SetupBaseLitKeywords (stencil etc)
            SetupBaseUnlitKeywords(material);

            if (doubleSidedEnable)
            {
-                BaseLitGUI.DoubleSidedNormalMode doubleSidedNormalMode = (BaseLitGUI.DoubleSidedNormalMode)material.GetFloat(k_DoubleSidedNormalMode);
+                BaseLitGUI.DoubleSidedNormalMode doubleSidedNormalMode =
+                    (BaseLitGUI.DoubleSidedNormalMode) material.GetFloat(k_DoubleSidedNormalMode);
                switch (doubleSidedNormalMode)
                {
                    case BaseLitGUI.DoubleSidedNormalMode.Mirror: // Mirror mode (in tangent space)
                }
            }

-            //NOTE: For SSS in forward and split lighting, obviously we don't have a gbuffer pass, 
-            // so no stencil tagging there, but velocity? To check...
-
            //TODO: stencil state, displacement, wind, depthoffset, tessellation

            SetupMainTexForAlphaTestGI("_BaseColorMap", "_BaseColor", material);
-            CoreUtils.SetKeyword(material, "_NORMALMAP_TANGENT_SPACE", true);
-            CoreUtils.SetKeyword(material, "_NORMALMAP", material.GetTexture(k_NormalMap));
-            CoreUtils.SetKeyword(material, "_SMOOTHNESSMASKMAPA", material.GetTexture(k_Smoothness1Map));
-            CoreUtils.SetKeyword(material, "_SMOOTHNESSMASKMAPB", material.GetTexture(k_Smoothness2Map));
-            CoreUtils.SetKeyword(material, "_METALLICMAP", material.GetTexture(k_MetallicMap));
-            CoreUtils.SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(k_EmissiveColorMap));
+            SetupTextureMaterialProperty(material, k_Metallic);
+            SetupTextureMaterialProperty(material, k_SmoothnessA);
+            SetupTextureMaterialProperty(material, k_SmoothnessB);
+            SetupTextureMaterialProperty(material, k_AmbientOcclusion);
+            SetupTextureMaterialProperty(material, k_SubsurfaceMask);
+            SetupTextureMaterialProperty(material, k_Thickness);
+            SetupTextureMaterialProperty(material, k_Anisotropy);
+            SetupTextureMaterialProperty(material, k_IridescenceThickness);
+            SetupTextureMaterialProperty(material, k_CoatSmoothness);
-            //bool needUV2 = (LitGUI.UVBaseMapping)material.GetFloat(k_UVBase) == LitGUI.UVBaseMapping.UV2;
-            //bool needUV3 = (LitGUI.UVBaseMapping)material.GetFloat(k_UVBase) == LitGUI.UVBaseMapping.UV3;
+            // Check if we are using specific UVs.
+            TextureProperty.UVMapping[] uvIndices = new[]
+            {
+                (TextureProperty.UVMapping) material.GetFloat(k_BaseColorMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_MetallicMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_NormalMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_SmoothnessAMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_SmoothnessBMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_AmbientOcclusionMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_EmissiveColorMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_SubsurfaceMaskMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_ThicknessMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_AnisotropyMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_IridescenceThicknessMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_CoatSmoothnessMapUV),
+                (TextureProperty.UVMapping) material.GetFloat(k_CoatNormalMapUV),
+            };
-            //if (needUV3)
-            //{
-            //    material.DisableKeyword("_REQUIRE_UV2");
-            //    material.EnableKeyword("_REQUIRE_UV3");
-            //}
-            //else if (needUV2)
-            //{
-            //    material.EnableKeyword("_REQUIRE_UV2");
-            //    material.DisableKeyword("_REQUIRE_UV3");
-            //}
-            //else
-            //{
-            //    material.DisableKeyword("_REQUIRE_UV2");
-            //    material.DisableKeyword("_REQUIRE_UV3");
-            //}
+            // Set keyword for mapping
-            CoreUtils.SetKeyword(material, "_EMISSIVE_COLOR_MAP", material.GetTexture(k_EmissiveColorMap));
+            //bool requireUv2 = false;
+            //bool requireUv3 = false;
+            bool requireTriplanar = false;
+            for (int i = 0; i < uvIndices.Length; ++i)
+            {
+                //requireUv2 = requireUv2 || uvIndices[i] == TextureProperty.UVMapping.UV2;
+                //requireUv3 = requireUv3 || uvIndices[i] == TextureProperty.UVMapping.UV3;
+                requireTriplanar = requireTriplanar || uvIndices[i] == TextureProperty.UVMapping.Triplanar;
+            }
+            CoreUtils.SetKeyword(material, "_USE_TRIPLANAR", requireTriplanar);
+
+            bool dualSpecularLobeEnabled = material.HasProperty(k_EnableDualSpecularLobe) && material.GetFloat(k_EnableDualSpecularLobe) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_DUAL_SPECULAR_LOBE", dualSpecularLobeEnabled);
+
+            bool anisotropyEnabled = material.HasProperty(k_EnableAnisotropy) && material.GetFloat(k_EnableAnisotropy) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_ANISOTROPY", anisotropyEnabled);
+
+            bool iridescenceEnabled = material.HasProperty(k_EnableIridescence) && material.GetFloat(k_EnableIridescence) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_IRIDESCENCE", iridescenceEnabled);
+
+            bool transmissionEnabled = material.HasProperty(k_EnableTransmission) && material.GetFloat(k_EnableTransmission) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_TRANSMISSION", transmissionEnabled);
+
+            bool sssEnabled = material.HasProperty(k_EnableSubsurfaceScattering) && material.GetFloat(k_EnableSubsurfaceScattering) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_SUBSURFACE_SCATTERING", sssEnabled);
+
+            bool coatEnabled = material.HasProperty(k_EnableCoat) && material.GetFloat(k_EnableCoat) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_COAT", coatEnabled);
+
+            bool coatNormalMapEnabled = material.HasProperty(k_EnableCoatNormalMap) && material.GetFloat(k_EnableCoatNormalMap) > 0.0f;
+            CoreUtils.SetKeyword(material, "_MATERIAL_FEATURE_COAT_NORMALMAP", coatNormalMapEnabled);
+
+            // TEMP - Remove once dev is finish
+            bool debugEnabled = material.HasProperty("_DebugEnable") && material.GetFloat("_DebugEnable") > 0.0f;
+            CoreUtils.SetKeyword(material, "_STACKLIT_DEBUG", debugEnabled);
+
+            bool vlayerRecomputePerLight = material.HasProperty("_VlayerRecomputePerLight") && material.GetFloat("_VlayerRecomputePerLight") > 0.0f;
+            CoreUtils.SetKeyword(material, "_VLAYERED_RECOMPUTE_PERLIGHT", vlayerRecomputePerLight);
+
+            bool vlayerUseRefractedAnglesForBase = material.HasProperty("_VlayerUseRefractedAnglesForBase") && material.GetFloat("_VlayerUseRefractedAnglesForBase") > 0.0f;
+            CoreUtils.SetKeyword(material, "_VLAYERED_USE_REFRACTED_ANGLES_FOR_BASE", vlayerUseRefractedAnglesForBase);
+
+
+            // Set the reference value for the stencil test - required for SSS
+            int stencilRef = (int)StencilLightingUsage.RegularLighting;
+            if (sssEnabled)
+            {
+                stencilRef = (int)StencilLightingUsage.SplitLighting;
+            }
+
+            // As we tag both during velocity pass and Gbuffer pass we need a separate state and we need to use the write mask
+            material.SetInt(kStencilRef, stencilRef);
+            material.SetInt(kStencilWriteMask, (int)HDRenderPipeline.StencilBitMask.LightingMask);
+            material.SetInt(kStencilRefMV, (int)HDRenderPipeline.StencilBitMask.ObjectVelocity);
+            material.SetInt(kStencilWriteMaskMV, (int)HDRenderPipeline.StencilBitMask.ObjectVelocity);
        }
    }
 } // namespace UnityEditor
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/FrameSettingsUI.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/FrameSettingsUI.cs
            EditorGUILayout.PropertyField(p.enableMotionVectors, _.GetContent("Enable Motion Vectors"));
            EditorGUILayout.PropertyField(p.enableObjectMotionVectors, _.GetContent("Enable Object Motion Vectors"));
            EditorGUILayout.PropertyField(p.enableDBuffer, _.GetContent("Enable DBuffer"));
-            EditorGUILayout.PropertyField(p.enableAtmosphericScattering, _.GetContent("Enable Atmospheric Scattering"));
            EditorGUILayout.PropertyField(p.enableRoughRefraction, _.GetContent("Enable Rough Refraction"));
            EditorGUILayout.PropertyField(p.enableDistortion, _.GetContent("Enable Distortion"));
            EditorGUILayout.PropertyField(p.enablePostprocess, _.GetContent("Enable Postprocess"));
            EditorGUILayout.PropertyField(p.enableSSAO, _.GetContent("Enable SSAO"));
            EditorGUILayout.PropertyField(p.enableSubsurfaceScattering, _.GetContent("Enable Subsurface Scattering"));
            EditorGUILayout.PropertyField(p.enableTransmission, _.GetContent("Enable Transmission"));
+            EditorGUILayout.PropertyField(p.enableAtmosphericScattering, _.GetContent("Enable Atmospheric Scattering"));
+            EditorGUILayout.PropertyField(p.enableVolumetric, _.GetContent("    Enable Volumetric"));
            EditorGUILayout.PropertyField(p.enableShadow, _.GetContent("Enable Shadow"));
            EditorGUILayout.PropertyField(p.enableContactShadow, _.GetContent("Enable Contact Shadows"));
            EditorGUILayout.PropertyField(p.enableShadowMask, _.GetContent("Enable Shadow Masks"));
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/GlobalLightLoopSettingsUI.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/GlobalLightLoopSettingsUI.cs
            EditorGUILayout.PropertyField(d.planarReflectionCacheCompressed, _.GetContent("Compress Planar Reflection Probe Cache"));
            EditorGUILayout.PropertyField(d.planarReflectionCubemapSize, _.GetContent("Planar Reflection Texture Size"));
            EditorGUILayout.PropertyField(d.planarReflectionProbeCacheSize, _.GetContent("Planar Probe Cache Size"));
-            EditorGUILayout.PropertyField(d.maxPlanarReflectionProbes, _.GetContent("Max Planar Probe Per Frame"));
-            d.maxPlanarReflectionProbes.intValue = Mathf.Max(1, d.maxPlanarReflectionProbes.intValue);
            --EditorGUI.indentLevel;
        }

--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/RenderPipelineSettingsUI.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/RenderPipelineSettingsUI.cs
            EditorGUILayout.PropertyField(d.supportMotionVectors, _.GetContent("Support Motion Vectors"));
            EditorGUILayout.PropertyField(d.supportStereo, _.GetContent("Support Stereo Rendering"));
            EditorGUILayout.PropertyField(d.enableUltraQualitySSS, _.GetContent("Increase SSS Sample Count"));
+            EditorGUILayout.PropertyField(d.supportVolumetric, _.GetContent("Support volumetric"));
            --EditorGUI.indentLevel;
        }
    }
--- a/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/SerializedFrameSettings.cs
+++ b/ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/RenderLoopSettings/SerializedFrameSettings.cs
        public SerializedProperty enableSSAO;
        public SerializedProperty enableSubsurfaceScattering;
        public SerializedProperty enableTransmission;
+        public SerializedProperty enableAtmosphericScattering;
+        public SerializedProperty enableVolumetric;

        public SerializedProperty diffuseGlobalDimmer;
        public SerializedProperty specularGlobalDimmer;
        public SerializedProperty enableMotionVectors;
        public SerializedProperty enableObjectMotionVectors;
        public SerializedProperty enableDBuffer;
-        public SerializedProperty enableAtmosphericScattering;
        public SerializedProperty enableRoughRefraction;
        public SerializedProperty enableTransparentPostpass;
        public SerializedProperty enableDistortion;
            enableSSAO = root.Find((FrameSettings d) => d.enableSSAO);
            enableSubsurfaceScattering = root.Find((FrameSettings d) => d.enableSubsurfaceScattering);
            enableTransmission = root.Find((FrameSettings d) => d.enableTransmission);
+            enableAtmosphericScattering = root.Find((FrameSettings d) => d.enableAtmosphericScattering);
+            enableVolumetric = root.Find((FrameSettings d) => d.enableVolumetric);
            diffuseGlobalDimmer = root.Find((FrameSettings d) => d.diffuseGlobalDimmer);
            specularGlobalDimmer = root.Find((FrameSettings d) => d.specularGlobalDimmer);
            enableForwardRenderingOnly = root.Find((FrameSettings d) => d.enableForwardRenderingOnly);
            enableObjectMotionVectors = root.Find((FrameSettings d) => d.enableObjectMotionVectors);
            enableDBuffer = root.Find((FrameSettings d) => d.enableDBuffer);
-            enableAtmosphericScattering = root.Find((FrameSettings d) => d.enableAtmosphericScattering);
            enableRoughRefraction = root.Find((FrameSettings d) => d.enableRoughRefraction);
            enableTransparentPostpass = root.Find((FrameSettings d) => d.enableTransparentPostpass);
            enableDistortion = root.Find((FrameSettings d) => d.enableDistortion);