Merge branch 'master' into prototype/decals

# Conflicts:
#	SampleScenes/HDTest/GraphicTest/RealtimeCubemaps.meta
#	ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipeline.cs
#	ScriptableRenderPipeline/HDRenderPipeline/HDStringConstants.cs
#	ScriptableRenderPipeline/HDRenderPipeline/Material/Lit/LitData.hlsl

.npmignore

 /SampleScenes*
 /TestbedPipelines*
 /Tests*
+/ScriptableRenderPipeline/HDRenderPipeline*
 /.collabignore
 /.gitignore
 /.gitmodules

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1101_Unlit.unity.png.meta

 fileFormatVersion: 2
 guid: c919820248440b84dad630c4f2236f90
-timeCreated: 1509984497
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1102_Unlit_Distortion.unity.png.meta

 fileFormatVersion: 2
 guid: d6dcc77f4721a6c4cad7af2a19555dcd
-timeCreated: 1509984600
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1103_Unlit_Distortion_DepthTest.unity.png.meta

 fileFormatVersion: 2
 guid: b1ef8abe969ee184a8b55e0fb17e753b
-timeCreated: 1509984497
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1201_Lit_Features.unity.png.meta

 fileFormatVersion: 2
 guid: 102270e14f9a17b48bf618e9591a7b92
-timeCreated: 1509984496
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1202_Lit_DoubleSideNormalMode.unity.png.meta

 fileFormatVersion: 2
 guid: 6194a91dfa0a32a4689e62698148533f
-timeCreated: 1509984574
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1203_Lit_Transparent.unity.png.meta

 fileFormatVersion: 2
 guid: 0568c9352e15d2e4dba0845329f3dcce
-timeCreated: 1509984496
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1204_Lit_Transparent_Fog.unity.png.meta

 fileFormatVersion: 2
 guid: e49523f9a39ecdc4e9c2a71f098a75e6
-timeCreated: 1509984541
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1205_Lit_Transparent_Refraction.unity.png.meta

 fileFormatVersion: 2
 guid: 5238d788166223d47a0d2e5bc4baff84
-timeCreated: 1509984497
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1206_Lit_Transparent_Distortion.unity.png.meta

 fileFormatVersion: 2
 guid: 7479636b4adc4ee45af4cfb4264ef854
-timeCreated: 1509984586
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
-    enableMipMap: 1
+    enableMipMap: 0
     sRGBTexture: 1
     linearTexture: 0
     fadeOut: 0
     filterMode: -1
     aniso: -1
     mipBias: -1
-    wrapU: -1
-    wrapV: -1
-    wrapW: -1
-  nPOTScale: 1
+    wrapU: 1
+    wrapV: 1
+    wrapW: 1
+  nPOTScale: 0
   lightmap: 0
   compressionQuality: 50
   spriteMode: 0
   spritePivot: {x: 0.5, y: 0.5}
   spriteBorder: {x: 0, y: 0, z: 0, w: 0}
   spritePixelsToUnits: 100
-  alphaUsage: 1
+  alphaUsage: 0
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: iPhone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Windows Store Apps
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/LightweightPipeline/Scenes/007_LitShaderMaps.unity.png.meta

 fileFormatVersion: 2
 guid: e086420c18dc7be409fbca698aa2f035
-timeCreated: 1504172927
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
   mipmaps:
     mipMapMode: 0
     enableMipMap: 1
   spriteTessellationDetail: -1
   textureType: 0
   textureShape: 1
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/LightweightPipeline/Scenes/023_Lighting_Mixed.unity.png.meta

 fileFormatVersion: 2
 guid: fad56126d031e40ffa9d93733bead554
-timeCreated: 1509374830
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
   mipmaps:
     mipMapMode: 0
     enableMipMap: 1
   spriteTessellationDetail: -1
   textureType: 0
   textureShape: 1
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/LightweightPipeline/Scenes/027_PostProcessing.unity.png.meta

 fileFormatVersion: 2
 guid: c40bd57fb760b4839a1ef80428356062
-timeCreated: 1509377483
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
   mipmaps:
     mipMapMode: 0
     enableMipMap: 1
   spriteTessellationDetail: -1
   textureType: 0
   textureShape: 1
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

ImageTemplates/LightweightPipeline/Scenes/036_Lighting_Scene_DirectionalBakedDirectional.unity.png.meta

 fileFormatVersion: 2
 guid: f1b41e73e6cf549d4a74497132c3aa3a
-timeCreated: 1509466261
-licenseType: Pro
-  serializedVersion: 4
+  serializedVersion: 5
   mipmaps:
     mipMapMode: 0
     enableMipMap: 1
   spriteTessellationDetail: -1
   textureType: 0
   textureShape: 1
+  singleChannelComponent: 0
-  - buildTarget: DefaultTexturePlatform
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
     maxTextureSize: 2048
     resizeAlgorithm: 0
     textureFormat: -1
     sprites: []
     outline: []
     physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
   spritePackingTag: 
   userData: 
   assetBundleName: 

SampleScenes/FPTL/FPTL.unity

     m_EnableBakedLightmaps: 0
     m_EnableRealtimeLightmaps: 0
   m_LightmapEditorSettings:
-    serializedVersion: 9
+    serializedVersion: 10
-    m_TextureWidth: 1024
-    m_TextureHeight: 1024
+    m_AtlasSize: 1024
     m_AO: 0
     m_AOMaxDistance: 1
     m_CompAOExponent: 0
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1713034008}
   m_Enabled: 1
-  m_ExtensionPropertyValues: []
 --- !u!124 &1713034010
 Behaviour:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!4 &1713034013
 Transform:
   m_ObjectHideFlags: 0
   m_Script: {fileID: 11500000, guid: 92bb16b4ee20841929b24d6bd771738d, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_RenderLoop: {fileID: 11400000, guid: 4dc14083116279a438e1b2de3830999f, type: 2}
 --- !u!114 &1713034015
 MonoBehaviour:
   m_ObjectHideFlags: 0
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
-  - {fileID: 2100000, guid: cb6536d04ba24874981eb01dfd87479e, type: 2}
+  - {fileID: 2100000, guid: 24e6a15bf9d2c0944b380d860a738528, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
-  - {fileID: 2100000, guid: cb6536d04ba24874981eb01dfd87479e, type: 2}
+  - {fileID: 2100000, guid: 24e6a15bf9d2c0944b380d860a738528, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
   m_CastShadows: 1
   m_ReceiveShadows: 1
   m_DynamicOccludee: 1
+  m_RenderingLayerMask: 4294967295
-  - {fileID: 2100000, guid: cb6536d04ba24874981eb01dfd87479e, type: 2}
+  - {fileID: 2100000, guid: 24e6a15bf9d2c0944b380d860a738528, type: 2}
   m_StaticBatchInfo:
     firstSubMesh: 0
     subMeshCount: 0

SampleScenes/FPTL/Materials/FwdMat.mat

   m_PrefabInternal: {fileID: 0}
   m_Name: FwdMat
   m_Shader: {fileID: 4800000, guid: 8f28d6dbfdba66d4dbae80224aca5669, type: 3}
-  m_ShaderKeywords: _EMISSION
+  m_ShaderKeywords: _ALPHAPREMULTIPLY_ON _EMISSION
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
   disabledShaderPasses: []
   m_SavedProperties:
     serializedVersion: 3
     - _BumpScale: 1
     - _Cutoff: 0.5
     - _DetailNormalMapScale: 1
-    - _DstBlend: 0
+    - _DstBlend: 10
-    - _Glossiness: 0.5
+    - _Glossiness: 0.806
-    - _Metallic: 0
-    - _Mode: 0
+    - _Metallic: 0.891
+    - _Mode: 3
     - _OcclusionStrength: 1
     - _Parallax: 0.02
     - _SmoothnessTextureChannel: 0
-    - _ZWrite: 1
+    - _ZWrite: 0
-    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 0.559}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _SpecColor: {r: 0.19999996, g: 0.19999996, b: 0.19999996, a: 1}

SampleScenes/HDTest/BasicProfiling/Lit_SSS.mat

   stringTagMap: {}
   disabledShaderPasses:
   - DistortionVectors
+  - TransparentBackface
+  - TransparentBackfaceDebugDisplay
   m_SavedProperties:
     serializedVersion: 3
     m_TexEnvs:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _AORemapMax: 1
+    - _AORemapMin: 0
     - _ATDistance: 1
     - _AlbedoAffectEmissive: 0
     - _AlphaCutoff: 0.5
     - _DistortionOnly: 0
     - _DistortionScale: 1
     - _DistortionSrcBlend: 1
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
     - _DoubleSidedEnable: 0
     - _DoubleSidedNormalMode: 1
     - _Drag: 1
     - _SrcBlend: 1
     - _StencilRef: 1
     - _Stiffness: 1
-    - _SubsurfaceProfile: 3
+    - _SubsurfaceProfile: 1
+    - _TransparentBackfaceEnable: 0
     - _UVBase: 0
     - _UVDetail: 0
     - _UVSec: 0
     - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
     - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
     - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
     - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}

SampleScenes/HDTest/ShadowsTest.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_IndirectSpecularColor: {r: 0.12544414, g: 0.13212782, b: 0.11914396, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     m_EnableBakedLightmaps: 0
     m_EnableRealtimeLightmaps: 0
   m_LightmapEditorSettings:
-    serializedVersion: 9
+    serializedVersion: 10
-    m_TextureWidth: 1024
-    m_TextureHeight: 1024
+    m_AtlasSize: 1024
     m_AO: 0
     m_AOMaxDistance: 1
     m_CompAOExponent: 1
     m_PVRFilteringAtrousPositionSigmaDirect: 0.5
     m_PVRFilteringAtrousPositionSigmaIndirect: 2
     m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
   m_LightingDataAsset: {fileID: 112000002, guid: e5562e1a270c3994d826092db897528c,
     type: 2}
   m_UseShadowmask: 1
   m_EditorClassIdentifier: 
   m_CommonSettings: {fileID: 11400000, guid: 075f395cb6ba2534196f2ce83c32e633, type: 2}
   m_SkySettings: {fileID: 11400000, guid: 622aa06566c087b41ac0edc80769f45f, type: 2}
-  m_SsaoSettings: {fileID: 0}
 --- !u!4 &8862570
 Transform:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!124 &25518111
 Behaviour:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!4 &25518113
 Transform:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &38548579
 Transform:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 38548578}
   m_Enabled: 1
-  m_ExtensionPropertyValues: []
 --- !u!124 &38548581
 Behaviour:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &43913312
 Prefab:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!81 &240603308
 AudioListener:
   m_ObjectHideFlags: 0
   m_Enabled: 1
-  m_ExtensionPropertyValues: []
 --- !u!124 &240603309
 Behaviour:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!4 &240603311
 Transform:
   m_ObjectHideFlags: 0
   m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_innerSpotPercent: 0
+  m_Version: 1
+  m_InnerSpotPercent: 0
-  archetype: 0
+  lightTypeExtent: 0
-  lightLength: 0
-  lightWidth: 0
+  shapeLength: 0
+  shapeWidth: 0
+  aspectRatio: 1
+  shapeRadius: 0
+  useOldInspector: 0
+  featuresFoldout: 1
+  showAdditionalSettings: 1
 --- !u!108 &367594608
 Light:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &401402600
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &454647942
 Prefab:
   m_ObjectHideFlags: 0
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 948836267934e104294e03adad5c7bf7, type: 2}
   m_StaticBatchInfo:
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 948836267934e104294e03adad5c7bf7, type: 2}
   m_StaticBatchInfo:
   m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_innerSpotPercent: 0
+  m_Version: 1
+  m_InnerSpotPercent: 0
-  archetype: 0
+  lightTypeExtent: 0
-  lightLength: 0
-  lightWidth: 0
+  shapeLength: 0
+  shapeWidth: 0
+  aspectRatio: 1
+  shapeRadius: 0
+  useOldInspector: 0
+  featuresFoldout: 1
+  showAdditionalSettings: 1
 --- !u!108 &886044557
 Light:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &912444934
 Transform:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 912444933}
   m_Enabled: 1
-  m_ExtensionPropertyValues: []
 --- !u!124 &912444936
 Behaviour:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &935997991
 Prefab:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1175480045
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &1188504521
 Prefab:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1232280518
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &1238924665
 Prefab:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1239387815
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &1291944202
 Prefab:
   m_ObjectHideFlags: 0
   m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_innerSpotPercent: 0
+  m_Version: 1
+  m_InnerSpotPercent: 0
-  archetype: 0
+  lightTypeExtent: 0
-  lightLength: 0
-  lightWidth: 0
+  shapeLength: 0
+  shapeWidth: 0
+  aspectRatio: 1
+  shapeRadius: 0
+  useOldInspector: 0
+  featuresFoldout: 1
+  showAdditionalSettings: 1
 --- !u!108 &1395086339
 Light:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1524083540
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &1532183583
 Prefab:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1558117774
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &1568431069
 Prefab:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1641371013
 Transform:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1641371012}
   m_Enabled: 1
-  m_ExtensionPropertyValues: []
 --- !u!124 &1641371015
 Behaviour:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &1642984832
 Prefab:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1769631028}
   m_Enabled: 1
-  m_ExtensionPropertyValues: []
 --- !u!124 &1769631030
 Behaviour:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!4 &1769631032
 Transform:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &1909327634
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &1935664259
 Prefab:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &2007753896
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &2018192138
 Prefab:
   m_ObjectHideFlags: 0
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!4 &2095847156
 Transform:
   m_ObjectHideFlags: 0
   m_OcclusionCulling: 1
   m_StereoConvergence: 10
   m_StereoSeparation: 0.022
-  m_StereoMirrorMode: 0
 --- !u!1001 &2097384754
 Prefab:
   m_ObjectHideFlags: 0
   m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-  m_innerSpotPercent: 0
+  m_Version: 1
+  m_InnerSpotPercent: 0
-  archetype: 0
+  lightTypeExtent: 0
-  lightLength: 0
-  lightWidth: 0
+  shapeLength: 0
+  shapeWidth: 0
+  aspectRatio: 1
+  shapeRadius: 0
+  useOldInspector: 0
+  featuresFoldout: 1
+  showAdditionalSettings: 1
 --- !u!108 &2102352250
 Light:
   m_ObjectHideFlags: 0

SampleScenes/HDTest/SkyFogTest.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.11442507, g: 0.09270345, b: 0.05664562, a: 1}
+  m_IndirectSpecularColor: {r: 0.26041162, g: 0.2929252, b: 0.32061547, a: 1}
 --- !u!157 &3
 LightmapSettings:
   m_ObjectHideFlags: 0
     m_EnableBakedLightmaps: 1
     m_EnableRealtimeLightmaps: 1
   m_LightmapEditorSettings:
-    serializedVersion: 9
+    serializedVersion: 10
-    m_TextureWidth: 1024
-    m_TextureHeight: 1024
+    m_AtlasSize: 1024
     m_AO: 0
     m_AOMaxDistance: 1
     m_CompAOExponent: 1
     m_PVRFilteringAtrousPositionSigmaDirect: 0.5
     m_PVRFilteringAtrousPositionSigmaIndirect: 2
     m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
   m_LightingDataAsset: {fileID: 0}
   m_UseShadowmask: 1
 --- !u!196 &4
   m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
+  m_Version: 1
   m_InnerSpotPercent: 0
   lightDimmer: 1
   fadeDistance: 10000
   spotLightShape: 0
   shapeLength: 0.5
   shapeWidth: 0.5
+  aspectRatio: 1
   shapeRadius: 0
   maxSmoothness: 1
   applyRangeAttenuation: 1
   m_Icon: {fileID: 0}
   m_NavMeshLayer: 0
   m_StaticEditorFlags: 0
-  m_IsActive: 1
+  m_IsActive: 0
 --- !u!81 &1276802630
 AudioListener:
   m_ObjectHideFlags: 0
   m_MotionVectors: 1
   m_LightProbeUsage: 1
   m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
   m_Materials:
   - {fileID: 2100000, guid: 948836267934e104294e03adad5c7bf7, type: 2}
   m_StaticBatchInfo:

ScriptableRenderPipeline/Core/Camera/FreeCamera.cs

 
         void Update()
         {
+            // If the debug menu is running, we don't want to conflict with its inputs.
+            if(DebugMenuManager.instance.menuUI.isEnabled)
+                return;
+
             float inputRotateAxisX = 0.0f;
             float inputRotateAxisY = 0.0f;
             if (Input.GetMouseButton(1))

ScriptableRenderPipeline/Core/CoreUtils.cs

-using System;
+using System;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.PostProcessing;
 
 
     public static class CoreUtils
     {
+        // Data useful for various cubemap processes.
+        // Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/bb204881(v=vs.85).aspx
+        static public readonly Vector3[] lookAtList =
+        {
+            new Vector3(1.0f, 0.0f, 0.0f),
+            new Vector3(-1.0f, 0.0f, 0.0f),
+            new Vector3(0.0f, 1.0f, 0.0f),
+            new Vector3(0.0f, -1.0f, 0.0f),
+            new Vector3(0.0f, 0.0f, 1.0f),
+            new Vector3(0.0f, 0.0f, -1.0f),
+        };
+
+        static public readonly Vector3[] upVectorList =
+        {
+            new Vector3(0.0f, 1.0f, 0.0f),
+            new Vector3(0.0f, 1.0f, 0.0f),
+            new Vector3(0.0f, 0.0f, -1.0f),
+            new Vector3(0.0f, 0.0f, 1.0f),
+            new Vector3(0.0f, 1.0f, 0.0f),
+            new Vector3(0.0f, 1.0f, 0.0f),
+        };
+
+
+        public const int editMenuPriority1 = 320;
+        public const int editMenuPriority2 = 331;
+        public const int assetCreateMenuPriority1 = 230;
+        public const int assetCreateMenuPriority2 = 241;
 
         // Render Target Management.
         public static void SetRenderTarget(CommandBuffer cmd, RenderTargetIdentifier buffer, ClearFlag clearFlag, Color clearColor, int miplevel = 0, CubemapFace cubemapFace = CubemapFace.Unknown, int depthSlice = 0)
         public static void ClearCubemap(CommandBuffer cmd, RenderTargetIdentifier buffer, Color clearColor)
         {
             for(int i = 0; i < 6; ++i)
-                SetRenderTarget(cmd, buffer, ClearFlag.Color, clearColorAllBlack, 0, (CubemapFace)i);
+                SetRenderTarget(cmd, buffer, ClearFlag.Color, clearColor, 0, (CubemapFace)i);
         }
 
         // Draws a full screen triangle as a faster alternative to drawing a full screen quad.

ScriptableRenderPipeline/Core/Debugging/DebugMenuManager.cs

             m_DebugMenuStateDirty = true;
         }
 
+        public void RemoveDebugItem(string debugPanelName, string name)
+        {
+            DebugPanel debugPanel = GetDebugPanel(debugPanelName);
+
+            if (debugPanel != null)
+            {
+                DebugItem item = debugPanel.GetDebugItem(name);
+                if (item != null)
+                    debugPanel.RemoveDebugItem(item);
+            }
+
+            m_DebugMenuStateDirty = true;
+
+        }
+
         public void SetDebugMenuState(DebugMenuState state)
         {
             m_DebugMenuStateDirty = true;

ScriptableRenderPipeline/Core/Debugging/Editor/DebugMenuEditor.cs

-using UnityEngine;
 using UnityEditor;
 
 namespace UnityEngine.Experimental.Rendering
         [SerializeField]
         private DebugMenuState m_DebugMenuState;
 
-        [MenuItem("HDRenderPipeline/Debug Window")]
+        [MenuItem("Edit/Render Pipeline/Tools/High Definition/Debug Window", priority = CoreUtils.editMenuPriority2)]
         static void DisplayDebugMenu()
         {
             var window = EditorWindow.GetWindow<DebugMenuEditor>("Debug Window");
         }
     }
 
-}
+}

ScriptableRenderPipeline/Core/Editor/CoreEditorUtils.cs

-using System;
+using System;
+using System.Linq;
 using System.Linq.Expressions;
 using System.Text;
 using UnityEngine;
     public static class CoreEditorUtils
     {
+        // GUIContent cache utilities
+        static Dictionary<string, GUIContent> s_GUIContentCache = new Dictionary<string, GUIContent>();
+
+        public static GUIContent GetContent(string textAndTooltip)
+        {
+            if (string.IsNullOrEmpty(textAndTooltip))
+                return GUIContent.none;
+
+            GUIContent content;
+
+            if (!s_GUIContentCache.TryGetValue(textAndTooltip, out content))
+            {
+                var s = textAndTooltip.Split('|');
+                content = new GUIContent(s[0]);
+
+                if (s.Length > 1 && !string.IsNullOrEmpty(s[1]))
+                    content.tooltip = s[1];
+
+                s_GUIContentCache.Add(textAndTooltip, content);
+            }
+
+            return content;
+        }
+
         // Serialization helpers
         public static string FindProperty<T, TValue>(Expression<Func<T, TValue>> expr)
         {
             }
 
             return state;
+        }
+
+        public static bool DrawHeaderToggle(string title, SerializedProperty group, SerializedProperty activeField, Action<Vector2> contextAction = null)
+        {
+            var backgroundRect = GUILayoutUtility.GetRect(1f, 17f);
+
+            var labelRect = backgroundRect;
+            labelRect.xMin += 16f;
+            labelRect.xMax -= 20f;
+
+            var toggleRect = backgroundRect;
+            toggleRect.y += 2f;
+            toggleRect.width = 13f;
+            toggleRect.height = 13f;
+
+            // Background rect should be full-width
+            backgroundRect.xMin = 0f;
+            backgroundRect.width += 4f;
+
+            // Background
+            float backgroundTint = EditorGUIUtility.isProSkin ? 0.1f : 1f;
+            EditorGUI.DrawRect(backgroundRect, new Color(backgroundTint, backgroundTint, backgroundTint, 0.2f));
+
+            // Title
+            using (new EditorGUI.DisabledScope(!activeField.boolValue))
+                EditorGUI.LabelField(labelRect, GetContent(title), EditorStyles.boldLabel);
+
+            // Active checkbox
+            activeField.serializedObject.Update();
+            activeField.boolValue = GUI.Toggle(toggleRect, activeField.boolValue, GUIContent.none, CoreEditorStyles.smallTickbox);
+            activeField.serializedObject.ApplyModifiedProperties();
+
+            // Context menu
+            var menuIcon = EditorGUIUtility.isProSkin
+                ? CoreEditorStyles.paneOptionsIconDark
+                : CoreEditorStyles.paneOptionsIconLight;
+
+            var menuRect = new Rect(labelRect.xMax + 4f, labelRect.y + 4f, menuIcon.width, menuIcon.height);
+
+            if (contextAction != null)
+                GUI.DrawTexture(menuRect, menuIcon);
+
+            // Handle events
+            var e = Event.current;
+
+            if (e.type == EventType.MouseDown)
+            {
+                if (contextAction != null && menuRect.Contains(e.mousePosition))
+                {
+                    contextAction(new Vector2(menuRect.x, menuRect.yMax));
+                    e.Use();
+                }
+                else if (labelRect.Contains(e.mousePosition))
+                {
+                    if (e.button == 0)
+                        group.isExpanded = !group.isExpanded;
+                    else if (contextAction != null)
+                        contextAction(e.mousePosition);
+
+                    e.Use();
+                }
+            }
+
+            return group.isExpanded;
+        }
+
+        public static void RemoveMaterialKeywords(Material material)
+        {
+            material.shaderKeywords = null;
+        }
+
+        public static T[] GetAdditionalData<T>(params UnityEngine.Object[] targets)
+            where T : Component
+        {
+            // Handles multi-selection
+            var data = targets.Cast<Component>()
+                .Select(t => t.GetComponent<T>())
+                .ToArray();
+
+            for (int i = 0; i < data.Length; i++)
+            {
+                if (data[i] == null)
+                    data[i] = Undo.AddComponent<T>(((Component)targets[i]).gameObject);
+            }
+
+            return data;
         }
     }
 }

ScriptableRenderPipeline/Core/ProfilingSample.cs

 using System;
 using UnityEngine.Rendering;
+using UnityEngine.Profiling;
-        public readonly CommandBuffer cmd;
-        public readonly string name;
+        readonly CommandBuffer m_Cmd;
+        readonly string m_Name;
+        CustomSampler m_Sampler;
-        public ProfilingSample(CommandBuffer cmd, string name)
+        public ProfilingSample(CommandBuffer cmd, string name,CustomSampler sampler = null)
-            this.cmd = cmd;
-            this.name = name;
+            m_Cmd = cmd;
+            m_Name = name;
+            m_Sampler = sampler;
+            if (m_Sampler != null)
+                m_Sampler.Begin();
-        public ProfilingSample(CommandBuffer cmd, string format, object arg)
+        public ProfilingSample(CommandBuffer cmd, string format, object arg) : this(cmd,string.Format(format, arg))
-            this.cmd = cmd;
-            name = string.Format(format, arg);
-            m_Disposed = false;
-            cmd.BeginSample(name);
-        public ProfilingSample(CommandBuffer cmd, string format, params object[] args)
+        public ProfilingSample(CommandBuffer cmd, string format, params object[] args) : this(cmd,string.Format(format, args))
-            this.cmd = cmd;
-            name = string.Format(format, args);
-            m_Disposed = false;
-            cmd.BeginSample(name);
         }
 
         public void Dispose()
             // As this is a struct, it could have been initialized using an empty constructor so we
             // need to make sure `cmd` isn't null to avoid a crash. Switching to a class would fix
             // this but will generate garbage on every frame (and this struct is used quite a lot).
-            if (disposing && cmd != null)
-                cmd.EndSample(name);
+            if (disposing && m_Cmd != null)
+            {
+                m_Cmd.EndSample(m_Name);
+                if (m_Sampler != null)
+                    m_Sampler.End();
+            }
 
             m_Disposed = true;
         }

ScriptableRenderPipeline/Core/Resources/GPUCopy.compute

 // Autogenerated file. Do not edit by hand
 
-#include "../ShaderLibrary/Common.hlsl"
+#include "ShaderLibrary/Common.hlsl"
 
 SamplerState sampler_LinearClamp;
 

ScriptableRenderPipeline/Core/ShaderGenerator/Editor/ShaderGeneratorMenu.cs

+using UnityEngine.Experimental.Rendering;
+
-        [UnityEditor.MenuItem("RenderPipeline/Generate Shader Includes")]
+        [UnityEditor.MenuItem("Edit/Render Pipeline/Tools/Generate Shader Includes", priority = CoreUtils.editMenuPriority1)]
         static void GenerateShaderIncludes()
         {
             CSharpToHLSL.GenerateAll();

ScriptableRenderPipeline/Core/ShaderLibrary/API/D3D11.hlsl

 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
 #define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
+
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
 #define TEXTURE3D_HALF TEXTURE3D

ScriptableRenderPipeline/Core/ShaderLibrary/API/Metal.hlsl

 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
 #define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
+
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
 #define TEXTURE3D_HALF TEXTURE3D

ScriptableRenderPipeline/Core/ShaderLibrary/API/PSSL.hlsl

 #define SAMPLE_TEXTURECUBE_SHADOW(textureName, samplerName, coord4) textureName.SampleCmpLevelZero(samplerName, (coord3).xyz, (coord3).w)
 #define SAMPLE_TEXTURECUBE_ARRAY_SHADOW(textureName, samplerName, coord4, index) textureName.SampleCmpLevelZero(samplerName, float4((coord4).xyz, index), (coord4).w)
 
+#define SAMPLE_DEPTH_TEXTURE(textureName, samplerName, coord2) SAMPLE_TEXTURE2D(textureName, samplerName, coord2).r
+#define SAMPLE_DEPTH_TEXTURE_LOD(textureName, samplerName, coord2, lod) SAMPLE_TEXTURE2D_LOD(textureName, samplerName, coord2, lod).r
+
 #define TEXTURE2D_HALF TEXTURE2D
 #define TEXTURE2D_FLOAT TEXTURE2D
 #define TEXTURE3D_HALF TEXTURE3D

ScriptableRenderPipeline/Core/ShaderLibrary/BSDF.hlsl

 // Specular BRDF
 //-----------------------------------------------------------------------------
 
-// With analytical light (not image based light) we clamp the minimun roughness in the NDF to avoid numerical instability.
-#define UNITY_MIN_ROUGHNESS 0.002
-
-float ClampRoughnessForAnalyticalLights(float roughness)
-{
-    return max(roughness, UNITY_MIN_ROUGHNESS);
-}
-
-    float a2 = roughness * roughness;
-    float f = (NdotH * a2 - NdotH) * NdotH + 1.0;
-    return a2 / (f * f);
+    float a2 = Sq(roughness);
+    float s  = (NdotH * a2 - NdotH) * NdotH + 1.0;
+    return a2 / (s * s);
 }
 
 float D_GGX(float NdotH, float roughness)
     // tan²(theta) = (1 - cos²(theta)) / cos²(theta) = 1 / cos²(theta) - 1.
     // Assume that (VdotH > 0), e.i. (acos(LdotV) < Pi).
 
-    float a2 = roughness * roughness;
-    float z2 = NdotV * NdotV;
-
-    return 1 / (0.5 + 0.5 * sqrt(1.0 + a2 * (1.0 / z2 - 1.0)));
+    return 1.0 / (0.5 + 0.5 * sqrt(1.0 + Sq(roughness) * (1.0 / Sq(NdotV) - 1.0)));
 }
 
 // Ref: Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs, p. 12.
 // Precompute part of lambdaV
 float GetSmithJointGGXPartLambdaV(float NdotV, float roughness)
 {
-    float a2 = roughness * roughness;
+    float a2 = Sq(roughness);
     return sqrt((-NdotV * a2 + NdotV) * NdotV + a2);
 }
 
 {
-    float a2 = roughness * roughness;
+    float a2 = Sq(roughness);
 
     // Original formulation:
     // lambda_v = (-1 + sqrt(a2 * (1 - NdotL2) / NdotL2 + 1)) * 0.5
 // Inline D_GGX() * V_SmithJointGGX() together for better code generation.
 float DV_SmithJointGGX(float NdotH, float NdotL, float NdotV, float roughness, float partLambdaV)
 {
-    float a2 = roughness * roughness;
-    float  f = (NdotH * a2 - NdotH) * NdotH + 1.0;
-    float2 D = float2(a2, f * f);            // Fraction without the constant (1/Pi)
+    float a2 = Sq(roughness);
+    float s  = (NdotH * a2 - NdotH) * NdotH + 1.0;
-    float2 G = float2(1, lambdaV + lambdaL); // Fraction without the constant (0.5)
+    float2 D = float2(a2, s * s);            // Fraction without the multiplier (1/Pi)
+    float2 G = float2(1, lambdaV + lambdaL); // Fraction without the multiplier (1/2)
 
     return (INV_PI * 0.5) * (D.x * G.x) / (D.y * G.y);
 }
 // roughnessB -> roughness in bitangent direction
 float D_GGXAnisoNoPI(float TdotH, float BdotH, float NdotH, float roughnessT, float roughnessB)
 {
-    float aT2 = roughnessT * roughnessT;
-    float aB2 = roughnessB * roughnessB;
+    float a2 = roughnessT * roughnessB;
+    float3 v = float3(roughnessB * TdotH, roughnessT * BdotH, a2 * NdotH);
+    float  s = dot(v, v);
-    float f = TdotH * TdotH / aT2 + BdotH * BdotH / aB2 + NdotH * NdotH;
-    return 1.0 / (roughnessT * roughnessB * f * f);
+    return a2 * Sq(a2 / s);
 }
 
 float D_GGXAniso(float TdotH, float BdotH, float NdotH, float roughnessT, float roughnessB)
 
 float GetSmithJointGGXAnisoPartLambdaV(float TdotV, float BdotV, float NdotV, float roughnessT, float roughnessB)
 {
-    float aT2 = roughnessT * roughnessT;
-    float aB2 = roughnessB * roughnessB;
-
-    return sqrt(aT2 * TdotV * TdotV + aB2 * BdotV * BdotV + NdotV * NdotV);
+    return length(float3(roughnessT * TdotV, roughnessB * BdotV, NdotV));
 }
 
 // Note: V = G / (4 * NdotL * NdotV)
-    float aT2 = roughnessT * roughnessT;
-    float aB2 = roughnessB * roughnessB;
-
-    float lambdaL = NdotV * sqrt(aT2 * TdotL * TdotL + aB2 * BdotL * BdotL + NdotL * NdotL);
+    float lambdaL = NdotV * length(float3(roughnessT * TdotL, roughnessB * BdotL, NdotL));
 
     return 0.5 / (lambdaV + lambdaL);
 }
 }
 
 // Inline D_GGXAniso() * V_SmithJointGGXAniso() together for better code generation.
-float DV_SmithJointGGXAniso(float TdotH, float BdotH, float NdotH,
-                            float TdotV, float BdotV, float NdotV,
+float DV_SmithJointGGXAniso(float TdotH, float BdotH, float NdotH, float NdotV,
-    float aT2 = roughnessT * roughnessT;
-    float aB2 = roughnessB * roughnessB;
-
-    float  f = TdotH * TdotH / aT2 + BdotH * BdotH / aB2 + NdotH * NdotH;
-    float2 D = float2(1, roughnessT * roughnessB * f * f); // Fraction without the constant (1/Pi)
+    float a2 = roughnessT * roughnessB;
+    float3 v = float3(roughnessB * TdotH, roughnessT * BdotH, a2 * NdotH);
+    float  s = dot(v, v);
-    float lambdaL = NdotV * sqrt(aT2 * TdotL * TdotL + aB2 * BdotL * BdotL + NdotL * NdotL);
+    float lambdaL = NdotV * length(float3(roughnessT * TdotL, roughnessB * BdotL, NdotL));
-    float2 G = float2(1, lambdaV + lambdaL);               // Fraction without the constant (0.5)
+    float2 D = float2(a2 * a2 * a2, s * s);  // Fraction without the multiplier (1/Pi)
+    float2 G = float2(1, lambdaV + lambdaL); // Fraction without the multiplier (1/2)
 
     return (INV_PI * 0.5) * (D.x * G.x) / (D.y * G.y);
 }
                             float roughnessT, float roughnessB)
 {
     float partLambdaV = GetSmithJointGGXAnisoPartLambdaV(TdotV, BdotV, NdotV, roughnessT, roughnessB);
-    return DV_SmithJointGGXAniso(TdotH, BdotH, NdotH,
-                                 TdotV, BdotV, NdotV,
-                                 TdotL, BdotL, NdotL,
+    return DV_SmithJointGGXAniso(TdotH, BdotH, NdotH, NdotV, TdotL, BdotL, NdotL,
                                  roughnessT, roughnessB, partLambdaV);
 }
 

ScriptableRenderPipeline/Core/ShaderLibrary/Color.hlsl

     return dot(linearRgb, float3(0.2126729f, 0.7151522f, 0.0721750f));
 }
 
+// This function take a rgb color (best is to provide color in sRGB space)
+// and return a YCoCg color in [0..1] space for 8bit (An offset is apply in the function)
-#define CHROMA_BIAS (0.5 * 256.0 / 255.0)
+#define YCOCG_CHROMA_BIAS (128.0 / 255.0)
-    YCoCg.y = dot(rgb, float3(0.5, 0.0, -0.5)) + CHROMA_BIAS;
-    YCoCg.z = dot(rgb, float3(-0.25, 0.5, -0.25)) + CHROMA_BIAS;
+    YCoCg.y = dot(rgb, float3(0.5, 0.0, -0.5)) + YCOCG_CHROMA_BIAS;
+    YCoCg.z = dot(rgb, float3(-0.25, 0.5, -0.25)) + YCOCG_CHROMA_BIAS;
 
     return YCoCg;
 }
     float Y = YCoCg.x;
-    float Co = YCoCg.y - CHROMA_BIAS;
-    float Cg = YCoCg.z - CHROMA_BIAS;
+    float Co = YCoCg.y - YCOCG_CHROMA_BIAS;
+    float Cg = YCoCg.z - YCOCG_CHROMA_BIAS;
 
     float3 rgb;
     rgb.r = Y + Co - Cg;
     return rgb;
 }
+
+// Following function can be use to reconstruct chroma component for a checkboard YCoCg pattern
+// Reference: The Compact YCoCg Frame Buffer
+float YCoCgCheckBoardEdgeFilter(float centerLum, float2 a0, float2 a1, float2 a2, float2 a3)
+{
+    float4 lum = float4(a0.x, a1.x, a2.x, a3.x);
+    // Optimize: float4 w = 1.0 - step(30.0 / 255.0, abs(lum - centerLum));
+    float4 w = 1.0 - saturate((abs(lum.xxxx - centerLum) - 30.0 / 255.0) * HALF_MAX);
+    float W = w.x + w.y + w.z + w.w;
+    // handle the special case where all the weights are zero.
+    return  (W == 0.0) ? a0.y : (w.x * a0.y + w.y* a1.y + w.z* a2.y + w.w * a3.y) / W;
+}
+
 #endif // UNITY_COLOR_INCLUDED

ScriptableRenderPipeline/Core/ShaderLibrary/Common.hlsl

 #include "API/D3D11_1.hlsl"
 #elif defined(SHADER_API_METAL)
 #include "API/Metal.hlsl"
+#elif defined(SHADER_API_VULKAN)
+#include "API/Vulkan.hlsl"
+#include "Macros.hlsl"
-// Some shader compiler don't support to do multiple ## for concatenation inside the same macro, it require an indirection.
-// This is the purpose of this macro
-#define MERGE_NAME(X, Y) X##Y
-
-// These define are use to abstract the way we sample into a cubemap array.
-// Some platform don't support cubemap array so we fallback on 2D latlong
-#ifdef UNITY_NO_CUBEMAP_ARRAY
-#define TEXTURECUBE_ARRAY_ABSTRACT TEXTURE2D_ARRAY
-#define SAMPLERCUBE_ABSTRACT SAMPLER2D
-#define TEXTURECUBE_ARRAY_ARGS_ABSTRACT TEXTURE2D_ARRAY_ARGS
-#define TEXTURECUBE_ARRAY_PARAM_ABSTRACT TEXTURE2D_ARRAY_PARAM
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(textureName, samplerName, coord3, index, lod) SAMPLE_TEXTURE2D_ARRAY_LOD(textureName, samplerName, DirectionToLatLongCoordinate(coord3), index, lod)
-#else
-#define TEXTURECUBE_ARRAY_ABSTRACT TEXTURECUBE_ARRAY
-#define SAMPLERCUBE_ABSTRACT SAMPLERCUBE
-#define TEXTURECUBE_ARRAY_ARGS_ABSTRACT TEXTURECUBE_ARRAY_ARGS
-#define TEXTURECUBE_ARRAY_PARAM_ABSTRACT TEXTURECUBE_ARRAY_PARAM
-#define SAMPLE_TEXTURECUBE_ARRAY_LOD_ABSTRACT(textureName, samplerName, coord3, index, lod) SAMPLE_TEXTURECUBE_ARRAY_LOD(textureName, samplerName, coord3, index, lod)
-#endif
-
-// unsigned integer bit field extract implementation
+// Unsigned integer bit field extraction.
+// Note that the intrinsic itself generates a vector instruction.
+// Wrap this function with WaveReadFirstLane() to get scalar output.
-    uint mask = 0xFFFFFFFFu >> (32u - numBits);
+    uint mask = UINT_MAX >> (32u - numBits);
-bool IsBitSet(uint data, uint bitPos)
+bool IsBitSet(uint data, uint offset)
-    return BitFieldExtract(data, 1u, bitPos) != 0;
+    return BitFieldExtract(data, 1u, offset) != 0;
-#ifndef INTRINSIC_WAVEREADFIRSTLANE
-// Warning: for correctness, the value you pass to the function must be constant across the wave!
-uint WaveReadFirstLane(uint scalarValue)
+void SetBit(inout uint data, uint offset)
-    return scalarValue;
+    data |= 1u << offset;
-#endif
-#ifndef INTRINSIC_MUL24
-int Mul24(int a, int b)
+void ClearBit(inout uint data, uint offset)
-    return a * b;
+    data &= ~(1u << offset);
-uint Mul24(uint a, uint b)
+void ToggleBit(inout uint data, uint offset)
-    return a * b;
+    data ^= 1u << offset;
+
+#ifndef INTRINSIC_WAVEREADFIRSTLANE
+    // Warning: for correctness, the argument must have the same value across the wave!
+    TEMPLATE_1_FLT(WaveReadFirstLane, scalarValue, return scalarValue)
+    TEMPLATE_1_INT(WaveReadFirstLane, scalarValue, return scalarValue)
+#endif
+
+#ifndef INTRINSIC_MUL24
+    TEMPLATE_2_INT(Mul24, a, b, return a * b)
-int Mad24(int a, int b, int c)
-{
-    return a * b + c;
-}
-
-uint Mad24(uint a, uint b, uint c)
-{
-    return a * b + c;
-}
+    TEMPLATE_3_INT(Mad24, a, b, c, return a * b + c)
-float Min3(float a, float b, float c)
-{
-    return min(min(a, b), c);
-}
-
-float2 Min3(float2 a, float2 b, float2 c)
-{
-    return min(min(a, b), c);
-}
-
-float3 Min3(float3 a, float3 b, float3 c)
-{
-    return min(min(a, b), c);
-}
-
-float4 Min3(float4 a, float4 b, float4 c)
-{
-    return min(min(a, b), c);
-}
-
-float Max3(float a, float b, float c)
-{
-    return max(max(a, b), c);
-}
-
-float2 Max3(float2 a, float2 b, float2 c)
-{
-    return max(max(a, b), c);
-}
-
-float3 Max3(float3 a, float3 b, float3 c)
-{
-    return max(max(a, b), c);
-}
-
-float4 Max3(float4 a, float4 b, float4 c)
-{
-    return max(max(a, b), c);
-}
+    TEMPLATE_3_FLT(Min3, a, b, c, return min(min(a, b), c))
+    TEMPLATE_3_INT(Min3, a, b, c, return min(min(a, b), c))
+    TEMPLATE_3_FLT(Max3, a, b, c, return max(max(a, b), c))
+    TEMPLATE_3_INT(Max3, a, b, c, return max(max(a, b), c))
-void Swap(inout float a, inout float b)
-{
-    float  t = a; a = b; b = t;
-}
-
-void Swap(inout float2 a, inout float2 b)
-{
-    float2 t = a; a = b; b = t;
-}
-
-void Swap(inout float3 a, inout float3 b)
-{
-    float3 t = a; a = b; b = t;
-}
-
-void Swap(inout float4 a, inout float4 b)
-{
-    float4 t = a; a = b; b = t;
-}
+TEMPLATE_SWAP(Swap) // Define a Swap(a, b) function for all types
 
 #define CUBEMAPFACE_POSITIVE_X 0
 #define CUBEMAPFACE_NEGATIVE_X 1
 #endif // INTRINSIC_CUBEMAP_FACE_ID
 
 // ----------------------------------------------------------------------------
-// Common math definition and fastmath function
+// Common math functions
-#define PI          3.14159265359
-#define TWO_PI      6.28318530718
-#define FOUR_PI     12.56637061436
-#define INV_PI      0.31830988618
-#define INV_TWO_PI  0.15915494309
-#define INV_FOUR_PI 0.07957747155
-#define HALF_PI     1.57079632679
-#define INV_HALF_PI 0.636619772367
-#define INFINITY    asfloat(0x7F800000)
-#define FLT_SMALL   0.0001
-#define LOG2_E      1.44269504089
-
-#define FLT_EPSILON 1.192092896e-07 // Smallest positive number, such that 1.0 + FLT_EPSILON != 1.0
-#define FLT_MIN     1.175494351e-38 // Minimum representable positive floating-point number
-#define FLT_MAX     3.402823466e+38 // Maximum representable floating-point number
-
-#define HFLT_MIN    0.00006103515625 // 2^14  it is the same for 10, 11 and 16bit float. ref: https://www.khronos.org/opengl/wiki/Small_Float_Formats
-
-    return deg * PI / 180.0;
+    return deg * (PI / 180.0);
-    return rad * 180.0 / PI;
+    return rad * (180.0 / PI);
-float Sqr(float x)
-{
-    return x * x;
-}
-
-float3 Sqr(float3 x)
-{
-    return x * x;
-}
+TEMPLATE_1_FLT(Sq, x, return x * x)
+TEMPLATE_1_INT(Sq, x, return x * x)
 
 // Input [0, 1] and output [0, PI/2]
 // 9 VALU
 // Using pow often result to a warning like this
 // "pow(f, e) will not work for negative f, use abs(f) or conditionally handle negative values if you expect them"
 // PositivePow remove this warning when you know the value is positive and avoid inf/NAN.
-float PositivePow(float base, float power)
-{
-    return pow(max(abs(base), float(FLT_EPSILON)), power);
-}
+TEMPLATE_2_FLT(PositivePow, base, power, return pow(max(abs(base), FLT_EPS), power))
-float2 PositivePow(float2 base, float2 power)
-{
-    return pow(max(abs(base), float2(FLT_EPSILON, FLT_EPSILON)), power);
-}
-
-float3 PositivePow(float3 base, float3 power)
-{
-    return pow(max(abs(base), float3(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
-}
-
-float4 PositivePow(float4 base, float4 power)
+// Computes (FastSign(s) * x) using 2x VALU.
+// See the comment about FastSign() below.
+float FastMulBySignOf(float s, float x, bool ignoreNegZero = true)
-    return pow(max(abs(base), float4(FLT_EPSILON, FLT_EPSILON, FLT_EPSILON, FLT_EPSILON)), power);
+    if (ignoreNegZero)
+    {
+        return (s >= 0) ? x : -x;
+    }
+    else
+    {
+        uint negZero = 0x80000000u;
+        uint signBit = negZero & asuint(s);
+        return asfloat(signBit ^ asuint(x));
+    }
-// Ref: https://twitter.com/SebAaltonen/status/878250919879639040
-// 2 mads (mad_sat and mad), faster than regular sign
-float3 FastSign(float x)
+// Returns -1 for negative numbers and 1 for positive numbers.
+// 0 can be handled in 2 different ways.
+// The IEEE floating point standard defines 0 as signed: +0 and -0.
+// However, mathematics typically treats 0 as unsigned.
+// Therefore, we treat -0 as +0 by default: FastSign(+0) = FastSign(-0) = 1.
+// If (ignoreNegZero = false), FastSign(-0, false) = -1.
+// Note that the sign() function in HLSL implements signum, which returns 0 for 0.
+float FastSign(float s, bool ignoreNegZero = true)
-    return  saturate(x * FLT_MAX) * 2.0 - 1.0;
+    return FastMulBySignOf(s, 1.0, ignoreNegZero);
 }
 
 // Orthonormalizes the tangent frame using the Gram-Schmidt process.
 }
 
 // ----------------------------------------------------------------------------
-// World position reconstruction / transformation
+// Depth encoding/decoding
 // ----------------------------------------------------------------------------
 
 // Z buffer to linear 0..1 depth (0 at near plane, 1 at far plane).
 // Z buffer to linear depth.
 // Correctly handles oblique view frustums. Only valid for projection matrices!
 // Ref: An Efficient Depth Linearization Method for Oblique View Frustums, Eq. 6.
-float LinearEyeDepth(float2 positionSS, float depthRaw, float4 invProjParam)
+float LinearEyeDepth(float2 positionNDC, float deviceDepth, float4 invProjParam)
-    float4 positionCS = float4(positionSS * 2.0 - 1.0, depthRaw, 1.0);
+    float4 positionCS = float4(positionNDC * 2.0 - 1.0, deviceDepth, 1.0);
-struct PositionInputs
+// Z buffer to linear depth.
+// Correctly handles oblique view frustums.
+// Typically, this is the cheapest variant, provided you've already computed 'positionWS'.
+float LinearEyeDepth(float3 positionWS, float4x4 viewProjMatrix)
+{
+    return mul(viewProjMatrix, float4(positionWS, 1.0)).w;
+}
+
+// ----------------------------------------------------------------------------
+// Space transformations
+// ----------------------------------------------------------------------------
+
+// Use case examples:
+// (position = positionCS) => (clipSpaceTransform = use default)
+// (position = positionVS) => (clipSpaceTransform = UNITY_MATRIX_P)
+// (position = positionWS) => (clipSpaceTransform = UNITY_MATRIX_VP)
+float2 ComputeNormalizedDeviceCoordinates(float3 position, float4x4 clipSpaceTransform = k_identity4x4)
-    // Normalize screen position (offset by 0.5)
-    float2 positionSS;
-    // Unormalize screen position (offset by 0.5)
-    uint2 unPositionSS;
-    uint2 unTileCoord;
+    float4 positionCS = mul(clipSpaceTransform, float4(position, 1.0));
+    float2 positionNDC = positionCS.xy * (rcp(positionCS.w) * 0.5) + 0.5;
+#if UNITY_UV_STARTS_AT_TOP
+    positionNDC.y = 1.0 - positionNDC.y;
+#endif
+    return positionNDC;
+}
-    float depthRaw; // raw depth from depth buffer
-    float depthVS;
+float4 ComputeClipSpacePosition(float2 positionNDC, float deviceDepth)
+{
+#if UNITY_UV_STARTS_AT_TOP
+    positionNDC.y = 1.0 - positionNDC.y;
+#endif
+    return float4(positionNDC * 2.0 - 1.0, deviceDepth, 1.0);
+}
-    float3 positionWS;
+float3 ComputeViewSpacePosition(float2 positionNDC, float deviceDepth, float4x4 invProjMatrix)
+{
+    float4 positionCS = ComputeClipSpacePosition(positionNDC, deviceDepth);
+    float4 positionVS = mul(invProjMatrix, positionCS);
+    // The view space uses a right-handed coordinate system.
+    positionVS.z = -positionVS.z;
+    return positionVS.xyz / positionVS.w;
+}
+
+float3 ComputeWorldSpacePosition(float2 positionNDC, float deviceDepth, float4x4 invViewProjMatrix)
+{
+    float4 positionCS  = ComputeClipSpacePosition(positionNDC, deviceDepth);
+    float4 hpositionWS = mul(invViewProjMatrix, positionCS);
+    return hpositionWS.xyz / hpositionWS.w;
+}
+
+// ----------------------------------------------------------------------------
+// PositionInputs
+// ----------------------------------------------------------------------------
+
+struct PositionInputs
+{
+    float3 positionWS;  // World space position (could be camera-relative)
+    float2 positionNDC; // Normalized screen UVs          : [0, 1) (with the half-pixel offset)
+    uint2  positionSS;  // Screen space pixel coordinates : [0, NumPixels)
+    uint2  tileCoord;   // Screen tile coordinates        : [0, NumTiles)
+    float  deviceDepth; // Depth from the depth buffer    : [0, 1] (typically reversed)
+    float  linearDepth; // View space Z coordinate        : [Near, Far]
-// If a compute shader call this function unPositionSS is an integer usually calculate like: uint2 unPositionSS = groupId.xy * BLOCK_SIZE + groupThreadId.xy
+// If a compute shader call this function positionSS is an integer usually calculate like: uint2 positionSS = groupId.xy * BLOCK_SIZE + groupThreadId.xy
-PositionInputs GetPositionInput(float2 unPositionSS, float2 invScreenSize, uint2 unTileCoord)   // Specify explicit tile coordinates so that we can easily make it lane invariant for compute evaluation.
+PositionInputs GetPositionInput(float2 positionSS, float2 invScreenSize, uint2 tileCoord)   // Specify explicit tile coordinates so that we can easily make it lane invariant for compute evaluation.
-    posInput.positionSS = unPositionSS;
+    posInput.positionNDC = positionSS;
-    posInput.positionSS.xy += float2(0.5, 0.5);
+    posInput.positionNDC.xy += float2(0.5, 0.5);
-    posInput.positionSS *= invScreenSize;
+    posInput.positionNDC *= invScreenSize;
-    posInput.unPositionSS = uint2(unPositionSS);
-    posInput.unTileCoord = unTileCoord;
+    posInput.positionSS = uint2(positionSS);
+    posInput.tileCoord = tileCoord;
-PositionInputs GetPositionInput(float2 unPositionSS, float2 invScreenSize)
+PositionInputs GetPositionInput(float2 positionSS, float2 invScreenSize)
-    return GetPositionInput(unPositionSS, invScreenSize, uint2(0, 0));
+    return GetPositionInput(positionSS, invScreenSize, uint2(0, 0));
-// depthRaw and depthVS come directly form .zw of SV_Position
-void UpdatePositionInput(float depthRaw, float depthVS, float3 positionWS, inout PositionInputs posInput)
-{
-    posInput.depthRaw   = depthRaw;
-    posInput.depthVS    = depthVS;
-    posInput.positionWS = positionWS;
-}
-
-float4 ComputeClipSpacePosition(float2 positionSS, float depthRaw)
-{
-#if UNITY_UV_STARTS_AT_TOP
-    positionSS.y = 1.0 - positionSS.y;
-#endif
-    return float4(positionSS * 2.0 - 1.0, depthRaw, 1.0);
-}
-
-float2 ComputeScreenSpacePosition(float4 positionCS)
-{
-    float2 positionSS = positionCS.xy * (rcp(positionCS.w) * 0.5) + 0.5;
-#if UNITY_UV_STARTS_AT_TOP
-    positionSS.y = 1.0 - positionSS.y;
-#endif
-    return positionSS;
-}
-
-float2 ComputeScreenSpacePosition(float3 positionWS, float4x4 viewProjectionMatrix)
-{
-    float4 positionCS = mul(viewProjectionMatrix, float4(positionWS, 1.0));
-    return ComputeScreenSpacePosition(positionCS);
-}
-
-float3 ComputeViewSpacePosition(float2 positionSS, float depthRaw, float4x4 invProjMatrix)
+// deviceDepth and linearDepth come directly from .zw of SV_Position
+void UpdatePositionInput(float deviceDepth, float linearDepth, float3 positionWS, inout PositionInputs posInput)
-    float4 positionCS = ComputeClipSpacePosition(positionSS, depthRaw);
-    float4 positionVS = mul(invProjMatrix, positionCS);
-    // The view space uses a right-handed coordinate system.
-    positionVS.z = -positionVS.z;
-    return positionVS.xyz / positionVS.w;
-}
-
-float3 ComputeWorldSpacePosition(float2 positionSS, float depthRaw, float4x4 invViewProjMatrix)
-{
-    float4 positionCS  = ComputeClipSpacePosition(positionSS, depthRaw);
-    float4 hpositionWS = mul(invViewProjMatrix, positionCS);
-    return hpositionWS.xyz / hpositionWS.w;
+    posInput.deviceDepth = deviceDepth;
+    posInput.linearDepth = linearDepth;
+    posInput.positionWS  = positionWS;
-void UpdatePositionInput(float depthRaw, float4x4 invViewProjMatrix, float4x4 viewProjMatrix, inout PositionInputs posInput)
+void UpdatePositionInput(float deviceDepth, float4x4 invViewProjMatrix, float4x4 viewProjMatrix, inout PositionInputs posInput)
-    posInput.depthRaw = depthRaw;
-
-    posInput.positionWS = ComputeWorldSpacePosition(posInput.positionSS, depthRaw, invViewProjMatrix);
+    posInput.deviceDepth = deviceDepth;
+    posInput.positionWS  = ComputeWorldSpacePosition(posInput.positionNDC, deviceDepth, invViewProjMatrix);
-    posInput.depthVS = mul(viewProjMatrix, float4(posInput.positionWS, 1.0)).w;
+    posInput.linearDepth = mul(viewProjMatrix, float4(posInput.positionWS, 1.0)).w;
 }
 
 // The view direction 'V' points towards the camera.
     posInput.positionWS += depthOffsetVS * (-V);
 
-    float4 positionCS = mul(viewProjMatrix, float4(posInput.positionWS, 1.0));
-    posInput.depthVS  = positionCS.w;
-    posInput.depthRaw = positionCS.z / positionCS.w;
+    float4 positionCS    = mul(viewProjMatrix, float4(posInput.positionWS, 1.0));
+    posInput.linearDepth = positionCS.w;
+    posInput.deviceDepth = positionCS.z / positionCS.w;
 }
 
 // ----------------------------------------------------------------------------
 // LOD dithering transition helper
 // LOD0 must use this function with ditherFactor 1..0
 // LOD1 must use this function with ditherFactor 0..1
-void LODDitheringTransition(uint2 unPositionSS, float ditherFactor)
+void LODDitheringTransition(uint2 positionSS, float ditherFactor)
-    float p = GenerateHashedRandomFloat(unPositionSS);
+    float p = GenerateHashedRandomFloat(positionSS);
 
     // We want to have a symmetry between 0..0.5 ditherFactor and 0.5..1 so no pixels are transparent during the transition
     // this is handled by this test which reverse the pattern
+
 
 #endif // UNITY_COMMON_INCLUDED

ScriptableRenderPipeline/Core/ShaderLibrary/CommonLighting.hlsl

 // These clamping function to max of floating point 16 bit are use to prevent INF in code in case of extreme value
 float ClampToFloat16Max(float value)
 {
-    return min(value, 65504.0);
+    return min(value, HALF_MAX);
-    return min(value, 65504.0);
+    return min(value, HALF_MAX);
-    return min(value, 65504.0);
+    return min(value, HALF_MAX);
-    return min(value, 65504.0);
+    return min(value, HALF_MAX);
 }
 
 // Ligthing convention
     return area;
 }
 
+// Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
+float ComputeWrappedDiffuseLighting(float NdotL, float w)
+{
+    return saturate((NdotL + w) / ((1 + w) * (1 + w)));
+}
+
 //-----------------------------------------------------------------------------
 // Helper functions
 //-----------------------------------------------------------------------------
 
     NdotV = dot(N, V);
 
-    N = (NdotV >= 0) ? N : (N - 2 * NdotV * V);
+    N = (NdotV >= 0.0) ? N : (N - 2.0 * NdotV * V);
     NdotV = abs(NdotV);
 
     return N;
     float x  = localZ.x;
     float y  = localZ.y;
     float z  = localZ.z;
-    float sz = z >= 0 ? 1 : -1;
+    float sz = FastSign(z);
     float a  = 1 / (sz + z);
     float ya = y * a;
     float b  = x * ya;
     return float3x3(localX, localY, localZ);
 }
 
+float3x3 GetLocalFrame(float3 localZ, float3 localX)
+{
+    float3 localY = cross(localZ, localX);
+
+    return float3x3(localX, localY, localZ);
+}
+
-    return Sqr((ior - 1.0) / (ior + 1.0));
+    return Sq((ior - 1.0) / (ior + 1.0));
 }
 
 #endif // UNITY_COMMON_LIGHTING_INCLUDED

ScriptableRenderPipeline/Core/ShaderLibrary/CommonMaterial.hlsl

 #define UNITY_COMMON_MATERIAL_INCLUDED
 
 //-----------------------------------------------------------------------------
-// Helper function for anisotropy
-//-----------------------------------------------------------------------------
-
-void ConvertAnisotropyToRoughness(float roughness, float anisotropy, out float roughnessT, out float roughnessB)
-{
-    // Use the parametrization of Sony Imageworks.
-    // Ref: Revisiting Physically Based Shading at Imageworks, p. 15.
-    roughnessT = roughness * (1 + anisotropy);
-    roughnessB = roughness * (1 - anisotropy);
-}
-
-//-----------------------------------------------------------------------------
-// Helper function for perceptual roughness
+// Helper functions for roughness
 //-----------------------------------------------------------------------------
 
 float PerceptualRoughnessToRoughness(float perceptualRoughness)
 float PerceptualSmoothnessToPerceptualRoughness(float perceptualSmoothness)
 {
     return (1.0 - perceptualSmoothness);
+}
+
+// Using roughness values of 0 leads to INFs and NANs. The only sensible place to use the roughness
+// value of 0 is IBL, so we do not modify the perceptual roughness which is used to select the MIP map level.
+// Note: making the constant too small results in aliasing.
+float ClampRoughnessForAnalyticalLights(float roughness)
+{
+    return max(roughness, 1.0/1024.0);
+}
+
+// 'bsdfData.roughnessT' and 'bsdfData.roughnessB' are clamped, and are meant to be used with analytical lights.
+// 'bsdfData.perceptualRoughness' is not clamped, and is meant to be used for IBL.
+// If IBL needs the linear roughness value for some reason, it can be computed as follows:
+// float roughness = PerceptualRoughnessToRoughness(bsdfData.perceptualRoughness);
+void ConvertAnisotropyToRoughness(float perceptualRoughness, float anisotropy, out float roughnessT, out float roughnessB)
+{
+    float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+
+    // Use the parametrization of Sony Imageworks.
+    // Ref: Revisiting Physically Based Shading at Imageworks, p. 15.
+    roughnessT = roughness * (1 + anisotropy);
+    roughnessB = roughness * (1 - anisotropy);
+
+    roughnessT = ClampRoughnessForAnalyticalLights(roughnessT);
+    roughnessB = ClampRoughnessForAnalyticalLights(roughnessB);
 }
 
 // ----------------------------------------------------------------------------
     return float3(oneMinusT, oneMinusT, oneMinusT) + b * t;
 }
 
-// ----------------------------------------------------------------------------
-// SSS/Transmittance
-// ----------------------------------------------------------------------------
-
-// Computes the fraction of light passing through the object.
-// Evaluate Int{0, inf}{2 * Pi * r * R(sqrt(r^2 + d^2))}, where R is the diffusion profile.
-// Note: 'volumeAlbedo' should be premultiplied by 0.25.
-// Ref: Approximate Reflectance Profiles for Efficient Subsurface Scattering by Pixar (BSSRDF only).
-float3 ComputeTransmittanceDisney(float3 S, float3 volumeAlbedo, float thickness, float radiusScale)
-{
-    // Thickness and SSS radius are decoupled for artists.
-    // In theory, we should modify the thickness by the inverse of the radius scale of the profile.
-    // thickness /= radiusScale;
-
-#if 0
-    float3 expOneThird = exp(((-1.0 / 3.0) * thickness) * S);
-#else
-    // Help the compiler.
-    float  k = (-1.0 / 3.0) * LOG2_E;
-    float3 p = (k * thickness) * S;
-    float3 expOneThird = exp2(p);
-#endif
-
-    // Premultiply & optimize: T = (1/4 * A) * (e^(-t * S) + 3 * e^(-1/3 * t * S))
-    return volumeAlbedo * (expOneThird * expOneThird * expOneThird + 3 * expOneThird);
-}
-
-// Evaluates transmittance for a linear combination of two normalized 2D Gaussians.
-// Ref: Real-Time Realistic Skin Translucency (2010), equation 9 (modified).
-// Note: 'volumeAlbedo' should be premultiplied by 0.25, correspondingly 'lerpWeight' by 4,
-// and 'halfRcpVariance1' should be prescaled by (0.1 * SssConstants.SSS_BASIC_DISTANCE_SCALE)^2.
-float3 ComputeTransmittanceJimenez(float3 halfRcpVariance1, float lerpWeight1,
-                                   float3 halfRcpVariance2, float lerpWeight2,
-                                   float3 volumeAlbedo, float thickness, float radiusScale)
-{
-    // Thickness and SSS radius are decoupled for artists.
-    // In theory, we should modify the thickness by the inverse of the radius scale of the profile.
-    // thickness /= radiusScale;
-
-    float t2 = thickness * thickness;
-
-    // T = A * lerp(exp(-t2 * halfRcpVariance1), exp(-t2 * halfRcpVariance2), lerpWeight2)
-    return volumeAlbedo * (exp(-t2 * halfRcpVariance1) * lerpWeight1 + exp(-t2 * halfRcpVariance2) * lerpWeight2);
-}
-
-// Ref: Steve McAuley - Energy-Conserving Wrapped Diffuse
-float ComputeWrappedDiffuseLighting(float NdotL, float w)
-{
-    return saturate((NdotL + w) / ((1 + w) * (1 + w)));
-}
-
-// In order to support subsurface scattering, we need to know which pixels have an SSS material.
-// It can be accomplished by reading the stencil buffer.
-// A faster solution (which avoids an extra texture fetch) is to simply make sure that
-// all pixels which belong to an SSS material are not black (those that don't always are).
-float3 TagLightingForSSS(float3 subsurfaceLighting)
-{
-    subsurfaceLighting.r = max(subsurfaceLighting.r, HFLT_MIN);
-    return subsurfaceLighting;
-}
-
-// See TagLightingForSSS() for details.
-bool TestLightingForSSS(float3 subsurfaceLighting)
-{
-    return subsurfaceLighting.r > 0;
-}
-
-// MACRO from Legacy Untiy
-// Transforms 2D UV by scale/bias property
-#define TRANSFORM_TEX(tex, name) ((tex.xy) * name##_ST.xy + name##_ST.zw)
-
-#define GET_TEXELSIZE_NAME(name) (name##_TexelSize)
 
 #endif // UNITY_COMMON_MATERIAL_INCLUDED

ScriptableRenderPipeline/Core/ShaderLibrary/ImageBasedLighting.hlsl

     float m = PerceptualRoughnessToRoughness(perceptualRoughness);
 
     // Remap to spec power. See eq. 21 in --> https://dl.dropboxusercontent.com/u/55891920/papers/mm_brdf.pdf
-    float n = (2.0 / max(FLT_EPSILON, m * m)) - 2.0;
+    float n = (2.0 / max(FLT_EPS, m * m)) - 2.0;
-    n /= (4.0 * max(NdotR, FLT_EPSILON));
+    n /= (4.0 * max(NdotR, FLT_EPS));
 
     // remap back to square root of real roughness (0.25 include both the sqrt root of the conversion and sqrt for going from roughness to perceptualRoughness)
     perceptualRoughness = pow(2.0 / (n + 2.0), 0.25);
     }
 
     // Prevent NaNs arising from the division of 0 by 0.
-    cbsdfInt = max(cbsdfInt, FLT_MIN);
+    cbsdfInt = max(cbsdfInt, FLT_EPS);
 
     return float4(lightInt / cbsdfInt, 1.0);
 }

ScriptableRenderPipeline/Core/ShaderLibrary/NormalSurfaceGradient.hlsl

 float3 SurfaceGradientFromPerturbedNormal(float3 nrmVertexNormal, float3 v)
 {
     float3 n = nrmVertexNormal;
-    float s = 1.0 / max(FLT_EPSILON, abs(dot(n, v)));
+    float s = 1.0 / max(FLT_EPS, abs(dot(n, v)));
     return s * (dot(n, v) * n - v);
 }
 

ScriptableRenderPipeline/Core/ShaderLibrary/Packing.hlsl

 #ifndef UNITY_PACKING_INCLUDED
 #define UNITY_PACKING_INCLUDED
 
-#include "Common.hlsl"
-
 //-----------------------------------------------------------------------------
 // Normal packing
 //-----------------------------------------------------------------------------
 // Packs an integer stored using at most 'numBits' into a [0..1] float.
 float PackInt(uint i, uint numBits)
 {
-    uint maxInt = 0xFFFFFFFFu >> (32u - numBits);
+    uint maxInt = UINT_MAX >> (32u - numBits);
     return saturate(i * rcp(maxInt));
 }
 
-    uint maxInt = 0xFFFFFFFFu >> (32u - numBits);
+    uint maxInt = UINT_MAX >> (32u - numBits);
     return (uint)(f * maxInt + 0.5); // Round instead of truncating
 }
 
 
 float UnpackUIntToFloat(uint src, uint numBits, uint offset)
 {
-    uint maxInt = 0xFFFFFFFFu >> (32u - numBits);
+    uint maxInt = UINT_MAX >> (32u - numBits);
     return float(BitFieldExtract(src, numBits, offset)) * rcp(maxInt);
 }
 

ScriptableRenderPipeline/Core/ShaderLibrary/Sampling.hlsl

     return TransformGLtoDX(SphericalToCartesian(phi, cosTheta));
 }
 
+// Convert a texel position into normalized position [-1..1]x[-1..1]
+float2 CubemapTexelToNVC(uint2 unPositionTXS, uint cubemapSize)
+{
+    return 2.0 * float2(unPositionTXS) / float(max(cubemapSize - 1, 1)) - 1.0;
+}
+
+// Map cubemap face to world vector basis
+static const float3 CUBEMAP_FACE_BASIS_MAPPING[6][3] =
+{
+    //XPOS face
+    {
+        float3(0.0, 0.0, -1.0),
+        float3(0.0, -1.0, 0.0),
+        float3(1.0, 0.0, 0.0)
+    },
+    //XNEG face
+    {
+        float3(0.0, 0.0, 1.0),
+        float3(0.0, -1.0, 0.0),
+        float3(-1.0, 0.0, 0.0)
+    },
+    //YPOS face
+    {
+        float3(1.0, 0.0, 0.0),
+        float3(0.0, 0.0, 1.0),
+        float3(0.0, 1.0, 0.0)
+    },
+    //YNEG face
+    {
+        float3(1.0, 0.0, 0.0),
+        float3(0.0, 0.0, -1.0),
+        float3(0.0, -1.0, 0.0)
+    },
+    //ZPOS face
+    {
+        float3(1.0, 0.0, 0.0),
+        float3(0.0, -1.0, 0.0),
+        float3(0.0, 0.0, 1.0)
+    },
+    //ZNEG face
+    {
+        float3(-1.0, 0.0, 0.0),
+        float3(0.0, -1.0, 0.0),
+        float3(0.0, 0.0, -1.0)
+    }
+};
+
+// Convert a normalized cubemap face position into a direction
+float3 CubemapTexelToDirection(float2 positionNVC, uint faceId)
+{
+    float3 dir = CUBEMAP_FACE_BASIS_MAPPING[faceId][0] * positionNVC.x
+               + CUBEMAP_FACE_BASIS_MAPPING[faceId][1] * positionNVC.y
+               + CUBEMAP_FACE_BASIS_MAPPING[faceId][2];
+
+    return normalize(dir);
+}
+
 //-----------------------------------------------------------------------------
 // Sampling function
 // Reference : http://www.cs.virginia.edu/~jdl/bib/globillum/mis/shirley96.pdf + PBRT

ScriptableRenderPipeline/Core/ShaderLibrary/Shadow/Shadow.hlsl

 #ifndef SHADOW_HLSL
 #define SHADOW_HLSL
+
-// First ShadowContext.hlsl must declare the specific ShadowContext struct and the loader that goes along with it.
+// First ShadowContext.hlsl provides a macro SHADOWCONTEXT_DECLARE that must be used in order to define the specific ShadowContext struct and accompanying loader.
-// Second there are two headers for shadow algorithms, whose signatures must match any of the Get...Attenuation function prototypes.
-// The first header contains engine defaults, whereas the second header is empty by default. All project specific custom shadow algorithms should go in there or leave empty.
-//
-// Last there's a dispatcher include. By default the Get...Attenuation functions are rerouted to their default implementations. This can be overridden for each
-// shadow type in the dispatcher source. For each overridden shadow type a specific define must be defined to prevent falling back to the default functions.
-//
+
+/* Required defines: (define these to the desired numbers - must be in sync with loading and resource setup from C#)
+#define SHADOWCONTEXT_MAX_TEX2DARRAY   0
+#define SHADOWCONTEXT_MAX_TEXCUBEARRAY 0
+#define SHADOWCONTEXT_MAX_SAMPLER      0
+#define SHADOWCONTEXT_MAX_COMPSAMPLER  0
+*/
+/* Default values for optional defines:
+#define SHADOW_SUPPORTS_DYNAMIC_INDEXING 0        // Dynamic indexing only works on >= sm 5.1
+#define SHADOW_OPTIMIZE_REGISTER_USAGE   0        // Redefine this as 1 in your ShadowContext.hlsl to optimize for register usage over instruction count
+// #define SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL    // Enable custom implementations of GetPunctualShadowAttenuation. If not defined, a default implementation will be used.
+// #define SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL // Enable custom implementations of GetDirectionalShadowAttenuation. If not defined, a default implementation will be used.
+*/
-#define SHADOW_SUPPORTS_DYNAMIC_INDEXING 0 // only on >= sm 5.1
-#define SHADOW_OPTIMIZE_REGISTER_USAGE   0 // redefine this as 1 in your ShadowContext.hlsl to optimize for register usage over instruction count
+#ifndef SHADOW_SUPPORTS_DYNAMIC_INDEXING
+    #define SHADOW_SUPPORTS_DYNAMIC_INDEXING 0
+#endif
+#ifndef SHADOW_OPTIMIZE_REGISTER_USAGE
+    #define SHADOW_OPTIMIZE_REGISTER_USAGE   0
+#endif
-#include "../../../Core/Shadow/ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
+#include "Shadow/ShadowBase.cs.hlsl"	// ShadowData definition, auto generated (don't modify)
-// Declares a shadow context struct with members and sampling code based on whether _...Slots > 0
-#define SHADOWCONTEXT_DECLARE( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )				\
-																													\
-	struct ShadowContext																							\
-	{																												\
-		StructuredBuffer<ShadowData>	shadowDatas;																\
-		StructuredBuffer<int4>			payloads;																	\
-		SHADOWCONTEXT_DECLARE_TEXTURES( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )	\
-	};																												\
-																													\
-	SHADOW_DEFINE_SAMPLING_FUNCS( _Tex2DArraySlots, _TexCubeArraySlots, _SamplerCompSlots, _SamplerSlots )
+struct ShadowContext
+{
+    StructuredBuffer<ShadowData>	shadowDatas;
+    StructuredBuffer<int4>			payloads;
+    SHADOWCONTEXT_DECLARE_TEXTURES( SHADOWCONTEXT_MAX_TEX2DARRAY, SHADOWCONTEXT_MAX_TEXCUBEARRAY, SHADOWCONTEXT_MAX_COMPSAMPLER, SHADOWCONTEXT_MAX_SAMPLER )
+};
-
-// Shadow context definition and initialization, i.e. resource binding (project header, must be kept in sync with C# runtime)
-#define SHADOW_CONTEXT_INCLUDE
-#include "../../ShadowIncludes.hlsl"
-#undef SHADOW_CONTEXT_INCLUDE
+SHADOW_DEFINE_SAMPLING_FUNCS( SHADOWCONTEXT_MAX_TEX2DARRAY, SHADOWCONTEXT_MAX_TEXCUBEARRAY, SHADOWCONTEXT_MAX_COMPSAMPLER, SHADOWCONTEXT_MAX_SAMPLER )
 
 // helper function to extract shadowmap data from the ShadowData struct
 void UnpackShadowmapId( uint shadowmapId, out uint texIdx, out uint sampIdx, out float slice )
 	shadowType = packedShadowType >> 10;
 }
 
-
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS );
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 positionSS );
+
-float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS );
-
+float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 positionSS );
-// wedge in the actual shadow sampling algorithms
-#include "ShadowAlgorithmsCustom.hlsl"	// project specific custom algorithms (project can modify this)
-
-// default dispatchers for the individual shadow types (with and without screenspace support)
-// point/spot light shadows
-float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L )
-{
-	return EvalShadow_PunctualDepth(shadowContext, positionWS, normalWS, shadowDataIndex, L);
-}
-float GetPunctualShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
-{
-	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
-}
-// directional light shadows
-float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L )
-{
-	return EvalShadow_CascadedDepth_Blend( shadowContext, positionWS, normalWS, shadowDataIndex, L );
-}
-float GetDirectionalShadowAttenuationDefault( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
-{
-	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
-}
-
-// include project specific shadow dispatcher. If this file is not empty, it MUST define which default shadows it's overriding
-#define SHADOW_DISPATCH_INCLUDE
-#include "../../ShadowIncludes.hlsl"
-#undef SHADOW_DISPATCH_INCLUDE
-
-// if shadow dispatch is empty we'll fall back to default shadow sampling implementations
-	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+    return EvalShadow_PunctualDepth(shadowContext, positionWS, normalWS, shadowDataIndex, L);
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
+
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 positionSS )
-	return GetPunctualShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L, unPositionSS );
+    return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+
-	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L );
+    return EvalShadow_CascadedDepth_Blend( shadowContext, positionWS, normalWS, shadowDataIndex, L );
-float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+
+float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 positionSS )
-	return GetDirectionalShadowAttenuationDefault( shadowContext, positionWS, normalWS, shadowDataIndex, L, unPositionSS );
+    return GetDirectionalShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }
 #endif
 

ScriptableRenderPipeline/Core/ShaderLibrary/Tessellation.hlsl

 float3 GetScreenSpaceTessFactor(float3 p0, float3 p1, float3 p2, float4x4 viewProjectionMatrix, float4 screenSize, float triangleSize)
 {
     // Get screen space adaptive scale factor
-    float2 edgeScreenPosition0 = ComputeScreenSpacePosition(p0, viewProjectionMatrix) * screenSize;
-    float2 edgeScreenPosition1 = ComputeScreenSpacePosition(p1, viewProjectionMatrix) * screenSize;
-    float2 edgeScreenPosition2 = ComputeScreenSpacePosition(p2, viewProjectionMatrix) * screenSize;
+    float2 edgeScreenPosition0 = ComputeNormalizedDeviceCoordinates(p0, viewProjectionMatrix) * screenSize.xy;
+    float2 edgeScreenPosition1 = ComputeNormalizedDeviceCoordinates(p1, viewProjectionMatrix) * screenSize.xy;
+    float2 edgeScreenPosition2 = ComputeNormalizedDeviceCoordinates(p2, viewProjectionMatrix) * screenSize.xy;
 
     float EdgeScale = 1.0 / triangleSize; // Edge size in reality, but name is simpler
     float3 tessFactor;

ScriptableRenderPipeline/Core/ShaderLibrary/VolumeRendering.hlsl

 // Absorption coefficient from Disney: http://blog.selfshadow.com/publications/s2015-shading-course/burley/s2015_pbs_disney_bsdf_notes.pdf
 float3 TransmittanceColorAtDistanceToAbsorption(float3 transmittanceColor, float atDistance)
 {
-    return -log(transmittanceColor + 0.00001) / max(atDistance, 0.000001);
+    return -log(transmittanceColor + FLT_EPS) / max(atDistance, FLT_EPS);
 }
 
 

ScriptableRenderPipeline/Core/Shadow/Resources/DebugDisplayShadowMap.shader

 {
     HLSLINCLUDE
         #pragma target 4.5
-        #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+        #pragma only_renderers d3d11 ps4 vulkan metal // TEMP: until we go further in dev
-        #include "../../../Core/ShaderLibrary/Common.hlsl"
+        #include "ShaderLibrary/Common.hlsl"
 
         float4 _TextureScaleBias;
         float _TextureSlice;

ScriptableRenderPipeline/Core/Shadow/Shadow.cs

 namespace UnityEngine.Experimental.Rendering
 {
     using ShadowRequestVector = VectorArray<ShadowmapBase.ShadowRequest>;
-    using ShadowDataVector    = VectorArray<ShadowData>;
+    using ShadowDataVector = VectorArray<ShadowData>;
-    using ShadowAlgoVector    = VectorArray<GPUShadowAlgorithm>;
+    using ShadowAlgoVector = VectorArray<GPUShadowAlgorithm>;
+    using Profiling;
 
     // Standard shadow map atlas implementation using one large shadow map
     public class ShadowAtlas : ShadowmapBase, IDisposable
         protected          float[]                    m_TmpBorders = new float[((k_MaxCascadesInShader+3)/4)*4];
         protected          ShadowAlgoVector           m_SupportedAlgorithms = new ShadowAlgoVector( 0, false );
         protected          Material                   m_DebugMaterial = null;
+
+        private CustomSampler   m_SamplerShadowMaps = CustomSampler.Create("ShadowMaps");
 
         protected struct Key
         {
         {
             m_Shadowmap = new RenderTexture( (int) m_Width, (int) m_Height, (int) m_ShadowmapBits, m_ShadowmapFormat, RenderTextureReadWrite.Linear );
             CreateShadowmap( m_Shadowmap );
+            m_Shadowmap.Create();
         }
 
         virtual protected void CreateShadowmap( RenderTexture shadowmap )
         {
             if (m_ActiveEntriesCount == 0)
                 return;
-
-            var profilingSample = new ProfilingSample(cmd, "Shadowmap{0}", m_TexSlot);
+            string sLabel = string.Format("Shadowmap{0}", m_TexSlot);
+            var profilingSample = new ProfilingSample(cmd, sLabel, m_SamplerShadowMaps);
 
             string cbName = "";
             if (!string.IsNullOrEmpty( m_ShaderKeyword ) )
         private ShadowRequestVector m_TmpRequests   = new ShadowRequestVector( 0, false );
         // The following vector holds data that are returned to the caller so it can be sent to GPU memory in some form. Contents are stable in between calls to ProcessShadowRequests.
         private ShadowIndicesVector m_ShadowIndices = new ShadowIndicesVector( 0, false );
-
+        private CustomSampler   m_SamplerRenderShadows = CustomSampler.Create("RenderShadows");
 
         public override uint GetShadowMapCount()
         {
 
         public override void RenderShadows( FrameId frameId, ScriptableRenderContext renderContext, CommandBuffer cmd, CullResults cullResults, List<VisibleLight> lights)
         {
-            using (new ProfilingSample(cmd, "Render Shadows"))
+            using (new ProfilingSample(cmd, "Render Shadows", m_SamplerRenderShadows))
             {
                 foreach( var sm in m_Shadowmaps )
                 {

ScriptableRenderPipeline/Core/TextureCache.cs

 using UnityEngine;
 using System.Collections.Generic;
+using UnityEngine.Rendering;
 #if UNITY_EDITOR
 using UnityEditor;
 #endif
     {
         private Texture2DArray m_Cache;
 
-        public override void TransferToSlice(int sliceIndex, Texture texture)
+        public override void TransferToSlice(CommandBuffer cmd, int sliceIndex, Texture texture)
         {
             var mismatch = (m_Cache.width != texture.width) || (m_Cache.height != texture.height);
 
 
             if (mismatch)
             {
-                if (!Graphics.ConvertTexture(texture, 0, m_Cache, sliceIndex))
-                {
-                    Debug.LogErrorFormat(texture, "Unable to convert texture \"{0}\" to match renderloop settings ({1}x{2} {3})",
-                        texture.name, m_Cache.width, m_Cache.height, m_Cache.format);
-                }
+                cmd.ConvertTexture(texture, 0, m_Cache, sliceIndex);
-                Graphics.CopyTexture(texture, 0, m_Cache, sliceIndex);
+                cmd.CopyTexture(texture, 0, m_Cache, sliceIndex);
             }
         }
 
         private int m_CubeMipLevelPropName;
         private int m_cubeSrcTexPropName;
 
-        public override void TransferToSlice(int sliceIndex, Texture texture)
+        public override void TransferToSlice(CommandBuffer cmd, int sliceIndex, Texture texture)
-                TransferToPanoCache(sliceIndex, texture);
+                TransferToPanoCache(cmd, sliceIndex, texture);
             else
             {
                 var mismatch = (m_Cache.width != texture.width) || (m_Cache.height != texture.height);
 
                 if (mismatch)
                 {
-                    bool failed = false;
-
-                        if (!Graphics.ConvertTexture(texture, f, m_Cache, 6 * sliceIndex + f))
-                        {
-                            failed = true;
-                            break;
-                        }
-                    }
-
-                    if (failed)
-                    {
-                        Debug.LogErrorFormat(texture, "Unable to convert texture \"{0}\" to match renderloop settings ({1}x{2} {3})",
-                            texture.name, m_Cache.width, m_Cache.height, m_Cache.format);
+                        cmd.ConvertTexture(texture, f, m_Cache, 6 * sliceIndex + f);
-                        Graphics.CopyTexture(texture, f, m_Cache, 6 * sliceIndex + f);
+                        cmd.CopyTexture(texture, f, m_Cache, 6 * sliceIndex + f);
                 }
             }
         }
                 Texture.DestroyImmediate(m_Cache);
         }
 
-        private void TransferToPanoCache(int sliceIndex, Texture texture)
+        private void TransferToPanoCache(CommandBuffer cmd, int sliceIndex, Texture texture)
-                Graphics.SetRenderTarget(m_StagingRTs[m]);
-                Graphics.Blit(null, m_CubeBlitMaterial, 0);
+                cmd.Blit(null, m_StagingRTs[m], m_CubeBlitMaterial, 0);
-                Graphics.CopyTexture(m_StagingRTs[m], 0, 0, m_CacheNoCubeArray, sliceIndex, m);
+                cmd.CopyTexture(m_StagingRTs[m], 0, 0, m_CacheNoCubeArray, sliceIndex, m);
         }
     }
 
             }
         }
 
-        public static TextureFormat GetPreferredHdrCompressedTextureFormat
+        public static TextureFormat GetPreferredHDRCompressedTextureFormat
         {
             get
             {
 
-                // On editor the texture is uncompressed when operating against mobile build targets
+//                // On editor the texture is uncompressed when operating against mobile build targets
 //#if UNITY_2017_2_OR_NEWER
                 if (SystemInfo.SupportsTextureFormat(probeFormat) && !UnityEngine.Rendering.GraphicsSettings.HasShaderDefine(UnityEngine.Rendering.BuiltinShaderDefine.UNITY_NO_DXT5nm))
                     format = probeFormat;
         {
             public uint    texId;
             public uint    countLRU;
-        #if UNITY_EDITOR
-            public Hash128 hash;
-        #endif
+            public uint    sliceEntryHash;
         };
 
         private int m_NumTextures;
         private static uint g_MaxFrameCount = unchecked((uint)(-1));
         private static uint g_InvalidTexID = (uint)0;
 
-        public int FetchSlice(Texture texture, bool forceReinject=false)
+
+        public uint GetTextureHash(Texture texture)
-            var sliceIndex = -1;
+            uint textureHash  = texture.updateCount;
+            // For baked probes in the editor we need to factor in the actual hash of texture because we can't increment the update count of a texture that's baked on the disk.
+            // This code leaks logic from reflection probe baking into the texture cache which is not good... TODO: Find a way to do that outside of the texture cache.
+#if UNITY_EDITOR
+            textureHash += (uint)texture.imageContentsHash.GetHashCode();
+#endif
+            return textureHash;
+        }
+        public int ReserveSlice(Texture texture, out bool needUpdate)
+        {
+            needUpdate = false;
-                return sliceIndex;
+                return -1;
-        #if UNITY_EDITOR
-            var hash  = texture.imageContentsHash;
-        #endif
-
-            //assert(TexID!=g_InvalidTexID);
-            if (texId == g_InvalidTexID) return 0;
-
-            var bSwapSlice = forceReinject;
-            var bFoundAvailOrExistingSlice = false;
+            if (texId == g_InvalidTexID)
+                return -1;
-            int cachedSlice;
-            if (m_LocatorInSliceArray.TryGetValue(texId, out cachedSlice))
+            var sliceIndex = -1;
+            var foundIndex = -1;
+            if (m_LocatorInSliceArray.TryGetValue(texId, out foundIndex))
-                sliceIndex = cachedSlice;
+                sliceIndex = foundIndex;
+
+                var textureHash  = GetTextureHash(texture);
+                needUpdate |= (m_SliceArray[sliceIndex].sliceEntryHash != textureHash);
+
-
-                bFoundAvailOrExistingSlice = true;
-            #if UNITY_EDITOR
-                bSwapSlice = bSwapSlice || (m_SliceArray[sliceIndex].hash != hash);
-            #endif
-            if (!bFoundAvailOrExistingSlice)
+            if(sliceIndex == -1)
             {
                 // look for first non zero entry. Will by the least recently used entry
                 // since the array was pre-sorted (in linear time) in NewFrame()
                 {
                     idx = m_SortedIdxArray[j];
-                    if (m_SliceArray[idx].countLRU == 0) ++j;       // if entry already snagged by a new texture in this frame then ++j
-                    else bFound = true;
+                    if (m_SliceArray[idx].countLRU == 0)
+                        ++j;       // if entry already snagged by a new texture in this frame then ++j
+                    else
+                        bFound = true;
+                    needUpdate = true;
                     // if we are replacing an existing entry delete it from m_locatorInSliceArray.
                     if (m_SliceArray[idx].texId != g_InvalidTexID)
                     {
                     m_SliceArray[idx].texId = texId;
 
                     sliceIndex = idx;
-                    bFoundAvailOrExistingSlice = true;
-                    bSwapSlice = true;
-            // wrap up
-            Debug.Assert(bFoundAvailOrExistingSlice, "The texture cache doesn't have enough space to store all textures. Please either increase the size of the texture cache, or use fewer unique textures.");
-            if (bFoundAvailOrExistingSlice)
+            if(sliceIndex != -1)
+            }
+
+            return sliceIndex;
+        }
+
-                if (bSwapSlice) // if this was a miss
+        // In case the texture content with which we update the cache is not the input texture, we need to provide the right update count.
+        public void UpdateSlice(CommandBuffer cmd, int sliceIndex, Texture content, uint textureHash)
-                #if UNITY_EDITOR
-                    m_SliceArray[sliceIndex].hash = hash;
-                #endif
+            // transfer new slice to sliceIndex from source texture
+            SetSliceHash(sliceIndex, textureHash);
+            TransferToSlice(cmd, sliceIndex, content);
+        }
-                    // transfer new slice to sliceIndex from source texture
-                    TransferToSlice(sliceIndex, texture);
+        public void SetSliceHash(int sliceIndex, uint hash)
+        {
+            // transfer new slice to sliceIndex from source texture
+            m_SliceArray[sliceIndex].sliceEntryHash = hash;
+        }
+
+        public void UpdateSlice(CommandBuffer cmd, int sliceIndex, Texture content)
+        {
+            UpdateSlice(cmd, sliceIndex, content, GetTextureHash(content));
+
+        public int FetchSlice(CommandBuffer cmd, Texture texture, bool forceReinject=false)
+        {
+            bool needUpdate = false;
+            var sliceIndex = ReserveSlice(texture, out needUpdate);
+
+            var bSwapSlice = forceReinject || needUpdate;
+
+            // wrap up
+            Debug.Assert(sliceIndex != -1, "The texture cache doesn't have enough space to store all textures. Please either increase the size of the texture cache, or use fewer unique textures.");
+            if (sliceIndex != -1 && bSwapSlice)
+            {
+                UpdateSlice(cmd, sliceIndex, texture);
             }
 
             return sliceIndex;
             m_NumMipLevels = 0;
         }
 
-        public virtual void TransferToSlice(int sliceIndex, Texture texture)
+        public virtual void TransferToSlice(CommandBuffer cmd, int sliceIndex, Texture texture)
         {
         }
 

ScriptableRenderPipeline/HDRenderPipeline/Camera/HDAdditionalCameraData.cs

     public class HDAdditionalCameraData : MonoBehaviour
     {
         public RenderingPathHDRP renderingPath;
+
+        Camera m_camera;
+
+        void OnEnable()
+        {
+            // Be sure legacy HDR option is disable on camera as it cause banding in SceneView. Yes, it is a contradiction, but well, Unity...
+            // When HDR option is enabled, Unity render in FP16 then convert to 8bit with a stretch copy (this cause banding as it should be convert to sRGB (or other color appropriate color space)), then do a final shader with sRGB conversion
+            // When LDR, unity render in 8bitSRGB, then do a final shader with sRGB conversion 
+            // What should be done is just in our Post process we convert to sRGB and store in a linear 10bit, but require C++ change...
+            m_camera = GetComponent<Camera>();
+            m_camera.allowHDR = false;
+        }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/Camera/HDCamera.cs

         public Plane[] frustumPlanes;
         public Vector4[] frustumPlaneEquations;
         public Camera camera;
+        public PostProcessRenderContext postprocessRenderContext;
 
         public Matrix4x4 viewProjMatrix
         {
         // Always true for cameras that just got added to the pool - needed for previous matrices to
         // avoid one-frame jumps/hiccups with temporal effects (motion blur, TAA...)
         public bool isFirstFrame { get; private set; }
+
+        public bool useForwardOnly { get; private set; }
+        public bool stereoEnabled { get; private set; }
 
         public Vector4 invProjParam
         {
             camera = cam;
             frustumPlanes = new Plane[6];
             frustumPlaneEquations = new Vector4[6];
+            postprocessRenderContext = new PostProcessRenderContext();
-        public void Update(PostProcessLayer postProcessLayer)
+        public void Update(PostProcessLayer postProcessLayer, GlobalRenderingSettings globalRenderingSettings, bool stereoActive)
         {
             // If TAA is enabled projMatrix will hold a jittered projection matrix. The original,
             // non-jittered projection matrix can be accessed via nonJitteredProjMatrix.
             frustumPlaneEquations[5] = new Vector4(-camera.transform.forward.x, -camera.transform.forward.y, -camera.transform.forward.z,  Vector3.Dot(camera.transform.forward, relPos) + camera.farClipPlane);
 
             m_LastFrameActive = Time.frameCount;
+
+            stereoEnabled = stereoActive && (camera.stereoTargetEye == StereoTargetEyeMask.Both);
+            useForwardOnly = globalRenderingSettings.ShouldUseForwardRenderingOnly() || stereoEnabled;
         }
 
         public void Reset()
+            stereoEnabled = false;
+            useForwardOnly = false;
-        public static HDCamera Get(Camera camera, PostProcessLayer postProcessLayer)
+        public static HDCamera Get(Camera camera, PostProcessLayer postProcessLayer, GlobalRenderingSettings globalRenderingSettings, bool stereoActive)
         {
             HDCamera hdcam;
 
                 s_Cameras.Add(camera, hdcam);
             }
 
-            hdcam.Update(postProcessLayer);
+            hdcam.Update(postProcessLayer, globalRenderingSettings, stereoActive);
             return hdcam;
         }
 
             material.SetVectorArray(HDShaderIDs._FrustumPlanes, frustumPlaneEquations);
         }
 
+        // TODO: We should set all the value below globally and not let it under the control of Unity,
+        // Need to test that because we are not sure in which order these value are setup, but we need to have control on them, or rename them in our shader.
+        // For now, apply it for all our compute shader to make it work
-            cmd.SetComputeMatrixParam(cs, HDShaderIDs._ViewMatrix, viewMatrix);
-            cmd.SetComputeMatrixParam(cs, HDShaderIDs._InvViewMatrix, viewMatrix.inverse);
-            cmd.SetComputeMatrixParam(cs, HDShaderIDs._ProjMatrix, projMatrix);
-            cmd.SetComputeMatrixParam(cs, HDShaderIDs._InvProjMatrix, projMatrix.inverse);
-            cmd.SetComputeMatrixParam(cs, HDShaderIDs._NonJitteredViewProjMatrix, nonJitteredViewProjMatrix);
-            cmd.SetComputeMatrixParam(cs, HDShaderIDs._ViewProjMatrix, viewProjMatrix);
-            cmd.SetComputeMatrixParam(cs, HDShaderIDs._InvViewProjMatrix, viewProjMatrix.inverse);
-            cmd.SetComputeVectorParam(cs, HDShaderIDs._InvProjParam, invProjParam);
-            cmd.SetComputeVectorParam(cs, HDShaderIDs._ScreenSize, screenSize);
-            cmd.SetComputeMatrixParam(cs, HDShaderIDs._PrevViewProjMatrix, prevViewProjMatrix);
-            cmd.SetComputeVectorArrayParam(cs, HDShaderIDs._FrustumPlanes, frustumPlaneEquations);
             // Copy values set by Unity which are not configured in scripts.
             cmd.SetComputeVectorParam(cs, HDShaderIDs.unity_OrthoParams, Shader.GetGlobalVector(HDShaderIDs.unity_OrthoParams));
             cmd.SetComputeVectorParam(cs, HDShaderIDs._ProjectionParams, Shader.GetGlobalVector(HDShaderIDs._ProjectionParams));

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 using UnityEngine;
 using System;
 
-    public enum DebugLightingMode
+    public enum FullScreenDebugMode
-        DiffuseLighting,
-        SpecularLighting,
-        VisualizeCascade,
-        IndirectDiffuseOcclusionFromSsao,
-        IndirectDiffuseGtaoFromSsao,
-        IndirectSpecularOcclusionFromSsao,
-        IndirectSpecularGtaoFromSsao
+        // Lighting
+        MinLightingFullScreenDebug,
+        SSAO,
+        DeferredShadows,
+        PreRefractionColorPyramid,
+        DepthPyramid,
+        FinalColorPyramid,
+        MaxLightingFullScreenDebug,
+
+        // Rendering
+        MinRenderingFullScreenDebug,
+        MotionVectors,
+        NanTracker,
+        MaxRenderingFullScreenDebug
     }
 
     public class DebugDisplaySettings
         public static string kFullScreenDebugMip = "Fullscreen Debug Mip";
         public static string kDisplaySkyReflectionDebug = "Display Sky Reflection";
         public static string kSkyReflectionMipmapDebug = "Sky Reflection Mipmap";
-        public static string kTileDebug = "Tile Debug By Category";
+        public static string kTileClusterCategoryDebug = "Tile/Cluster Debug By Category";
+        public static string kTileClusterDebug = "Tile/Cluster Debug";
 
 
         public float debugOverlayRatio = 0.33f;
         public LightingDebugSettings lightingDebugSettings = new LightingDebugSettings();
         public RenderingDebugSettings renderingDebugSettings = new RenderingDebugSettings();
 
-        private static bool isDebugViewMaterialInit = false;
-        public static GUIContent[] debugViewMaterialStrings = null;
-        public static int[] debugViewMaterialValues = null;
-        public static GUIContent[] debugViewEngineStrings = null;
-        public static int[] debugViewEngineValues = null;
-        public static GUIContent[] debugViewMaterialVaryingStrings = null;
-        public static int[] debugViewMaterialVaryingValues = null;
-        public static GUIContent[] debugViewMaterialPropertiesStrings = null;
-        public static int[] debugViewMaterialPropertiesValues = null;
-        public static GUIContent[] debugViewMaterialGBufferStrings = null;
-        public static int[] debugViewMaterialGBufferValues = null;
-
-
-            BuildDebugRepresentation();
+            FillFullScreenDebugEnum(ref lightingFullScreenDebugStrings, ref lightingFullScreenDebugValues, FullScreenDebugMode.MinLightingFullScreenDebug, FullScreenDebugMode.MaxLightingFullScreenDebug);
+            FillFullScreenDebugEnum(ref renderingFullScreenDebugStrings, ref renderingFullScreenDebugValues, FullScreenDebugMode.MinRenderingFullScreenDebug, FullScreenDebugMode.MaxRenderingFullScreenDebug);
         }
 
         public int GetDebugMaterialIndex()
             DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Rate", () => 1.0f / Time.smoothDeltaTime, null, DebugItemFlag.DynamicDisplay);
             DebugMenuManager.instance.AddDebugItem<float>("Display Stats", "Frame Time (ms)", () => Time.smoothDeltaTime * 1000.0f, null, DebugItemFlag.DynamicDisplay);
 
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "Material",() => materialDebugSettings.debugViewMaterial, (value) => SetDebugViewMaterial((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialStrings, DebugDisplaySettings.debugViewMaterialValues));
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "Engine",() => materialDebugSettings.debugViewEngine, (value) => SetDebugViewEngine((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewEngineStrings, DebugDisplaySettings.debugViewEngineValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "Material",() => materialDebugSettings.debugViewMaterial, (value) => SetDebugViewMaterial((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(MaterialDebugSettings.debugViewMaterialStrings, MaterialDebugSettings.debugViewMaterialValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "Engine",() => materialDebugSettings.debugViewEngine, (value) => SetDebugViewEngine((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(MaterialDebugSettings.debugViewEngineStrings, MaterialDebugSettings.debugViewEngineValues));
-            DebugMenuManager.instance.AddDebugItem<int>("Material", "GBuffer",() => materialDebugSettings.debugViewGBuffer, (value) => SetDebugViewGBuffer((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.debugViewMaterialGBufferStrings, DebugDisplaySettings.debugViewMaterialGBufferValues));
+            DebugMenuManager.instance.AddDebugItem<int>("Material", "GBuffer",() => materialDebugSettings.debugViewGBuffer, (value) => SetDebugViewGBuffer((int)value), DebugItemFlag.None, new DebugItemHandlerIntEnum(MaterialDebugSettings.debugViewMaterialGBufferStrings, MaterialDebugSettings.debugViewMaterialGBufferValues));
 
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, bool>(kEnableShadowDebug, () => lightingDebugSettings.enableShadows, (value) => lightingDebugSettings.enableShadows = (bool)value);
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, ShadowMapDebugMode>(kShadowDebugMode, () => lightingDebugSettings.shadowDebugMode, (value) => lightingDebugSettings.shadowDebugMode = (ShadowMapDebugMode)value);
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, Color>(kDebugLightingAlbedo, () => lightingDebugSettings.debugLightingAlbedo, (value) => lightingDebugSettings.debugLightingAlbedo = (Color)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Lighting", kDisplaySkyReflectionDebug, () => lightingDebugSettings.displaySkyReflection, (value) => lightingDebugSettings.displaySkyReflection = (bool)value);
             DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, float>(kSkyReflectionMipmapDebug, () => lightingDebugSettings.skyReflectionMipmap, (value) => lightingDebugSettings.skyReflectionMipmap = (float)value, DebugItemFlag.None, new DebugItemHandlerFloatMinMax(0.0f, 1.0f));
-            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, TilePass.TileSettings.TileDebug>(kTileDebug,() => lightingDebugSettings.tileDebugByCategory, (value) => lightingDebugSettings.tileDebugByCategory = (TilePass.TileSettings.TileDebug)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, LightLoopSettings.TileClusterDebug>(kTileClusterDebug,() => lightingDebugSettings.tileClusterDebug, (value) => lightingDebugSettings.tileClusterDebug = (LightLoopSettings.TileClusterDebug)value);
+            DebugMenuManager.instance.AddDebugItem<LightingDebugPanel, LightLoopSettings.TileClusterCategoryDebug>(kTileClusterCategoryDebug,() => lightingDebugSettings.tileClusterDebugByCategory, (value) => lightingDebugSettings.tileClusterDebugByCategory = (LightLoopSettings.TileClusterCategoryDebug)value);
 
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Opaque",() => renderingDebugSettings.displayOpaqueObjects, (value) => renderingDebugSettings.displayOpaqueObjects = (bool)value);
             DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Display Transparency",() => renderingDebugSettings.displayTransparentObjects, (value) => renderingDebugSettings.displayTransparentObjects = (bool)value);
+            DebugMenuManager.instance.AddDebugItem<bool>("Rendering", "Allow Stereo Rendering",() => renderingDebugSettings.allowStereo, (value) => renderingDebugSettings.allowStereo = (bool)value);
             DebugMenuManager.instance.AddDebugItem<int>("Rendering", kFullScreenDebugMode, () => (int)fullScreenDebugMode, (value) => fullScreenDebugMode = (FullScreenDebugMode)value, DebugItemFlag.None, new DebugItemHandlerIntEnum(DebugDisplaySettings.renderingFullScreenDebugStrings, DebugDisplaySettings.renderingFullScreenDebugValues));
         }
 
         }
 
-        // className include the additional "/"
-        void FillWithProperties(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string className, ref int index)
-        {
-            var attributes = type.GetCustomAttributes(true);
-            // Get attribute to get the start number of the value for the enum
-            var attr = attributes[0] as GenerateHLSL;
-
-            if (!attr.needParamDebug)
-            {
-                return;
-            }
-
-            var fields = type.GetFields();
-
-            var localIndex = 0;
-            foreach (var field in fields)
-            {
-                var fieldName = field.Name;
-
-                // Check if the display name have been override by the users
-                if (Attribute.IsDefined(field, typeof(SurfaceDataAttributes)))
-                {
-                    var propertyAttr = (SurfaceDataAttributes[])field.GetCustomAttributes(typeof(SurfaceDataAttributes), false);
-                    if (propertyAttr[0].displayName != "")
-                    {
-                        fieldName = propertyAttr[0].displayName;
-                    }
-                }
-
-                fieldName = className + fieldName;
-
-                debugViewMaterialStrings[index] = new GUIContent(fieldName);
-                debugViewMaterialValues[index] = attr.paramDefinesStart + (int)localIndex;
-                index++;
-                localIndex++;
-            }
-        }
-
-        void FillWithPropertiesEnum(Type type, GUIContent[] debugViewMaterialStrings, int[] debugViewMaterialValues, string prefix, ref int index)
-        {
-            var names = Enum.GetNames(type);
-
-            var localIndex = 0;
-            foreach (var value in Enum.GetValues(type))
-            {
-                var valueName = prefix + names[localIndex];
-
-                debugViewMaterialStrings[index] = new GUIContent(valueName);
-                debugViewMaterialValues[index] = (int)value;
-                index++;
-                localIndex++;
-            }
-        }
-
-        public class MaterialItem
-        {
-            public String className;
-            public Type surfaceDataType;
-            public Type bsdfDataType;
-        };
-
-        void BuildDebugRepresentation()
-        {
-            if (!isDebugViewMaterialInit)
-            {
-                List<RenderPipelineMaterial> materialList = HDUtils.GetRenderPipelineMaterialList();
-
-                // TODO: Share this code to retrieve deferred material with HDRenderPipeline
-                // Find first material that have non 0 Gbuffer count and assign it as deferredMaterial
-                Type bsdfDataDeferredType = null;
-                foreach (RenderPipelineMaterial material in materialList)
-                {
-                    if (material.GetMaterialGBufferCount() > 0)
-                    {
-                        bsdfDataDeferredType = material.GetType().GetNestedType("BSDFData");
-                    }
-                }
-
-                // TODO: Handle the case of no Gbuffer material
-                Debug.Assert(bsdfDataDeferredType != null);
-
-                List<MaterialItem> materialItems = new List<MaterialItem>();
-
-                int numSurfaceDataFields = 0;
-                int numBSDFDataFields = 0;
-                foreach (RenderPipelineMaterial material in materialList)
-                {
-                    MaterialItem item = new MaterialItem();
-
-                    item.className = material.GetType().Name + "/";
-
-                    item.surfaceDataType = material.GetType().GetNestedType("SurfaceData");
-                    numSurfaceDataFields += item.surfaceDataType.GetFields().Length;
-
-                    item.bsdfDataType = material.GetType().GetNestedType("BSDFData");
-                    numBSDFDataFields += item.bsdfDataType.GetFields().Length;
-
-                    materialItems.Add(item);
-                }
-
-                // Material properties debug
-                var num =   typeof(Builtin.BuiltinData).GetFields().Length * materialList.Count // BuildtinData are duplicated for each material
-                            + numSurfaceDataFields + 1; // +1 for None case
-
-                debugViewMaterialStrings = new GUIContent[num];
-                debugViewMaterialValues = new int[num];
-                // Special case for None since it cannot be inferred from SurfaceData/BuiltinData
-                debugViewMaterialStrings[0] = new GUIContent("None");
-                debugViewMaterialValues[0] = 0;
-                var index = 1;
-                // 0 is a reserved number and should not be used (allow to track error)
-                foreach (MaterialItem item in materialItems)
-                {
-                    // BuiltinData are duplicated for each material
-                    FillWithProperties(typeof(Builtin.BuiltinData), debugViewMaterialStrings, debugViewMaterialValues, item.className, ref index);
-                    FillWithProperties(item.surfaceDataType, debugViewMaterialStrings, debugViewMaterialValues, item.className, ref index);
-                }
-
-                // Engine properties debug
-                num = numBSDFDataFields + 1; // +1 for None case
-                debugViewEngineStrings = new GUIContent[num];
-                debugViewEngineValues = new int[num];
-                // 0 is a reserved number and should not be used (allow to track error)
-                debugViewEngineStrings[0] = new GUIContent("None");
-                debugViewEngineValues[0] = 0;
-                index = 1;
-                foreach (MaterialItem item in materialItems)
-                {
-                    FillWithProperties(item.bsdfDataType, debugViewEngineStrings, debugViewEngineValues, item.className, ref index);
-                }
-
-                // Attributes debug
-                var varyingNames = Enum.GetNames(typeof(Attributes.DebugViewVarying));
-                debugViewMaterialVaryingStrings = new GUIContent[varyingNames.Length];
-                debugViewMaterialVaryingValues = new int[varyingNames.Length];
-                index = 0;
-                FillWithPropertiesEnum(typeof(Attributes.DebugViewVarying), debugViewMaterialVaryingStrings, debugViewMaterialVaryingValues, "", ref index);
-
-                // Properties debug
-                var propertiesNames = Enum.GetNames(typeof(Attributes.DebugViewProperties));
-                debugViewMaterialPropertiesStrings = new GUIContent[propertiesNames.Length];
-                debugViewMaterialPropertiesValues = new int[propertiesNames.Length];
-                index = 0;
-                FillWithPropertiesEnum(typeof(Attributes.DebugViewProperties), debugViewMaterialPropertiesStrings, debugViewMaterialPropertiesValues, "", ref index);
-
-                // Gbuffer debug
-                var gbufferNames = Enum.GetNames(typeof(Attributes.DebugViewGbuffer));
-                debugViewMaterialGBufferStrings = new GUIContent[gbufferNames.Length + bsdfDataDeferredType.GetFields().Length];
-                debugViewMaterialGBufferValues = new int[gbufferNames.Length + bsdfDataDeferredType.GetFields().Length];
-                index = 0;
-                FillWithPropertiesEnum(typeof(Attributes.DebugViewGbuffer), debugViewMaterialGBufferStrings, debugViewMaterialGBufferValues, "", ref index);
-                FillWithProperties(typeof(Lit.BSDFData), debugViewMaterialGBufferStrings, debugViewMaterialGBufferValues, "", ref index);
-
-                // Lighting Full Screen Debug
-                FillFullScreenDebugEnum(ref lightingFullScreenDebugStrings, ref lightingFullScreenDebugValues, FullScreenDebugMode.MinLightingFullScreenDebug, FullScreenDebugMode.MaxLightingFullScreenDebug);
-                FillFullScreenDebugEnum(ref renderingFullScreenDebugStrings, ref renderingFullScreenDebugValues, FullScreenDebugMode.MinRenderingFullScreenDebug, FullScreenDebugMode.MaxRenderingFullScreenDebug);
-
-                isDebugViewMaterialInit = true;
-            }
-        }
-
         void FillFullScreenDebugEnum(ref GUIContent[] strings, ref int[] values, FullScreenDebugMode min, FullScreenDebugMode max)
         {
             int count = max - min - 1;
                 values[index] = i;
                 index++;
             }
-        }
-    }
-
-
-    namespace Attributes
-    {
-        // 0 is reserved!
-        [GenerateHLSL]
-        public enum DebugViewVarying
-        {
-            None = 0,
-            Texcoord0 = 1,
-            Texcoord1,
-            Texcoord2,
-            Texcoord3,
-            VertexTangentWS,
-            VertexBitangentWS,
-            VertexNormalWS,
-            VertexColor,
-            VertexColorAlpha,
-            Last,
-        };
-
-        // Number must be contiguous
-        [GenerateHLSL]
-        public enum DebugViewGbuffer
-        {
-            None = 0,
-            Depth = DebugViewVarying.Last,
-            BakeDiffuseLightingWithAlbedoPlusEmissive,
-            BakeShadowMask0,
-            BakeShadowMask1,
-            BakeShadowMask2,
-            BakeShadowMask3,
-            Last,
-        }
-
-        // Number must be contiguous
-        [GenerateHLSL]
-        public enum DebugViewProperties
-        {
-            None = 0,
-            Tessellation = DebugViewGbuffer.Last,
-            PixelDisplacement,
-            VertexDisplacement,
-            TessellationDisplacement,
-            DepthOffset,
-            Lightmap,
-        }
-    }
-
-    [Serializable]
-    public class MaterialDebugSettings
-    {
-        public int debugViewMaterial { get { return m_DebugViewMaterial; } }
-        public int debugViewEngine { get { return m_DebugViewEngine; } }
-        public Attributes.DebugViewVarying debugViewVarying { get { return m_DebugViewVarying; } }
-        public Attributes.DebugViewProperties debugViewProperties { get { return m_DebugViewProperties; } }
-        public int debugViewGBuffer { get { return m_DebugViewGBuffer; } }
-
-        int                             m_DebugViewMaterial = 0; // No enum there because everything is generated from materials.
-        int                             m_DebugViewEngine = 0;  // No enum there because everything is generated from BSDFData
-        Attributes.DebugViewVarying     m_DebugViewVarying = Attributes.DebugViewVarying.None;
-        Attributes.DebugViewProperties  m_DebugViewProperties = Attributes.DebugViewProperties.None;
-        int                             m_DebugViewGBuffer = 0; // Can't use GBuffer enum here because the values are actually split between this enum and values from Lit.BSDFData
-
-        public int GetDebugMaterialIndex()
-        {
-            // This value is used in the shader for the actual debug display.
-            // There is only one uniform parameter for that so we just add all of them
-            // They are all mutually exclusive so return the sum will return the right index.
-            return m_DebugViewGBuffer + m_DebugViewMaterial + m_DebugViewEngine + (int)m_DebugViewVarying + (int)m_DebugViewProperties;
-        }
-
-        public void DisableMaterialDebug()
-        {
-            m_DebugViewMaterial = 0;
-            m_DebugViewEngine = 0;
-            m_DebugViewVarying = Attributes.DebugViewVarying.None;
-            m_DebugViewProperties = Attributes.DebugViewProperties.None;
-            m_DebugViewGBuffer = 0;
-        }
-
-        public void SetDebugViewMaterial(int value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewMaterial = value;
-        }
-
-        public void SetDebugViewEngine(int value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewEngine = value;
-        }
-
-        public void SetDebugViewVarying(Attributes.DebugViewVarying value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewVarying = value;
-        }
-        public void SetDebugViewProperties(Attributes.DebugViewProperties value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewProperties = value;
-        }
-
-        public void SetDebugViewGBuffer(int value)
-        {
-            if (value != 0)
-                DisableMaterialDebug();
-            m_DebugViewGBuffer = value;
-        }
-
-
-        public bool IsDebugGBufferEnabled()
-        {
-            return m_DebugViewGBuffer != 0;
-        }
-
-        public bool IsDebugDisplayEnabled()
-        {
-            return (m_DebugViewEngine != 0 || m_DebugViewMaterial != 0 || m_DebugViewVarying != Attributes.DebugViewVarying.None || m_DebugViewProperties != Attributes.DebugViewProperties.None || m_DebugViewGBuffer != 0);
-        }
-    }
-
-    [Serializable]
-    public class RenderingDebugSettings
-    {
-        public bool displayOpaqueObjects = true;
-        public bool displayTransparentObjects = true;
-        public bool enableDistortion = true;
-        public bool enableGaussianPyramid = true;
-        public bool enableSSSAndTransmission = true;
-        public bool enableAtmosphericScattering = true;
-    }
-
-    public enum ShadowMapDebugMode
-    {
-        None,
-        VisualizeAtlas,
-        VisualizeShadowMap
-    }
-
-    [GenerateHLSL]
-    public enum FullScreenDebugMode
-    {
-        None,
-        // Lighting
-        MinLightingFullScreenDebug,
-        SSAO,
-        DeferredShadows,
-        PreRefractionColorPyramid,
-        DepthPyramid,
-        FinalColorPyramid,
-        MaxLightingFullScreenDebug,
-
-        // Rendering
-        MinRenderingFullScreenDebug,
-        MotionVectors,
-        NanTracker,
-        MaxRenderingFullScreenDebug
-    }
-
-    [Serializable]
-    public class LightingDebugSettings
-    {
-        public bool IsDebugDisplayEnabled()
-        {
-            return debugLightingMode != DebugLightingMode.None;
-        }
-
-        public DebugLightingMode    debugLightingMode = DebugLightingMode.None;
-        public bool                 enableShadows = true;
-        public ShadowMapDebugMode   shadowDebugMode = ShadowMapDebugMode.None;
-        public bool                 shadowDebugUseSelection = false;
-        public uint                 shadowMapIndex = 0;
-        public uint                 shadowAtlasIndex = 0;
-        public float                shadowMinValue = 0.0f;
-        public float                shadowMaxValue = 1.0f;
-
-        public bool                 overrideSmoothness = false;
-        public float                overrideSmoothnessValue = 0.5f;
-        public Color                debugLightingAlbedo = new Color(0.5f, 0.5f, 0.5f);
-
-        public bool                 displaySkyReflection = false;
-        public float                skyReflectionMipmap = 0.0f;
-
-        public TilePass.TileSettings.TileDebug  tileDebugByCategory = TilePass.TileSettings.TileDebug.None;
-
-        public void OnValidate()
-        {
-            overrideSmoothnessValue = Mathf.Clamp(overrideSmoothnessValue, 0.0f, 1.0f);
-            skyReflectionMipmap = Mathf.Clamp(skyReflectionMipmap, 0.0f, 1.0f);
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.cs.hlsl

 #ifndef DEBUGDISPLAY_CS_HLSL
 #define DEBUGDISPLAY_CS_HLSL
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.DebugLightingMode:  static fields
-//
-#define DEBUGLIGHTINGMODE_NONE (0)
-#define DEBUGLIGHTINGMODE_DIFFUSE_LIGHTING (1)
-#define DEBUGLIGHTINGMODE_SPECULAR_LIGHTING (2)
-#define DEBUGLIGHTINGMODE_VISUALIZE_CASCADE (3)
-#define DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION_FROM_SSAO (4)
-#define DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_GTAO_FROM_SSAO (5)
-#define DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_OCCLUSION_FROM_SSAO (6)
-#define DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_GTAO_FROM_SSAO (7)
-
-//
-// UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewVarying:  static fields
-//
-#define DEBUGVIEWVARYING_NONE (0)
-#define DEBUGVIEWVARYING_TEXCOORD0 (1)
-#define DEBUGVIEWVARYING_TEXCOORD1 (2)
-#define DEBUGVIEWVARYING_TEXCOORD2 (3)
-#define DEBUGVIEWVARYING_TEXCOORD3 (4)
-#define DEBUGVIEWVARYING_VERTEX_TANGENT_WS (5)
-#define DEBUGVIEWVARYING_VERTEX_BITANGENT_WS (6)
-#define DEBUGVIEWVARYING_VERTEX_NORMAL_WS (7)
-#define DEBUGVIEWVARYING_VERTEX_COLOR (8)
-#define DEBUGVIEWVARYING_VERTEX_COLOR_ALPHA (9)
-#define DEBUGVIEWVARYING_LAST (10)
-
-//
-// UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewGbuffer:  static fields
-//
-#define DEBUGVIEWGBUFFER_NONE (0)
-#define DEBUGVIEWGBUFFER_DEPTH (10)
-#define DEBUGVIEWGBUFFER_BAKE_DIFFUSE_LIGHTING_WITH_ALBEDO_PLUS_EMISSIVE (11)
-#define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK0 (12)
-#define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK1 (13)
-#define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK2 (14)
-#define DEBUGVIEWGBUFFER_BAKE_SHADOW_MASK3 (15)
-#define DEBUGVIEWGBUFFER_LAST (16)
-
-//
-// UnityEngine.Experimental.Rendering.HDPipeline.Attributes.DebugViewProperties:  static fields
-//
-#define DEBUGVIEWPROPERTIES_NONE (0)
-#define DEBUGVIEWPROPERTIES_TESSELLATION (16)
-#define DEBUGVIEWPROPERTIES_PIXEL_DISPLACEMENT (17)
-#define DEBUGVIEWPROPERTIES_VERTEX_DISPLACEMENT (18)
-#define DEBUGVIEWPROPERTIES_TESSELLATION_DISPLACEMENT (19)
-#define DEBUGVIEWPROPERTIES_DEPTH_OFFSET (20)
-#define DEBUGVIEWPROPERTIES_LIGHTMAP (21)
-
-//
 // UnityEngine.Experimental.Rendering.HDPipeline.FullScreenDebugMode:  static fields
 //
 #define FULLSCREENDEBUGMODE_NONE (0)

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplay.hlsl

 #define UNITY_DEBUG_DISPLAY_INCLUDED
 
 #include "DebugDisplay.cs.hlsl"
+#include "MaterialDebug.cs.hlsl"
+#include "LightingDebug.cs.hlsl"
 
 // Set of parameters available when switching to debug shader mode
 int _DebugLightingMode; // Match enum DebugLightingMode

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugDisplayLatlong.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+            #pragma only_renderers d3d11 ps4 vulkan metal // TEMP: until we go further in dev
-            #include "../../Core/ShaderLibrary/Common.hlsl"
-            #include "../../Core/ShaderLibrary/ImageBasedLighting.hlsl"
+            #include "ShaderLibrary/Common.hlsl"
+            #include "ShaderLibrary/ImageBasedLighting.hlsl"
 
             TEXTURECUBE(_InputCubemap);
             SAMPLERCUBE(sampler_InputCubemap);

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugFullScreen.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: unitl we go futher in dev
+            #pragma only_renderers d3d11 ps4 vulkan metal // TEMP: until we go further in dev
-            #include "../../Core/ShaderLibrary/Common.hlsl"
+            #include "ShaderLibrary/Common.hlsl"
             #include "../Debug/DebugDisplay.cs.hlsl"
             #include "../ShaderVariables.hlsl"
 

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewMaterialGBuffer.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
+            #pragma only_renderers d3d11 ps4 vulkan metal // TEMP: until we go further in dev
 
             #pragma vertex Vert
             #pragma fragment Frag
-            #include "../../Core/ShaderLibrary/Common.hlsl"
-            #include "../../Core/ShaderLibrary/Color.hlsl"
+            #include "ShaderLibrary/Common.hlsl"
 
             // CAUTION: In case deferred lighting need to support various lighting model statically, we will require to do multicompile with different define like UNITY_MATERIAL_LIT
             #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
             #include "../Material/Material.hlsl"
 
-            DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
             #ifdef SHADOWS_SHADOWMASK
             TEXTURE2D(_ShadowMaskTexture);
             #endif
             {
                 // input.positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw);
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-                UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+                float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.positionSS).x;
+                UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
-                FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-                DECODE_FROM_GBUFFER(gbuffer, 0xFFFFFFFF, bsdfData, bakeLightingData.bakeDiffuseLighting);
+                DECODE_FROM_GBUFFER(posInput.positionSS, UINT_MAX, bsdfData, bakeLightingData.bakeDiffuseLighting);
-                DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
+                DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.positionSS), bakeLightingData.bakeShadowMask);
                 #endif
 
                 // Init to not expected value
                 if (_DebugViewMaterial == DEBUGVIEWGBUFFER_DEPTH)
                 {
-                    float linearDepth = frac(posInput.depthVS * 0.1);
+                    float linearDepth = frac(posInput.linearDepth * 0.1);
                     result = linearDepth.xxx;
                 }
                 // Caution: This value is not the same than the builtin data bakeDiffuseLighting. It also include emissive and multiply by the albedo

ScriptableRenderPipeline/HDRenderPipeline/Debug/DebugViewTiles.shader

         Pass
         {
             ZWrite Off
+            ZTest Always
-            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
+            #pragma only_renderers d3d11 ps4 vulkan metal // TEMP: until we go further in dev
 
             #pragma vertex Vert
             #pragma fragment Frag
             // Include
             //-------------------------------------------------------------------------------------
 
-            #include "../../Core/ShaderLibrary/Common.hlsl"
+            #include "ShaderLibrary/Common.hlsl"
 
             // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
             // deferred material must replace the old one here. If in the future we want to support multiple layout (cause a lot of consistency problem),
             {
                 // positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, uint2(input.positionCS.xy) / GetTileSize());
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-                UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+                float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.positionSS).x;
+                UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
-                int2 pixelCoord = posInput.unPositionSS.xy;
+                int2 pixelCoord = posInput.positionSS.xy;
                 int2 tileCoord = (float2)pixelCoord / GetTileSize();
                 int2 mouseTileCoord = _MousePixelCoord / GetTileSize();
                 int2 offsetInTile = pixelCoord - tileCoord * GetTileSize();
                 // Tile overlap counter
                 if (n >= 0)
                 {
-                    result = OverlayHeatMap(int2(posInput.unPositionSS.xy) & (GetTileSize() - 1), n);
+                    result = OverlayHeatMap(int2(posInput.positionSS.xy) & (GetTileSize() - 1), n);
                 }
 
 #ifdef SHOW_LIGHT_CATEGORIES
                 if (tileCoord.y < LIGHTCATEGORY_COUNT && tileCoord.x < maxLights + 3)
                 {
                     PositionInputs mousePosInput = GetPositionInput(_MousePixelCoord, _ScreenSize.zw, mouseTileCoord);
-                    float depthMouse = LOAD_TEXTURE2D(_MainDepthTexture, mousePosInput.unPositionSS).x;
-                    UpdatePositionInput(depthMouse, _InvViewProjMatrix, _ViewProjMatrix, mousePosInput);
+                    float depthMouse = LOAD_TEXTURE2D(_MainDepthTexture, mousePosInput.positionSS).x;
+                    UpdatePositionInput(depthMouse, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, mousePosInput);
 
                     uint category = (LIGHTCATEGORY_COUNT - 1) - tileCoord.y;
                     uint start;

ScriptableRenderPipeline/HDRenderPipeline/Debug/LightingDebugPanel.cs

-using UnityEngine;
+using UnityEngine;
 using System;
 
 #if UNITY_EDITOR
                         break;
                 }
 
-
-                m_DebugPanel.GetDebugItem(DebugDisplaySettings.kTileDebug).handler.OnEditorGUI();
+                DebugItem tileClusterDebug = m_DebugPanel.GetDebugItem(DebugDisplaySettings.kTileClusterDebug);
+                tileClusterDebug.handler.OnEditorGUI();
+                if ((int)tileClusterDebug.GetValue() != 0 && (int)tileClusterDebug.GetValue() != 3) // None and FeatureVariant
+                {
+                    EditorGUI.indentLevel++;
+                    m_DebugPanel.GetDebugItem(DebugDisplaySettings.kTileClusterCategoryDebug).handler.OnEditorGUI();
+                    EditorGUI.indentLevel--;
+                }
 
                 DebugItem displaySkyReflecItem = m_DebugPanel.GetDebugItem(DebugDisplaySettings.kDisplaySkyReflectionDebug);
                 displaySkyReflecItem.handler.OnEditorGUI();

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDAssetFactory.cs

-using UnityEngine;
+using System.IO;
+using UnityEngine;
+using UnityEngine.Experimental.Rendering;
 using UnityEngine.Experimental.Rendering.HDPipeline;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
             get { return HDEditorUtils.GetHDRenderPipelinePath() + "RenderPipelineResources/HDRenderPipelineResources.asset"; }
         }
 
-        [MenuItem("RenderPipeline/HDRenderPipeline/Create Pipeline Asset", false, 16)]
-        static void CreateHDRenderPipeline()
+        static string s_DefaultMaterialPath
-            var instance = ScriptableObject.CreateInstance<HDRenderPipelineAsset>();
-            AssetDatabase.CreateAsset(instance, HDEditorUtils.GetHDRenderPipelinePath() + "HDRenderPipelineAsset.asset");
+            get { return HDEditorUtils.GetHDRenderPipelinePath() + "RenderPipelineResources/DefaultHDMaterial.mat"; }
+        }
-            // If it exist, load renderPipelineResources
-            instance.renderPipelineResources = AssetDatabase.LoadAssetAtPath<RenderPipelineResources>(s_RenderPipelineResourcesPath);
+        static string s_DefaultShaderPath
+        {
+            get { return HDEditorUtils.GetHDRenderPipelinePath() + "Material/Lit/Lit.shader"; }
-        // TODO skybox/cubemap
+        class DoCreateNewAssetHDRenderPipeline : ProjectWindowCallback.EndNameEditAction
+        {
+            public override void Action(int instanceId, string pathName, string resourceFile)
+            {
+                var newAsset = CreateInstance<HDRenderPipelineAsset>();
+                newAsset.name = Path.GetFileName(pathName);
+                // Load default renderPipelineResources / Material / Shader
+                newAsset.renderPipelineResources = AssetDatabase.LoadAssetAtPath<RenderPipelineResources>(s_RenderPipelineResourcesPath);
+                newAsset.defaultDiffuseMaterial = AssetDatabase.LoadAssetAtPath<Material>(s_DefaultMaterialPath);
+                newAsset.defaultShader = AssetDatabase.LoadAssetAtPath<Shader>(s_DefaultShaderPath);
+                AssetDatabase.CreateAsset(newAsset, pathName);
+                ProjectWindowUtil.ShowCreatedAsset(newAsset);
+            }
+        }
-        [MenuItem("RenderPipeline/HDRenderPipeline/Create Resources Asset", false, 15)]
-        static void CreateRenderPipelineResources()
+        [MenuItem("Assets/Create/Render Pipeline/High Definition/Render Pipeline", priority = CoreUtils.assetCreateMenuPriority1)]
+        static void CreateHDRenderPipeline()
-            string HDRenderPipelinePath = HDEditorUtils.GetHDRenderPipelinePath();
-            string PostProcessingPath = HDEditorUtils.GetPostProcessingPath();
-            string CorePath = HDEditorUtils.GetCorePath();
+            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetHDRenderPipeline>(), "New HDRenderPipelineAsset.asset", icon, null);
+        }
-            var instance = ScriptableObject.CreateInstance<RenderPipelineResources>();
+        // Note: move this to a static using once we can target C#6+
+        static T Load<T>(string path) where T : UnityObject
+        {
+            return AssetDatabase.LoadAssetAtPath<T>(path);
+        }
-            instance.debugDisplayLatlongShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugDisplayLatlong.Shader");
-            instance.debugViewMaterialGBufferShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewMaterialGBuffer.Shader");
-            instance.debugViewTilesShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewTiles.Shader");
-            instance.debugFullScreenShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugFullScreen.Shader");
+        class DoCreateNewAssetHDRenderPipelineResources : ProjectWindowCallback.EndNameEditAction
+        {
+            public override void Action(int instanceId, string pathName, string resourceFile)
+            {
+                var newAsset = CreateInstance<RenderPipelineResources>();
+                newAsset.name = Path.GetFileName(pathName);
-            instance.deferredShader = Load<Shader>(HDRenderPipelinePath + "Lighting/Deferred.Shader");
-            instance.subsurfaceScatteringCS = Load<ComputeShader>(HDRenderPipelinePath + "Material/Lit/Resources/SubsurfaceScattering.compute");
-            instance.volumetricLightingCS = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/Volumetrics/Resources/VolumetricLighting.compute");
-            instance.gaussianPyramidCS = Load<ComputeShader>(PostProcessingPath + "Shaders/Builtins/GaussianDownsample.compute");
-            instance.depthPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/DepthDownsample.compute");
-            instance.copyChannelCS = Load<ComputeShader>(CorePath + "Resources/GPUCopy.compute");
-            instance.applyDistortionCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/ApplyDistorsion.compute");
+                // Load default renderPipelineResources / Material / Shader
+                string HDRenderPipelinePath = HDEditorUtils.GetHDRenderPipelinePath();
+                string PostProcessingPath = HDEditorUtils.GetPostProcessingPath();
+                string CorePath = HDEditorUtils.GetCorePath();
-            instance.clearDispatchIndirectShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/cleardispatchindirect.compute");
-            instance.buildDispatchIndirectShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/builddispatchindirect.compute");
-            instance.buildScreenAABBShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/scrbound.compute");
-            instance.buildPerTileLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild.compute");
-            instance.buildPerBigTileLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild-bigtile.compute");
-            instance.buildPerVoxelLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/lightlistbuild-clustered.compute");
-            instance.buildMaterialFlagsShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/materialflags.compute");
-            instance.deferredComputeShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/Deferred.compute");
+                newAsset.debugDisplayLatlongShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugDisplayLatlong.Shader");
+                newAsset.debugViewMaterialGBufferShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewMaterialGBuffer.Shader");
+                newAsset.debugViewTilesShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugViewTiles.Shader");
+                newAsset.debugFullScreenShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugFullScreen.Shader");
-            instance.deferredDirectionalShadowComputeShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/TilePass/DeferredDirectionalShadow.compute");
+                newAsset.deferredShader = Load<Shader>(HDRenderPipelinePath + "Lighting/Deferred.Shader");
+                newAsset.subsurfaceScatteringCS = Load<ComputeShader>(HDRenderPipelinePath + "Material/Lit/Resources/SubsurfaceScattering.compute");
+                newAsset.gaussianPyramidCS = Load<ComputeShader>(PostProcessingPath + "Shaders/Builtins/GaussianDownsample.compute");
+                newAsset.depthPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/DepthDownsample.compute");
+                newAsset.copyChannelCS = Load<ComputeShader>(CorePath + "Resources/GPUCopy.compute");
+                newAsset.applyDistortionCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/ApplyDistorsion.compute");
-            // SceneSettings
-            // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime (only to draw in editor)
-            // instance.drawSssProfile = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "SceneSettings/DrawSssProfile.shader");
-            // instance.drawTransmittanceGraphShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "SceneSettings/DrawTransmittanceGraph.shader");
+                newAsset.clearDispatchIndirectShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/cleardispatchindirect.compute");
+                newAsset.buildDispatchIndirectShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/builddispatchindirect.compute");
+                newAsset.buildScreenAABBShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/scrbound.compute");
+                newAsset.buildPerTileLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/lightlistbuild.compute");
+                newAsset.buildPerBigTileLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/lightlistbuild-bigtile.compute");
+                newAsset.buildPerVoxelLightListShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/lightlistbuild-clustered.compute");
+                newAsset.buildMaterialFlagsShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/materialflags.compute");
+                newAsset.deferredComputeShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/LightLoop/Deferred.compute");
-            instance.cameraMotionVectors = Load<Shader>(HDRenderPipelinePath + "RenderPipelineResources/CameraMotionVectors.shader");
+                newAsset.deferredDirectionalShadowComputeShader = Load<ComputeShader>(HDRenderPipelinePath + "Lighting/DeferredDirectionalShadow.compute");
-            // Sky
-            instance.blitCubemap = Load<Shader>(HDRenderPipelinePath + "Sky/BlitCubemap.shader");
-            instance.buildProbabilityTables = Load<ComputeShader>(HDRenderPipelinePath + "Sky/BuildProbabilityTables.compute");
-            instance.computeGgxIblSampleData = Load<ComputeShader>(HDRenderPipelinePath + "Sky/ComputeGgxIblSampleData.compute");
-            instance.GGXConvolve = Load<Shader>(HDRenderPipelinePath + "Sky/GGXConvolve.shader");
-            instance.opaqueAtmosphericScattering = Load<Shader>(HDRenderPipelinePath + "Sky/OpaqueAtmosphericScattering.shader");
+                // SceneSettings
+                // These shaders don't need to be reference by RenderPipelineResource as they are not use at runtime (only to draw in editor)
+                // instance.drawSssProfile = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "SceneSettings/DrawSssProfile.shader");
+                // instance.drawTransmittanceGraphShader = UnityEditor.AssetDatabase.LoadAssetAtPath<Shader>(HDRenderPipelinePath + "SceneSettings/DrawTransmittanceGraph.shader");
+
+                newAsset.cameraMotionVectors = Load<Shader>(HDRenderPipelinePath + "RenderPipelineResources/CameraMotionVectors.shader");
-            // Skybox/Cubemap is a builtin shader, must use Sahder.Find to access it. It is fine because we are in the editor
-            instance.skyboxCubemap = Shader.Find("Skybox/Cubemap");
+                // Sky
+                newAsset.blitCubemap = Load<Shader>(HDRenderPipelinePath + "Sky/BlitCubemap.shader");
+                newAsset.buildProbabilityTables = Load<ComputeShader>(HDRenderPipelinePath + "Material/GGXConvolution/BuildProbabilityTables.compute");
+                newAsset.computeGgxIblSampleData = Load<ComputeShader>(HDRenderPipelinePath + "Material/GGXConvolution/ComputeGgxIblSampleData.compute");
+                newAsset.GGXConvolve = Load<Shader>(HDRenderPipelinePath + "Material/GGXConvolution/GGXConvolve.shader");
+                newAsset.opaqueAtmosphericScattering = Load<Shader>(HDRenderPipelinePath + "Sky/OpaqueAtmosphericScattering.shader");
+
+                newAsset.encodeBC6HCS = Load<ComputeShader>(CorePath + "Resources/EncodeBC6H.compute");
+
+                // Skybox/Cubemap is a builtin shader, must use Sahder.Find to access it. It is fine because we are in the editor
+                newAsset.skyboxCubemap = Shader.Find("Skybox/Cubemap");
-            AssetDatabase.CreateAsset(instance, s_RenderPipelineResourcesPath);
-            AssetDatabase.SaveAssets();
-            AssetDatabase.Refresh();
+                AssetDatabase.CreateAsset(newAsset, pathName);
+                ProjectWindowUtil.ShowCreatedAsset(newAsset);
+            }
-        // Note: move this to a static using once we can target C#6+
-        static T Load<T>(string path)
-            where T : UnityObject
+        [MenuItem("Assets/Create/Render Pipeline/High Definition/Render Pipeline Resources", priority = CoreUtils.assetCreateMenuPriority1)]
+        static void CreateRenderPipelineResources()
-            return AssetDatabase.LoadAssetAtPath<T>(path);
+            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
+            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetHDRenderPipelineResources>(), "New HDRenderPipelineResources.asset", icon, null);
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDEditorCLI.cs

-using System;
+using System;
 using UnityEngine;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
                             {
                                 action.operation = (CommandLineOperation)Enum.Parse(typeof(CommandLineOperation), args[i]);
                             }
-                            catch (Exception e) { }
+                            catch (Exception e) { Debug.Log(e.ToString());  }
                         }
                         break;
                     }

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDEditorUtils.cs

-using System.Collections.Generic;
+using System.Collections.Generic;
 using System.IO;
 using UnityEngine;
 
             return path;
         }
 
-        // TODO: The two following functions depend on HDRP, they should be made generic
+        // TODO: The following functions depend on HDRP, they should be made generic
+        public static string GetScriptableRenderPipelinePath()
+        {
+            var hdrpPath = GetHDRenderPipelinePath();
+            var fullPath = Path.GetFullPath(hdrpPath + "../");
+            var relativePath = fullPath.Substring(fullPath.IndexOf("Assets"));
+            return relativePath.Replace("\\", "/") + "/";
+        }
+
         public static string GetPostProcessingPath()
         {
             var hdrpPath = GetHDRenderPipelinePath();
             MaterialResetter resetter;
             if (k_MaterialResetters.TryGetValue(material.shader.name, out resetter))
             {
-                RemoveMaterialKeywords(material);
+                CoreEditorUtils.RemoveMaterialKeywords(material);
-        }
-
-        public static void RemoveMaterialKeywords(Material material)
-        {
-            material.shaderKeywords = null;
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.Styles.cs

-using UnityEngine;
+using UnityEngine;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
         sealed class Styles
         {
             public readonly GUIContent defaults = new GUIContent("Defaults");
+            public readonly GUIContent renderPipelineResources = new GUIContent("Render Pipeline Resources", "Set of resources that need to be loaded when creating stand alone");
             public readonly GUIContent defaultDiffuseMaterial = new GUIContent("Default Diffuse Material", "Material to use when creating objects");
             public readonly GUIContent defaultShader = new GUIContent("Default Shader", "Shader to use when creating materials");
 
             public readonly GUIContent spotCookieSize = new GUIContent("Spot Cookie Size");
             public readonly GUIContent pointCookieSize = new GUIContent("Point Cookie Size");
             public readonly GUIContent reflectionCubemapSize = new GUIContent("Reflection Cubemap Size");
+            public readonly GUIContent reflectionCacheCompressed = new GUIContent("Compress Reflection Probe Cache");
 
             public readonly GUIContent sssSettings = new GUIContent("Subsurface Scattering Settings");
 
             public readonly GUIContent enableComputeLightEvaluation = new GUIContent("Compute Light Evaluation");
             public readonly GUIContent enableComputeLightVariants = new GUIContent("Compute Light Variants");
             public readonly GUIContent enableComputeMaterialVariants = new GUIContent("Compute Material Variants");
-            public readonly GUIContent enableClustered = new GUIContent("Clustered");
-            public readonly GUIContent enableFptlForOpaqueWhenClustered = new GUIContent("Fptl For Opaque When Clustered");
+            public readonly GUIContent enableFptlForForwardOpaque = new GUIContent("Fptl for forward opaque");
+            public readonly GUIContent enableAsyncCompute = new GUIContent("Enable Async Compute");
         }
 
         static Styles s_Styles;

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineInspector.cs

     [CustomEditor(typeof(HDRenderPipelineAsset))]
     public sealed partial class HDRenderPipelineInspector : HDBaseEditor<HDRenderPipelineAsset>
     {
+        SerializedProperty m_RenderPipelineResources;
-        // TilePass settings
+        // LightLoop settings
-        SerializedProperty m_enableClustered;
-        SerializedProperty m_enableFptlForOpaqueWhenClustered;
+        SerializedProperty m_enableFptlForForwardOpaque;
+        SerializedProperty m_enableAsyncCompute;
 
         // Rendering Settings
         SerializedProperty m_RenderingUseForwardOnly;
         SerializedProperty m_SpotCookieSize;
         SerializedProperty m_PointCookieSize;
         SerializedProperty m_ReflectionCubemapSize;
+        SerializedProperty m_ReflectionCacheCompressed;
+            m_RenderPipelineResources = properties.Find("m_RenderPipelineResources");
-            m_enableTileAndCluster = properties.Find(x => x.tileSettings.enableTileAndCluster);
-            m_enableComputeLightEvaluation = properties.Find(x => x.tileSettings.enableComputeLightEvaluation);
-            m_enableComputeLightVariants = properties.Find(x => x.tileSettings.enableComputeLightVariants);
-            m_enableComputeMaterialVariants = properties.Find(x => x.tileSettings.enableComputeMaterialVariants);
-            m_enableClustered = properties.Find(x => x.tileSettings.enableClustered);
-            m_enableFptlForOpaqueWhenClustered = properties.Find(x => x.tileSettings.enableFptlForOpaqueWhenClustered);
-            m_enableBigTilePrepass = properties.Find(x => x.tileSettings.enableBigTilePrepass);
+            m_enableTileAndCluster = properties.Find(x => x.lightLoopSettings.enableTileAndCluster);
+            m_enableComputeLightEvaluation = properties.Find(x => x.lightLoopSettings.enableComputeLightEvaluation);
+            m_enableComputeLightVariants = properties.Find(x => x.lightLoopSettings.enableComputeLightVariants);
+            m_enableComputeMaterialVariants = properties.Find(x => x.lightLoopSettings.enableComputeMaterialVariants);
+            m_enableFptlForForwardOpaque = properties.Find(x => x.lightLoopSettings.enableFptlForForwardOpaque);
+            m_enableBigTilePrepass = properties.Find(x => x.lightLoopSettings.enableBigTilePrepass);
+            m_enableAsyncCompute = properties.Find(x => x.lightLoopSettings.enableAsyncCompute);
 
             // Shadow settings
             m_ShadowAtlasWidth = properties.Find(x => x.shadowInitParams.shadowAtlasWidth);
-            m_SpotCookieSize = properties.Find(x => x.textureSettings.spotCookieSize);
-            m_PointCookieSize = properties.Find(x => x.textureSettings.pointCookieSize);
-            m_ReflectionCubemapSize = properties.Find(x => x.textureSettings.reflectionCubemapSize);
+            m_SpotCookieSize = properties.Find(x => x.globalTextureSettings.spotCookieSize);
+            m_PointCookieSize = properties.Find(x => x.globalTextureSettings.pointCookieSize);
+            m_ReflectionCubemapSize = properties.Find(x => x.globalTextureSettings.reflectionCubemapSize);
+            m_ReflectionCacheCompressed = properties.Find(x => x.globalTextureSettings.reflectionCacheCompressed);
-            m_RenderingUseForwardOnly = properties.Find(x => x.renderingSettings.useForwardRenderingOnly);
-            m_RenderingUseDepthPrepass = properties.Find(x => x.renderingSettings.useDepthPrepassWithDeferredRendering);
-            m_RenderingUseDepthPrepassAlphaTestOnly = properties.Find(x => x.renderingSettings.renderAlphaTestOnlyInDeferredPrepass);
+            m_RenderingUseForwardOnly = properties.Find(x => x.globalRenderingSettings.useForwardRenderingOnly);
+            m_RenderingUseDepthPrepass = properties.Find(x => x.globalRenderingSettings.useDepthPrepassWithDeferredRendering);
+            m_RenderingUseDepthPrepassAlphaTestOnly = properties.Find(x => x.globalRenderingSettings.renderAlphaTestOnlyInDeferredPrepass);
 
             // Subsurface Scattering Settings
             m_SubsurfaceScatteringSettings = properties.Find(x => x.sssSettings);
             {
                 EditorGUI.indentLevel++;
                 EditorGUILayout.PropertyField(m_enableBigTilePrepass, s_Styles.enableBigTilePrepass);
-                EditorGUILayout.PropertyField(m_enableClustered, s_Styles.enableClustered);
-                // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-                // if (m_enableClustered.boolValue)
-                if (m_enableClustered.boolValue && !m_enableComputeLightEvaluation.boolValue)
-                {
-                    EditorGUI.indentLevel++;
-                    EditorGUILayout.PropertyField(m_enableFptlForOpaqueWhenClustered, s_Styles.enableFptlForOpaqueWhenClustered);
-                    EditorGUI.indentLevel--;
-                }
+                // Allow to disable cluster for foward opaque when in forward only (option have no effect when MSAA is enabled)
+                // Deferred opaque are always tiled
+                EditorGUILayout.PropertyField(m_enableFptlForForwardOpaque, s_Styles.enableFptlForForwardOpaque);
+
-                    // Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-                    m_enableFptlForOpaqueWhenClustered.boolValue = true; // Force fptl to be always true if compute evaluation is enable
-
+                EditorGUILayout.PropertyField(m_enableAsyncCompute, s_Styles.enableAsyncCompute);
             }
 
             if (EditorGUI.EndChangeCheck())
             EditorGUILayout.PropertyField(m_SpotCookieSize, s_Styles.spotCookieSize);
             EditorGUILayout.PropertyField(m_PointCookieSize, s_Styles.pointCookieSize);
             EditorGUILayout.PropertyField(m_ReflectionCubemapSize, s_Styles.reflectionCubemapSize);
+            
+            // Commented ou until we have proper realtime BC6H compression
+            //EditorGUILayout.PropertyField(m_ReflectionCacheCompressed, s_Styles.reflectionCacheCompressed);
 
             if (EditorGUI.EndChangeCheck())
             {
 
             EditorGUILayout.LabelField(s_Styles.defaults, EditorStyles.boldLabel);
             EditorGUI.indentLevel++;
+            EditorGUILayout.PropertyField(m_RenderPipelineResources, s_Styles.renderPipelineResources);            
             EditorGUILayout.PropertyField(m_DefaultDiffuseMaterial, s_Styles.defaultDiffuseMaterial);
             EditorGUILayout.PropertyField(m_DefaultShader, s_Styles.defaultShader);
             EditorGUI.indentLevel--;

ScriptableRenderPipeline/HDRenderPipeline/Editor/HDRenderPipelineMenuItems.cs

 
     public class HDRenderPipelineMenuItems
     {
-        [MenuItem("HDRenderPipeline/Add \"Additional Light-shadow Data\" (if not present)")]
+        [MenuItem("Internal/HDRenderPipeline/Add \"Additional Light-shadow Data\" (if not present)")]
         static void AddAdditionalLightData()
         {
             var lights = UnityObject.FindObjectsOfType(typeof(Light)) as Light[];
             }
         }
 
-        [MenuItem("HDRenderPipeline/Add \"Additional Camera Data\" (if not present)")]
+        [MenuItem("Internal/HDRenderPipeline/Add \"Additional Camera Data\" (if not present)")]
         static void AddAdditionalCameraData()
         {
             var cameras = UnityObject.FindObjectsOfType(typeof(Camera)) as Camera[];
         }
 
         // This script is a helper for the artists to re-synchronize all layered materials
-        [MenuItem("HDRenderPipeline/Synchronize all Layered materials")]
+        [MenuItem("Internal/HDRenderPipeline/Synchronize all Layered materials")]
         static void SynchronizeAllLayeredMaterial()
         {
             var materials = Resources.FindObjectsOfTypeAll<Material>();
         // In case the shader code have change and the inspector have been update with new kind of keywords we need to regenerate the set of keywords use by the material.
         // This script will remove all keyword of a material and trigger the inspector that will re-setup all the used keywords.
         // It require that the inspector of the material have a static function call that update all keyword based on material properties.
-        [MenuItem("HDRenderPipeline/Test/Reset all materials keywords")]
+        [MenuItem("Edit/Render Pipeline/Upgrade/High Definition/Reset All Materials Keywords (Loaded Materials)", priority = CoreUtils.editMenuPriority2)]
         static void ResetAllMaterialKeywords()
         {
             try
             }
         }
 
-        [MenuItem("HDRenderPipeline/Test/Reset all materials keywords in project")]
+        [MenuItem("Edit/Render Pipeline/Upgrade/High Definition/Reset All Materials Keywords (Materials in Project)", priority = CoreUtils.editMenuPriority2)]
         static void ResetAllMaterialKeywordsInProject()
         {
             try
             }
         }
 
-        [MenuItem("HDRenderPipeline/Update/Update SSS profile indices")]
+        [MenuItem("Internal/HDRenderPipeline/Update/Update SSS profile indices")]
         static void UpdateSSSProfileIndices()
         {
             try
         }
 
         // Function used only to check performance of data with and without tessellation
-        [MenuItem("HDRenderPipeline/Test/Remove tessellation materials (not reversible)")]
+        [MenuItem("Internal/HDRenderPipeline/Test/Remove tessellation materials (not reversible)")]
         static void RemoveTessellationMaterials()
         {
             var materials = Resources.FindObjectsOfTypeAll<Material>();
                 {
                     mat.shader = litShader;
                     // We remove all keyword already present
-                    HDEditorUtils.RemoveMaterialKeywords(mat);
+                    CoreEditorUtils.RemoveMaterialKeywords(mat);
                     LitGUI.SetupMaterialKeywordsAndPass(mat);
                     EditorUtility.SetDirty(mat);
                 }
                     // We remove all keyword already present
-                    HDEditorUtils.RemoveMaterialKeywords(mat);
+                    CoreEditorUtils.RemoveMaterialKeywords(mat);
                     LayeredLitGUI.SetupMaterialKeywordsAndPass(mat);
                     EditorUtility.SetDirty(mat);
                 }
-        [MenuItem("HDRenderPipeline/Export Sky to Image")]
+        [MenuItem("Edit/Render Pipeline/Tools/High Definition/Export Sky to Image", priority = CoreUtils.editMenuPriority2)]
         static void ExportSkyToImage()
         {
             var renderpipeline = RenderPipelineManager.currentPipeline as HDRenderPipeline;
             }
         }
 
-        [MenuItem("GameObject/HD Render Pipeline/Scene Settings", false, 10)]
+        [MenuItem("GameObject/Render Pipeline/High Definition/Scene Settings", priority = 10)]
         static void CreateCustomGameObject(MenuCommand menuCommand)
         {
             var sceneSettings = new GameObject("Scene Settings");
 
         class DoCreateNewAssetCommonSettings : DoCreateNewAsset<CommonSettings> {}
         class DoCreateNewAssetHDRISkySettings : DoCreateNewAsset<HDRISkySettings> {}
-        class DoCreateNewAssetBlacksmithSkySettings : DoCreateNewAsset<BlacksmithSkySettings> {}
-        [MenuItem("Assets/Create/HDRenderPipeline/Common Settings", priority = 700)]
+        [MenuItem("Assets/Create/Render Pipeline/High Definition/Common Settings", priority = CoreUtils.assetCreateMenuPriority2)]
         static void MenuCreateCommonSettings()
         {
             var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
-        [MenuItem("Assets/Create/HDRenderPipeline/Subsurface Scattering Settings", priority = 702)]
+        [MenuItem("Assets/Create/Render Pipeline/High Definition/Subsurface Scattering Settings", priority = CoreUtils.assetCreateMenuPriority2)]
         static void MenuCreateSubsurfaceScatteringProfile()
         {
             var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
-        [MenuItem("Assets/Create/HDRenderPipeline/HDRISky Settings", priority = 750)]
+        [MenuItem("Assets/Create/Render Pipeline/High Definition/HDRISky Settings", priority = CoreUtils.assetCreateMenuPriority2)]
         static void MenuCreateHDRISkySettings()
         {
             var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
-        [MenuItem("Assets/Create/HDRenderPipeline/BlacksmithSky Settings", priority = 751)]
-        static void MenuCreateBlacksmithSkySettings()
-        {
-            var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");
-            ProjectWindowUtil.StartNameEditingIfProjectWindowExists(0, ScriptableObject.CreateInstance<DoCreateNewAssetBlacksmithSkySettings>(), "New BlacksmithSkySettings.asset", icon, null);
-        }
-
-        [MenuItem("Assets/Create/HDRenderPipeline/ProceduralSky Settings", priority = 752)]
+        [MenuItem("Assets/Create/Render Pipeline/High Definition/ProceduralSky Settings", priority = CoreUtils.assetCreateMenuPriority2)]
         static void MenuCreateProceduralSkySettings()
         {
             var icon = EditorGUIUtility.FindTexture("ScriptableObject Icon");

ScriptableRenderPipeline/HDRenderPipeline/Editor/UpgradeStandardShaderMaterials.cs

 using System.Collections.Generic;
 using UnityEngine;
+using UnityEngine.Experimental.Rendering;
 
 namespace UnityEditor.Experimental.Rendering.HDPipeline
 {
             return upgraders;
         }
 
-        [MenuItem("RenderPipeline/HDRenderPipeline/Material Upgraders/Upgrade Standard Materials to Lit Materials - Project Folder", false, 1)]
+        [MenuItem("Edit/Render Pipeline/Upgrade/High Definition/Upgrade Standard Materials to Lit Materials (Project)", priority = CoreUtils.editMenuPriority2)]
-        [MenuItem("RenderPipeline/HDRenderPipeline/Material Upgraders/Upgrade Standard Materials to Lit Materials - Selection", false, 2)]
+        [MenuItem("Edit/Render Pipeline/Upgrade/High Definition/Upgrade Standard Materials to Lit Materials (Selection)", priority = CoreUtils.editMenuPriority2)]
-        [MenuItem("RenderPipeline/HDRenderPipeline/Material Upgraders/Modify Light Intensity for Upgrade - Scene Only", false, 3)]
+        [MenuItem("Edit/Render Pipeline/Upgrade/High Definition/Modify Light Intensity for Upgrade (Scene Only)", priority = CoreUtils.editMenuPriority2)]
         static void UpgradeLights()
         {
             Light[] lights = Light.GetLights(LightType.Directional, 0);

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset

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

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.asset.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRenderPipelineAsset.cs

-using UnityEngine.Experimental.Rendering.HDPipeline.TilePass;
-
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
     // The HDRenderPipeline assumes linear lighting. Doesn't work with gamma.
         // NOTE: All those properties are public because of how HDRenderPipelineInspector retrieves those properties via serialization/reflection
         // Doing it this way allows to change parameters name and still retrieve correct serialized values
 
-        // Renderer Settings
-        public RenderingSettings renderingSettings = new RenderingSettings();
+        // Global Renderer Settings
+        public GlobalRenderingSettings globalRenderingSettings = new GlobalRenderingSettings();
+        public GlobalTextureSettings globalTextureSettings = new GlobalTextureSettings();
-        public TileSettings tileSettings = new TileSettings();
+        public LightLoopSettings lightLoopSettings = new LightLoopSettings();
-        // Texture Settings
-        public TextureSettings textureSettings = new TextureSettings();
-
-
         [SerializeField]
         Material m_DefaultDiffuseMaterial;
         [SerializeField]
         {
             get { return m_DefaultDiffuseMaterial; }
-            private set { m_DefaultDiffuseMaterial = value; }
+            set { m_DefaultDiffuseMaterial = value; }
-            private set { m_DefaultShader = value; }
+            set { m_DefaultShader = value; }
         }
 
         public override Shader GetDefaultShader()

ScriptableRenderPipeline/HDRenderPipeline/HDStringConstants.cs

         public static readonly string s_MotionVectorsStr = "MotionVectors";
         public static readonly string s_DistortionVectorsStr = "DistortionVectors";
         public static readonly string s_TransparentDepthPrepassStr = "TransparentDepthPrepass";
+        public static readonly string s_TransparentBackfaceStr = "TransparentBackface";
+        public static readonly string s_TransparentBackfaceDebugDisplayStr = "TransparentBackfaceDebugDisplay";
+        public static readonly string s_TransparentDepthPostpassStr = "TransparentDepthPostpass";
         public static readonly string s_MetaStr = "Meta";
         public static readonly string s_ShadowCasterStr = "ShadowCaster";
 
         public static readonly ShaderPassName s_MotionVectorsName = new ShaderPassName(s_MotionVectorsStr);
         public static readonly ShaderPassName s_DistortionVectorsName = new ShaderPassName(s_DistortionVectorsStr);
         public static readonly ShaderPassName s_TransparentDepthPrepassName = new ShaderPassName(s_TransparentDepthPrepassStr);
+        public static readonly ShaderPassName s_TransparentBackfaceName = new ShaderPassName(s_TransparentBackfaceStr);
+        public static readonly ShaderPassName s_TransparentBackfaceDebugDisplayName = new ShaderPassName(s_TransparentBackfaceDebugDisplayStr);
+        public static readonly ShaderPassName s_TransparentDepthPostpassName = new ShaderPassName(s_TransparentDepthPostpassStr);
 
         // Legacy name
         public static readonly ShaderPassName s_AlwaysName = new ShaderPassName("Always");
 
         public static readonly int g_BaseFeatureFlags = Shader.PropertyToID("g_BaseFeatureFlags");
         public static readonly int g_TileFeatureFlags = Shader.PropertyToID("g_TileFeatureFlags");
-
-        public static readonly int _GBufferTexture0 = Shader.PropertyToID("_GBufferTexture0");
-        public static readonly int _GBufferTexture1 = Shader.PropertyToID("_GBufferTexture1");
-        public static readonly int _GBufferTexture2 = Shader.PropertyToID("_GBufferTexture2");
-        public static readonly int _GBufferTexture3 = Shader.PropertyToID("_GBufferTexture3");
 
         public static readonly int g_DispatchIndirectBuffer = Shader.PropertyToID("g_DispatchIndirectBuffer");
         public static readonly int g_TileList = Shader.PropertyToID("g_TileList");
 
         public static readonly int[] _DBufferTexture =
         {
-            Shader.PropertyToID("_DBufferTexture0"),
+            Shader.PropertyToID("_DBufferTexture0"), 
+        };
+
+        public static readonly int[] _SSSBufferTexture = 
+        {
+            Shader.PropertyToID("_SSSBufferTexture0"),
+            Shader.PropertyToID("_SSSBufferTexture1"),
+            Shader.PropertyToID("_SSSBufferTexture2"),
+            Shader.PropertyToID("_SSSBufferTexture3"),
         };
 
         public static readonly int _VelocityTexture = Shader.PropertyToID("_VelocityTexture");

ScriptableRenderPipeline/HDRenderPipeline/HDUtils.cs

     public class HDUtils
     {
         public const RendererConfiguration k_RendererConfigurationBakedLighting = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
-        public const RendererConfiguration k_RendererConfigurationBakedLightingWithShadowMask = RendererConfiguration.PerObjectLightProbe | RendererConfiguration.PerObjectLightmaps | RendererConfiguration.PerObjectLightProbeProxyVolume;
+        public const RendererConfiguration k_RendererConfigurationBakedLightingWithShadowMask = k_RendererConfigurationBakedLighting | RendererConfiguration.PerObjectOcclusionProbe | RendererConfiguration.PerObjectOcclusionProbeProxyVolume | RendererConfiguration.PerObjectShadowMask;
 
         public static List<RenderPipelineMaterial> GetRenderPipelineMaterialList()
         {
                 y -= s_OverlayLineHeight;
                 s_OverlayLineHeight = -1.0f;
             }
+        }
+
+
+        public static Matrix4x4 ComputePixelCoordToWorldSpaceViewDirectionMatrix(float verticalFoV, Vector4 screenSize, Matrix4x4 worldToViewMatrix, bool renderToCubemap)
+        {
+            // Compose the view space version first.
+            // V = -(X, Y, Z), s.t. Z = 1,
+            // X = (2x / resX - 1) * tan(vFoV / 2) * ar = x * [(2 / resX) * tan(vFoV / 2) * ar] + [-tan(vFoV / 2) * ar] = x * [-m00] + [-m20]
+            // Y = (2y / resY - 1) * tan(vFoV / 2)      = y * [(2 / resY) * tan(vFoV / 2)]      + [-tan(vFoV / 2)]      = y * [-m11] + [-m21]
+            float tanHalfVertFoV = Mathf.Tan(0.5f * verticalFoV);
+            float aspectRatio    = screenSize.x * screenSize.w;
+
+            // Compose the matrix.
+            float m21 = tanHalfVertFoV;
+            float m20 = tanHalfVertFoV * aspectRatio;
+            float m00 = -2.0f * screenSize.z * m20;
+            float m11 = -2.0f * screenSize.w * m21;
+            float m33 = -1.0f;
+
+            if (renderToCubemap)
+            {
+                // Flip Y.
+                m11 = -m11;
+                m21 = -m21;
+            }
+
+            var viewSpaceRasterTransform = new Matrix4x4(new Vector4(m00, 0.0f, 0.0f, 0.0f),
+                                                         new Vector4(0.0f, m11, 0.0f, 0.0f),
+                                                         new Vector4(m20, m21, m33, 0.0f),
+                                                         new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
+
+            // Remove the translation component.
+            var homogeneousZero = new Vector4(0, 0, 0, 1);
+            worldToViewMatrix.SetColumn(3, homogeneousZero);
+
+            // Flip the Z to make the coordinate system left-handed.
+            worldToViewMatrix.SetRow(2, -worldToViewMatrix.GetRow(2));
+
+            // Transpose for HLSL.
+            return Matrix4x4.Transpose(worldToViewMatrix.transpose * viewSpaceRasterTransform);
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Deferred.shader

 
             HLSLPROGRAM
             #pragma target 4.5
-            #pragma only_renderers d3d11 ps4 metal // TEMP: until we go further in dev
+            #pragma only_renderers d3d11 ps4 vulkan metal // TEMP: until we go further in dev
             // #pragma enable_d3d11_debug_symbols
 
             #pragma vertex Vert
             #pragma multi_compile LIGHTLOOP_SINGLE_PASS LIGHTLOOP_TILE_PASS
-            #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST
 
             // Split lighting is utilized during the SSS pass.
             #pragma multi_compile _ OUTPUT_SPLIT_LIGHTING
+            #define USE_FPTL_LIGHTLIST // deferred opaque always use FPTL
+
-            #include "../../Core/ShaderLibrary/Common.hlsl"
+            #include "ShaderLibrary/Common.hlsl"
             #include "../Debug/DebugDisplay.hlsl"
 
             // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
             // variable declaration
             //-------------------------------------------------------------------------------------
 
-            DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
             #ifdef SHADOWS_SHADOWMASK
             TEXTURE2D(_ShadowMaskTexture);
             #endif
 
                 // input.positionCS is SV_Position
                 PositionInputs posInput = GetPositionInput(input.positionCS.xy, _ScreenSize.zw, uint2(input.positionCS.xy) / GetTileSize());
-                float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
-                UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+                float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.positionSS).x;
+                UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
-                FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-                DECODE_FROM_GBUFFER(gbuffer, MATERIAL_FEATURE_MASK_FLAGS, bsdfData, bakeLightingData.bakeDiffuseLighting);
+                DECODE_FROM_GBUFFER(posInput.positionSS, MATERIAL_FEATURE_MASK_FLAGS, bsdfData, bakeLightingData.bakeDiffuseLighting);
-                DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
+                DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.positionSS), bakeLightingData.bakeShadowMask);
                 #endif
 
                 PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);
                 LightLoop(V, posInput, preLightData, bsdfData, bakeLightingData, LIGHT_FEATURE_MASK_FLAGS_OPAQUE, diffuseLighting, specularLighting);
 
                 Outputs outputs;
+
-                outputs.specularLighting = float4(specularLighting, 1.0);
-                outputs.diffuseLighting  = TagLightingForSSS(diffuseLighting);
+                if (_EnableSSSAndTransmission != 0 && bsdfData.materialId == MATERIALID_LIT_SSS)
+                {
+                    outputs.specularLighting = float4(specularLighting, 1.0);
+                    outputs.diffuseLighting  = TagLightingForSSS(diffuseLighting);
+                }
+                else
+                {
+                    outputs.specularLighting = float4(diffuseLighting + specularLighting, 1.0);
+                    outputs.diffuseLighting  = 0;
+                }
             #else
                 outputs.combinedLighting = float4(diffuseLighting + specularLighting, 1.0);
             #endif

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

         sealed class Styles
         {
             // Base
-            public readonly GUIContent range = new GUIContent("Range", "Controls how far the light is emitted from the center of the object.");
-            public readonly GUIContent color = new GUIContent("Color", "Controls the color being emitted by the light.");
-            public readonly GUIContent spotAngle = new GUIContent("Angle", "Controls the angle in degrees at the base of a Spot light's cone.");
-            public readonly GUIContent useColorTemperature = new GUIContent("Use Color Temperature", "Choose between RGB and temperature mode for light's color.");
-            public readonly GUIContent colorFilter = new GUIContent("Filter", "A colored gel can be put in front of the light source to tint the light.");
-            public readonly GUIContent colorTemperature = new GUIContent("Temperature", "Also known as CCT (Correlated color temperature). The color temperature of the electromagnetic radiation emitted from an ideal black body is defined as its surface temperature in Kelvin. White is 6500K");
-            public readonly GUIContent intensity = new GUIContent("Intensity", "Controls the brightness of the light. Light color is multiplied by this value.");
-            public readonly GUIContent lightmappingMode = new GUIContent("Mode", "Specifies the light mode used to determine if and how a light will be baked. Possible modes are Baked, Mixed, and Realtime.");
-            public readonly GUIContent lightBounceIntensity = new GUIContent("Indirect Multiplier", "Controls the intensity of indirect light being contributed to the scene. A value of 0 will cause Realtime lights to be removed from realtime global illumination and Baked and Mixed lights to no longer emit indirect lighting. Has no effect when both Realtime and Baked Global Illumination are disabled.");
-            public readonly GUIContent cookie = new GUIContent("Cookie", "Specifies the Texture mask to cast shadows, create silhouettes, or patterned illumination for the light.");
             public readonly GUIContent cookieSizeX = new GUIContent("Size X", "Controls the size of the cookie mask currently assigned to the light.");
             public readonly GUIContent cookieSizeY = new GUIContent("Size Y", "Controls the size of the cookie mask currently assigned to the light.");
             public readonly GUIContent shadowBias = new GUIContent("Bias", "Controls the distance at which the shadows will be pushed away from the light. Useful for avoiding false self-shadowing artifacts.");
             public readonly GUIContent bakedShadowAngle = new GUIContent("Baked Shadow Angle", "Controls the amount of artificial softening applied to the edges of shadows cast by directional lights.");
-
-            public readonly GUIContent bakingWarning = new GUIContent("Light mode is currently overridden to Realtime mode. Enable Baked Global Illumination to use Mixed or Baked light modes.");
-            public readonly GUIContent indirectBounceShadowWarning = new GUIContent("Realtime indirect bounce shadowing is not supported for Spot and Point lights.");
-            public readonly GUIContent cookieWarning = new GUIContent("Cookie textures for spot lights should be set to clamp, not repeat, to avoid artifacts.");
 
             // Additional light data
             public readonly GUIContent maxSmoothness = new GUIContent("Max Smoothness", "Very low cost way of faking spherical area lighting. This will modify the roughness of the material lit. This is useful when the specular highlight is too small or too sharp.");

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Editor/HDLightEditor.cs

 using System;
-using System.Linq;
-using UnityEngine.Rendering;
-    // TODO: Simplify this editor once we can target 2018.1
-        sealed class SerializedBaseData
-        {
-            public SerializedProperty type;
-            public SerializedProperty range;
-            public SerializedProperty spotAngle;
-            public SerializedProperty cookie;
-            public SerializedProperty cookieSize;
-            public SerializedProperty color;
-            public SerializedProperty intensity;
-            public SerializedProperty bounceIntensity;
-            public SerializedProperty colorTemperature;
-            public SerializedProperty useColorTemperature;
-            public SerializedProperty shadowsType;
-            public SerializedProperty shadowsBias;
-            public SerializedProperty shadowsNormalBias;
-            public SerializedProperty shadowsNearPlane;
-            public SerializedProperty lightmapping;
-            public SerializedProperty areaSizeX;
-            public SerializedProperty areaSizeY;
-            public SerializedProperty bakedShadowRadius;
-            public SerializedProperty bakedShadowAngle;
-        }
-
         sealed class SerializedLightData
         {
             public SerializedProperty spotInnerPercent;
         SerializedObject m_SerializedAdditionalLightData;
         SerializedObject m_SerializedAdditionalShadowData;
 
-        SerializedBaseData m_BaseData;
-        // Copied over from teh original LightEditor class. Will go away once we can target 2018.1
-        bool m_TypeIsSame { get { return !m_BaseData.type.hasMultipleDifferentValues; } }
-        bool m_LightmappingTypeIsSame { get { return !m_BaseData.lightmapping.hasMultipleDifferentValues; } }
-        bool m_IsCompletelyBaked { get { return m_BaseData.lightmapping.intValue == 2; } }
-        bool m_IsRealtime { get { return m_BaseData.lightmapping.intValue == 4; } }
-        Light light { get { return serializedObject.targetObject as Light; } }
-        Texture m_Cookie { get { return m_BaseData.cookie.objectReferenceValue as Texture; } }
-        bool m_BakingWarningValue { get { return !UnityEditor.Lightmapping.bakedGI && m_LightmappingTypeIsSame && !m_IsRealtime; } }
-        bool m_BounceWarningValue
-        {
-            get
-            {
-                return m_TypeIsSame && (light.type == LightType.Point || light.type == LightType.Spot) &&
-                    m_LightmappingTypeIsSame && m_IsRealtime && !m_BaseData.bounceIntensity.hasMultipleDifferentValues
-                    && m_BaseData.bounceIntensity.floatValue > 0.0f;
-            }
-        }
-        public bool cookieWarningValue
-        {
-            get
-            {
-                return m_TypeIsSame && light.type == LightType.Spot &&
-                    !m_BaseData.cookie.hasMultipleDifferentValues && m_Cookie && m_Cookie.wrapMode != TextureWrapMode.Clamp;
-            }
-        }
-
         // LightType + LightTypeExtent combined
         enum LightShape
         {
         // Used for UI only; the processing code must use LightTypeExtent and LightType
         LightShape m_LightShape;
 
-        void OnEnable()
+        protected override void OnEnable()
+            base.OnEnable();
+
-            var lightData = GetAdditionalData<HDAdditionalLightData>();
-            var shadowData = GetAdditionalData<AdditionalShadowData>();
+            var lightData = CoreEditorUtils.GetAdditionalData<HDAdditionalLightData>(targets);
+            var shadowData = CoreEditorUtils.GetAdditionalData<AdditionalShadowData>(targets);
-            // Grab all the serialized data we need
-            m_BaseData = new SerializedBaseData
-            {
-                type = serializedObject.FindProperty("m_Type"),
-                range = serializedObject.FindProperty("m_Range"),
-                spotAngle = serializedObject.FindProperty("m_SpotAngle"),
-                cookie = serializedObject.FindProperty("m_Cookie"),
-                cookieSize = serializedObject.FindProperty("m_CookieSize"),
-                color = serializedObject.FindProperty("m_Color"),
-                intensity = serializedObject.FindProperty("m_Intensity"),
-                bounceIntensity = serializedObject.FindProperty("m_BounceIntensity"),
-                colorTemperature = serializedObject.FindProperty("m_ColorTemperature"),
-                useColorTemperature = serializedObject.FindProperty("m_UseColorTemperature"),
-                shadowsType = serializedObject.FindProperty("m_Shadows.m_Type"),
-                shadowsBias = serializedObject.FindProperty("m_Shadows.m_Bias"),
-                shadowsNormalBias = serializedObject.FindProperty("m_Shadows.m_NormalBias"),
-                shadowsNearPlane = serializedObject.FindProperty("m_Shadows.m_NearPlane"),
-                lightmapping = serializedObject.FindProperty("m_Lightmapping"),
-                areaSizeX = serializedObject.FindProperty("m_AreaSize.x"),
-                areaSizeY = serializedObject.FindProperty("m_AreaSize.y"),
-                bakedShadowRadius = serializedObject.FindProperty("m_ShadowRadius"),
-                bakedShadowAngle = serializedObject.FindProperty("m_ShadowAngle")
-            };
-
             using (var o = new PropertyFetcher<HDAdditionalLightData>(m_SerializedAdditionalLightData))
             m_AdditionalLightData = new SerializedLightData
             {
             ApplyAdditionalComponentsVisibility(true);
             CheckStyles();
 
-            serializedObject.Update();
+            settings.Update();
-            DrawFoldout(m_BaseData.type, "Shape", DrawShape);
-            DrawFoldout(m_BaseData.intensity, "Light", DrawLightSettings);
+            DrawFoldout(settings.lightType, "Shape", DrawShape);
+            DrawFoldout(settings.intensity, "Light", DrawLightSettings);
-            if (m_BaseData.shadowsType.enumValueIndex != (int)LightShadows.None)
-                DrawFoldout(m_BaseData.shadowsType, "Shadows", DrawShadows);
+            if (settings.shadowsType.enumValueIndex != (int)LightShadows.None)
+                DrawFoldout(settings.shadowsType, "Shadows", DrawShadows);
 
             CoreEditorUtils.DrawSplitter();
             EditorGUILayout.Space();
-            serializedObject.ApplyModifiedProperties();
+            settings.ApplyModifiedProperties();
         }
 
         void DrawFoldout(SerializedProperty foldoutProperty, string title, Action func)
 
         void DrawFeatures()
         {
-            EditorGUILayout.PropertyField(m_AdditionalLightData.showAdditionalSettings);
-
-            bool disabledScope = m_IsCompletelyBaked
+            bool disabledScope = settings.isCompletelyBaked
-                bool shadowsEnabled = EditorGUILayout.Toggle(new GUIContent("Enable Shadows"), m_BaseData.shadowsType.enumValueIndex != 0);
-                m_BaseData.shadowsType.enumValueIndex = shadowsEnabled ? (int)LightShadows.Hard : (int)LightShadows.None;
+                bool shadowsEnabled = EditorGUILayout.Toggle(CoreEditorUtils.GetContent("Enable Shadows"), settings.shadowsType.enumValueIndex != 0);
+                settings.shadowsType.enumValueIndex = shadowsEnabled ? (int)LightShadows.Hard : (int)LightShadows.None;
+
+            EditorGUILayout.PropertyField(m_AdditionalLightData.showAdditionalSettings);
         }
 
         void DrawShape()
             switch (m_LightShape)
             {
                 case LightShape.Directional:
-                    m_BaseData.type.enumValueIndex = (int)LightType.Directional;
+                    settings.lightType.enumValueIndex = (int)LightType.Directional;
-                    m_BaseData.type.enumValueIndex = (int)LightType.Point;
+                    settings.lightType.enumValueIndex = (int)LightType.Point;
-                    m_BaseData.type.enumValueIndex = (int)LightType.Spot;
+                    settings.lightType.enumValueIndex = (int)LightType.Spot;
                     m_AdditionalLightData.lightTypeExtent.enumValueIndex = (int)LightTypeExtent.Punctual;
                     EditorGUILayout.PropertyField(m_AdditionalLightData.spotLightShape, s_Styles.spotLightShape);
                     var spotLightShape = (SpotLightShape)m_AdditionalLightData.spotLightShape.enumValueIndex;
-                        EditorGUILayout.Slider(m_BaseData.spotAngle, 0f, 179.9f, s_Styles.spotAngle);
+                        settings.DrawSpotAngle();
-                        EditorGUILayout.Slider(m_BaseData.spotAngle, 0f, 179.9f, s_Styles.spotAngle);
+                        settings.DrawSpotAngle();
                         EditorGUILayout.Slider(m_AdditionalLightData.aspectRatio, 0.05f, 20.0f, s_Styles.aspectRatioPyramid);
                     }
                     else if (spotLightShape == SpotLightShape.Box)
                 case LightShape.Rectangle:
                     // TODO: Currently if we use Area type as it is offline light in legacy, the light will not exist at runtime
                     //m_BaseData.type.enumValueIndex = (int)LightType.Area;
-                    m_BaseData.type.enumValueIndex = (int)LightType.Point;
+                    settings.lightType.enumValueIndex = (int)LightType.Point;
-                    m_BaseData.areaSizeX.floatValue = m_AdditionalLightData.shapeLength.floatValue;
-                    m_BaseData.areaSizeY.floatValue = m_AdditionalLightData.shapeWidth.floatValue;
-                    m_BaseData.shadowsType.enumValueIndex = (int)LightShadows.None;
+                    settings.areaSizeX.floatValue = m_AdditionalLightData.shapeLength.floatValue;
+                    settings.areaSizeY.floatValue = m_AdditionalLightData.shapeWidth.floatValue;
+                    settings.shadowsType.enumValueIndex = (int)LightShadows.None;
-                    m_BaseData.type.enumValueIndex = (int)LightType.Point;
+                    settings.lightType.enumValueIndex = (int)LightType.Point;
-                    m_BaseData.areaSizeX.floatValue = m_AdditionalLightData.shapeLength.floatValue;
-                    m_BaseData.areaSizeY.floatValue = 0.01f;
-                    m_BaseData.shadowsType.enumValueIndex = (int)LightShadows.None;
+                    settings.areaSizeX.floatValue = m_AdditionalLightData.shapeLength.floatValue;
+                    settings.areaSizeY.floatValue = 0.01f;
+                    settings.shadowsType.enumValueIndex = (int)LightShadows.None;
                     break;
 
                 case (LightShape)(-1):
 
         void DrawLightSettings()
         {
-            if (GraphicsSettings.lightsUseLinearIntensity && GraphicsSettings.lightsUseColorTemperature)
-            {
-                EditorGUILayout.PropertyField(m_BaseData.useColorTemperature, s_Styles.useColorTemperature);
-                if (m_BaseData.useColorTemperature.boolValue)
-                {
-                    const float kMinKelvin = 1000f;
-                    const float kMaxKelvin = 20000f;
-
-                    EditorGUILayout.LabelField(s_Styles.color);
-                    EditorGUI.indentLevel += 1;
-                    EditorGUILayout.PropertyField(m_BaseData.color, s_Styles.colorFilter);
-                    EditorGUILayout.Slider(m_BaseData.colorTemperature, kMinKelvin, kMaxKelvin, s_Styles.colorTemperature);
-                    EditorGUI.indentLevel -= 1;
-                }
-                else EditorGUILayout.PropertyField(m_BaseData.color, s_Styles.color);
-            }
-            else EditorGUILayout.PropertyField(m_BaseData.color, s_Styles.color);
-
-            EditorGUILayout.PropertyField(m_BaseData.intensity, s_Styles.intensity);
-            EditorGUILayout.PropertyField(m_BaseData.bounceIntensity, s_Styles.lightBounceIntensity);
-
-            // Indirect shadows warning (Should be removed when we support realtime indirect shadows)
-            if (m_BounceWarningValue)
-                EditorGUILayout.HelpBox(s_Styles.indirectBounceShadowWarning.text, MessageType.Info);
-
-            EditorGUILayout.PropertyField(m_BaseData.range, s_Styles.range);
-            EditorGUILayout.PropertyField(m_BaseData.lightmapping, s_Styles.lightmappingMode);
-
-            // Warning if GI Baking disabled and m_Lightmapping isn't realtime
-            if (m_BakingWarningValue)
-                EditorGUILayout.HelpBox(s_Styles.bakingWarning.text, MessageType.Info);
+            settings.DrawColor();
+            settings.DrawIntensity();
+            settings.DrawBounceIntensity();
+            settings.DrawRange(false);
+            settings.DrawLightmapping();
-                EditorGUILayout.PropertyField(m_BaseData.cookie, s_Styles.cookie);
-
-                // Warn on spotlights if the cookie is set to repeat
-                if (cookieWarningValue)
-                    EditorGUILayout.HelpBox(s_Styles.cookieWarning.text, MessageType.Warning);
+                settings.DrawCookie();
-                if (m_Cookie != null && m_LightShape == LightShape.Directional)
+                if (settings.cookie != null && m_LightShape == LightShape.Directional)
+                    EditorGUI.indentLevel++;
+                    EditorGUI.indentLevel--;
+                EditorGUILayout.Space();
                 EditorGUILayout.LabelField("Additional Settings", EditorStyles.boldLabel);
                 EditorGUI.indentLevel++;
                 EditorGUILayout.PropertyField(m_AdditionalLightData.affectDiffuse, s_Styles.affectDiffuse);
             }
         }
 
-        void DrawShadows()
+        void DrawBakedShadowParameters()
-            if (m_IsCompletelyBaked)
+            switch ((LightType)settings.lightType.enumValueIndex)
-                switch ((LightType)m_BaseData.type.enumValueIndex)
-                {
-                    case LightType.Directional:
-                        EditorGUILayout.Slider(m_BaseData.bakedShadowAngle, 0f, 90f, s_Styles.bakedShadowAngle);
-                        break;
-                    case LightType.Spot:
-                    case LightType.Point:
-                        EditorGUILayout.PropertyField(m_BaseData.bakedShadowRadius, s_Styles.bakedShadowRadius);
-                        break;
-                }
+                case LightType.Directional:
+                    EditorGUILayout.Slider(settings.bakedShadowAngleProp, 0f, 90f, s_Styles.bakedShadowAngle);
+                    break;
+                case LightType.Spot:
+                case LightType.Point:
+                    EditorGUILayout.PropertyField(settings.bakedShadowRadiusProp, s_Styles.bakedShadowRadius);
+                    break;
+            }
+        }
+        void DrawShadows()
+        {
+            if (settings.isCompletelyBaked)
+            {
+                DrawBakedShadowParameters();
-            EditorGUILayout.Slider(m_BaseData.shadowsBias, 0.001f, 1f, s_Styles.shadowBias);
-            EditorGUILayout.Slider(m_BaseData.shadowsNormalBias, 0.001f, 1f, s_Styles.shadowNormalBias);
-            EditorGUILayout.Slider(m_BaseData.shadowsNearPlane, 0.01f, 10f, s_Styles.shadowNearPlane);
-
-            if (m_BaseData.type.enumValueIndex != (int)LightType.Directional)
-                return;
+            EditorGUILayout.Slider(settings.shadowsBias, 0.001f, 1f, s_Styles.shadowBias);
+            EditorGUILayout.Slider(settings.shadowsNormalBias, 0.001f, 1f, s_Styles.shadowNormalBias);
+            EditorGUILayout.Slider(settings.shadowsNearPlane, 0.01f, 10f, s_Styles.shadowNearPlane);
-            using (var scope = new EditorGUI.ChangeCheckScope())
+            if (settings.lightType.enumValueIndex == (int)LightType.Directional)
-                EditorGUILayout.IntSlider(m_AdditionalShadowData.cascadeCount, 1, 4, s_Styles.shadowCascadeCount);
-
-                if (scope.changed)
+                using (var scope = new EditorGUI.ChangeCheckScope())
-                    int len = m_AdditionalShadowData.cascadeCount.intValue;
-                    m_AdditionalShadowData.cascadeRatios.arraySize = len - 1;
-                    m_AdditionalShadowData.cascadeBorders.arraySize = len;
+                    EditorGUILayout.IntSlider(m_AdditionalShadowData.cascadeCount, 1, 4, s_Styles.shadowCascadeCount);
+
+                    if (scope.changed)
+                    {
+                        int len = m_AdditionalShadowData.cascadeCount.intValue;
+                        m_AdditionalShadowData.cascadeRatios.arraySize = len - 1;
+                        m_AdditionalShadowData.cascadeBorders.arraySize = len;
+                    }
-            }
-            EditorGUI.indentLevel++;
+                EditorGUI.indentLevel++;
-            using (var scope = new EditorGUI.ChangeCheckScope())
-            {
-                // Draw each field first...
-                int arraySize = m_AdditionalShadowData.cascadeRatios.arraySize;
-                for (int i = 0; i < arraySize; i++)
-                    EditorGUILayout.Slider(m_AdditionalShadowData.cascadeRatios.GetArrayElementAtIndex(i), 0f, 1f, s_Styles.shadowCascadeRatios[i]);
-
-                if (scope.changed)
+                using (var scope = new EditorGUI.ChangeCheckScope())
-                    // ...then clamp values to avoid out of bounds cascade ratios
+                    // Draw each field first...
+                    int arraySize = m_AdditionalShadowData.cascadeRatios.arraySize;
-                    {
-                        var ratios = m_AdditionalShadowData.cascadeRatios;
-                        var ratioProp = ratios.GetArrayElementAtIndex(i);
-                        float val = ratioProp.floatValue;
+                        EditorGUILayout.Slider(m_AdditionalShadowData.cascadeRatios.GetArrayElementAtIndex(i), 0f, 1f, s_Styles.shadowCascadeRatios[i]);
-                        if (i > 0)
+                    if (scope.changed)
+                    {
+                        // ...then clamp values to avoid out of bounds cascade ratios
+                        for (int i = 0; i < arraySize; i++)
-                            var prevRatioProp = ratios.GetArrayElementAtIndex(i - 1);
-                            float prevVal = prevRatioProp.floatValue;
-                            val = Mathf.Max(val, prevVal);
-                        }
+                            var ratios = m_AdditionalShadowData.cascadeRatios;
+                            var ratioProp = ratios.GetArrayElementAtIndex(i);
+                            float val = ratioProp.floatValue;
+
+                            if (i > 0)
+                            {
+                                var prevRatioProp = ratios.GetArrayElementAtIndex(i - 1);
+                                float prevVal = prevRatioProp.floatValue;
+                                val = Mathf.Max(val, prevVal);
+                            }
+
+                            if (i < arraySize - 1)
+                            {
+                                var nextRatioProp = ratios.GetArrayElementAtIndex(i + 1);
+                                float nextVal = nextRatioProp.floatValue;
+                                val = Mathf.Min(val, nextVal);
+                            }
-                        if (i < arraySize - 1)
-                        {
-                            var nextRatioProp = ratios.GetArrayElementAtIndex(i + 1);
-                            float nextVal = nextRatioProp.floatValue;
-                            val = Mathf.Min(val, nextVal);
+                            ratioProp.floatValue = val;
-
-                        ratioProp.floatValue = val;
+
+                EditorGUI.indentLevel--;
-            EditorGUI.indentLevel--;
+            if (settings.isBakedOrMixed)
+                DrawBakedShadowParameters();
+                EditorGUILayout.Space();
-                EditorGUILayout.PropertyField(m_AdditionalShadowData.fadeDistance, s_Styles.shadowFadeDistance);
+
+                if (settings.lightType.enumValueIndex == (int)LightType.Point || settings.lightType.enumValueIndex == (int)LightType.Spot)
+                    EditorGUILayout.PropertyField(m_AdditionalShadowData.fadeDistance, s_Styles.shadowFadeDistance);
+
                 EditorGUILayout.PropertyField(m_AdditionalShadowData.dimmer, s_Styles.shadowDimmer);
                 EditorGUI.indentLevel--;
             }
 
         void ResolveLightShape()
         {
-            var type = m_BaseData.type;
+            var type = settings.lightType;
 
             // Special case for multi-selection: don't resolve light shape or it'll corrupt lights
             if (type.hasMultipleDifferentValues)
                         break;
                 }
             }
-        }
-
-        // TODO: Move this to a generic EditorUtilities class
-        T[] GetAdditionalData<T>()
-            where T : Component
-        {
-            // Handles multi-selection
-            var data = targets.Cast<Component>()
-                .Select(t => t.GetComponent<T>())
-                .ToArray();
-
-            for (int i = 0; i < data.Length; i++)
-            {
-                if (data[i] == null)
-                    data[i] = Undo.AddComponent<T>(((Component)targets[i]).gameObject);
-            }
-
-            return data;
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Forward.hlsl

 // Those that are control from inside the "Material".shader with "Pass" concept like forward lighting. Call later forward lighting architecture.
 // Those that are control outside the "Material".shader in a "Lighting".shader like deferred lighting. Call later deferred lighting architecture.
 
-// When dealing with deferred lighting architecture, the renderloop is in charge to call the correct .shader.
-// RenderLoop can do multiple call of various deferred lighting architecture.
+// When dealing with deferred lighting architecture, the renderPipeline is in charge to call the correct .shader.
+// renderPipeline can do multiple call of various deferred lighting architecture.
-// When dealing with forward lighting architecture, the renderloop must specify a shader pass (like "forward") but it also need
+// When dealing with forward lighting architecture, the renderPipeline must specify a shader pass (like "forward") but it also need
-// Renderloop can suppose dynamically switching from regular forward to tile forward for example within the same "Forward" pass.
 
 // The purpose of the following pragma is to define the variant available for "Forward" Pass in "Material".shader.
 // If only one keyword is present it mean that only one type of forward lighting architecture is supported.
-
-// No USE_FPTL_LIGHTLIST as we are in forward and this use the cluster path (but cluster path can use the tile light list for opaque)
-#define USE_CLUSTERED_LIGHTLIST
+// For forward transparent are always cluster and opaque can be either cluster or fptl (sadly we have no to do multicompile only if opaque)
+// Moreover, we would like to do it only for LIGHTLOOP_TILE_PASS variant...
+// #pragma multi_compile USE_FPTL_LIGHTLIST USE_CLUSTERED_LIGHTLIST

ScriptableRenderPipeline/HDRenderPipeline/Lighting/HDAdditionalLightData.cs

     [RequireComponent(typeof(Light))]
     public class HDAdditionalLightData : MonoBehaviour
     {
+ #pragma warning disable 414 // CS0414 The private field '...' is assigned but its value is never used
+        // We can't rely on Unity for our additional data, we need to version it ourself.
+        [SerializeField]
+        float m_Version = 1.0f;
+ #pragma warning restore 414
+            
         [Range(0.0f, 100.0f)]
         [FormerlySerializedAs("m_innerSpotPercent")]
         public float m_InnerSpotPercent = 0.0f; // To display this field in the UI this need to be public

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs

         public Vector3 forward;
         public int cookieIndex; // -1 if unused
 
-        public Vector3 right;   // Rescaled by (2 / shapeLenght)
+        public Vector3 right;   // Rescaled by (2 / shapeLength)
-        public bool dynamicShadowCasterOnly; // Use with ShadowMask feature
+        public bool dynamicShadowCasterOnly; // Use with ShadowMask feature
 
         public Vector4 shadowMaskSelector; // Use with ShadowMask feature
     };
         public Vector3 forward;
         public int cookieIndex; // -1 if unused
 
-        public Vector3 right;   // If spot: rescaled by cot(outerHalfAngle); if projector: rescaled by (2 / shapeLenght)
+        public Vector3 right;   // If spot: rescaled by cot(outerHalfAngle); if projector: rescaled by (2 / shapeLength)
-        public Vector3 up;      // If spot: rescaled by cot(outerHalfAngle); if projector: rescaled by * (2 / shapeWidth)
+        public Vector3 up;      // If spot: rescaled by cot(outerHalfAngle); if projector: rescaled by (2 / shapeWidth)
         public float diffuseScale;
 
         public float angleScale;  // Spot light
 
-        public Vector2 size;      // Used by area, frustum projector and spot lights (x = cot(outerHalfAngle))
+        public Vector4 shadowMaskSelector; // Use with ShadowMask feature
+
+        public Vector2 size;      // Used by area and pyramid projector lights
-
-        public Vector4 shadowMaskSelector; // Use with ShadowMask feature
-
 
 
     [GenerateHLSL]

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightDefinition.cs.hlsl

     float specularScale;
     float3 up;
     float diffuseScale;
-    bool dynamicShadowCasterOnly;
+    bool dynamicShadowCasterOnly;
     float4 shadowMaskSelector;
 };
 
     float angleOffset;
     float shadowDimmer;
     bool dynamicShadowCasterOnly;
+    float4 shadowMaskSelector;
-    float4 shadowMaskSelector;
 };
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.EnvLightData
 {
 	return value.diffuseScale;
 }
-bool GetDynamicShadowCasterOnly(DirectionalLightData value)
-{
-	return value.dynamicShadowCasterOnly;
-}
 float2 GetFadeDistanceScaleAndBias(DirectionalLightData value)
 {
 	return value.fadeDistanceScaleAndBias;
 	return value.unused0;
 }
+bool GetDynamicShadowCasterOnly(DirectionalLightData value)
+{
+	return value.dynamicShadowCasterOnly;
+}
 float4 GetShadowMaskSelector(DirectionalLightData value)
 {
 	return value.shadowMaskSelector;
 {
 	return value.dynamicShadowCasterOnly;
 }
+float4 GetShadowMaskSelector(LightData value)
+{
+	return value.shadowMaskSelector;
+}
 float2 GetSize(LightData value)
 {
 	return value.size;
 float GetMinRoughness(LightData value)
 {
 	return value.minRoughness;
-}
-float4 GetShadowMaskSelector(LightData value)
-{
-	return value.shadowMaskSelector;
 }
 
 //

ScriptableRenderPipeline/HDRenderPipeline/Lighting/Lighting.hlsl

 #ifndef UNITY_LIGHTING_INCLUDED
 #define UNITY_LIGHTING_INCLUDED
 
-#include "../../Core/ShaderLibrary/CommonLighting.hlsl"
-#include "../../Core/ShaderLibrary/CommonShadow.hlsl"
-#include "../../Core/ShaderLibrary/Sampling.hlsl"
-#include "../../Core/ShaderLibrary/AreaLighting.hlsl"
-#include "../../Core/ShaderLibrary/ImageBasedLighting.hlsl"
+#include "ShaderLibrary/CommonLighting.hlsl"
+#include "ShaderLibrary/CommonShadow.hlsl"
+#include "ShaderLibrary/Sampling.hlsl"
+#include "ShaderLibrary/AreaLighting.hlsl"
+#include "ShaderLibrary/ImageBasedLighting.hlsl"
 
 // The light loop (or lighting architecture) is in charge to:
 // - Define light list
 #include "../Lighting/LightDefinition.cs.hlsl"
 #include "../Lighting/LightUtilities.hlsl"
 
-#define SHADOW_TILEPASS
-#include "../../Core/ShaderLibrary/Shadow/Shadow.hlsl"
-#undef SHADOW_TILEPASS
+#include "LightLoop/Shadow.hlsl"
-#include "../Lighting/TilePass/TilePass.hlsl"
+#include "../Lighting/LightLoop/LightLoopDef.hlsl"
 #endif
 
 // Shadow use samling function define in header above and must be include before Material.hlsl
 #if defined(LIGHTLOOP_SINGLE_PASS) || defined(LIGHTLOOP_TILE_PASS)
-#include "../Lighting/TilePass/TilePassLoop.hlsl"
+#include "../Lighting/LightLoop/LightLoop.hlsl"
 #endif
 
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/Shadow.hlsl

-// This file is empty by default.
-// Project specific file to override the default shadow sampling routines.
-// We need to define which dispatchers we're overriding, otherwise the compiler will pick default implementations which will lead to compilation errors.
-// Check Shadow.hlsl right below where this header is included for the individual defines.
+#ifndef LIGHTLOOP_SHADOW_HLSL
+#define LIGHTLOOP_SHADOW_HLSL
+#define SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL
+#define SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL
+#include "ShadowContext.hlsl"
 
 // This is an example of how to override the default dynamic resource dispatcher
 // by hardcoding the resources used and calling the shadow sampling routines that take an explicit texture and sampler.
 
-#define SHADOW_DISPATCH_USE_CUSTOM_DIRECTIONAL	    // enables hardcoded resources and algorithm for directional lights
-#define SHADOW_DISPATCH_USE_CUSTOM_PUNCTUAL		    // enables hardcoded resources and algorithm for punctual lights
 //#define SHADOW_DISPATCH_USE_SEPARATE_CASCADE_ALGOS  // enables separate cascade sampling variants for each cascade
 //#define SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS	    // enables separate resources and algorithms for spot and point lights
 
 	return EvalShadow_CascadedDepth_Blend( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
 }
 
-float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 unPositionSS )
+float GetDirectionalShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float3 L, float2 positionSS )
 {
 	return GetDirectionalShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }
 		return EvalShadow_SpotDepth( shadowContext, algo, tex, compSamp, positionWS, normalWS, shadowDataIndex, L );
 	}
 #else
-	// example for choosing the same algo 
+	// example for choosing the same algo
 	Texture2DArray			tex      = shadowContext.tex2DArray[SHADOW_DISPATCH_PUNC_TEX];
 	SamplerComparisonState	compSamp = shadowContext.compSamplers[SHADOW_DISPATCH_PUNC_SMP];
 	uint					algo     = SHADOW_DISPATCH_PUNC_ALG;
-float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 unPositionSS )
+float GetPunctualShadowAttenuation( ShadowContext shadowContext, float3 positionWS, float3 normalWS, int shadowDataIndex, float4 L, float2 positionSS )
 {
 	return GetPunctualShadowAttenuation( shadowContext, positionWS, normalWS, shadowDataIndex, L );
 }
 #ifdef SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS
 #undef SHADOW_DISPATCH_USE_SEPARATE_PUNC_ALGOS
 #endif
+
+
+
+#endif // LIGHTLOOP_SHADOW_HLSL

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/LightLoopDef.hlsl

-#include "TilePass.cs.hlsl"
+#include "LightLoop.cs.hlsl"
-#define DWORD_PER_TILE 16 // See dwordsPerTile in TilePass.cs, we have roomm for 31 lights and a number of light value all store on 16 bit (ushort)
+#define DWORD_PER_TILE 16 // See dwordsPerTile in LightLoop.cs, we have roomm for 31 lights and a number of light value all store on 16 bit (ushort)
 
 CBUFFER_START(UnityTilePass)
 uint _NumTileFtplX;
 int g_iLog2NumClusters; // We need to always define these to keep constant buffer layouts compatible
 
 uint g_isLogBaseBufferEnabled;
-uint _UseTileLightList;
 //#endif
 
 //#ifdef USE_CLUSTERED_LIGHTLIST

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/LightLoop.hlsl

 // Calculate the offset in global light index light for current light category
 int GetTileOffset(PositionInputs posInput, uint lightCategory)
 {
-    uint2 tileIndex = posInput.unTileCoord;
+    uint2 tileIndex = posInput.tileCoord;
     return (tileIndex.y + lightCategory * _NumTileFtplY) * _NumTileFtplX + tileIndex.x;
 }
 
 
 uint GetTileSize()
 {
-    if (_UseTileLightList)
-        return TILE_SIZE_FPTL;
-    else
-        return TILE_SIZE_CLUSTERED;
+    return TILE_SIZE_CLUSTERED;
-    uint2 tileIndex = posInput.unTileCoord;
+    uint2 tileIndex = posInput.tileCoord;
 
     float logBase = g_fClustBase;
     if (g_isLogBaseBufferEnabled)
 
-    int clustIdx = SnapToClusterIdxFlex(posInput.depthVS, logBase, g_isLogBaseBufferEnabled != 0);
+    int clustIdx = SnapToClusterIdxFlex(posInput.linearDepth, logBase, g_isLogBaseBufferEnabled != 0);
 
     int nrClusters = (1 << g_iLog2NumClusters);
     const int idx = ((lightCategory * nrClusters + clustIdx) * _NumTileClusteredY + tileIndex.y) * _NumTileClusteredX + tileIndex.x;
 
 void GetCountAndStart(PositionInputs posInput, uint lightCategory, out uint start, out uint lightCount)
 {
-    if (_UseTileLightList)
-        GetCountAndStartTile(posInput, lightCategory, start, lightCount);
-    else
-        GetCountAndStartCluster(posInput, lightCategory, start, lightCount);
+    GetCountAndStartCluster(posInput, lightCategory, start, lightCount);
-    uint offset = tileOffset + lightIndex;
-    const uint lightIndexPlusOne = lightIndex + 1; // Add +1 as first slot is reserved to store number of light
-
-    if (_UseTileLightList)
-        offset = DWORD_PER_TILE * tileOffset + (lightIndexPlusOne >> 1);
-
-    // Avoid generated HLSL bytecode to always access g_vLightListGlobal with
-    // two different offsets, fixes out of bounds issue
-    uint value = g_vLightListGlobal[offset];
-
-    // Light index are store on 16bit
-    return (_UseTileLightList ? ((value >> ((lightIndexPlusOne & 1) * DWORD_PER_TILE)) & 0xffff) : value);
+    return g_vLightListGlobal[tileOffset + lightIndex];
 }
 
 #endif // USE_FPTL_LIGHTLIST
 
 #endif // LIGHTLOOP_TILE_PASS
 
+LightData FetchLight(uint start, uint i)
+{
+#ifdef LIGHTLOOP_TILE_PASS
+    int j = FetchIndex(start, i);
+#else
+    int j = start + i;
+#endif
+    return _LightDatas[j];
+}
+
 // bakeDiffuseLighting is part of the prototype so a user is able to implement a "base pass" with GI and multipass direct light (aka old unity rendering path)
 void LightLoop( float3 V, PositionInputs posInput, PreLightData preLightData, BSDFData bsdfData, BakeLightingData bakeLightingData, uint featureFlags,
                 out float3 diffuseLighting,
 
     if (featureFlags & LIGHTFEATUREFLAGS_PUNCTUAL)
     {
-        #ifdef LIGHTLOOP_TILE_PASS
+        uint lightCount, lightStart;
-        // TODO: Convert the for loop below to a while on each type as we know we are sorted and compare performance.
-        uint punctualLightStart;
-        uint punctualLightCount;
-        GetCountAndStart(posInput, LIGHTCATEGORY_PUNCTUAL, punctualLightStart, punctualLightCount);
+    #ifdef LIGHTLOOP_TILE_PASS
+        GetCountAndStart(posInput, LIGHTCATEGORY_PUNCTUAL, lightStart, lightCount);
+    #else
+        lightCount = _PunctualLightCount;
+        lightStart = 0;
+    #endif
-        for (i = 0; i < punctualLightCount; ++i)
+        for (i = 0; i < lightCount; i++)
-            int punctualIndex = FetchIndex(punctualLightStart, i);
-            DirectLighting lighting = EvaluateBSDF_Punctual(context, V, posInput, preLightData, _LightDatas[punctualIndex], bsdfData, bakeLightingData, _LightDatas[punctualIndex].lightType);
-            AccumulateDirectLighting(lighting, aggregateLighting);
-        }
-
-        #else
+            LightData lightData = FetchLight(lightStart, i);
-        for (i = 0; i < _PunctualLightCount; ++i)
-        {
-            DirectLighting lighting = EvaluateBSDF_Punctual(context, V, posInput, preLightData, _LightDatas[i], bsdfData, bakeLightingData, _LightDatas[i].lightType);
+            DirectLighting lighting = EvaluateBSDF_Punctual(context, V, posInput, preLightData, lightData, bsdfData, bakeLightingData);
-
-        #endif
-        #ifdef LIGHTLOOP_TILE_PASS
+        uint lightCount, lightStart;
-        uint areaLightStart;
-        uint areaLightCount;
-        GetCountAndStart(posInput, LIGHTCATEGORY_AREA, areaLightStart, areaLightCount);
+    #ifdef LIGHTLOOP_TILE_PASS
+        GetCountAndStart(posInput, LIGHTCATEGORY_AREA, lightStart, lightCount);
+    #else
+        lightCount = _AreaLightCount;
+        lightStart = _PunctualLightCount;
+    #endif
 
         // COMPILER BEHAVIOR WARNING!
         // If rectangle lights are before line lights, the compiler will duplicate light matrices in VGPR because they are used differently between the two types of lights.
-        i = 0;
-        if (areaLightCount > 0)
+        if (lightCount > 0)
-            uint areaIndex = FetchIndex(areaLightStart, 0);
-            uint lightType = _LightDatas[areaIndex].lightType;
+            i = 0;
+
+            uint      last      = lightCount - 1;
+            LightData lightData = FetchLight(lightStart, i);
-            while (i < areaLightCount && lightType == GPULIGHTTYPE_LINE)
+            while (i <= last && lightData.lightType == GPULIGHTTYPE_LINE)
-                DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[areaIndex], bsdfData, bakeLightingData, GPULIGHTTYPE_LINE);
+                lightData.lightType = GPULIGHTTYPE_LINE; // Enforce constant propagation
+
+                DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, lightData, bsdfData, bakeLightingData);
-                i++;
-                areaIndex = i < areaLightCount ? FetchIndex(areaLightStart, i) : 0;
-                lightType = i < areaLightCount ? _LightDatas[areaIndex].lightType : 0xFF;
+                lightData = FetchLight(lightStart, min(++i, last));
-            while (i < areaLightCount && lightType == GPULIGHTTYPE_RECTANGLE)
+            while (i <= last && lightData.lightType == GPULIGHTTYPE_RECTANGLE)
-                DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[areaIndex], bsdfData, bakeLightingData, GPULIGHTTYPE_RECTANGLE);
+                lightData.lightType = GPULIGHTTYPE_RECTANGLE; // Enforce constant propagation
+
+                DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, lightData, bsdfData, bakeLightingData);
-                i++;
-                areaIndex = i < areaLightCount ? FetchIndex(areaLightStart, i) : 0;
-                lightType = i < areaLightCount ? _LightDatas[areaIndex].lightType : 0xFF;
+                lightData = FetchLight(lightStart, min(++i, last));
-
-        #else
-
-        for (i = _PunctualLightCount; i < _PunctualLightCount + _AreaLightCount; ++i)
-        {
-            DirectLighting lighting = EvaluateBSDF_Area(context, V, posInput, preLightData, _LightDatas[i], bsdfData, bakeLightingData, _LightDatas[i].lightType);
-            AccumulateDirectLighting(lighting, aggregateLighting);
-        }
-
-        #endif
     }
 
     float reflectionHierarchyWeight = 0.0; // Max: 1.0

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/LightLoop.cs.hlsl

 // This file was automatically generated. Please don't edit by hand.
 //
 
-#ifndef TILEPASS_CS_HLSL
-#define TILEPASS_CS_HLSL
+#ifndef LIGHTLOOP_CS_HLSL
+#define LIGHTLOOP_CS_HLSL
-// UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightVolumeType:  static fields
+// UnityEngine.Experimental.Rendering.HDPipeline.LightVolumeType:  static fields
 //
 #define LIGHTVOLUMETYPE_CONE (0)
 #define LIGHTVOLUMETYPE_SPHERE (1)
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightCategory:  static fields
+// UnityEngine.Experimental.Rendering.HDPipeline.LightCategory:  static fields
 //
 #define LIGHTCATEGORY_PUNCTUAL (0)
 #define LIGHTCATEGORY_AREA (1)
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightFeatureFlags:  static fields
+// UnityEngine.Experimental.Rendering.HDPipeline.LightFeatureFlags:  static fields
 //
 #define LIGHTFEATUREFLAGS_PUNCTUAL (4096)
 #define LIGHTFEATUREFLAGS_AREA (8192)
 #define LIGHTFEATUREFLAGS_SSREFLECTION (262144)
 
 //
-// UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightDefinitions:  static fields
+// UnityEngine.Experimental.Rendering.HDPipeline.LightDefinitions:  static fields
 //
 #define MAX_NR_LIGHTS_PER_CAMERA (1024)
 #define MAX_NR_BIG_TILE_LIGHTS_PLUS_ONE (512)
 #define LIGHT_FEATURE_MASK_FLAGS_TRANSPARENT (16510976)
 #define MATERIAL_FEATURE_MASK_FLAGS (4095)
 
-// Generated from UnityEngine.Experimental.Rendering.HDPipeline.TilePass.SFiniteLightBound
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.SFiniteLightBound
 // PackingRules = Exact
 struct SFiniteLightBound
 {
     float radius;
 };
 
-// Generated from UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightVolumeData
+// Generated from UnityEngine.Experimental.Rendering.HDPipeline.LightVolumeData
 // PackingRules = Exact
 struct LightVolumeData
 {
 };
 
 //
-// Accessors for UnityEngine.Experimental.Rendering.HDPipeline.TilePass.SFiniteLightBound
+// Accessors for UnityEngine.Experimental.Rendering.HDPipeline.SFiniteLightBound
 //
 float3 GetBoxAxisX(SFiniteLightBound value)
 {
 }
 
 //
-// Accessors for UnityEngine.Experimental.Rendering.HDPipeline.TilePass.LightVolumeData
+// Accessors for UnityEngine.Experimental.Rendering.HDPipeline.LightVolumeData
 //
 float3 GetLightPos(LightVolumeData value)
 {

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/scrbound.compute

 
 #pragma kernel ScreenBoundsAABB
 
-#include "../../../Core/ShaderLibrary/common.hlsl"
-#include "TilePass.cs.hlsl"
+#include "ShaderLibrary/common.hlsl"
+#include "LightLoop.cs.hlsl"
 
 uniform int g_isOrthographic;
 uniform int g_iNrVisibLights;
 				float fW = vPnts[k].w;
 				float fS = fW<0 ? -1 : 1;
 				float fWabs = fW<0 ? (-fW) : fW;
-				fW = fS * (fWabs<FLT_EPSILON ? FLT_EPSILON : fWabs);
+				fW = fS * (fWabs<FLT_EPS ? FLT_EPS : fWabs);
 				float3 vP = float3(vPnts[k].x/fW, vPnts[k].y/fW, vPnts[k].z/fW);
 				if(k==0) { vMin=vP; vMax=vP; }
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/materialflags.compute

 
 // #pragma enable_d3d11_debug_symbols
 
-#include "../../../Core/ShaderLibrary/common.hlsl"
+#include "ShaderLibrary/common.hlsl"
-#include "TilePass.cs.hlsl"
+#include "LightLoop.cs.hlsl"
 
 #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
 #include "../../Material/Material.hlsl" // This includes Material.hlsl
 RWStructuredBuffer<uint> g_TileFeatureFlags;
 
 TEXTURE2D(_StencilTexture);               // DXGI_FORMAT_R8_UINT is not supported by Unity
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 
 [numthreads(NR_THREADS, 1, 1)]
 void MATERIALFLAGSGEN(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
 		int idx = i * NR_THREADS + threadID;
 		uint2 uCrd = min( uint2(viTilLL.x + (idx & 0xf), viTilLL.y + (idx >> 4)), uint2(iWidth - 1, iHeight - 1));
 
-		if (UnpackByte(LOAD_TEXTURE2D(_StencilTexture, uCrd).r) != STENCILLIGHTINGUSAGE_NO_LIGHTING) // This test is we are the sky/background or not
+        // StencilTexture here contain the result of testing if we are not equal to stencil usage NoLighting. i.e (stencil value != NoLighting). The 1.0 mean true.
+        // This test if we are the sky/background or a forward opaque (which tag the stencil as NoLighting)
+		if (LOAD_TEXTURE2D(_StencilTexture, uCrd).r == 1.0)
-			FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-			materialFeatureFlags |= MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(gbuffer);
+            materialFeatureFlags |= MATERIAL_FEATURE_FLAGS_FROM_GBUFFER(posInput.positionSS);
 		}
 	}
 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/lightlistbuild.compute

 
 //#pragma #pragma enable_d3d11_debug_symbols
 
-#include "../../../Core/ShaderLibrary/common.hlsl"
+#include "ShaderLibrary/common.hlsl"
-#include "TilePass.cs.hlsl"
+#include "LightLoop.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)

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

 #pragma kernel TileLightListGen_DepthRT_MSAA_SrcBigTile		LIGHTLISTGEN=TileLightListGen_DepthRT_MSAA_SrcBigTile		ENABLE_DEPTH_TEXTURE_BACKPLANE		MSAA_ENABLED		USE_TWO_PASS_TILED_LIGHTING
 #pragma kernel ClearAtomic
 
-#include "../../../Core/ShaderLibrary/common.hlsl"
+#include "ShaderLibrary/common.hlsl"
-#include "TilePass.cs.hlsl"
+#include "LightLoop.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 		SFiniteLightBound lgtDat = g_data[coarseList[l]];
 
 		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius, g_isOrthographic!=0) )
-			coarseList[l]=0xffffffff;
+			coarseList[l]=UINT_MAX;
 	}
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 		int offs = 0;
 		for(int l=0; l<iNrCoarseLights; l++)
 		{
-			if(coarseList[l]!=0xffffffff)
+			if(coarseList[l]!=UINT_MAX)
 				coarseList[offs++] = coarseList[l];
 		}
 		lightOffsSph = offs;

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

 #pragma kernel BigTileLightListGen
 
-#include "../../../Core/ShaderLibrary/common.hlsl"
-#include "TilePass.cs.hlsl"
+#include "ShaderLibrary/common.hlsl"
+#include "LightLoop.cs.hlsl"
 #include "LightingConvexHullUtils.hlsl"
 #include "SortingComputeUtils.hlsl"
 
 		SFiniteLightBound lgtDat = g_data[lightsListLDS[l]];
 
 		if( !DoesSphereOverlapTile(V, halfTileSizeAtZDistOne, lgtDat.center.xyz, lgtDat.radius, g_isOrthographic!=0) )
-			lightsListLDS[l]=0xffffffff;
+			lightsListLDS[l]=UINT_MAX;
 	}
 
 #if !defined(SHADER_API_XBOXONE) && !defined(SHADER_API_PSSL)
 				int resf = (positive>0 && negative>0) ? 0 : (positive>0 ? 1 : (negative>0 ? (-1) : 0));
 
 				bool bFoundSepPlane = (resh*resf)<0;
-				if(bFoundSepPlane) lightsListLDS[l]=0xffffffff;
+				if(bFoundSepPlane) lightsListLDS[l]=UINT_MAX;
 			}
 		}
 	}

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/builddispatchindirect.compute

 #pragma kernel BuildDispatchIndirect
 
-
-#include "TilePass.cs.hlsl"
+#include "ShaderLibrary/Common.hlsl"
+#include "LightLoop.cs.hlsl"
 
 #define UNITY_MATERIAL_LIT // Need to be define before including Material.hlsl
 #include "../../Material/Material.hlsl" // This includes Material.hlsl

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/SortingComputeUtils.hlsl

 // have to make this sort routine a macro unfortunately because hlsl doesn't take
 // groupshared memory of unspecified length as an input parameter to a function.
 // maxcapacity_in must be a power of two.
-// all data from length_in and up to closest power of two will be filled with 0xffffffff
+// all data from length_in and up to closest power of two will be filled with UINT_MAX
-    for(int t=length+localThreadID; t<N; t+=nrthreads) { data[t]=0xffffffff; }              \
+    for(int t=length+localThreadID; t<N; t+=nrthreads) { data[t]=UINT_MAX; }              \
     GroupMemoryBarrierWithGroupSync();                                                      \
                                                                                             \
     for(int k=2; k<=N; k=2*k)                                                               \

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

 fileFormatVersion: 2
 guid: b0e81431fe3a7604fb9f9dd2a96bd7e0
-timeCreated: 1491321445
-licenseType: Pro
+  externalObjects: {}
+  nonModifiableTextures: []
   userData: 
   assetBundleName: 
   assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/ShadowContext.hlsl

-
-// This can be custom for each project and needs to be in sync with the ShadowMgr
+#ifndef LIGHTLOOP_SHADOW_CONTEXT_HLSL
+#define LIGHTLOOP_SHADOW_CONTEXT_HLSL
-
-#undef  SHADOW_OPTIMIZE_REGISTER_USAGE
-SHADOWCONTEXT_DECLARE( SHADOWCONTEXT_MAX_TEX2DARRAY, SHADOWCONTEXT_MAX_TEXCUBEARRAY, SHADOWCONTEXT_MAX_COMPSAMPLER, SHADOWCONTEXT_MAX_SAMPLER );
+#include "ShaderLibrary/Shadow/Shadow.hlsl"
 
 TEXTURE2D_ARRAY(_ShadowmapExp_VSM_0);
 SAMPLER2D(sampler_ShadowmapExp_VSM_0);
 	return sc;
 }
 
+#endif // LIGHTLOOP_SHADOW_CONTEXT_HLSL

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/LightingConvexHullUtils.hlsl

 #ifndef __LIGHTINGCONVEXHULLUTILS_H__
 #define __LIGHTINGCONVEXHULLUTILS_H__
 
-#include "TilePass.cs.hlsl"
+#include "LightLoop.cs.hlsl"
 
 float3 GetHullVertex(const float3 boxX, const float3 boxY, const float3 boxZ, const float3 center, const float2 scaleXY, const int p)
 {

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/Deferred.compute

-#pragma kernel Deferred_Direct_Fptl                                 SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl                                USE_FPTL_LIGHTLIST
-#pragma kernel Deferred_Direct_Fptl_DebugDisplay                    SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl_DebugDisplay                   USE_FPTL_LIGHTLIST          DEBUG_DISPLAY
-#pragma kernel Deferred_Direct_ShadowMask_Fptl                     SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl                    USE_FPTL_LIGHTLIST          SHADOWS_SHADOWMASK
-#pragma kernel Deferred_Direct_ShadowMask_Fptl_DebugDisplay        SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl_DebugDisplay       USE_FPTL_LIGHTLIST          SHADOWS_SHADOWMASK  DEBUG_DISPLAY
-#pragma kernel Deferred_Direct_Clustered                            SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered                           USE_CLUSTERED_LIGHTLIST
-#pragma kernel Deferred_Direct_Clustered_DebugDisplay               SHADE_OPAQUE_ENTRY=Deferred_Direct_Clustered_DebugDisplay              USE_CLUSTERED_LIGHTLIST     DEBUG_DISPLAY
-#pragma kernel Deferred_Direct_ShadowMask_Clustered                SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Clustered               USE_CLUSTERED_LIGHTLIST     SHADOWS_SHADOWMASK
-#pragma kernel Deferred_Direct_ShadowMask_Clustered_DebugDisplay   SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Clustered_DebugDisplay  USE_CLUSTERED_LIGHTLIST     SHADOWS_SHADOWMASK  DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_Fptl                                SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl
+#pragma kernel Deferred_Direct_Fptl_DebugDisplay                   SHADE_OPAQUE_ENTRY=Deferred_Direct_Fptl_DebugDisplay             DEBUG_DISPLAY
+#pragma kernel Deferred_Direct_ShadowMask_Fptl                     SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl               SHADOWS_SHADOWMASK
+#pragma kernel Deferred_Direct_ShadowMask_Fptl_DebugDisplay        SHADE_OPAQUE_ENTRY=Deferred_Direct_ShadowMask_Fptl_DebugDisplay  SHADOWS_SHADOWMASK  DEBUG_DISPLAY
-#pragma kernel Deferred_Indirect_Fptl_Variant0      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant0      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=0
-#pragma kernel Deferred_Indirect_Fptl_Variant1      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant1      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=1
-#pragma kernel Deferred_Indirect_Fptl_Variant2      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant2      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=2
-#pragma kernel Deferred_Indirect_Fptl_Variant3      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant3      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=3
-#pragma kernel Deferred_Indirect_Fptl_Variant4      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant4      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=4
-#pragma kernel Deferred_Indirect_Fptl_Variant5      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant5      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=5
-#pragma kernel Deferred_Indirect_Fptl_Variant6      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant6      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=6
-#pragma kernel Deferred_Indirect_Fptl_Variant7      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant7      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=7
-#pragma kernel Deferred_Indirect_Fptl_Variant8      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant8      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=8
-#pragma kernel Deferred_Indirect_Fptl_Variant9      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant9      USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=9
-#pragma kernel Deferred_Indirect_Fptl_Variant10     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant10     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=10
-#pragma kernel Deferred_Indirect_Fptl_Variant11     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant11     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=11
-#pragma kernel Deferred_Indirect_Fptl_Variant12     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant12     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=12
-#pragma kernel Deferred_Indirect_Fptl_Variant13     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant13     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=13
-#pragma kernel Deferred_Indirect_Fptl_Variant14     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant14     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=14
-#pragma kernel Deferred_Indirect_Fptl_Variant15     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant15     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=15
-#pragma kernel Deferred_Indirect_Fptl_Variant16     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant16     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=16
-#pragma kernel Deferred_Indirect_Fptl_Variant17     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant17     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=17
-#pragma kernel Deferred_Indirect_Fptl_Variant18     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant18     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=18
-#pragma kernel Deferred_Indirect_Fptl_Variant19     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant19     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=19
-#pragma kernel Deferred_Indirect_Fptl_Variant20     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant20     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=20
-#pragma kernel Deferred_Indirect_Fptl_Variant21     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant21     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=21
-#pragma kernel Deferred_Indirect_Fptl_Variant22     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant22     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=22
-#pragma kernel Deferred_Indirect_Fptl_Variant23     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant23     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=23
-#pragma kernel Deferred_Indirect_Fptl_Variant24     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant24     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=24
-#pragma kernel Deferred_Indirect_Fptl_Variant25     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant25     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=25
-#pragma kernel Deferred_Indirect_Fptl_Variant26     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant26     USE_FPTL_LIGHTLIST      USE_INDIRECT    VARIANT=26
+#pragma kernel Deferred_Indirect_Fptl_Variant0      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant0      USE_INDIRECT    VARIANT=0
+#pragma kernel Deferred_Indirect_Fptl_Variant1      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant1      USE_INDIRECT    VARIANT=1
+#pragma kernel Deferred_Indirect_Fptl_Variant2      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant2      USE_INDIRECT    VARIANT=2
+#pragma kernel Deferred_Indirect_Fptl_Variant3      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant3      USE_INDIRECT    VARIANT=3
+#pragma kernel Deferred_Indirect_Fptl_Variant4      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant4      USE_INDIRECT    VARIANT=4
+#pragma kernel Deferred_Indirect_Fptl_Variant5      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant5      USE_INDIRECT    VARIANT=5
+#pragma kernel Deferred_Indirect_Fptl_Variant6      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant6      USE_INDIRECT    VARIANT=6
+#pragma kernel Deferred_Indirect_Fptl_Variant7      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant7      USE_INDIRECT    VARIANT=7
+#pragma kernel Deferred_Indirect_Fptl_Variant8      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant8      USE_INDIRECT    VARIANT=8
+#pragma kernel Deferred_Indirect_Fptl_Variant9      SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant9      USE_INDIRECT    VARIANT=9
+#pragma kernel Deferred_Indirect_Fptl_Variant10     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant10     USE_INDIRECT    VARIANT=10
+#pragma kernel Deferred_Indirect_Fptl_Variant11     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant11     USE_INDIRECT    VARIANT=11
+#pragma kernel Deferred_Indirect_Fptl_Variant12     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant12     USE_INDIRECT    VARIANT=12
+#pragma kernel Deferred_Indirect_Fptl_Variant13     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant13     USE_INDIRECT    VARIANT=13
+#pragma kernel Deferred_Indirect_Fptl_Variant14     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant14     USE_INDIRECT    VARIANT=14
+#pragma kernel Deferred_Indirect_Fptl_Variant15     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant15     USE_INDIRECT    VARIANT=15
+#pragma kernel Deferred_Indirect_Fptl_Variant16     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant16     USE_INDIRECT    VARIANT=16
+#pragma kernel Deferred_Indirect_Fptl_Variant17     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant17     USE_INDIRECT    VARIANT=17
+#pragma kernel Deferred_Indirect_Fptl_Variant18     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant18     USE_INDIRECT    VARIANT=18
+#pragma kernel Deferred_Indirect_Fptl_Variant19     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant19     USE_INDIRECT    VARIANT=19
+#pragma kernel Deferred_Indirect_Fptl_Variant20     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant20     USE_INDIRECT    VARIANT=20
+#pragma kernel Deferred_Indirect_Fptl_Variant21     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant21     USE_INDIRECT    VARIANT=21
+#pragma kernel Deferred_Indirect_Fptl_Variant22     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant22     USE_INDIRECT    VARIANT=22
+#pragma kernel Deferred_Indirect_Fptl_Variant23     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant23     USE_INDIRECT    VARIANT=23
+#pragma kernel Deferred_Indirect_Fptl_Variant24     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant24     USE_INDIRECT    VARIANT=24
+#pragma kernel Deferred_Indirect_Fptl_Variant25     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant25     USE_INDIRECT    VARIANT=25
+#pragma kernel Deferred_Indirect_Fptl_Variant26     SHADE_OPAQUE_ENTRY=Deferred_Indirect_Fptl_Variant26     USE_INDIRECT    VARIANT=26
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant0       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant0       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=0
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant1       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant1       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=1
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant2       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant2       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=2
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant3       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant3       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=3
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant4       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant4       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=4
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant5       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant5       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=5
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant6       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant6       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=6
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant7       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant7       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=7
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant8       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant8       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=8
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant9       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant9       USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=9
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant10      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant10      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=10
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant11      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant11      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=11
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant12      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant12      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=12
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant13      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant13      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=13
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant14      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant14      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=14
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant15      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant15      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=15
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant16      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant16      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=16
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant17      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant17      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=17
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant18      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant18      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=18
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant19      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant19      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=19
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant20      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant20      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=20
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant21      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant21      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=21
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant22      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant22      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=22
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant23      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant23      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=23
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant24      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant24      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=24
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant25      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant25      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=25
-#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant26      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant26      USE_FPTL_LIGHTLIST      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=26
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant0       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant0       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=0
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant1       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant1       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=1
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant2       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant2       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=2
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant3       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant3       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=3
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant4       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant4       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=4
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant5       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant5       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=5
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant6       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant6       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=6
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant7       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant7       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=7
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant8       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant8       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=8
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant9       SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant9       USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=9
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant10      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant10      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=10
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant11      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant11      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=11
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant12      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant12      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=12
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant13      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant13      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=13
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant14      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant14      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=14
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant15      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant15      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=15
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant16      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant16      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=16
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant17      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant17      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=17
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant18      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant18      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=18
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant19      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant19      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=19
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant20      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant20      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=20
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant21      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant21      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=21
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant22      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant22      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=22
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant23      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant23      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=23
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant24      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant24      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=24
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant25      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant25      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=25
+#pragma kernel Deferred_Indirect_ShadowMask_Fptl_Variant26      SHADE_OPAQUE_ENTRY=Deferred_Indirect_ShadowMask_Fptl_Variant26      USE_INDIRECT    SHADOWS_SHADOWMASK  VARIANT=26
-/* Tag: SUPPORT_COMPUTE_CLUSTER_OPAQUE - Uncomment this if you want to do cluster opaque with compute shader (by default we support only fptl on opaque)
-#pragma kernel Deferred_Indirect_Clustered_Variant0          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant0              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=0
-#pragma kernel Deferred_Indirect_Clustered_Variant1          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant1              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=1
-#pragma kernel Deferred_Indirect_Clustered_Variant2          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant2              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=2
-#pragma kernel Deferred_Indirect_Clustered_Variant3          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant3              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=3
-#pragma kernel Deferred_Indirect_Clustered_Variant4          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant4              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=4
-#pragma kernel Deferred_Indirect_Clustered_Variant5          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant5              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=5
-#pragma kernel Deferred_Indirect_Clustered_Variant6          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant6              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=6
-#pragma kernel Deferred_Indirect_Clustered_Variant7          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant7              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=7
-#pragma kernel Deferred_Indirect_Clustered_Variant8          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant8              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=8
-#pragma kernel Deferred_Indirect_Clustered_Variant9          SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant9              USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=9
-#pragma kernel Deferred_Indirect_Clustered_Variant10         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant10             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=10
-#pragma kernel Deferred_Indirect_Clustered_Variant11         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant11             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=11
-#pragma kernel Deferred_Indirect_Clustered_Variant12         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant12             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=12
-#pragma kernel Deferred_Indirect_Clustered_Variant13         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant13             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=13
-#pragma kernel Deferred_Indirect_Clustered_Variant14         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant14             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=14
-#pragma kernel Deferred_Indirect_Clustered_Variant15         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant15             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=15
-#pragma kernel Deferred_Indirect_Clustered_Variant16         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant16             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=16
-#pragma kernel Deferred_Indirect_Clustered_Variant17         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant17             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=17
-#pragma kernel Deferred_Indirect_Clustered_Variant18         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant18             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=18
-#pragma kernel Deferred_Indirect_Clustered_Variant19         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant19             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=19
-#pragma kernel Deferred_Indirect_Clustered_Variant20         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant20             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=20
-#pragma kernel Deferred_Indirect_Clustered_Variant21         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant21             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=21
-#pragma kernel Deferred_Indirect_Clustered_Variant22         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant22             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=22
-#pragma kernel Deferred_Indirect_Clustered_Variant23         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant23             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=23
-#pragma kernel Deferred_Indirect_Clustered_Variant24         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant24             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=24
-#pragma kernel Deferred_Indirect_Clustered_Variant25         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant25             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=25
-#pragma kernel Deferred_Indirect_Clustered_Variant26         SHADE_OPAQUE_ENTRY=Deferred_Indirect_Clustered_Variant26             USE_CLUSTERED_LIGHTLIST     USE_INDIRECT    VARIANT=26
-*/
+// deferred opaque always use FPTL
+#define USE_FPTL_LIGHTLIST 1
 
 //#pragma enable_d3d11_debug_symbols
 
 
-#include "../../../Core/ShaderLibrary/Common.hlsl"
+#include "ShaderLibrary/Common.hlsl"
 #include "../../Debug/DebugDisplay.hlsl"
 
 // Note: We have fix as guidelines that we have only one deferred material (with control of GBuffer enabled). Mean a users that add a new
 // variable declaration
 //-------------------------------------------------------------------------------------
 
-DECLARE_GBUFFER_TEXTURE(_GBufferTexture);
 #ifdef SHADOWS_SHADOWMASK
 TEXTURE2D(_ShadowMaskTexture);
 #endif
 
     PositionInputs posInput = GetPositionInput(pixelCoord.xy, _ScreenSize.zw, tileCoord);
 
-    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.unPositionSS).x;
+    float depth = LOAD_TEXTURE2D(_MainDepthTexture, posInput.positionSS).x;
 
     // For indirect case: we can still overlap inside a tile with the sky/background, reject it
     // Can't rely on stencil as we are in compute shader
         return;
     }
 
-    UpdatePositionInput(depth, _InvViewProjMatrix, _ViewProjMatrix, posInput);
+    UpdatePositionInput(depth, UNITY_MATRIX_I_VP, UNITY_MATRIX_VP, posInput);
-    FETCH_GBUFFER(gbuffer, _GBufferTexture, posInput.unPositionSS);
-    DECODE_FROM_GBUFFER(gbuffer, featureFlags, bsdfData, bakeLightingData.bakeDiffuseLighting);
+    DECODE_FROM_GBUFFER(posInput.positionSS, featureFlags, bsdfData, bakeLightingData.bakeDiffuseLighting);
-    DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.unPositionSS), bakeLightingData.bakeShadowMask);
+    DecodeShadowMask(LOAD_TEXTURE2D(_ShadowMaskTexture, posInput.positionSS), bakeLightingData.bakeShadowMask);
     #endif
 
     PreLightData preLightData = GetPreLightData(V, posInput, bsdfData);

ScriptableRenderPipeline/HDRenderPipeline/Lighting/LightLoop/ClusteredUtils.hlsl

 float SuggestLogBase50(float tileFarPlane)
 {
     const float C = (float)(1 << g_iLog2NumClusters);
-    float rangeFittedDistance = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPSILON, 1.0);
+    float rangeFittedDistance = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPS, 1.0);
     float suggested_base = pow((1.0 + sqrt(max(0.0, 1.0 - 4.0 * rangeFittedDistance * (1.0 - rangeFittedDistance)))) / (2.0 * rangeFittedDistance), 2.0 / C);      //
     return max(g_fClustBase, suggested_base);
 }
 {
     const float C = (float)(1 << g_iLog2NumClusters);
-    float rangeFittedDistance = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPSILON, 1.0);
+    float rangeFittedDistance = clamp((tileFarPlane - g_fNearPlane) / (g_fFarPlane - g_fNearPlane), FLT_EPS, 1.0);
     float suggested_base = pow((1 / 2.3) * max(0.0, (0.8 / rangeFittedDistance) - 1), 4.0 / (C * 2));     // approximate inverse of d*x^4 + (-x) + (1-d) = 0       - d is normalized distance
     return max(g_fClustBase, suggested_base);
 }