Merge branch 'master' into HDRP-Tests

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/BSDF.hlsl

     return I;
 }
 
+//-----------------------------------------------------------------------------
+// Cloth
+//-----------------------------------------------------------------------------
+
+// Ref: https://knarkowicz.wordpress.com/2018/01/04/cloth-shading/
+real D_CharlieNoPI(real NdotH, real roughness)
+{
+    float invR = rcp(roughness);
+    float cos2h = NdotH * NdotH;
+    float sin2h = 1.0 - cos2h;
+    // Note: We have sin^2 so multiply by 0.5 to cancel it
+    return (2.0 + invR) * PositivePow(sin2h, invR * 0.5) / 2.0;
+}
+
+real D_Charlie(real NdotH, real roughness)
+{
+    return INV_PI * D_CharlieNoPI(NdotH, roughness);
+}
+
+real CharlieL(real x, real r)
+{
+    r = saturate(r);
+    r = (1. - r * r);
+
+    float a = lerp(25.3245, 21.5473, r);
+    float b = lerp(3.32435, 3.82987, r);
+    float c = lerp(0.16801, 0.19823, r);
+    float d = lerp(-1.27393, -1.97760, r);
+    float e = lerp(-4.85967, -4.32054, r);
+
+    return a / (1. + b * PositivePow(x, c)) + d * x + e;
+}
+
+// Note: This version don't include the softening of the paper: Production Friendly Microfacet Sheen BRDF
+real V_Charlie(real NdotL, real NdotV, real roughness)
+{
+    real lambdaV = NdotV < 0.5 ? exp(CharlieL(NdotV, roughness)) : exp(2.0 * CharlieL(0.5, roughness) - CharlieL(1.0 - NdotV, roughness));
+    real lambdaL = NdotL < 0.5 ? exp(CharlieL(NdotL, roughness)) : exp(2.0 * CharlieL(0.5, roughness) - CharlieL(1.0 - NdotL, roughness));
+
+    return 1.0 / ((1.0 + lambdaV + lambdaL) * (4.0 * NdotV * NdotL));
+}
+
+// We use V_Ashikhmin instead of V_Charlie in practice for game due to the cost of V_Charlie
+real V_Ashikhmin(real NdotL, real NdotV)
+{
+    // Use soft visibility term introduce in: Crafting a Next-Gen Material Pipeline for The Order : 1886
+    return 1.0 / (4.0 * (NdotL + NdotV - NdotL * NdotV));
+}
+
+// A diffuse term use with cloth done by tech artist - empirical
+real ClothLambertNoPI(real roughness)
+{
+    return lerp(1.0, 0.5, roughness);
+}
+
+real ClothLambert(real roughness)
+{
+    return INV_PI * ClothLambertNoPI(roughness);
+}
+
+
 #endif // UNITY_BSDF_INCLUDED

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/CommonLighting.hlsl

     return max(NdotV, 0.0001);
 }
 
+// return usual BSDF angle
+void GetBSDFAngle(float3 V, float3 L, float NdotL, float unclampNdotV, out float LdotV, out float NdotH, out float LdotH, out float clampNdotV, out float invLenLV)
+{
+    // Optimized math. Ref: PBR Diffuse Lighting for GGX + Smith Microsurfaces (slide 114).
+    LdotV = dot(L, V);
+    invLenLV = rsqrt(max(2.0 * LdotV + 2.0, FLT_EPS));    // invLenLV = rcp(length(L + V)), clamp to avoid rsqrt(0) = NaN
+    NdotH = saturate((NdotL + unclampNdotV) * invLenLV);        // Do not clamp NdotV here
+    LdotH = saturate(invLenLV * LdotV + invLenLV);
+    clampNdotV = ClampNdotV(unclampNdotV);
+}
+
 // Inputs:    normalized normal and view vectors.
 // Outputs:   front-facing normal, and the new non-negative value of the cosine of the view angle.
 // Important: call Orthonormalize() on the tangent and recompute the bitangent afterwards.

com.unity.render-pipelines.core/CoreRP/ShaderLibrary/ImageBasedLighting.hlsl

 
 #if !defined SHADER_API_GLES
 // Ref: Listing 18 in "Moving Frostbite to PBR" + https://knarkowicz.wordpress.com/2014/12/27/analytical-dfg-term-for-ibl/
-real4 IntegrateGGXAndDisneyFGD(real3 V, real3 N, real roughness, uint sampleCount = 8192)
+real4 IntegrateGGXAndDisneyDiffuseFGD(real3 V, real3 N, real roughness, uint sampleCount = 8192)
 {
     real NdotV     = ClampNdotV(dot(N, V));
     real4 acc      = real4(0.0, 0.0, 0.0, 0.0);
 }
 #else
 // Not supported due to lack of random library in GLES 2
-#define IntegrateGGXAndDisneyFGD ERROR_ON_UNSUPPORTED_FUNCTION(IntegrateGGXAndDisneyFGD)
+#define IntegrateGGXAndDisneyDiffuseFGD ERROR_ON_UNSUPPORTED_FUNCTION(IntegrateGGXAndDisneyDiffuseFGD)
+#endif
+
+#if !defined SHADER_API_GLES
+real4 IntegrateCharlieAndClothLambertFGD(real3 V, real3 N, real roughness, uint sampleCount = 8192)
+{
+    real NdotV     = ClampNdotV(dot(N, V));
+    real4 acc      = real4(0.0, 0.0, 0.0, 0.0);
+    // Add some jittering on Hammersley2d
+    real2 randNum  = InitRandom(V.xy * 0.5 + 0.5);
+
+    real3x3 localToWorld = GetLocalFrame(N);
+
+    for (uint i = 0; i < sampleCount; ++i)
+    {
+        real2 u = frac(randNum + Hammersley2d(i, sampleCount));
+
+        real NdotL;
+        real weightOverPdf;
+
+        // Ref: Production Friendly Microfacet Sheen BRDF
+        // Paper recommend plain uniform sampling of upper hemisphere instead of importance sampling for Charlie
+        real3 localL = SampleHemisphereUniform(u.x, u.y);
+        real3 L = mul(localL, localToWorld);
+        NdotL = saturate(dot(N, L));
+
+        if (NdotL > 0.0)
+        {
+            // Sampling weight for each sample
+            // pdf = 1 / 2PI
+            // weight = fr * (N.L) with fr = CharlieV * CharlieD  / PI
+            // weight over pdf is:
+            // weightOverPdf = (CharlieV * CharlieD / PI) * (N.L) / (1 / 2PI)
+            // weightOverPdf = 2 * CharlieV * CharlieD * (N.L)
+            real3 H = normalize(V + L);
+            real NdotH = dot(N, H);
+            // Note: we use V_Charlie and not the approx when computing FGD texture as we can afford it
+            weightOverPdf = 2.0 * V_Charlie(NdotL, NdotV, roughness) * D_CharlieNoPI(NdotH, roughness) * NdotL;
+
+            // Integral{BSDF * <N,L> dw} =
+            // Integral{(F0 + (1 - F0) * (1 - <V,H>)^5) * (BSDF / F) * <N,L> dw} =
+            // (1 - F0) * Integral{(1 - <V,H>)^5 * (BSDF / F) * <N,L> dw} + F0 * Integral{(BSDF / F) * <N,L> dw}=
+            // (1 - F0) * x + F0 * y = lerp(x, y, F0)
+            real VdotH = dot(V, H);
+            acc.x += weightOverPdf * pow(1 - VdotH, 5);
+            acc.y += weightOverPdf;
+        }
+
+        // for cloth Lambert we still use a Cosine importance sampling
+        ImportanceSampleLambert(u, localToWorld, L, NdotL, weightOverPdf);
+
+        if (NdotL > 0.0)
+        {
+            real clothLambert = ClothLambertNoPI(roughness);
+            acc.z += clothLambert * weightOverPdf;
+        }
+    }
+
+    acc /= sampleCount;
+
+    return acc;
+}
+#else
+// Not supported due to lack of random library in GLES 2
+#define IntegrateCharlieAndClothLambertFGD ERROR_ON_UNSUPPORTED_FUNCTION(IntegrateCharlieAndClothLambertFGD)
 #endif
 
 uint GetIBLRuntimeFilterSampleCount(uint mipLevel)

com.unity.render-pipelines.high-definition/CHANGELOG.md

-
+All notable changes to this package will be documented in this file.
-## [2018.3]
+The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
+and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
-### Improvements
+## [Unreleased]
-### Changed, Removals and deprecations
+## [2.0.4-preview]
+- Fix issue when disabling rough refraction and building a player. Was causing a crash.
-## [2018.2 / next ]
+## [2.0.3-preview]
+
+### Improvements
+- Increased debug color picker limit up to 260k lux
+
+## [2.0.2-preview]
+
+### Improvements
 - Add Light -> Planar Reflection Probe command
 - Added a false color mode in rendering debug
 - Add support for mesh decals
 - Provide a define in lit.hlsl (FORWARD_MATERIAL_READ_FROM_WRITTEN_NORMAL_BUFFER) when output buffer normal is used to read the normal and roughness instead of caclulating it (can save performance, but lower quality due to compression)
 - Add color swatch to decal material
 
-### Improvements
-
 ### Changed, Removals and deprecations
 - Change Render -> Planar Reflection creation to 3D Object -> Mirror
 - Change "Enable Reflector" name on SpotLight to "Angle Affect Intensity"
 - Fix issue with StackLit in deferred mode with deferredDirectionalShadow due to GBuffer not being cleared. Gbuffer is still not clear and issue was fix with the new Output of normal buffer.
+- Fixed an issue where interpolation volumes were not updated correctly for reflection captures.
+- Fixed an exception in Light Loop settings UI
-## [2018.2 / 2.0.1-preview]
+## [2.0.1-preview]
 
 ### Improvements
 - Add stripper of shader variant when building a player. Save shader compile time.

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugColorPicker.shader

             SAMPLER(sampler_DebugColorPickerTexture);
 
             float4 _ColorPickerParam; // 4 increasing threshold
-            int _ColorPickerMode;
             float3 _ColorPickerFontColor;
             float _ApplyLinearToSRGB;
             float _RequireToFlipInputTexture;
 
                 float4 result = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, input.texcoord);
 
-                float4 mousePixelCoord = _MousePixelCoord;
-                if (_RequireToFlipInputTexture > 0.0)
-                {
-                    mousePixelCoord.y = _ScreenSize.y - mousePixelCoord.y;
-                    // Note: We must not flip the mousePixelCoord.w coordinate
-                }
-
-                float4 mouseResult = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, mousePixelCoord.zw);
-                // Reverse debug exposure in order to display the real values.
-                // _DebugExposure will be set to zero if the debug view does not need it so we don't need to make a special case here. It's handled in only one place in C#
-                mouseResult = mouseResult / exp2(_DebugExposure);
+                //Decompress value if luxMeter is active
+                if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER && _ColorPickerMode != COLORPICKERDEBUGMODE_NONE)
+                    result.rgb = result.rgb * LUXMETER_COMPRESSION_RATIO;
-                
-                float4 finalResult = result;
-                    finalResult = DisplayPixelInformationAtMousePosition(input, result, mouseResult, mousePixelCoord);
+                {
+                    float4 mousePixelCoord = _MousePixelCoord;
+                    if (_RequireToFlipInputTexture > 0.0)
+                    {
+                        mousePixelCoord.y = _ScreenSize.y - mousePixelCoord.y;
+                        // Note: We must not flip the mousePixelCoord.w coordinate
+                    }
+
+                    float4 mouseResult = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, mousePixelCoord.zw);
+                    
+                    //Decompress value if luxMeter is active
+                    if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
+                        mouseResult = mouseResult * LUXMETER_COMPRESSION_RATIO;
+
+                    // Reverse debug exposure in order to display the real values.
+                    // _DebugExposure will be set to zero if the debug view does not need it so we don't need to make a special case here. It's handled in only one place in C#
+                    mouseResult = mouseResult / exp2(_DebugExposure);
+
+                    result = DisplayPixelInformationAtMousePosition(input, result, mouseResult, mousePixelCoord);
+                }
-                return finalResult;
+                return result;
             }
 
             ENDHLSL

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugDisplay.cs

             return mipMapDebugSettings.debugMipMapMode;
         }
 
+        public ColorPickerDebugMode GetDebugColorPickerMode()
+        {
+            return colorPickerDebugSettings.colorPickerMode;
+        }
+
         public bool IsDebugDisplayEnabled()
         {
             return materialDebugSettings.IsDebugDisplayEnabled() || lightingDebugSettings.IsDebugDisplayEnabled() || mipMapDebugSettings.IsDebugDisplayEnabled() || IsDebugFullScreenEnabled();

com.unity.render-pipelines.high-definition/HDRP/Debug/DebugDisplay.hlsl

 int _DebugLightingSubMode;
 int _DebugViewMaterial; // Contain the id (define in various materialXXX.cs.hlsl) of the property to display
 int _DebugMipMapMode; // Match enum DebugMipMapMode
+int _ColorPickerMode; // Match enum ColorPickerDebugMode
 int _DebugStep;
 float4 _DebugLightingAlbedo; // x == bool override, yzw = albedo for diffuse
 float4 _DebugLightingSmoothness; // x == bool override, y == override value
 float4 _MouseClickPixelCoord;  // xy unorm, zw norm
 float _DebugExposure;
 CBUFFER_END
+
+// When displaying lux meter we compress the light in order to be able to display value higher than 65504
+// The sun is between 100 000 and 150 000, so we use 4 to be able to cover such a range (4 * 65504)
+#define LUXMETER_COMPRESSION_RATIO  4
 
 TEXTURE2D(_DebugFont); // Debug font to write string in shader
 RWStructuredBuffer<ScreenSpaceTracingDebug> _DebugScreenSpaceTracingData : register(u7); // TODO: Change the register number for PS4

com.unity.render-pipelines.high-definition/HDRP/Editor/RenderPipeline/HDAssetFactory.cs

                 newAsset.skyboxCubemap = Shader.Find("Skybox/Cubemap");
 
                 // Material
-                newAsset.preIntegratedFGD = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD/PreIntegratedFGD.shader");
+                newAsset.preIntegratedFGD_GGXDisneyDiffuse = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD/PreIntegratedFGD_GGXDisneyDiffuse.shader");
+                newAsset.preIntegratedFGD_CharlieClothLambert = Load<Shader>(HDRenderPipelinePath + "Material/PreIntegratedFGD/PreIntegratedFGD_CharlieClothLambert.shader");
 
                 // Utilities / Core
                 newAsset.encodeBC6HCS = Load<ComputeShader>(CorePath + "CoreResources/EncodeBC6H.compute");

com.unity.render-pipelines.high-definition/HDRP/Editor/RenderPipeline/Settings/LightLoopSettingsUI.cs

                     EditorGUILayout.PropertyField(p.enableComputeMaterialVariants, _.GetContent("Enable Compute Material Variants"));
                     EditorGUI.indentLevel--;
                 }
-                EditorGUILayout.EndFadeGroup();
-            EditorGUILayout.EndFadeGroup();
             GUILayout.EndVertical();
 
             //EditorGUI.indentLevel--;

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRPass.template

     //-------------------------------------------------------------------------------------
     // Render Modes (Blend, Cull, ZTest, Stencil, etc)
     //-------------------------------------------------------------------------------------
-${Blending}
-${Culling}
-${ZTest}
-${ZWrite}
-${Stencil}
-${ColorMask}
+        ${Blending}
+        ${Culling}
+        ${ZTest}
+        ${ZWrite}
+        ${Stencil}
+        ${ColorMask}
     //-------------------------------------------------------------------------------------
     // End Render Modes
     //-------------------------------------------------------------------------------------
         $BlendMode.Alpha:                #define _BLENDMODE_ALPHA 1
         $BlendMode.Add:                  #define _BLENDMODE_ADD 1
     //-------------------------------------------------------------------------------------
-    // End Variant
+    // End Variant Definitions
     //-------------------------------------------------------------------------------------
 
     #pragma vertex Vert
             $VertexDescriptionInputs.WorldSpaceNormal:          output.WorldSpaceNormal =            TransformObjectToWorldNormal(input.normalOS);
             $VertexDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             TransformWorldToViewDir(output.WorldSpaceNormal);
             $VertexDescriptionInputs.TangentSpaceNormal:        output.TangentSpaceNormal =          float3(0.0f, 0.0f, 1.0f);
-
-
-
-
-
             $VertexDescriptionInputs.ScreenPosition:            output.ScreenPosition =              ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x);
             $VertexDescriptionInputs.uv0:                       output.uv0 =                         float4(input.uv0, 0.0f, 0.0f);
             $VertexDescriptionInputs.uv1:                       output.uv1 =                         float4(input.uv1, 0.0f, 0.0f);
             $SurfaceDescriptionInputs.ObjectSpaceNormal:         output.ObjectSpaceNormal =           mul(output.WorldSpaceNormal, (float3x3) unity_ObjectToWorld);      // transposed multiplication by inverse matrix to handle normal scale
             $SurfaceDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V);         // transposed multiplication by inverse matrix to handle normal scale
             $SurfaceDescriptionInputs.TangentSpaceNormal:        output.TangentSpaceNormal =          float3(0.0f, 0.0f, 1.0f);
-
-
-
-
-            // TODO: FragInputs.positionWS is badly named -- it's camera relative, not in world space
-            // we have to fix it up here to match graph input expectations
+            $SurfaceDescriptionInputs.WorldSpacePosition:        // TODO: FragInputs.positionWS is badly named -- it's camera relative, not in world space
+            $SurfaceDescriptionInputs.WorldSpacePosition:        // we have to fix it up here to match graph input expectations
-
-            // TODO: positionSS is SV_Position, graph input expects screenPosition to be 0..1 across the active viewport (?)
-            $SurfaceDescriptionInputs.ScreenPosition:            output.ScreenPosition =             ComputeScreenPos(TransformWorldToHClip(input.positionWS), _ProjectionParams.x);
-
-            $SurfaceDescriptionInputs.uv0:                       output.uv0 =    float4(input.texCoord0, 0.0f, 0.0f);
-            $SurfaceDescriptionInputs.uv1:                       output.uv1 =    float4(input.texCoord1, 0.0f, 0.0f);
-            $SurfaceDescriptionInputs.uv2:                       output.uv2 =    float4(input.texCoord2, 0.0f, 0.0f);
-            $SurfaceDescriptionInputs.uv3:                       output.uv3 =    float4(input.texCoord3, 0.0f, 0.0f);
-
-            $SurfaceDescriptionInputs.VertexColor:               output.VertexColor =    input.color;
+            $SurfaceDescriptionInputs.ScreenPosition:            output.ScreenPosition =              ComputeScreenPos(TransformWorldToHClip(input.positionWS), _ProjectionParams.x);
+            $SurfaceDescriptionInputs.uv0:                       output.uv0 =                         float4(input.texCoord0, 0.0f, 0.0f);
+            $SurfaceDescriptionInputs.uv1:                       output.uv1 =                         float4(input.texCoord1, 0.0f, 0.0f);
+            $SurfaceDescriptionInputs.uv2:                       output.uv2 =                         float4(input.texCoord2, 0.0f, 0.0f);
+            $SurfaceDescriptionInputs.uv3:                       output.uv3 =                         float4(input.texCoord3, 0.0f, 0.0f);
+            
+            $SurfaceDescriptionInputs.VertexColor:               output.VertexColor =                 input.color;
 
             $SurfaceDescriptionInputs.FaceSign:                  output.FaceSign =    input.isFrontFace;
 
 
         // It is safe to call this function here as surfaceData have been filled
         // We want to know if we must enable transmission on GI for SSS material, if the material have no SSS, this code will be remove by the compiler.
-        BSDFData bsdfData = ConvertSurfaceDataToBSDFData(surfaceData);
+        BSDFData bsdfData = ConvertSurfaceDataToBSDFData(posInput.positionSS.xy, surfaceData);
         if (HasFeatureFlag(bsdfData.materialFeatures, MATERIALFEATUREFLAGS_LIT_TRANSMISSION))
         {
             // For now simply recall the function with inverted normal, the compiler should be able to optimize the lightmap case to not resample the directional lightmap

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDPBRSubShader.cs

                 activeFields.Add("AlphaTest");
             }
 
-//             if (kTesselationMode != TessellationMode.None)
-//             {
-//                 defines.AddShaderChunk("#define _TESSELLATION_PHONG 1", true);
-//             }
-
-            // #pragma shader_feature _ _VERTEX_DISPLACEMENT _PIXEL_DISPLACEMENT
-//             switch (kDisplacementMode)
-//             {
-//                 case DisplacementMode.None:
-//                     break;
-//                 case DisplacementMode.Vertex:
-//                     defines.AddShaderChunk("#define _VERTEX_DISPLACEMENT 1", true);
-//                     break;
-//                 case DisplacementMode.Pixel:
-//                     defines.AddShaderChunk("#define _PIXEL_DISPLACEMENT 1", true);
-            // Depth offset is only enabled if per pixel displacement is
-//                     if (kDepthOffsetEnable)
-//                     {
-//                         // #pragma shader_feature _DEPTHOFFSET_ON
-//                         defines.AddShaderChunk("#define _DEPTHOFFSET_ON 1", true);
-//                     }
-//                     break;
-//                 case DisplacementMode.Tessellation:
-//                     if (kTessellationEnabled)
-//                     {
-//                         defines.AddShaderChunk("#define _TESSELLATION_DISPLACEMENT 1", true);
-//                     }
-//                     break;
-//             }
-
-            // #pragma shader_feature _VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE
-            // #pragma shader_feature _DISPLACEMENT_LOCK_TILING_SCALE
-            // #pragma shader_feature _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE
-            // #pragma shader_feature _VERTEX_WIND
-            // #pragma shader_feature _ _REFRACTION_PLANE _REFRACTION_SPHERE
-            //
-            // #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR          // MOVE to a node
-            // #pragma shader_feature _NORMALMAP_TANGENT_SPACE
-            // #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3
-
-            // #pragma shader_feature _MASKMAP
-            // #pragma shader_feature _BENTNORMALMAP
-            // #pragma shader_feature _EMISSIVE_COLOR_MAP
-            // #pragma shader_feature _ENABLESPECULAROCCLUSION
-            // #pragma shader_feature _HEIGHTMAP
-            // #pragma shader_feature _TANGENTMAP
-            // #pragma shader_feature _ANISOTROPYMAP
-            // #pragma shader_feature _SUBSURFACE_RADIUS_MAP
-            // #pragma shader_feature _THICKNESSMAP
-            // #pragma shader_feature _SPECULARCOLORMAP
-            // #pragma shader_feature _TRANSMITTANCECOLORMAP
-
             // Keywords for transparent
             // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT
             if (masterNode.surfaceType != SurfaceType.Opaque)
 //                {
 //                    defines.AddShaderChunk("#define _BLENDMODE_PRE_MULTIPLY 1", true);
 //                }
-
-                // #pragma shader_feature _BLENDMODE_PRESERVE_SPECULAR_LIGHTING
-//                 if (kEnableBlendModePreserveSpecularLighting)
-//                 {
-//                     defines.AddShaderChunk("#define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1", true);
-//                 }
-
-                // #pragma shader_feature _ENABLE_FOG_ON_TRANSPARENT
-//                 if (kEnableFogOnTransparent)
-//                 {
-//                     defines.AddShaderChunk("#define _ENABLE_FOG_ON_TRANSPARENT 1", true);
-//                 }
             }
             else
             {
 
         private static bool GenerateShaderPassLit(AbstractMaterialNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions, ShaderGenerator result, List<string> sourceAssetDependencyPaths)
         {
-            var templateLocation = Path.Combine(Path.Combine(Path.Combine(HDEditorUtils.GetHDRenderPipelinePath(), "Editor"), "ShaderGraph"), pass.TemplateName);
-            if (!File.Exists(templateLocation))
-            {
-                // TODO: produce error here
-                return false;
-            }
-
-            if (sourceAssetDependencyPaths != null)
-                sourceAssetDependencyPaths.Add(templateLocation);
-
-            // grab all of the active nodes (for pixel and vertex graphs)
-            var vertexNodes = ListPool<INode>.Get();
-            NodeUtils.DepthFirstCollectNodesFromNode(vertexNodes, masterNode, NodeUtils.IncludeSelf.Include, pass.VertexShaderSlots);
-
-            var pixelNodes = ListPool<INode>.Get();
-            NodeUtils.DepthFirstCollectNodesFromNode(pixelNodes, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
-
-            // graph requirements describe what the graph itself requires
-            var pixelRequirements = ShaderGraphRequirements.FromNodes(pixelNodes, ShaderStageCapability.Fragment, false);   // TODO: is ShaderStageCapability.Fragment correct?
-            var vertexRequirements = ShaderGraphRequirements.FromNodes(vertexNodes, ShaderStageCapability.Vertex, false);
-
-            // Function Registry tracks functions to remove duplicates, it wraps a string builder that stores the combined function string
-            ShaderStringBuilder graphNodeFunctions = new ShaderStringBuilder();
-            graphNodeFunctions.IncreaseIndent();
-            var functionRegistry = new FunctionRegistry(graphNodeFunctions);
-
-            // TODO: this can be a shared function for all HDRP master nodes -- From here through GraphUtil.GenerateSurfaceDescription(..)
-
-            // Build the list of active slots based on what the pass requires
-            var pixelSlots = HDSubShaderUtilities.FindMaterialSlotsOnNode(pass.PixelShaderSlots, masterNode);
-            var vertexSlots = HDSubShaderUtilities.FindMaterialSlotsOnNode(pass.VertexShaderSlots, masterNode);
-
-            // properties used by either pixel and vertex shader
-            PropertyCollector sharedProperties = new PropertyCollector();
-
-            // build the graph outputs structure to hold the results of each active slots (and fill out activeFields to indicate they are active)
-            string pixelGraphInputStructName = "SurfaceDescriptionInputs";
-            string pixelGraphOutputStructName = "SurfaceDescription";
-            string pixelGraphEvalFunctionName = "SurfaceDescriptionFunction";
-            ShaderStringBuilder pixelGraphEvalFunction = new ShaderStringBuilder();
-            ShaderStringBuilder pixelGraphOutputs = new ShaderStringBuilder();
-
-            // dependency tracker -- set of active fields
+            // apply master node options to active fields
-            // build initial requirements
-            HDRPShaderStructs.AddActiveFieldsFromPixelGraphRequirements(activeFields, pixelRequirements);
-
-            // build the graph outputs structure, and populate activeFields with the fields of that structure
-            GraphUtil.GenerateSurfaceDescriptionStruct(pixelGraphOutputs, pixelSlots, true, pixelGraphOutputStructName, activeFields);
-
-            // Build the graph evaluation code, to evaluate the specified slots
-            GraphUtil.GenerateSurfaceDescriptionFunction(
-                pixelNodes,
-                masterNode,
-                masterNode.owner as AbstractMaterialGraph,
-                pixelGraphEvalFunction,
-                functionRegistry,
-                sharedProperties,
-                pixelRequirements,  // TODO : REMOVE UNUSED
-                mode,
-                pixelGraphEvalFunctionName,
-                pixelGraphOutputStructName,
-                null,
-                pixelSlots,
-                pixelGraphInputStructName);
-
-            string vertexGraphInputStructName = "VertexDescriptionInputs";
-            string vertexGraphOutputStructName = "VertexDescription";
-            string vertexGraphEvalFunctionName = "VertexDescriptionFunction";
-            ShaderStringBuilder vertexGraphEvalFunction = new ShaderStringBuilder();
-            ShaderStringBuilder vertexGraphOutputs = new ShaderStringBuilder();
-
-            // check for vertex animation -- enables HAVE_VERTEX_MODIFICATION
-            bool vertexActive = false;
-            if (masterNode.IsSlotConnected(PBRMasterNode.PositionSlotId))
-            {
-                vertexActive = true;
-                activeFields.Add("features.modifyMesh");
-                HDRPShaderStructs.AddActiveFieldsFromVertexGraphRequirements(activeFields, vertexRequirements);
-
-                // -------------------------------------
-                // Generate Output structure for Vertex Description function
-                GraphUtil.GenerateVertexDescriptionStruct(vertexGraphOutputs, vertexSlots, vertexGraphOutputStructName, activeFields);
-
-                // -------------------------------------
-                // Generate Vertex Description function
-                GraphUtil.GenerateVertexDescriptionFunction(
-                    masterNode.owner as AbstractMaterialGraph,
-                    vertexGraphEvalFunction,
-                    functionRegistry,
-                    sharedProperties,
-                    mode,
-                    vertexNodes,
-                    vertexSlots,
-                    vertexGraphInputStructName,
-                    vertexGraphEvalFunctionName,
-                    vertexGraphOutputStructName);
-            }
-
-            var blendCode = new ShaderStringBuilder();
-            var cullCode = new ShaderStringBuilder();
-            var zTestCode = new ShaderStringBuilder();
-            var zWriteCode = new ShaderStringBuilder();
-            var stencilCode = new ShaderStringBuilder();
-            var colorMaskCode = new ShaderStringBuilder();
-            HDSubShaderUtilities.BuildRenderStatesFromPassAndMaterialOptions(pass, materialOptions, blendCode, cullCode, zTestCode, zWriteCode, stencilCode, colorMaskCode);
-
-            HDRPShaderStructs.AddRequiredFields(pass.RequiredFields, activeFields);
-
-            // apply dependencies to the active fields, and build interpolators (TODO: split this function)
-            var packedInterpolatorCode = new ShaderGenerator();
-            HDRPShaderStructs.Generate(
-                packedInterpolatorCode,
-                activeFields);
-
-            // debug output all active fields
-            var interpolatorDefines = new ShaderGenerator();
-            {
-                interpolatorDefines.AddShaderChunk("// ACTIVE FIELDS:");
-                foreach (string f in activeFields)
-                {
-                    interpolatorDefines.AddShaderChunk("//   " + f);
-                }
-            }
-
-            // build graph inputs structures
-            ShaderGenerator pixelGraphInputs = new ShaderGenerator();
-            ShaderSpliceUtil.BuildType(typeof(HDRPShaderStructs.SurfaceDescriptionInputs), activeFields, pixelGraphInputs);
-            ShaderGenerator vertexGraphInputs = new ShaderGenerator();
-            ShaderSpliceUtil.BuildType(typeof(HDRPShaderStructs.VertexDescriptionInputs), activeFields, vertexGraphInputs);
-
-            ShaderGenerator defines = new ShaderGenerator();
-            {
-                defines.AddShaderChunk(string.Format("#define SHADERPASS {0}", pass.ShaderPassName), true);
-                if (pass.ExtraDefines != null)
-                {
-                    foreach (var define in pass.ExtraDefines)
-                        defines.AddShaderChunk(define);
-                }
-                defines.AddGenerator(interpolatorDefines);
-            }
-
-            var shaderPassIncludes = new ShaderGenerator();
-            if (pass.Includes != null)
-            {
-                foreach (var include in pass.Includes)
-                    shaderPassIncludes.AddShaderChunk(include);
-            }
-
-
-            // build graph code
-            var graph = new ShaderGenerator();
-            {
-                graph.AddShaderChunk("// Shared Graph Properties (uniform inputs)");
-                graph.AddShaderChunk(sharedProperties.GetPropertiesDeclaration(1));
-
-                if (vertexActive)
-                {
-                    graph.AddShaderChunk("// Vertex Graph Inputs");
-                    graph.Indent();
-                    graph.AddGenerator(vertexGraphInputs);
-                    graph.Deindent();
-                    graph.AddShaderChunk("// Vertex Graph Outputs");
-                    graph.Indent();
-                    graph.AddShaderChunk(vertexGraphOutputs.ToString());
-                    graph.Deindent();
-                }
-
-                graph.AddShaderChunk("// Pixel Graph Inputs");
-                graph.Indent();
-                graph.AddGenerator(pixelGraphInputs);
-                graph.Deindent();
-                graph.AddShaderChunk("// Pixel Graph Outputs");
-                graph.Indent();
-                graph.AddShaderChunk(pixelGraphOutputs.ToString());
-                graph.Deindent();
-
-                graph.AddShaderChunk("// Shared Graph Node Functions");
-                graph.AddShaderChunk(graphNodeFunctions.ToString());
-
-                if (vertexActive)
-                {
-                    graph.AddShaderChunk("// Vertex Graph Evaluation");
-                    graph.Indent();
-                    graph.AddShaderChunk(vertexGraphEvalFunction.ToString());
-                    graph.Deindent();
-                }
-
-                graph.AddShaderChunk("// Pixel Graph Evaluation");
-                graph.Indent();
-                graph.AddShaderChunk(pixelGraphEvalFunction.ToString());
-                graph.Deindent();
-            }
-
-            // build the hash table of all named fragments      TODO: could make this Dictionary<string, ShaderGenerator / string>  ?
-            Dictionary<string, string> namedFragments = new Dictionary<string, string>();
-            namedFragments.Add("${Defines}",                defines.GetShaderString(2, false));
-            namedFragments.Add("${Graph}",                  graph.GetShaderString(2, false));
-            namedFragments.Add("${LightMode}",              pass.LightMode);
-            namedFragments.Add("${PassName}",               pass.Name);
-            namedFragments.Add("${Includes}",               shaderPassIncludes.GetShaderString(2, false));
-            namedFragments.Add("${InterpolatorPacking}",    packedInterpolatorCode.GetShaderString(2, false));
-            namedFragments.Add("${Blending}",               blendCode.ToString());
-            namedFragments.Add("${Culling}",                cullCode.ToString());
-            namedFragments.Add("${ZTest}",                  zTestCode.ToString());
-            namedFragments.Add("${ZWrite}",                 zWriteCode.ToString());
-            namedFragments.Add("${Stencil}",                stencilCode.ToString());
-            namedFragments.Add("${ColorMask}",              colorMaskCode.ToString());
-            namedFragments.Add("${LOD}",                    materialOptions.lod.ToString());
-
-            // process the template to generate the shader code for this pass   TODO: could make this a shared function
-            string[] templateLines = File.ReadAllLines(templateLocation);
-            System.Text.StringBuilder builder = new System.Text.StringBuilder();
-            foreach (string line in templateLines)
-            {
-                ShaderSpliceUtil.PreprocessShaderCode(line, activeFields, namedFragments, builder);
-                builder.AppendLine();
-            }
-
-            result.AddShaderChunk(builder.ToString(), false);
-
-            return true;
+            // use standard shader pass generation
+            return HDSubShaderUtilities.GenerateShaderPass(masterNode, pass, mode, materialOptions, activeFields, result, sourceAssetDependencyPaths);
         }
 
         public string GetSubshader(IMasterNode iMasterNode, GenerationMode mode, List<string> sourceAssetDependencyPaths = null)

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDSubShaderUtilities.cs

         struct AttributesMesh
         {
             [Semantic("POSITION")]              Vector3 positionOS;
-            [Semantic("NORMAL")][Optional]     Vector3 normalOS;
-            [Semantic("TANGENT")][Optional]    Vector4 tangentOS;       // Stores bi-tangent sign in w
-            [Semantic("TEXCOORD0")][Optional]  Vector2 uv0;
-            [Semantic("TEXCOORD1")][Optional]  Vector2 uv1;
-            [Semantic("TEXCOORD2")][Optional]  Vector2 uv2;
-            [Semantic("TEXCOORD3")][Optional]  Vector2 uv3;
-            [Semantic("COLOR")][Optional]      Vector4 color;
+            [Semantic("NORMAL")][Optional]      Vector3 normalOS;
+            [Semantic("TANGENT")][Optional]     Vector4 tangentOS;       // Stores bi-tangent sign in w
+            [Semantic("TEXCOORD0")][Optional]   Vector2 uv0;
+            [Semantic("TEXCOORD1")][Optional]   Vector2 uv1;
+            [Semantic("TEXCOORD2")][Optional]   Vector2 uv2;
+            [Semantic("TEXCOORD3")][Optional]   Vector2 uv3;
+            [Semantic("COLOR")][Optional]       Vector4 color;
         };
 
         struct VaryingsMeshToPS
                 new Dependency("SurfaceDescriptionInputs.uv2",                       "FragInputs.texCoord2"),
                 new Dependency("SurfaceDescriptionInputs.uv3",                       "FragInputs.texCoord3"),
                 new Dependency("SurfaceDescriptionInputs.VertexColor",               "FragInputs.color"),
-                new Dependency("SurfaceDescriptionInputs.FaceSign",                 "FragInputs.isFrontFace"),
+                new Dependency("SurfaceDescriptionInputs.FaceSign",                  "FragInputs.isFrontFace"),
             };
         };
 
 
     public static class HDSubShaderUtilities
     {
+        public static bool GenerateShaderPass(AbstractMaterialNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions, HashSet<string> activeFields, ShaderGenerator result, List<string> sourceAssetDependencyPaths)
+        {
+            var templateLocation = Path.Combine(Path.Combine(Path.Combine(HDEditorUtils.GetHDRenderPipelinePath(), "Editor"), "ShaderGraph"), pass.TemplateName);
+            if (!File.Exists(templateLocation))
+            {
+                // TODO: produce error here
+                return false;
+            }
+
+            bool debugOutput = false;
+
+            if (sourceAssetDependencyPaths != null)
+                sourceAssetDependencyPaths.Add(templateLocation);
+
+            // grab all of the active nodes (for pixel and vertex graphs)
+            var vertexNodes = ListPool<INode>.Get();
+            NodeUtils.DepthFirstCollectNodesFromNode(vertexNodes, masterNode, NodeUtils.IncludeSelf.Include, pass.VertexShaderSlots);
+
+            var pixelNodes = ListPool<INode>.Get();
+            NodeUtils.DepthFirstCollectNodesFromNode(pixelNodes, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
+
+            // graph requirements describe what the graph itself requires
+            var pixelRequirements = ShaderGraphRequirements.FromNodes(pixelNodes, ShaderStageCapability.Fragment, false);   // TODO: is ShaderStageCapability.Fragment correct?
+            var vertexRequirements = ShaderGraphRequirements.FromNodes(vertexNodes, ShaderStageCapability.Vertex, false);
+
+            // Function Registry tracks functions to remove duplicates, it wraps a string builder that stores the combined function string
+            ShaderStringBuilder graphNodeFunctions = new ShaderStringBuilder();
+            graphNodeFunctions.IncreaseIndent();
+            var functionRegistry = new FunctionRegistry(graphNodeFunctions);
+
+            // TODO: this can be a shared function for all HDRP master nodes -- From here through GraphUtil.GenerateSurfaceDescription(..)
+
+            // Build the list of active slots based on what the pass requires
+            var pixelSlots = HDSubShaderUtilities.FindMaterialSlotsOnNode(pass.PixelShaderSlots, masterNode);
+            var vertexSlots = HDSubShaderUtilities.FindMaterialSlotsOnNode(pass.VertexShaderSlots, masterNode);
+
+            // properties used by either pixel and vertex shader
+            PropertyCollector sharedProperties = new PropertyCollector();
+
+            // build the graph outputs structure to hold the results of each active slots (and fill out activeFields to indicate they are active)
+            string pixelGraphInputStructName = "SurfaceDescriptionInputs";
+            string pixelGraphOutputStructName = "SurfaceDescription";
+            string pixelGraphEvalFunctionName = "SurfaceDescriptionFunction";
+            ShaderStringBuilder pixelGraphEvalFunction = new ShaderStringBuilder();
+            ShaderStringBuilder pixelGraphOutputs = new ShaderStringBuilder();
+
+            // build initial requirements
+            HDRPShaderStructs.AddActiveFieldsFromPixelGraphRequirements(activeFields, pixelRequirements);
+
+            // build the graph outputs structure, and populate activeFields with the fields of that structure
+            GraphUtil.GenerateSurfaceDescriptionStruct(pixelGraphOutputs, pixelSlots, true, pixelGraphOutputStructName, activeFields);
+
+            // Build the graph evaluation code, to evaluate the specified slots
+            GraphUtil.GenerateSurfaceDescriptionFunction(
+                pixelNodes,
+                masterNode,
+                masterNode.owner as AbstractMaterialGraph,
+                pixelGraphEvalFunction,
+                functionRegistry,
+                sharedProperties,
+                pixelRequirements,  // TODO : REMOVE UNUSED
+                mode,
+                pixelGraphEvalFunctionName,
+                pixelGraphOutputStructName,
+                null,
+                pixelSlots,
+                pixelGraphInputStructName);
+
+            string vertexGraphInputStructName = "VertexDescriptionInputs";
+            string vertexGraphOutputStructName = "VertexDescription";
+            string vertexGraphEvalFunctionName = "VertexDescriptionFunction";
+            ShaderStringBuilder vertexGraphEvalFunction = new ShaderStringBuilder();
+            ShaderStringBuilder vertexGraphOutputs = new ShaderStringBuilder();
+
+            // check for vertex animation -- enables HAVE_VERTEX_MODIFICATION
+            bool vertexActive = false;
+            if (masterNode.IsSlotConnected(PBRMasterNode.PositionSlotId))
+            {
+                vertexActive = true;
+                activeFields.Add("features.modifyMesh");
+                HDRPShaderStructs.AddActiveFieldsFromVertexGraphRequirements(activeFields, vertexRequirements);
+
+                // -------------------------------------
+                // Generate Output structure for Vertex Description function
+                GraphUtil.GenerateVertexDescriptionStruct(vertexGraphOutputs, vertexSlots, vertexGraphOutputStructName, activeFields);
+
+                // -------------------------------------
+                // Generate Vertex Description function
+                GraphUtil.GenerateVertexDescriptionFunction(
+                    masterNode.owner as AbstractMaterialGraph,
+                    vertexGraphEvalFunction,
+                    functionRegistry,
+                    sharedProperties,
+                    mode,
+                    vertexNodes,
+                    vertexSlots,
+                    vertexGraphInputStructName,
+                    vertexGraphEvalFunctionName,
+                    vertexGraphOutputStructName);
+            }
+
+            var blendCode = new ShaderStringBuilder();
+            var cullCode = new ShaderStringBuilder();
+            var zTestCode = new ShaderStringBuilder();
+            var zWriteCode = new ShaderStringBuilder();
+            var stencilCode = new ShaderStringBuilder();
+            var colorMaskCode = new ShaderStringBuilder();
+            HDSubShaderUtilities.BuildRenderStatesFromPassAndMaterialOptions(pass, materialOptions, blendCode, cullCode, zTestCode, zWriteCode, stencilCode, colorMaskCode);
+
+            HDRPShaderStructs.AddRequiredFields(pass.RequiredFields, activeFields);
+
+            // apply dependencies to the active fields, and build interpolators (TODO: split this function)
+            var packedInterpolatorCode = new ShaderGenerator();
+            HDRPShaderStructs.Generate(
+                packedInterpolatorCode,
+                activeFields);
+
+            // debug output all active fields
+            var interpolatorDefines = new ShaderGenerator();
+            if (debugOutput)
+            {
+                interpolatorDefines.AddShaderChunk("// ACTIVE FIELDS:");
+                foreach (string f in activeFields)
+                {
+                    interpolatorDefines.AddShaderChunk("//   " + f);
+                }
+            }
+
+            // build graph inputs structures
+            ShaderGenerator pixelGraphInputs = new ShaderGenerator();
+            ShaderSpliceUtil.BuildType(typeof(HDRPShaderStructs.SurfaceDescriptionInputs), activeFields, pixelGraphInputs);
+            ShaderGenerator vertexGraphInputs = new ShaderGenerator();
+            ShaderSpliceUtil.BuildType(typeof(HDRPShaderStructs.VertexDescriptionInputs), activeFields, vertexGraphInputs);
+
+            ShaderGenerator defines = new ShaderGenerator();
+            {
+                defines.AddShaderChunk(string.Format("#define SHADERPASS {0}", pass.ShaderPassName), true);
+                if (pass.ExtraDefines != null)
+                {
+                    foreach (var define in pass.ExtraDefines)
+                        defines.AddShaderChunk(define);
+                }
+                defines.AddGenerator(interpolatorDefines);
+            }
+
+            var shaderPassIncludes = new ShaderGenerator();
+            if (pass.Includes != null)
+            {
+                foreach (var include in pass.Includes)
+                    shaderPassIncludes.AddShaderChunk(include);
+            }
+
+
+            // build graph code
+            var graph = new ShaderGenerator();
+            {
+                graph.AddShaderChunk("// Shared Graph Properties (uniform inputs)");
+                graph.AddShaderChunk(sharedProperties.GetPropertiesDeclaration(1));
+
+                if (vertexActive)
+                {
+                    graph.AddShaderChunk("// Vertex Graph Inputs");
+                    graph.Indent();
+                    graph.AddGenerator(vertexGraphInputs);
+                    graph.Deindent();
+                    graph.AddShaderChunk("// Vertex Graph Outputs");
+                    graph.Indent();
+                    graph.AddShaderChunk(vertexGraphOutputs.ToString());
+                    graph.Deindent();
+                }
+
+                graph.AddShaderChunk("// Pixel Graph Inputs");
+                graph.Indent();
+                graph.AddGenerator(pixelGraphInputs);
+                graph.Deindent();
+                graph.AddShaderChunk("// Pixel Graph Outputs");
+                graph.Indent();
+                graph.AddShaderChunk(pixelGraphOutputs.ToString());
+                graph.Deindent();
+
+                graph.AddShaderChunk("// Shared Graph Node Functions");
+                graph.AddShaderChunk(graphNodeFunctions.ToString());
+
+                if (vertexActive)
+                {
+                    graph.AddShaderChunk("// Vertex Graph Evaluation");
+                    graph.Indent();
+                    graph.AddShaderChunk(vertexGraphEvalFunction.ToString());
+                    graph.Deindent();
+                }
+
+                graph.AddShaderChunk("// Pixel Graph Evaluation");
+                graph.Indent();
+                graph.AddShaderChunk(pixelGraphEvalFunction.ToString());
+                graph.Deindent();
+            }
+
+            // build the hash table of all named fragments      TODO: could make this Dictionary<string, ShaderGenerator / string>  ?
+            Dictionary<string, string> namedFragments = new Dictionary<string, string>();
+            namedFragments.Add("${Defines}", defines.GetShaderString(2, false));
+            namedFragments.Add("${Graph}", graph.GetShaderString(2, false));
+            namedFragments.Add("${LightMode}", pass.LightMode);
+            namedFragments.Add("${PassName}", pass.Name);
+            namedFragments.Add("${Includes}", shaderPassIncludes.GetShaderString(2, false));
+            namedFragments.Add("${InterpolatorPacking}", packedInterpolatorCode.GetShaderString(2, false));
+            namedFragments.Add("${Blending}", blendCode.ToString());
+            namedFragments.Add("${Culling}", cullCode.ToString());
+            namedFragments.Add("${ZTest}", zTestCode.ToString());
+            namedFragments.Add("${ZWrite}", zWriteCode.ToString());
+            namedFragments.Add("${Stencil}", stencilCode.ToString());
+            namedFragments.Add("${ColorMask}", colorMaskCode.ToString());
+            namedFragments.Add("${LOD}", materialOptions.lod.ToString());
+
+            // process the template to generate the shader code for this pass   TODO: could make this a shared function
+            string[] templateLines = File.ReadAllLines(templateLocation);
+            System.Text.StringBuilder builder = new System.Text.StringBuilder();
+            foreach (string line in templateLines)
+            {
+                ShaderSpliceUtil.PreprocessShaderCode(line, activeFields, namedFragments, builder, debugOutput);
+            }
+
+            result.AddShaderChunk(builder.ToString(), false);
+
+            return true;
+        }
+
         public static List<MaterialSlot> FindMaterialSlotsOnNode(IEnumerable<int> slots, AbstractMaterialNode node)
         {
             var activeSlots = new List<MaterialSlot>();

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitPassForward.template

     //-------------------------------------------------------------------------------------
     // Render Modes (Blend, Cull, ZTest, Stencil, etc)
     //-------------------------------------------------------------------------------------
-${Blending}
-${Culling}
-${ZTest}
-${ZWrite}
-${Stencil}
-${ColorMask}
+        ${Blending}
+        ${Culling}
+        ${ZTest}
+        ${ZWrite}
+        ${Stencil}
+        ${ColorMask}
     //-------------------------------------------------------------------------------------
     // End Render Modes
     //-------------------------------------------------------------------------------------
     //#pragma enable_d3d11_debug_symbols
 
     //-------------------------------------------------------------------------------------
-    // Variant Definitions
+    // Variant Definitions (active field translations to HDRP defines)
-${VariantDefines}
+        $AlphaTest:                      #define _ALPHATEST_ON 1
+        $Material.SubsurfaceScattering:  #define _MATERIAL_FEATURE_SUBSURFACE_SCATTERING 1
+        $Material.Transmission:          #define _MATERIAL_FEATURE_TRANSMISSION 1
+        $Material.Anisotropy:            #define _MATERIAL_FEATURE_ANISOTROPY 1
+        $Material.ClearCoat:             #define _MATERIAL_FEATURE_CLEAR_COAT 1
+        $Material.Iridescence:           #define _MATERIAL_FEATURE_IRIDESCENCE 1
+        $Material.SpecularColor:         #define _MATERIAL_FEATURE_SPECULAR_COLOR 1
+        $SurfaceType.Transparent:        #define _SURFACE_TYPE_TRANSPARENT 1
+        $BlendMode.Alpha:                #define _BLENDMODE_ALPHA 1
+        $BlendMode.Add:                  #define _BLENDMODE_ADD 1
-    // End Variant
+    // End Variant Definitions
     //-------------------------------------------------------------------------------------
 
     #pragma vertex Vert
             $VertexDescriptionInputs.WorldSpaceNormal:          output.WorldSpaceNormal =            TransformObjectToWorldNormal(input.normalOS);
             $VertexDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             TransformWorldToViewDir(output.WorldSpaceNormal);
             $VertexDescriptionInputs.TangentSpaceNormal:        output.TangentSpaceNormal =          float3(0.0f, 0.0f, 1.0f);
-
-
-
-
-
             $VertexDescriptionInputs.ScreenPosition:            output.ScreenPosition =              ComputeScreenPos(TransformWorldToHClip(output.WorldSpacePosition), _ProjectionParams.x);
             $VertexDescriptionInputs.uv0:                       output.uv0 =                         float4(input.uv0, 0.0f, 0.0f);
             $VertexDescriptionInputs.uv1:                       output.uv1 =                         float4(input.uv1, 0.0f, 0.0f);
             $SurfaceDescriptionInputs.ObjectSpaceNormal:         output.ObjectSpaceNormal =           mul(output.WorldSpaceNormal, (float3x3) unity_ObjectToWorld);      // transposed multiplication by inverse matrix to handle normal scale
             $SurfaceDescriptionInputs.ViewSpaceNormal:           output.ViewSpaceNormal =             mul(output.WorldSpaceNormal, (float3x3) UNITY_MATRIX_I_V);         // transposed multiplication by inverse matrix to handle normal scale
             $SurfaceDescriptionInputs.TangentSpaceNormal:        output.TangentSpaceNormal =          float3(0.0f, 0.0f, 1.0f);
-
-
-
-
-            // TODO: FragInputs.positionWS is badly named -- it's camera relative, not in world space
-            // we have to fix it up here to match graph input expectations
+            $SurfaceDescriptionInputs.WorldSpacePosition:        // TODO: FragInputs.positionWS is badly named -- it's camera relative, not in world space
+            $SurfaceDescriptionInputs.WorldSpacePosition:        // we have to fix it up here to match graph input expectations
-
-            // TODO: positionSS is SV_Position, graph input expects screenPosition to be 0..1 across the active viewport (?)
-            $SurfaceDescriptionInputs.ScreenPosition:            output.ScreenPosition =             ComputeScreenPos(TransformWorldToHClip(input.positionWS), _ProjectionParams.x);
-
-            $SurfaceDescriptionInputs.uv0:                       output.uv0 =    float4(input.texCoord0, 0.0f, 0.0f);
-            $SurfaceDescriptionInputs.uv1:                       output.uv1 =    float4(input.texCoord1, 0.0f, 0.0f);
-            $SurfaceDescriptionInputs.uv2:                       output.uv2 =    float4(input.texCoord2, 0.0f, 0.0f);
-            $SurfaceDescriptionInputs.uv3:                       output.uv3 =    float4(input.texCoord3, 0.0f, 0.0f);
-
-            $SurfaceDescriptionInputs.VertexColor:               output.VertexColor =    input.color;
+            $SurfaceDescriptionInputs.ScreenPosition:            output.ScreenPosition =              ComputeScreenPos(TransformWorldToHClip(input.positionWS), _ProjectionParams.x);
+            
+            $SurfaceDescriptionInputs.uv0:                       output.uv0 =                         float4(input.texCoord0, 0.0f, 0.0f);
+            $SurfaceDescriptionInputs.uv1:                       output.uv1 =                         float4(input.texCoord1, 0.0f, 0.0f);
+            $SurfaceDescriptionInputs.uv2:                       output.uv2 =                         float4(input.texCoord2, 0.0f, 0.0f);
+            $SurfaceDescriptionInputs.uv3:                       output.uv3 =                         float4(input.texCoord3, 0.0f, 0.0f);
+            
+            $SurfaceDescriptionInputs.VertexColor:               output.VertexColor =                 input.color;
 
             $SurfaceDescriptionInputs.FaceSign:                  output.FaceSign =    input.isFrontFace;
 

com.unity.render-pipelines.high-definition/HDRP/Editor/ShaderGraph/HDUnlitSubShader.cs

             UnlitMasterNode masterNode = iMasterNode as UnlitMasterNode;
             if (masterNode == null)
             {
-                return null;
+                return activeFields;
             }
 
             if (masterNode.twoSided.isOn)
                 activeFields.Add("AlphaTest");
             }
 
-//             if (kTesselationMode != TessellationMode.None)
-//             {
-//                 defines.AddShaderChunk("#define _TESSELLATION_PHONG 1", true);
-//             }
-
-            // #pragma shader_feature _ _VERTEX_DISPLACEMENT _PIXEL_DISPLACEMENT
-//             switch (kDisplacementMode)
-//             {
-//                 case DisplacementMode.None:
-//                     break;
-//                 case DisplacementMode.Vertex:
-//                     defines.AddShaderChunk("#define _VERTEX_DISPLACEMENT 1", true);
-//                     break;
-//                 case DisplacementMode.Pixel:
-//                     defines.AddShaderChunk("#define _PIXEL_DISPLACEMENT 1", true);
-            // Depth offset is only enabled if per pixel displacement is
-//                     if (kDepthOffsetEnable)
-//                     {
-//                         // #pragma shader_feature _DEPTHOFFSET_ON
-//                         defines.AddShaderChunk("#define _DEPTHOFFSET_ON 1", true);
-//                     }
-//                     break;
-//                 case DisplacementMode.Tessellation:
-//                     if (kTessellationEnabled)
-//                     {
-//                         defines.AddShaderChunk("#define _TESSELLATION_DISPLACEMENT 1", true);
-//                     }
-//                     break;
-//             }
-
-            // #pragma shader_feature _VERTEX_DISPLACEMENT_LOCK_OBJECT_SCALE
-            // #pragma shader_feature _DISPLACEMENT_LOCK_TILING_SCALE
-            // #pragma shader_feature _PIXEL_DISPLACEMENT_LOCK_OBJECT_SCALE
-            // #pragma shader_feature _VERTEX_WIND
-            // #pragma shader_feature _ _REFRACTION_PLANE _REFRACTION_SPHERE
-            //
-            // #pragma shader_feature _ _MAPPING_PLANAR _MAPPING_TRIPLANAR          // MOVE to a node
-            // #pragma shader_feature _NORMALMAP_TANGENT_SPACE
-            // #pragma shader_feature _ _REQUIRE_UV2 _REQUIRE_UV3
-
-            // #pragma shader_feature _MASKMAP
-            // #pragma shader_feature _BENTNORMALMAP
-            // #pragma shader_feature _EMISSIVE_COLOR_MAP
-            // #pragma shader_feature _ENABLESPECULAROCCLUSION
-            // #pragma shader_feature _HEIGHTMAP
-            // #pragma shader_feature _TANGENTMAP
-            // #pragma shader_feature _ANISOTROPYMAP
-            // #pragma shader_feature _SUBSURFACE_RADIUS_MAP
-            // #pragma shader_feature _THICKNESSMAP
-            // #pragma shader_feature _SPECULARCOLORMAP
-            // #pragma shader_feature _TRANSMITTANCECOLORMAP
-
             // Keywords for transparent
             // #pragma shader_feature _SURFACE_TYPE_TRANSPARENT
             if (masterNode.surfaceType != SurfaceType.Opaque)
 //                {
 //                    defines.AddShaderChunk("#define _BLENDMODE_PRE_MULTIPLY 1", true);
 //                }
-
-                // #pragma shader_feature _BLENDMODE_PRESERVE_SPECULAR_LIGHTING
-//                 if (kEnableBlendModePreserveSpecularLighting)
-//                 {
-//                     defines.AddShaderChunk("#define _BLENDMODE_PRESERVE_SPECULAR_LIGHTING 1", true);
-//                 }
-
-                // #pragma shader_feature _ENABLE_FOG_ON_TRANSPARENT
-//                 if (kEnableFogOnTransparent)
-//                 {
-//                     defines.AddShaderChunk("#define _ENABLE_FOG_ON_TRANSPARENT 1", true);
-//                 }
             }
             else
             {
 
         private static bool GenerateShaderPassUnlit(AbstractMaterialNode masterNode, Pass pass, GenerationMode mode, SurfaceMaterialOptions materialOptions, ShaderGenerator result, List<string> sourceAssetDependencyPaths)
         {
-            var templateLocation = Path.Combine(Path.Combine(Path.Combine(HDEditorUtils.GetHDRenderPipelinePath(), "Editor"), "ShaderGraph"), pass.TemplateName);
-            if (!File.Exists(templateLocation))
-            {
-                // TODO: produce error here
-                return false;
-            }
-
-            if (sourceAssetDependencyPaths != null)
-                sourceAssetDependencyPaths.Add(templateLocation);
-
-            // grab all of the active nodes (for pixel and vertex graphs)
-            var vertexNodes = ListPool<INode>.Get();
-            NodeUtils.DepthFirstCollectNodesFromNode(vertexNodes, masterNode, NodeUtils.IncludeSelf.Include, pass.VertexShaderSlots);
-
-            var pixelNodes = ListPool<INode>.Get();
-            NodeUtils.DepthFirstCollectNodesFromNode(pixelNodes, masterNode, NodeUtils.IncludeSelf.Include, pass.PixelShaderSlots);
-
-            // graph requirements describe what the graph itself requires
-            var pixelRequirements = ShaderGraphRequirements.FromNodes(pixelNodes, ShaderStageCapability.Fragment, false);   // TODO: is ShaderStageCapability.Fragment correct?
-            var vertexRequirements = ShaderGraphRequirements.FromNodes(vertexNodes, ShaderStageCapability.Vertex, false);
-
-            // Function Registry tracks functions to remove duplicates, it wraps a string builder that stores the combined function string
-            ShaderStringBuilder graphNodeFunctions = new ShaderStringBuilder();
-            graphNodeFunctions.IncreaseIndent();
-            var functionRegistry = new FunctionRegistry(graphNodeFunctions);
-
-            // TODO: this can be a shared function for all HDRP master nodes -- From here through GraphUtil.GenerateSurfaceDescription(..)
-
-            // Build the list of active slots based on what the pass requires
-            var pixelSlots = HDSubShaderUtilities.FindMaterialSlotsOnNode(pass.PixelShaderSlots, masterNode);
-            var vertexSlots = HDSubShaderUtilities.FindMaterialSlotsOnNode(pass.VertexShaderSlots, masterNode);
-
-            // properties used by either pixel and vertex shader
-            PropertyCollector sharedProperties = new PropertyCollector();
-
-            // build the graph outputs structure to hold the results of each active slots (and fill out activeFields to indicate they are active)
-            string pixelGraphInputStructName = "SurfaceDescriptionInputs";
-            string pixelGraphOutputStructName = "SurfaceDescription";
-            string pixelGraphEvalFunctionName = "SurfaceDescriptionFunction";
-            ShaderStringBuilder pixelGraphEvalFunction = new ShaderStringBuilder();
-            ShaderStringBuilder pixelGraphOutputs = new ShaderStringBuilder();
-
-            // dependency tracker -- set of active fields
+            // apply master node options to active fields
-            // build initial requirements
-            HDRPShaderStructs.AddActiveFieldsFromPixelGraphRequirements(activeFields, pixelRequirements);
-
-            // build the graph outputs structure, and populate activeFields with the fields of that structure
-            GraphUtil.GenerateSurfaceDescriptionStruct(pixelGraphOutputs, pixelSlots, true, pixelGraphOutputStructName, activeFields);
-
-            // Build the graph evaluation code, to evaluate the specified slots
-            GraphUtil.GenerateSurfaceDescriptionFunction(
-                pixelNodes,
-                masterNode,
-                masterNode.owner as AbstractMaterialGraph,
-                pixelGraphEvalFunction,
-                functionRegistry,
-                sharedProperties,
-                pixelRequirements,  // TODO : REMOVE UNUSED
-                mode,
-                pixelGraphEvalFunctionName,
-                pixelGraphOutputStructName,
-                null,
-                pixelSlots,
-                pixelGraphInputStructName);
-
-            string vertexGraphInputStructName = "VertexDescriptionInputs";
-            string vertexGraphOutputStructName = "VertexDescription";
-            string vertexGraphEvalFunctionName = "VertexDescriptionFunction";
-            ShaderStringBuilder vertexGraphEvalFunction = new ShaderStringBuilder();
-            ShaderStringBuilder vertexGraphOutputs = new ShaderStringBuilder();
-
-            // check for vertex animation -- enables HAVE_VERTEX_MODIFICATION
-            bool vertexActive = false;
-            if (masterNode.IsSlotConnected(PBRMasterNode.PositionSlotId))
-            {
-                vertexActive = true;
-                activeFields.Add("features.modifyMesh");
-                HDRPShaderStructs.AddActiveFieldsFromVertexGraphRequirements(activeFields, vertexRequirements);
-
-                // -------------------------------------
-                // Generate Output structure for Vertex Description function
-                GraphUtil.GenerateVertexDescriptionStruct(vertexGraphOutputs, vertexSlots, vertexGraphOutputStructName, activeFields);
-
-                // -------------------------------------
-                // Generate Vertex Description function
-                GraphUtil.GenerateVertexDescriptionFunction(
-                    masterNode.owner as AbstractMaterialGraph,
-                    vertexGraphEvalFunction,
-                    functionRegistry,
-                    sharedProperties,
-                    mode,
-                    vertexNodes,
-                    vertexSlots,
-                    vertexGraphInputStructName,
-                    vertexGraphEvalFunctionName,
-                    vertexGraphOutputStructName);
-            }
-
-            var blendCode = new ShaderStringBuilder();
-            var cullCode = new ShaderStringBuilder();
-            var zTestCode = new ShaderStringBuilder();
-            var zWriteCode = new ShaderStringBuilder();
-            var stencilCode = new ShaderStringBuilder();
-            var colorMaskCode = new ShaderStringBuilder();
-            HDSubShaderUtilities.BuildRenderStatesFromPassAndMaterialOptions(pass, materialOptions, blendCode, cullCode, zTestCode, zWriteCode, stencilCode, colorMaskCode);
-
-            HDRPShaderStructs.AddRequiredFields(pass.RequiredFields, activeFields);
-
-            // apply dependencies to the active fields, and build interpolators (TODO: split this function)
-            var packedInterpolatorCode = new ShaderGenerator();
-            HDRPShaderStructs.Generate(
-                packedInterpolatorCode,
-                activeFields);
-
-            // debug output all active fields
-            var interpolatorDefines = new ShaderGenerator();
-            {
-                interpolatorDefines.AddShaderChunk("// ACTIVE FIELDS:");
-                foreach (string f in activeFields)
-                {
-                    interpolatorDefines.AddShaderChunk("//   " + f);
-                }
-            }
-
-            // build graph inputs structures
-            ShaderGenerator pixelGraphInputs = new ShaderGenerator();
-            ShaderSpliceUtil.BuildType(typeof(HDRPShaderStructs.SurfaceDescriptionInputs), activeFields, pixelGraphInputs);
-            ShaderGenerator vertexGraphInputs = new ShaderGenerator();
-            ShaderSpliceUtil.BuildType(typeof(HDRPShaderStructs.VertexDescriptionInputs), activeFields, vertexGraphInputs);
-
-            ShaderGenerator defines = new ShaderGenerator();
-            {
-                defines.AddShaderChunk(string.Format("#define SHADERPASS {0}", pass.ShaderPassName), true);
-                if (pass.ExtraDefines != null)
-                {
-                    foreach (var define in pass.ExtraDefines)
-                        defines.AddShaderChunk(define);
-                }
-                defines.AddGenerator(interpolatorDefines);
-            }
-
-            var shaderPassIncludes = new ShaderGenerator();
-            if (pass.Includes != null)
-            {
-                foreach (var include in pass.Includes)
-                    shaderPassIncludes.AddShaderChunk(include);
-            }
-
-
-            // build graph code
-            var graph = new ShaderGenerator();
-            {
-                graph.AddShaderChunk("// Shared Graph Properties (uniform inputs)");
-                graph.AddShaderChunk(sharedProperties.GetPropertiesDeclaration(1));
-
-                if (vertexActive)
-                {
-                    graph.AddShaderChunk("// Vertex Graph Inputs");
-                    graph.Indent();
-                    graph.AddGenerator(vertexGraphInputs);
-                    graph.Deindent();
-                    graph.AddShaderChunk("// Vertex Graph Outputs");
-                    graph.Indent();
-                    graph.AddShaderChunk(vertexGraphOutputs.ToString());
-                    graph.Deindent();
-                }
-
-                graph.AddShaderChunk("// Pixel Graph Inputs");
-                graph.Indent();
-                graph.AddGenerator(pixelGraphInputs);
-                graph.Deindent();
-                graph.AddShaderChunk("// Pixel Graph Outputs");
-                graph.Indent();
-                graph.AddShaderChunk(pixelGraphOutputs.ToString());
-                graph.Deindent();
-
-                graph.AddShaderChunk("// Shared Graph Node Functions");
-                graph.AddShaderChunk(graphNodeFunctions.ToString());
-
-                if (vertexActive)
-                {
-                    graph.AddShaderChunk("// Vertex Graph Evaluation");
-                    graph.Indent();
-                    graph.AddShaderChunk(vertexGraphEvalFunction.ToString());
-                    graph.Deindent();
-                }
-
-                graph.AddShaderChunk("// Pixel Graph Evaluation");
-                graph.Indent();
-                graph.AddShaderChunk(pixelGraphEvalFunction.ToString());
-                graph.Deindent();
-            }
-
-            // build the hash table of all named fragments      TODO: could make this Dictionary<string, ShaderGenerator / string>  ?
-            Dictionary<string, string> namedFragments = new Dictionary<string, string>();
-            namedFragments.Add("${Defines}",                defines.GetShaderString(2, false));
-            namedFragments.Add("${Graph}",                  graph.GetShaderString(2, false));
-            namedFragments.Add("${LightMode}",              pass.LightMode);
-            namedFragments.Add("${PassName}",               pass.Name);
-            namedFragments.Add("${Includes}",               shaderPassIncludes.GetShaderString(2, false));
-            namedFragments.Add("${InterpolatorPacking}",    packedInterpolatorCode.GetShaderString(2, false));
-            namedFragments.Add("${Blending}",               blendCode.ToString());
-            namedFragments.Add("${Culling}",                cullCode.ToString());
-            namedFragments.Add("${ZTest}",                  zTestCode.ToString());
-            namedFragments.Add("${ZWrite}",                 zWriteCode.ToString());
-            namedFragments.Add("${Stencil}",                stencilCode.ToString());
-            namedFragments.Add("${ColorMask}",              colorMaskCode.ToString());
-            namedFragments.Add("${LOD}",                    materialOptions.lod.ToString());
-
-            // process the template to generate the shader code for this pass   TODO: could make this a shared function
-            string[] templateLines = File.ReadAllLines(templateLocation);
-            System.Text.StringBuilder builder = new System.Text.StringBuilder();
-            foreach (string line in templateLines)
-            {
-                ShaderSpliceUtil.PreprocessShaderCode(line, activeFields, namedFragments, builder);
-                builder.AppendLine();
-            }
-
-            result.AddShaderChunk(builder.ToString(), false);
-
-            return true;
+            // use standard shader pass generation
+            return HDSubShaderUtilities.GenerateShaderPass(masterNode, pass, mode, materialOptions, activeFields, result, sourceAssetDependencyPaths);
-        public string GetSubshader(IMasterNode inMasterNode, GenerationMode mode, List<string> sourceAssetDependencyPaths = null)
+        public string GetSubshader(IMasterNode iMasterNode, GenerationMode mode, List<string> sourceAssetDependencyPaths = null)
         {
             if (sourceAssetDependencyPaths != null)
             {
                 sourceAssetDependencyPaths.Add(AssetDatabase.GUIDToAssetPath("713ced4e6eef4a44799a4dd59041484b"));
             }
 
-            var masterNode = inMasterNode as UnlitMasterNode;
+            var masterNode = iMasterNode as UnlitMasterNode;
             var subShader = new ShaderGenerator();
             subShader.AddShaderChunk("SubShader", true);
             subShader.AddShaderChunk("{", true);

com.unity.render-pipelines.high-definition/HDRP/Lighting/LightEvaluation.hlsl

     weight = Smoothstep01(weight);
     weight *= lightData.weight;
 }
-
-// Ambient occlusion
-struct AmbientOcclusionFactor
-{
-    float3 indirectAmbientOcclusion;
-    float3 directAmbientOcclusion;
-    float3 indirectSpecularOcclusion;
-};
-
-void GetScreenSpaceAmbientOcclusion(float2 positionSS, float NdotV, float perceptualRoughness, float ambientOcclusionFromData, float specularOcclusionFromData, out AmbientOcclusionFactor aoFactor)
-{
-    // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
-    // We use this property to have a neutral value for AO that doesn't consume a sampler and work also with compute shader (i.e use ImageLoad)
-    // We store inverse AO so neutral is black. So either we sample inside or outside the texture it return 0 in case of neutral
-
-    // Ambient occlusion use for indirect lighting (reflection probe, baked diffuse lighting)
-#ifndef _SURFACE_TYPE_TRANSPARENT
-    float indirectAmbientOcclusion = 1.0 - LOAD_TEXTURE2D(_AmbientOcclusionTexture, positionSS).x;
-    // Ambient occlusion use for direct lighting (directional, punctual, area)
-    float directAmbientOcclusion = lerp(1.0, indirectAmbientOcclusion, _AmbientOcclusionParam.w);
-#else
-    float indirectAmbientOcclusion = 1.0;
-    float directAmbientOcclusion = 1.0;
-#endif
-
-    float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
-    float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(NdotV), indirectAmbientOcclusion, roughness);
-
-    aoFactor.indirectSpecularOcclusion  = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), min(specularOcclusionFromData, specularOcclusion));
-    aoFactor.indirectAmbientOcclusion   = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), min(ambientOcclusionFromData, indirectAmbientOcclusion));
-    aoFactor.directAmbientOcclusion     = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), directAmbientOcclusion);
-}
-
-void GetScreenSpaceAmbientOcclusionMultibounce(float2 positionSS, float NdotV, float perceptualRoughness, float ambientOcclusionFromData, float specularOcclusionFromData, float3 diffuseColor, float3 fresnel0, out AmbientOcclusionFactor aoFactor)
-{
-    // Use GTAOMultiBounce approximation for ambient occlusion (allow to get a tint from the diffuseColor)
-    // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
-    // We use this property to have a neutral value for AO that doesn't consume a sampler and work also with compute shader (i.e use ImageLoad)
-    // We store inverse AO so neutral is black. So either we sample inside or outside the texture it return 0 in case of neutral
-
-    // Ambient occlusion use for indirect lighting (reflection probe, baked diffuse lighting)
-#ifndef _SURFACE_TYPE_TRANSPARENT
-    float indirectAmbientOcclusion = 1.0 - LOAD_TEXTURE2D(_AmbientOcclusionTexture, positionSS).x;
-    // Ambient occlusion use for direct lighting (directional, punctual, area)
-    float directAmbientOcclusion = lerp(1.0, indirectAmbientOcclusion, _AmbientOcclusionParam.w);
-#else
-    float indirectAmbientOcclusion = 1.0;
-    float directAmbientOcclusion = 1.0;
-#endif
-
-    float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
-    float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(NdotV), indirectAmbientOcclusion, roughness);
-
-    aoFactor.indirectSpecularOcclusion  = GTAOMultiBounce(min(specularOcclusionFromData, specularOcclusion), fresnel0);
-    aoFactor.indirectAmbientOcclusion   = GTAOMultiBounce(min(ambientOcclusionFromData, indirectAmbientOcclusion), diffuseColor);
-    aoFactor.directAmbientOcclusion     = GTAOMultiBounce(directAmbientOcclusion, diffuseColor);
-}

com.unity.render-pipelines.high-definition/HDRP/Material/Builtin/BuiltinData.cs

         // LightTransportData
         // This struct is use to store information for Enlighten/Progressive light mapper. both at runtime or off line.
         //-----------------------------------------------------------------------------
-        [GenerateHLSL(PackingRules.Exact, false, true, 120)]
+        [GenerateHLSL(PackingRules.Exact, false, true, 150)]
         public struct LightTransportData
         {
             [SurfaceDataAttributes("", false, true)]

com.unity.render-pipelines.high-definition/HDRP/Material/Builtin/BuiltinData.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Builtin+LightTransportData:  static fields
 //
-#define DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_DIFFUSE_COLOR (120)
-#define DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_EMISSIVE_COLOR (121)
+#define DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_DIFFUSE_COLOR (150)
+#define DEBUGVIEW_BUILTIN_LIGHTTRANSPORTDATA_EMISSIVE_COLOR (151)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.Builtin+BuiltinData
 // PackingRules = Exact

com.unity.render-pipelines.high-definition/HDRP/Material/Decal/Decal.cs

     public partial class Decal
     {
         // Main structure that store the user data (i.e user input of master node in material graph)
-        [GenerateHLSL(PackingRules.Exact, false, true, 10000)]
+        [GenerateHLSL(PackingRules.Exact, false, true, 200)]
         public struct DecalSurfaceData
         {
             [SurfaceDataAttributes("Base Color", false, true)]

com.unity.render-pipelines.high-definition/HDRP/Material/Decal/Decal.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Decal+DecalSurfaceData:  static fields
 //
-#define DEBUGVIEW_DECAL_DECALSURFACEDATA_BASE_COLOR (10000)
-#define DEBUGVIEW_DECAL_DECALSURFACEDATA_NORMAL (10001)
-#define DEBUGVIEW_DECAL_DECALSURFACEDATA_MASK (10002)
-#define DEBUGVIEW_DECAL_DECALSURFACEDATA_HTILE_MASK (10003)
+#define DEBUGVIEW_DECAL_DECALSURFACEDATA_BASE_COLOR (200)
+#define DEBUGVIEW_DECAL_DECALSURFACEDATA_NORMAL (201)
+#define DEBUGVIEW_DECAL_DECALSURFACEDATA_MASK (202)
+#define DEBUGVIEW_DECAL_DECALSURFACEDATA_HTILE_MASK (203)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Decal+DBufferMaterial:  static fields
     float4 diffuseScaleBias;
     float4 normalScaleBias;
     float4 maskScaleBias;
-	float4 baseColor;
+    float4 baseColor;
 };
 
 //
 float4 GetMaskScaleBias(DecalData value)
 {
     return value.maskScaleBias;
+}
+float4 GetBaseColor(DecalData value)
+{
+    return value.baseColor;
 }
 
 //

com.unity.render-pipelines.high-definition/HDRP/Material/Decal/ShaderPass/DecalSharePass.hlsl

 #endif
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.cs

         // BSDFData
         //-----------------------------------------------------------------------------
 
-        [GenerateHLSL(PackingRules.Exact, false, true, 1030)]
+        [GenerateHLSL(PackingRules.Exact, false, true, 1050)]
         public struct BSDFData
         {
             public uint materialFeatures;
 
         public override void Build(HDRenderPipelineAsset hdAsset)
         {
-            PreIntegratedFGD.instance.Build();
+            PreIntegratedFGD.instance.Build(PreIntegratedFGD.FGDIndex.FGD_GGXAndDisneyDiffuse);
             LTCAreaLight.instance.Build();
 
             m_isInit = false;
         {
-            PreIntegratedFGD.instance.Cleanup();
+            PreIntegratedFGD.instance.Cleanup(PreIntegratedFGD.FGDIndex.FGD_GGXAndDisneyDiffuse);
             LTCAreaLight.instance.Cleanup();
 
             m_isInit = false;
             if (m_isInit)
                 return;
 
-            PreIntegratedFGD.instance.RenderInit(cmd);
+            PreIntegratedFGD.instance.RenderInit(PreIntegratedFGD.FGDIndex.FGD_GGXAndDisneyDiffuse, cmd);
 
             m_isInit = true;
         }
-            PreIntegratedFGD.instance.Bind();
+            PreIntegratedFGD.instance.Bind(PreIntegratedFGD.FGDIndex.FGD_GGXAndDisneyDiffuse);
             LTCAreaLight.instance.Bind();
         }
     }

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+BSDFData:  static fields
 //
-#define DEBUGVIEW_LIT_BSDFDATA_MATERIAL_FEATURES (1030)
-#define DEBUGVIEW_LIT_BSDFDATA_DIFFUSE_COLOR (1031)
-#define DEBUGVIEW_LIT_BSDFDATA_FRESNEL0 (1032)
-#define DEBUGVIEW_LIT_BSDFDATA_SPECULAR_OCCLUSION (1033)
-#define DEBUGVIEW_LIT_BSDFDATA_NORMAL_WS (1034)
-#define DEBUGVIEW_LIT_BSDFDATA_NORMAL_VIEW_SPACE (1035)
-#define DEBUGVIEW_LIT_BSDFDATA_PERCEPTUAL_ROUGHNESS (1036)
-#define DEBUGVIEW_LIT_BSDFDATA_COAT_MASK (1037)
-#define DEBUGVIEW_LIT_BSDFDATA_DIFFUSION_PROFILE (1038)
-#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_MASK (1039)
-#define DEBUGVIEW_LIT_BSDFDATA_THICKNESS (1040)
-#define DEBUGVIEW_LIT_BSDFDATA_USE_THICK_OBJECT_MODE (1041)
-#define DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE (1042)
-#define DEBUGVIEW_LIT_BSDFDATA_TANGENT_WS (1043)
-#define DEBUGVIEW_LIT_BSDFDATA_BITANGENT_WS (1044)
-#define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T (1045)
-#define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B (1046)
-#define DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY (1047)
-#define DEBUGVIEW_LIT_BSDFDATA_IRIDESCENCE_THICKNESS (1048)
-#define DEBUGVIEW_LIT_BSDFDATA_IRIDESCENCE_MASK (1049)
-#define DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS (1050)
-#define DEBUGVIEW_LIT_BSDFDATA_IOR (1051)
-#define DEBUGVIEW_LIT_BSDFDATA_ABSORPTION_COEFFICIENT (1052)
-#define DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE_MASK (1053)
+#define DEBUGVIEW_LIT_BSDFDATA_MATERIAL_FEATURES (1050)
+#define DEBUGVIEW_LIT_BSDFDATA_DIFFUSE_COLOR (1051)
+#define DEBUGVIEW_LIT_BSDFDATA_FRESNEL0 (1052)
+#define DEBUGVIEW_LIT_BSDFDATA_SPECULAR_OCCLUSION (1053)
+#define DEBUGVIEW_LIT_BSDFDATA_NORMAL_WS (1054)
+#define DEBUGVIEW_LIT_BSDFDATA_NORMAL_VIEW_SPACE (1055)
+#define DEBUGVIEW_LIT_BSDFDATA_PERCEPTUAL_ROUGHNESS (1056)
+#define DEBUGVIEW_LIT_BSDFDATA_COAT_MASK (1057)
+#define DEBUGVIEW_LIT_BSDFDATA_DIFFUSION_PROFILE (1058)
+#define DEBUGVIEW_LIT_BSDFDATA_SUBSURFACE_MASK (1059)
+#define DEBUGVIEW_LIT_BSDFDATA_THICKNESS (1060)
+#define DEBUGVIEW_LIT_BSDFDATA_USE_THICK_OBJECT_MODE (1061)
+#define DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE (1062)
+#define DEBUGVIEW_LIT_BSDFDATA_TANGENT_WS (1063)
+#define DEBUGVIEW_LIT_BSDFDATA_BITANGENT_WS (1064)
+#define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_T (1065)
+#define DEBUGVIEW_LIT_BSDFDATA_ROUGHNESS_B (1066)
+#define DEBUGVIEW_LIT_BSDFDATA_ANISOTROPY (1067)
+#define DEBUGVIEW_LIT_BSDFDATA_IRIDESCENCE_THICKNESS (1068)
+#define DEBUGVIEW_LIT_BSDFDATA_IRIDESCENCE_MASK (1069)
+#define DEBUGVIEW_LIT_BSDFDATA_COAT_ROUGHNESS (1070)
+#define DEBUGVIEW_LIT_BSDFDATA_IOR (1071)
+#define DEBUGVIEW_LIT_BSDFDATA_ABSORPTION_COEFFICIENT (1072)
+#define DEBUGVIEW_LIT_BSDFDATA_TRANSMITTANCE_MASK (1073)
 
 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Lit+GBufferMaterial:  static fields

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/Lit.hlsl

 #define CLEAR_COAT_IOR 1.5
 #define CLEAR_COAT_IETA (1.0 / CLEAR_COAT_IOR) // IETA is the inverse eta which is the ratio of IOR of two interface
 #define CLEAR_COAT_F0 0.04 // IORToFresnel0(CLEAR_COAT_IOR)
-#define CLEAR_COAT_ROUGHNESS 0.001
+#define CLEAR_COAT_ROUGHNESS 0.03
 #define CLEAR_COAT_PERCEPTUAL_SMOOTHNESS RoughnessToPerceptualSmoothness(CLEAR_COAT_ROUGHNESS)
 #define CLEAR_COAT_PERCEPTUAL_ROUGHNESS RoughnessToPerceptualRoughness(CLEAR_COAT_ROUGHNESS)
 
 #define USE_DEFERRED_DIRECTIONAL_SHADOWS // Deferred shadows are always enabled for opaque objects
 #endif
 
-#include "../../Lighting/LightEvaluation.hlsl"
-
-//-----------------------------------------------------------------------------
-// Lighting structure for light accumulation
-//-----------------------------------------------------------------------------
-
-// These structure allow to accumulate lighting accross the Lit material
-// AggregateLighting is init to zero and transfer to EvaluateBSDF, but the LightLoop can't access its content.
-struct DirectLighting
-{
-    float3 diffuse;
-    float3 specular;
-};
-
-struct IndirectLighting
-{
-    float3 specularReflected;
-    float3 specularTransmitted;
-};
-
-struct AggregateLighting
-{
-    DirectLighting   direct;
-    IndirectLighting indirect;
-};
-
-void AccumulateDirectLighting(DirectLighting src, inout AggregateLighting dst)
-{
-    dst.direct.diffuse += src.diffuse;
-    dst.direct.specular += src.specular;
-}
-
-void AccumulateIndirectLighting(IndirectLighting src, inout AggregateLighting dst)
-{
-    dst.indirect.specularReflected += src.specularReflected;
-    dst.indirect.specularTransmitted += src.specularTransmitted;
-}
+#include "HDRP/Material/MaterialEvaluation.hlsl"
+#include "HDRP/Lighting/LightEvaluation.hlsl"
 
 //-----------------------------------------------------------------------------
 // BSDF share between directional light, punctual light and area light (reference)
             out float3 diffuseLighting,
             out float3 specularLighting)
 {
-    float3 N = bsdfData.normalWS;
-
-    // Optimized math. Ref: PBR Diffuse Lighting for GGX + Smith Microsurfaces (slide 114).
-    float LdotV    = dot(L, V);
-    float invLenLV = rsqrt(max(2.0 * LdotV + 2.0, FLT_EPS));            // invLenLV = rcp(length(L + V)), clamp to avoid rsqrt(0) = NaN
-    float NdotH    = saturate((NdotL + preLightData.NdotV) * invLenLV); // Do not clamp NdotV here
-    float LdotH    = saturate(invLenLV * LdotV + invLenLV);
-    float NdotV    = ClampNdotV(preLightData.NdotV);
+    float LdotV, NdotH, LdotH, NdotV, invLenLV;
+    GetBSDFAngle(V, L, NdotL, preLightData.NdotV, LdotV, NdotH, LdotH, NdotV, invLenLV);
 
     float3 F = F_Schlick(bsdfData.fresnel0, LdotH);
     // Remark: Fresnel must be use with LdotH angle. But Fresnel for iridescence is expensive to compute at each light.
                         PreLightData preLightData, BSDFData bsdfData, BakeLightingData bakeLightingData, AggregateLighting lighting,
                         out float3 diffuseLighting, out float3 specularLighting)
 {
-    float3 bakeDiffuseLighting = bakeLightingData.bakeDiffuseLighting;
-
     AmbientOcclusionFactor aoFactor;
     // Use GTAOMultiBounce approximation for ambient occlusion (allow to get a tint from the baseColor)
 #if 0
 #endif
 
-    // Add indirect diffuse + emissive (if any) - Ambient occlusion is multiply by emissive which is wrong but not a big deal
-    bakeDiffuseLighting                 *= aoFactor.indirectAmbientOcclusion;
-    lighting.indirect.specularReflected *= aoFactor.indirectSpecularOcclusion;
-    lighting.direct.diffuse             *= aoFactor.directAmbientOcclusion;
+    ApplyAmbientOcclusionFactor(aoFactor, bakeLightingData, lighting);
 
     // Subsurface scattering mdoe
     uint   texturingMode        = (bsdfData.materialFeatures >> MATERIAL_FEATURE_FLAGS_SSS_TEXTURING_MODE_OFFSET) & 3;
     // diffuse lighting has already had the albedo applied in GetBakedDiffuseLighting().
-    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + bakeDiffuseLighting;
+    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
 
     // If refraction is enable we use the transmittanceMask to lerp between current diffuse lighting and refraction value
     // Physically speaking, transmittanceMask should be 1, but for artistic reasons, we let the value vary
     specularLighting *= 1.0 + bsdfData.fresnel0 * preLightData.energyCompensation;
 
 #ifdef DEBUG_DISPLAY
-
-    if (_DebugLightingMode != 0)
-    {
-        // Caution: _DebugLightingMode is used in other part of the code, don't do anything outside of
-        // current cases
-        switch (_DebugLightingMode)
-        {
-        case DEBUGLIGHTINGMODE_LUX_METER:
-            diffuseLighting = lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
-            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            break;
-
-        case DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION:
-            diffuseLighting = aoFactor.indirectAmbientOcclusion;
-            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            break;
-
-        case DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_OCCLUSION:
-            diffuseLighting = aoFactor.indirectSpecularOcclusion;
-            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            break;
-
-        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFRACTION:
-            if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
-                diffuseLighting = lighting.indirect.specularTransmitted;
-            break;
-
-        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFLECTION:
-            if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
-                diffuseLighting = lighting.indirect.specularReflected;
-            break;
-
-        case DEBUGLIGHTINGMODE_VISUALIZE_SHADOW_MASKS:
-            #ifdef SHADOWS_SHADOWMASK
-            diffuseLighting = float3(
-                bakeLightingData.bakeShadowMask.r / 2 + bakeLightingData.bakeShadowMask.g / 2,
-                bakeLightingData.bakeShadowMask.g / 2 + bakeLightingData.bakeShadowMask.b / 2,
-                bakeLightingData.bakeShadowMask.b / 2 + bakeLightingData.bakeShadowMask.a / 2
-            );
-            specularLighting = float3(0, 0, 0);
-            #endif
-            break ;
-        }
-    }
-    else if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
-    {
-        diffuseLighting = bsdfData.diffuseColor;
-        specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-    }
-
+    PostEvaluateBSDFDebugDisplay(aoFactor, bakeLightingData, lighting, bsdfData.diffuseColor, diffuseLighting, specularLighting);
 #endif
 }
 

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/ShaderPass/LitDepthPass.hlsl

 #endif
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/ShaderPass/LitDistortionPass.hlsl

 #endif
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/ShaderPass/LitSharePass.hlsl

 #endif
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Lit/ShaderPass/LitVelocityPass.hlsl

 #endif
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.cs

             }
         }
 
-        bool m_isInit;
-        int m_refCounting;
+        public enum FGDIndex
+        {
+            FGD_GGXAndDisneyDiffuse = 0,
+            FGD_CharlieAndClothLambert = 1,
+            Count = 2
+        }
+
+        bool[] m_isInit = new bool[(int)FGDIndex.Count];
+        int[] m_refCounting = new int[(int)FGDIndex.Count];
-        // For image based lighting
-        Material m_PreIntegratedFGDMaterial;
-        RenderTexture m_PreIntegratedFGD;
+        Material[] m_PreIntegratedFGDMaterial = new Material[(int)FGDIndex.Count];
+        RenderTexture[] m_PreIntegratedFGD = new RenderTexture[(int)FGDIndex.Count];
-        {
-            m_isInit = false;
-            m_refCounting = 0;
+        {            
+            for (int i = 0; i < (int)FGDIndex.Count; ++i)
+            {
+                m_isInit[i] = false;
+                m_refCounting[i] = 0;
+            }
-        public void Build()
+        public void Build(FGDIndex index)
-            Debug.Assert(m_refCounting >= 0);
+            Debug.Assert(index != FGDIndex.Count);
+            Debug.Assert(m_refCounting[(int)index] >= 0);
-            if (m_refCounting == 0)
+            if (m_refCounting[(int)index] == 0)
-                m_PreIntegratedFGDMaterial = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.preIntegratedFGD);
+                switch(index)
+                {
+                    case FGDIndex.FGD_GGXAndDisneyDiffuse:
+                        m_PreIntegratedFGDMaterial[(int)index] = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.preIntegratedFGD_GGXDisneyDiffuse);
+                        m_PreIntegratedFGD[(int)index] = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear);
+                        m_PreIntegratedFGD[(int)index].hideFlags = HideFlags.HideAndDontSave;
+                        m_PreIntegratedFGD[(int)index].filterMode = FilterMode.Bilinear;
+                        m_PreIntegratedFGD[(int)index].wrapMode = TextureWrapMode.Clamp;
+                        m_PreIntegratedFGD[(int)index].name = CoreUtils.GetRenderTargetAutoName(128, 128, 1, RenderTextureFormat.ARGB2101010, "preIntegratedFGD_GGXDisneyDiffuse");
+                        m_PreIntegratedFGD[(int)index].Create();
+                        break;
-                m_PreIntegratedFGD = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear);
-                m_PreIntegratedFGD.hideFlags = HideFlags.HideAndDontSave;
-                m_PreIntegratedFGD.filterMode = FilterMode.Bilinear;
-                m_PreIntegratedFGD.wrapMode = TextureWrapMode.Clamp;
-                m_PreIntegratedFGD.hideFlags = HideFlags.DontSave;
-                m_PreIntegratedFGD.name = CoreUtils.GetRenderTargetAutoName(128, 128, 1, RenderTextureFormat.ARGB2101010, "PreIntegratedFGD");
-                m_PreIntegratedFGD.Create();
+                    case FGDIndex.FGD_CharlieAndClothLambert:
+                        m_PreIntegratedFGDMaterial[(int)index] = CoreUtils.CreateEngineMaterial(hdrp.renderPipelineResources.preIntegratedFGD_CharlieClothLambert);
+                        m_PreIntegratedFGD[(int)index] = new RenderTexture(128, 128, 0, RenderTextureFormat.ARGB2101010, RenderTextureReadWrite.Linear);
+                        m_PreIntegratedFGD[(int)index].hideFlags = HideFlags.HideAndDontSave;
+                        m_PreIntegratedFGD[(int)index].filterMode = FilterMode.Bilinear;
+                        m_PreIntegratedFGD[(int)index].wrapMode = TextureWrapMode.Clamp;
+                        m_PreIntegratedFGD[(int)index].name = CoreUtils.GetRenderTargetAutoName(128, 128, 1, RenderTextureFormat.ARGB2101010, "preIntegratedFGD_CharlieClothLambert");
+                        m_PreIntegratedFGD[(int)index].Create();
+                        break;
-                m_isInit = false;
+                    default:
+                        break;
+                }
+
+                m_isInit[(int)index] = false;
-            m_refCounting++;
+            m_refCounting[(int)index]++;
-        public void RenderInit(CommandBuffer cmd)
+        public void RenderInit(FGDIndex index, CommandBuffer cmd)
-            if (m_isInit)
+            if (m_isInit[(int)index])
-                CoreUtils.DrawFullScreen(cmd, m_PreIntegratedFGDMaterial, new RenderTargetIdentifier(m_PreIntegratedFGD));
+                CoreUtils.DrawFullScreen(cmd, m_PreIntegratedFGDMaterial[(int)index], new RenderTargetIdentifier(m_PreIntegratedFGD[(int)index]));
-            m_isInit = true;
+            m_isInit[(int)index] = true;
-        public void Cleanup()
+        public void Cleanup(FGDIndex index)
-            m_refCounting--;
+            m_refCounting[(int)index]--;
-            if (m_refCounting == 0)
+            if (m_refCounting[(int)index] == 0)
-                CoreUtils.Destroy(m_PreIntegratedFGDMaterial);
-                CoreUtils.Destroy(m_PreIntegratedFGD);
+                CoreUtils.Destroy(m_PreIntegratedFGDMaterial[(int)index]);
+                CoreUtils.Destroy(m_PreIntegratedFGD[(int)index]);
-                m_isInit = false;
+                m_isInit[(int)index] = false;
-            Debug.Assert(m_refCounting >= 0);
+            Debug.Assert(m_refCounting[(int)index] >= 0);
-        public void Bind()
+        public void Bind(FGDIndex index)
-            Shader.SetGlobalTexture("_PreIntegratedFGD", m_PreIntegratedFGD);
+            switch (index)
+            {
+                case FGDIndex.FGD_GGXAndDisneyDiffuse:
+                    Shader.SetGlobalTexture(HDShaderIDs._PreIntegratedFGD_GGXDisneyDiffuse, m_PreIntegratedFGD[(int)index]);
+                    break;
+
+                case FGDIndex.FGD_CharlieAndClothLambert:
+                    Shader.SetGlobalTexture(HDShaderIDs._PreIntegratedFGD_CharlieAndCloth, m_PreIntegratedFGD[(int)index]);
+                    break;
+
+                default:
+                    break;
+            }
         }
     }
 }

com.unity.render-pipelines.high-definition/HDRP/Material/PreIntegratedFGD/PreIntegratedFGD.hlsl

-TEXTURE2D(_PreIntegratedFGD);
+TEXTURE2D(_PreIntegratedFGD_GGXDisneyDiffuse);
 
 // For image based lighting, a part of the BSDF is pre-integrated.
 // This is done both for specular GGX height-correlated and DisneyDiffuse
-    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD, s_linear_clamp_sampler, float2(NdotV, perceptualRoughness), 0).xyz;
+    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD_GGXDisneyDiffuse, s_linear_clamp_sampler, float2(NdotV, perceptualRoughness), 0).xyz;
 
     // Pre-integrate GGX FGD
     // Integral{BSDF * <N,L> dw} =
 
     reflectivity = preFGD.y;
 }
+
+TEXTURE2D(_PreIntegratedFGD_CharlieAndCloth);
+
+void GetPreIntegratedFGDCharlieAndClothLambert(float NdotV, float perceptualRoughness, float3 fresnel0, out float3 CharlieSpecularFGD, out float clothLambertDiffuseFGD, out float reflectivity)
+{
+    float3 preFGD = SAMPLE_TEXTURE2D_LOD(_PreIntegratedFGD_CharlieAndCloth, s_linear_clamp_sampler, float2(NdotV, perceptualRoughness), 0).xyz;
+
+    CharlieSpecularFGD = lerp(preFGD.xxx, preFGD.yyy, fresnel0);
+    // z = ClothLambert
+    clothLambertDiffuseFGD = preFGD.z;
+
+    reflectivity = preFGD.y;
+}

com.unity.render-pipelines.high-definition/HDRP/Material/PreIntegratedFGD/preIntegratedFGD_CharlieClothLambert.shader

-Shader "Hidden/HDRenderPipeline/PreIntegratedFGD"
+Shader "Hidden/HDRenderPipeline/preIntegratedFGD_CharlieClothLambert"
 {
     SubShader
     {
                 float3 N                    = float3(0.0, 0.0, 1.0);
 
                 // Pre integrate GGX with smithJoint visibility as well as DisneyDiffuse
-                float4 preFGD = IntegrateGGXAndDisneyFGD(V, N, PerceptualRoughnessToRoughness(perceptualRoughness));
+                float4 preFGD = IntegrateCharlieAndClothLambertFGD(V, N, PerceptualRoughnessToRoughness(perceptualRoughness));
 
                 return float4(preFGD.xyz, 1.0);
             }

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/ShaderPass/StackLitDepthPass.hlsl

 #endif //..._ALPHATEST_ON
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/ShaderPass/StackLitDistortionPass.hlsl

 #define VARYINGS_NEED_TEXCOORD0
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/ShaderPass/StackLitSharePass.hlsl

 #endif
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLit.cs

         //-----------------------------------------------------------------------------
 
         // Main structure that store the user data (i.e user input of master node in material graph)
-        [GenerateHLSL(PackingRules.Exact, false, true, 1300)]
+        [GenerateHLSL(PackingRules.Exact, false, true, 1100)]
         public struct SurfaceData
         {
             [SurfaceDataAttributes("Material Features")]
         //-----------------------------------------------------------------------------
         // BSDFData
         //-----------------------------------------------------------------------------
-        [GenerateHLSL(PackingRules.Exact, false, true, 1400)]
+        [GenerateHLSL(PackingRules.Exact, false, true, 1150)]
         public struct BSDFData
         {
             public uint materialFeatures;
 
         public override void Build(HDRenderPipelineAsset hdAsset)
         {
-            PreIntegratedFGD.instance.Build();
+            PreIntegratedFGD.instance.Build(PreIntegratedFGD.FGDIndex.FGD_GGXAndDisneyDiffuse);
             //LTCAreaLight.instance.Build();
 
             m_isInit = false;
         {
-            PreIntegratedFGD.instance.Cleanup();
+            PreIntegratedFGD.instance.Cleanup(PreIntegratedFGD.FGDIndex.FGD_GGXAndDisneyDiffuse);
             //LTCAreaLight.instance.Cleanup();
 
             m_isInit = false;
             if (m_isInit)
                 return;
 
-            PreIntegratedFGD.instance.RenderInit(cmd);
+            PreIntegratedFGD.instance.RenderInit(PreIntegratedFGD.FGDIndex.FGD_GGXAndDisneyDiffuse, cmd);
 
             m_isInit = true;
         }
-            PreIntegratedFGD.instance.Bind();
+            PreIntegratedFGD.instance.Bind(PreIntegratedFGD.FGDIndex.FGD_GGXAndDisneyDiffuse);
             //LTCAreaLight.instance.Bind();
         }
     }

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLit.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.StackLit+SurfaceData:  static fields
 //
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_MATERIAL_FEATURES (1300)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_BASE_COLOR (1301)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_AMBIENT_OCCLUSION (1302)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_METALLIC (1303)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_IOR (1304)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL (1305)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE (1306)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL (1307)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL_VIEW_SPACE (1308)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL (1309)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL_VIEW_SPACE (1310)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1311)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1312)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1313)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_TANGENT (1314)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_ANISOTROPY (1315)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_IOR (1316)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS (1317)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_SMOOTHNESS (1318)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR (1319)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_THICKNESS (1320)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_EXTINCTION_COEFFICIENT (1321)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_DIFFUSION_PROFILE (1322)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_SUBSURFACE_MASK (1323)
-#define DEBUGVIEW_STACKLIT_SURFACEDATA_THICKNESS (1324)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_MATERIAL_FEATURES (1100)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_BASE_COLOR (1101)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_AMBIENT_OCCLUSION (1102)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_METALLIC (1103)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IOR (1104)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL (1105)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_NORMAL_VIEW_SPACE (1106)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL (1107)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_GEOMETRIC_NORMAL_VIEW_SPACE (1108)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL (1109)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_NORMAL_VIEW_SPACE (1110)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_A (1111)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SMOOTHNESS_B (1112)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_LOBE_MIXING (1113)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_TANGENT (1114)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_ANISOTROPY (1115)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_IOR (1116)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_IRIDESCENCE_THICKNESS (1117)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_SMOOTHNESS (1118)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_IOR (1119)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_THICKNESS (1120)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_COAT_EXTINCTION_COEFFICIENT (1121)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_DIFFUSION_PROFILE (1122)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_SUBSURFACE_MASK (1123)
+#define DEBUGVIEW_STACKLIT_SURFACEDATA_THICKNESS (1124)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_MATERIAL_FEATURES (1400)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSE_COLOR (1401)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_FRESNEL0 (1402)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_AMBIENT_OCCLUSION (1403)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_WS (1404)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE (1405)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_GEOMETRIC_NORMAL (1406)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_GEOMETRIC_NORMAL_VIEW_SPACE (1407)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_NORMAL (1408)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_NORMAL_VIEW_SPACE (1409)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A (1410)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_B (1411)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIX (1412)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_TANGENT_WS (1413)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_BITANGENT_WS (1414)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT (1415)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AB (1416)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BT (1417)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BB (1418)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY (1419)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_ROUGHNESS (1420)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_PERCEPTUAL_ROUGHNESS (1421)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_IOR (1422)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_THICKNESS (1423)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_EXTINCTION (1424)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_IOR (1425)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_THICKNESS (1426)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSION_PROFILE (1427)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_SUBSURFACE_MASK (1428)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_THICKNESS (1429)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_USE_THICK_OBJECT_MODE (1430)
-#define DEBUGVIEW_STACKLIT_BSDFDATA_TRANSMITTANCE (1431)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_MATERIAL_FEATURES (1150)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSE_COLOR (1151)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_FRESNEL0 (1152)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_AMBIENT_OCCLUSION (1153)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_WS (1154)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_NORMAL_VIEW_SPACE (1155)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_GEOMETRIC_NORMAL (1156)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_GEOMETRIC_NORMAL_VIEW_SPACE (1157)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_NORMAL (1158)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_NORMAL_VIEW_SPACE (1159)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_A (1160)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_PERCEPTUAL_ROUGHNESS_B (1161)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_LOBE_MIX (1162)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_TANGENT_WS (1163)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_BITANGENT_WS (1164)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AT (1165)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_AB (1166)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BT (1167)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ROUGHNESS_BB (1168)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_ANISOTROPY (1169)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_ROUGHNESS (1170)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_PERCEPTUAL_ROUGHNESS (1171)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_IOR (1172)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_THICKNESS (1173)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_COAT_EXTINCTION (1174)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_IOR (1175)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_IRIDESCENCE_THICKNESS (1176)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_DIFFUSION_PROFILE (1177)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_SUBSURFACE_MASK (1178)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_THICKNESS (1179)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_USE_THICK_OBJECT_MODE (1180)
+#define DEBUGVIEW_STACKLIT_BSDFDATA_TRANSMITTANCE (1181)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.StackLit+SurfaceData
 // PackingRules = Exact

com.unity.render-pipelines.high-definition/HDRP/Material/StackLit/StackLit.hlsl

 #include "StackLit.cs.hlsl"
 #include "../SubsurfaceScattering/SubsurfaceScattering.hlsl"
 #include "../NormalBuffer.hlsl"
-//#include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
+#include "CoreRP/ShaderLibrary/VolumeRendering.hlsl"
-//NEWLITTODO : wireup CBUFFERs for ambientocclusion, and other uniforms and samplers used:
+//NEWLITTODO : wireup CBUFFERs for uniforms and samplers used:
 //
 // We need this for AO, Depth/Color pyramids, LTC lights data, FGD pre-integrated data.
 //
 #define USE_DEFERRED_DIRECTIONAL_SHADOWS // Deferred shadows are always enabled for opaque objects
 #endif
 
-#include "../../Lighting/LightEvaluation.hlsl"
-#include "../../Lighting/Reflection/VolumeProjection.hlsl"
-
-//-----------------------------------------------------------------------------
-// Lighting structure for light accumulation
-//-----------------------------------------------------------------------------
-
-// These structure allow to accumulate lighting accross the Lit material
-// AggregateLighting is init to zero and transfer to EvaluateBSDF, but the LightLoop can't access its content.
-//
-// In fact, all structures here are opaque but used by LightLoop.hlsl.
-// The Accumulate* functions are also used by LightLoop to accumulate the contributions of lights.
-//
-struct DirectLighting
-{
-    float3 diffuse;
-    float3 specular;
-};
-
-struct IndirectLighting
-{
-    float3 specularReflected;
-    float3 specularTransmitted;
-};
-
-struct AggregateLighting
-{
-    DirectLighting   direct;
-    IndirectLighting indirect;
-};
-
-void AccumulateDirectLighting(DirectLighting src, inout AggregateLighting dst)
-{
-    dst.direct.diffuse += src.diffuse;
-    dst.direct.specular += src.specular;
-}
+#include "HDRP/Material/MaterialEvaluation.hlsl"
+#include "HDRP/Lighting/LightEvaluation.hlsl"
-void AccumulateIndirectLighting(IndirectLighting src, inout AggregateLighting dst)
-{
-    dst.indirect.specularReflected += src.specularReflected;
-    dst.indirect.specularTransmitted += src.specularTransmitted;
-}
+#include "HDRP/Lighting/Reflection/VolumeProjection.hlsl"
 
 //-----------------------------------------------------------------------------
 // BSDF share between directional light, punctual light and area light (reference)
                         PreLightData preLightData, BSDFData bsdfData, BakeLightingData bakeLightingData, AggregateLighting lighting,
                         out float3 diffuseLighting, out float3 specularLighting)
 {
-    float3 bakeDiffuseLighting = bakeLightingData.bakeDiffuseLighting;
-
-    float3 N; float unclampedNdotV;
+    float3 N;
+    float unclampedNdotV;
     EvaluateBSDF_GetNormalUnclampedNdotV(bsdfData, preLightData, V, N, unclampedNdotV);
 
     AmbientOcclusionFactor aoFactor;
 
-    // Add indirect diffuse + emissive (if any) - Ambient occlusion is multiply by emissive which is wrong but not a big deal
-    bakeDiffuseLighting                 *= aoFactor.indirectAmbientOcclusion;
-    lighting.direct.diffuse             *= aoFactor.directAmbientOcclusion;
+    ApplyAmbientOcclusionFactor(aoFactor, bakeLightingData, lighting);
 
     // Subsurface scattering mdoe
     uint   texturingMode = (bsdfData.materialFeatures >> MATERIAL_FEATURE_FLAGS_SSS_TEXTURING_MODE_OFFSET) & 3;
     // diffuse lighting has already had the albedo applied in GetBakedDiffuseLighting().
-    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + bakeDiffuseLighting;
+    diffuseLighting = modifiedDiffuseColor * lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
-
-    if (_DebugLightingMode != 0)
-    {
-        // Caution: _DebugLightingMode is used in other part of the code, don't do anything outside of
-        // current cases
-        switch (_DebugLightingMode)
-        {
-        case DEBUGLIGHTINGMODE_LUX_METER:
-            diffuseLighting = lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
-            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            break;
-
-        case DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION:
-            diffuseLighting = aoFactor.indirectAmbientOcclusion;
-            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            break;
-
-        case DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_OCCLUSION:
-            diffuseLighting = aoFactor.indirectSpecularOcclusion;
-            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-            break;
-
-        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFRACTION:
-            //if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
-             //   diffuseLighting = lighting.indirect.specularTransmitted;
-            break;
-
-        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFLECTION:
-            //if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
-            //    diffuseLighting = lighting.indirect.specularReflected;
-            break;
-
-        case DEBUGLIGHTINGMODE_VISUALIZE_SHADOW_MASKS:
-            #ifdef SHADOWS_SHADOWMASK
-            diffuseLighting = float3(
-                bakeLightingData.bakeShadowMask.r / 2 + bakeLightingData.bakeShadowMask.g / 2,
-                bakeLightingData.bakeShadowMask.g / 2 + bakeLightingData.bakeShadowMask.b / 2,
-                bakeLightingData.bakeShadowMask.b / 2 + bakeLightingData.bakeShadowMask.a / 2
-            );
-            specularLighting = float3(0, 0, 0);
-            #endif
-            break ;
-        }
-    }
-    else if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
-    {
-        diffuseLighting = bsdfData.diffuseColor;
-        specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
-    }
-
+    PostEvaluateBSDFDebugDisplay(aoFactor, bakeLightingData, lighting, bsdfData.diffuseColor, diffuseLighting, specularLighting);
 #endif
 }
 

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/ShaderPass/UnlitDepthPass.hlsl

 #endif
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/ShaderPass/UnlitDistortionPass.hlsl

 #define VARYINGS_NEED_TEXCOORD0
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/ShaderPass/UnlitSharePass.hlsl

 #define VARYINGS_NEED_TEXCOORD0
 
 // This include will define the various Attributes/Varyings structure
-#include "../../ShaderPass/VaryingMesh.hlsl"
+#include "HDRP/ShaderPass/VaryingMesh.hlsl"

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/Unlit.cs

         //-----------------------------------------------------------------------------
 
         // Main structure that store the user data (i.e user input of master node in material graph)
-        [GenerateHLSL(PackingRules.Exact, false, true, 1100)]
+        [GenerateHLSL(PackingRules.Exact, false, true, 300)]
         public struct SurfaceData
         {
             [SurfaceDataAttributes("Color", false, true)]
         // BSDFData
         //-----------------------------------------------------------------------------
 
-        [GenerateHLSL(PackingRules.Exact, false, true, 1130)]
+        [GenerateHLSL(PackingRules.Exact, false, true, 350)]
         public struct BSDFData
         {
             [SurfaceDataAttributes("", false, true)]

com.unity.render-pipelines.high-definition/HDRP/Material/Unlit/Unlit.cs.hlsl

 //
 // UnityEngine.Experimental.Rendering.HDPipeline.Unlit+SurfaceData:  static fields
 //
-#define DEBUGVIEW_UNLIT_SURFACEDATA_COLOR (1100)
+#define DEBUGVIEW_UNLIT_SURFACEDATA_COLOR (300)
-#define DEBUGVIEW_UNLIT_BSDFDATA_COLOR (1130)
+#define DEBUGVIEW_UNLIT_BSDFDATA_COLOR (350)
 
 // Generated from UnityEngine.Experimental.Rendering.HDPipeline.Unlit+SurfaceData
 // PackingRules = Exact

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDRenderPipeline.cs

                     else
                     {
                         m_CurrentDebugDisplaySettings = m_DebugDisplaySettings;
+                    }
-                        using (new ProfilingSample(cmd, "Volume Update", CustomSamplerId.VolumeUpdate.GetSampler()))
+                    using (new ProfilingSample(cmd, "Volume Update", CustomSamplerId.VolumeUpdate.GetSampler()))
+                    {
+                        LayerMask layerMask = -1;
+                        if (additionalCameraData != null)
+                        {
+                            layerMask = additionalCameraData.volumeLayerMask;
+                        }
+                        else
-                            LayerMask layerMask = -1;
-                            if (additionalCameraData != null)
-                            {
-                                layerMask = additionalCameraData.volumeLayerMask;
-                            }
-                            else
+                            // Temporary hack:
+                            // For scene view, by default, we use the "main" camera volume layer mask if it exists
+                            // Otherwise we just remove the lighting override layers in the current sky to avoid conflicts
+                            // This is arbitrary and should be editable in the scene view somehow.
+                            if (camera.cameraType == CameraType.SceneView)
-                                // Temporary hack:
-                                // For scene view, by default, we use the "main" camera volume layer mask if it exists
-                                // Otherwise we just remove the lighting override layers in the current sky to avoid conflicts
-                                // This is arbitrary and should be editable in the scene view somehow.
-                                if (camera.cameraType == CameraType.SceneView)
+                                var mainCamera = Camera.main;
+                                bool needFallback = true;
+                                if (mainCamera != null)
-                                    var mainCamera = Camera.main;
-                                    bool needFallback = true;
-                                    if (mainCamera != null)
+                                    var mainCamAdditionalData = mainCamera.GetComponent<HDAdditionalCameraData>();
+                                    if (mainCamAdditionalData != null)
-                                        var mainCamAdditionalData = mainCamera.GetComponent<HDAdditionalCameraData>();
-                                        if (mainCamAdditionalData != null)
-                                        {
-                                            layerMask = mainCamAdditionalData.volumeLayerMask;
-                                            needFallback = false;
-                                        }
+                                        layerMask = mainCamAdditionalData.volumeLayerMask;
+                                        needFallback = false;
+                                }
-                                    if (needFallback)
-                                    {
-                                        // If the override layer is "Everything", we fall-back to "Everything" for the current layer mask to avoid issues by having no current layer
-                                        // In practice we should never have "Everything" as an override mask as it does not make sense (a warning is issued in the UI)
-                                        if (m_Asset.renderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask == -1)
-                                            layerMask = -1;
-                                        else
-                                            layerMask = (-1 & ~m_Asset.renderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask);
-                                    }
+                                if (needFallback)
+                                {
+                                    // If the override layer is "Everything", we fall-back to "Everything" for the current layer mask to avoid issues by having no current layer
+                                    // In practice we should never have "Everything" as an override mask as it does not make sense (a warning is issued in the UI)
+                                    if (m_Asset.renderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask == -1)
+                                        layerMask = -1;
+                                    else
+                                        layerMask = (-1 & ~m_Asset.renderPipelineSettings.lightLoopSettings.skyLightingOverrideLayerMask);
-                            VolumeManager.instance.Update(camera.transform, layerMask);
+                        VolumeManager.instance.Update(camera.transform, layerMask);
                     }
 
                     var postProcessLayer = camera.GetComponent<PostProcessLayer>();
                     ClearBuffers(hdCamera, cmd);
 
                     // TODO: Add stereo occlusion mask
-                    RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd, m_DbufferManager.EnableDBUffer);
+                    RenderDepthPrepass(m_CullResults, hdCamera, renderContext, cmd);
 
                     // This will bind the depth buffer if needed for DBuffer)
                     RenderDBuffer(hdCamera, cmd, renderContext, m_CullResults);
         // Forward only renderer: We always render everything
         // Deferred renderer: We always render depth prepass for alpha tested (optimization), other object are render based on engine configuration.
         // Forward opaque with deferred renderer (DepthForwardOnly pass): We always render everything
-        void RenderDepthPrepass(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd, bool forcePrepass)
+        void RenderDepthPrepass(CullResults cull, HDCamera hdCamera, ScriptableRenderContext renderContext, CommandBuffer cmd)
         {
             // In case of deferred renderer, we can have forward opaque material. These materials need to be render in the depth buffer to correctly build the light list.
             // And they will tag the stencil to not be lit during the deferred lighting pass.
                     RenderOpaqueRenderList(cull, hdCamera, renderContext, cmd, m_DepthOnlyAndDepthForwardOnlyPassNames, 0, HDRenderQueue.k_RenderQueue_AllOpaque);
                 }
             }
-            else if (hdCamera.frameSettings.enableDepthPrepassWithDeferredRendering || forcePrepass)
+            // If we enable DBuffer, we need a full depth prepass
+            else if (hdCamera.frameSettings.enableDepthPrepassWithDeferredRendering || m_DbufferManager.EnableDBUffer)
-                using (new ProfilingSample(cmd, "Depth Prepass (deferred)", CustomSamplerId.DepthPrepass.GetSampler()))
+                using (new ProfilingSample(cmd, m_DbufferManager.EnableDBUffer ? "Depth Prepass (deferred) force by DBuffer" : "Depth Prepass (deferred)", CustomSamplerId.DepthPrepass.GetSampler()))
                 {
                     cmd.DisableShaderKeyword("WRITE_NORMAL_BUFFER"); // Note: This only disable the output of normal buffer for Lit shader, not the other shader that don't use multicompile
                     
                     return;
             }
 
+            // TODO: Move allocation in separate method call in start of the render loop
             var cameraRT = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.ColorPyramid)
                 ?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.ColorPyramid, m_BufferPyramid.AllocColorRT);
 
             if (!hdCamera.frameSettings.enableRoughRefraction)
                 return;
 
+            // TODO: Move allocation in separate method call in start of the render loop
             var cameraRT = hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.DepthPyramid)
                 ?? hdCamera.AllocHistoryFrameRT((int)HDCameraFrameHistoryType.DepthPyramid, m_BufferPyramid.AllocDepthRT);
 
                 cmd.SetGlobalInt(HDShaderIDs._DebugLightingMode, (int)m_CurrentDebugDisplaySettings.GetDebugLightingMode());
                 cmd.SetGlobalInt(HDShaderIDs._DebugLightingSubMode, (int)m_CurrentDebugDisplaySettings.GetDebugLightingSubMode());
                 cmd.SetGlobalInt(HDShaderIDs._DebugMipMapMode, (int)m_CurrentDebugDisplaySettings.GetDebugMipMapMode());
+                cmd.SetGlobalInt(HDShaderIDs._ColorPickerMode, (int)m_CurrentDebugDisplaySettings.GetDebugColorPickerMode());
 
                 cmd.SetGlobalVector(HDShaderIDs._DebugLightingAlbedo, debugAlbedo);
                 cmd.SetGlobalVector(HDShaderIDs._DebugLightingSmoothness, debugSmoothness);
                     // (i.e. we have perform a flip, we need to flip the input texture)
                     m_DebugFullScreen.SetFloat(HDShaderIDs._RequireToFlipInputTexture, hdCamera.camera.cameraType != CameraType.SceneView ? 1.0f : 0.0f);
                     m_DebugFullScreen.SetBuffer(HDShaderIDs._DebugScreenSpaceTracingData, m_DebugScreenSpaceTracingData);
-                    m_DebugFullScreen.SetTexture(HDShaderIDs._DepthPyramidTexture, hdCamera.GetCurrentFrameRT((int)HDCameraFrameHistoryType.DepthPyramid));
                     HDUtils.DrawFullScreen(cmd, hdCamera, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
 
                     PushColorPickerDebugTexture(hdCamera, cmd, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
                     cmd.SetGlobalTexture(HDShaderIDs._DebugColorPickerTexture, m_DebugColorPickerBuffer); // No SetTexture with RenderTarget identifier... so use SetGlobalTexture
                     // TODO: Replace with command buffer call when available
                     m_DebugColorPicker.SetColor(HDShaderIDs._ColorPickerFontColor, colorPickerDebugSettings.fontColor);
-                    m_DebugColorPicker.SetInt(HDShaderIDs._ColorPickerMode, (int)colorPickerDebugSettings.colorPickerMode);
                     m_DebugColorPicker.SetInt(HDShaderIDs._FalseColorEnabled, falseColorDebugSettings.falseColor ? 1 : 0);
                     m_DebugColorPicker.SetVector(HDShaderIDs._FalseColorThresholds, falseColorThresholds);
                     // The material display debug perform sRGBToLinear conversion as the final blit currently hardcode a linearToSrgb conversion. As when we read with color picker this is not done,

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/HDStringConstants.cs

         public static readonly int g_TileListOffset = Shader.PropertyToID("g_TileListOffset");
 
         public static readonly int _LtcData = Shader.PropertyToID("_LtcData");
-        public static readonly int _PreIntegratedFGD = Shader.PropertyToID("_PreIntegratedFGD");
         public static readonly int _LtcGGXMatrix = Shader.PropertyToID("_LtcGGXMatrix");
         public static readonly int _LtcDisneyDiffuseMatrix = Shader.PropertyToID("_LtcDisneyDiffuseMatrix");
         public static readonly int _LtcMultiGGXFresnelDisneyDiffuse = Shader.PropertyToID("_LtcMultiGGXFresnelDisneyDiffuse");
         public static readonly int _NumVisibleDensityVolumes       = Shader.PropertyToID("_NumVisibleDensityVolumes");
         public static readonly int _VolumeMaskAtlas                = Shader.PropertyToID("_VolumeMaskAtlas");
         public static readonly int _VolumeMaskDimensions           = Shader.PropertyToID("_VolumeMaskDimensions");
+
+        // Preintegrated texture name
+        public static readonly int _PreIntegratedFGD_GGXDisneyDiffuse = Shader.PropertyToID("_PreIntegratedFGD_GGXDisneyDiffuse");
+        public static readonly int _PreIntegratedFGD_CharlieAndCloth = Shader.PropertyToID("_PreIntegratedFGD_CharlieAndCloth");
     }
 }

com.unity.render-pipelines.high-definition/HDRP/RenderPipeline/SceneViewDrawMode.cs

             cameraMode.drawMode == DrawCameraMode.DeferredNormal ||
             cameraMode.drawMode == DrawCameraMode.ValidateAlbedo ||
             cameraMode.drawMode == DrawCameraMode.ValidateMetalSpecular ||
-            cameraMode.drawMode == DrawCameraMode.ShadowMasks ||
             cameraMode.drawMode == DrawCameraMode.LightOverlap
             )
             return false;

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/CameraMotionVectors.shader

         #pragma target 4.5
 
         #include "CoreRP/ShaderLibrary/Common.hlsl"
-        #include "../ShaderVariables.hlsl"
-        #include "../ShaderPass/FragInputs.hlsl"
-        #include "../ShaderPass/VaryingMesh.hlsl"
-        #include "../ShaderPass/VertMesh.hlsl"
-        #include "../Material/Builtin/BuiltinData.hlsl"
+        #include "HDRP/ShaderVariables.hlsl"
+        #include "HDRP/ShaderPass/FragInputs.hlsl"
+        #include "HDRP/ShaderPass/VaryingMesh.hlsl"
+        #include "HDRP/ShaderPass/VertMesh.hlsl"
+        #include "HDRP/Material/Builtin/BuiltinData.hlsl"
 
         struct Attributes
         {

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

   hdriSky: {fileID: 4800000, guid: 9bd32a6ece529fd4f9408b8d7e00c10d, type: 3}
   proceduralSky: {fileID: 4800000, guid: ec63f47fd265df243a7b1d40f9ef7fe7, type: 3}
   skyboxCubemap: {fileID: 103, guid: 0000000000000000f000000000000000, type: 0}
-  preIntegratedFGD: {fileID: 4800000, guid: 123f13d52852ef547b2962de4bd9eaad, type: 3}
+  preIntegratedFGD_GGXDisneyDiffuse: {fileID: 4800000, guid: 123f13d52852ef547b2962de4bd9eaad,
+    type: 3}
+  preIntegratedFGD_CharlieClothLambert: {fileID: 4800000, guid: 3b3bf235775cf8b4baae7f3306787ab0,
+    type: 3}
   encodeBC6HCS: {fileID: 7200000, guid: aa922d239de60304f964e24488559eeb, type: 3}
   cubeToPanoShader: {fileID: 4800000, guid: 595434cc3b6405246b6cd3086d0b6f7d, type: 3}
   blitCubeTextureFace: {fileID: 4800000, guid: d850d0a2481878d4bbf17e5126b04163, type: 3}

com.unity.render-pipelines.high-definition/HDRP/RenderPipelineResources/RenderPipelineResources.cs

         public Shader skyboxCubemap;
 
         // Material
-        public Shader preIntegratedFGD;
+        public Shader preIntegratedFGD_GGXDisneyDiffuse;
+        public Shader preIntegratedFGD_CharlieClothLambert;
 
         // Utilities / Core
         public ComputeShader encodeBC6HCS;

com.unity.render-pipelines.lightweight/CHANGELOG.md

 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-
-## [2.0.1-preview]
-
+- GLCore compute buffer compiler error
+- Occlusion strength not being applied on LW standard shaders
+- CopyDepth pass is being called even when a depth from prepass is available
+- GLES2 shader compiler error in IntegrationTests
+- Can't set RenderScale and ShadowDistance by script
 - VR Single Pass Instancing shadows
 
 ## [2.0.0-preview]

com.unity.render-pipelines.lightweight/LWRP/Data/LightweightPipelineAsset.cs

         public float renderScale
         {
             get { return m_RenderScale; }
+            set { m_RenderScale = value; }
         }
 
         public bool supportsDynamicBatching
         public float shadowDistance
         {
             get { return m_ShadowDistance; }
+            set { m_ShadowDistance = value; }
         }
 
         public int cascadeCount

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderGraph/lightweightPBRForwardPass.template

     #pragma multi_compile _ _SHADOWS_ENABLED
     #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
     #pragma multi_compile _ _SHADOWS_SOFT
-
+    #pragma multi_compile _ _SHADOWS_CASCADE
+    
 	// -------------------------------------
     // Unity defined keywords
     #pragma multi_compile _ DIRLIGHTMAP_COMBINED
     }
 
 	ENDHLSL
-}
+}

com.unity.render-pipelines.lightweight/LWRP/Editor/ShaderPreprocessor.cs

         public static readonly ShaderKeyword DirectionalShadows = new ShaderKeyword(LightweightKeywordStrings.DirectionalShadows);
         public static readonly ShaderKeyword LocalShadows = new ShaderKeyword(LightweightKeywordStrings.LocalShadows);
         public static readonly ShaderKeyword SoftShadows = new ShaderKeyword(LightweightKeywordStrings.SoftShadows);
+        public static readonly ShaderKeyword CascadeShadows = new ShaderKeyword(LightweightKeywordStrings.CascadeShadows);
 
         public static readonly ShaderKeyword Lightmap = new ShaderKeyword("LIGHTMAP_ON");
         public static readonly ShaderKeyword DirectionalLightmap = new ShaderKeyword("DIRLIGHTMAP_COMBINED");
 
         bool StripInvalidVariants(ShaderCompilerData compilerData)
         {
-            bool isShadowVariant = compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.DirectionalShadows) ||
-                compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.LocalShadows);
+            bool isDirectionalShadows = compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.DirectionalShadows);
+            bool isShadowVariant = isDirectionalShadows || compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.LocalShadows);
+
+            if (!isDirectionalShadows && compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.CascadeShadows))
+                return true;
-            if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.SoftShadows) && !isShadowVariant)
+            if (!isShadowVariant && compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.SoftShadows))
                 return true;
 
             if (compilerData.shaderKeywordSet.IsEnabled(LightweightKeyword.VertexLights) &&

com.unity.render-pipelines.lightweight/LWRP/LightweightForwardRenderer.cs

             get
             {
                 return SystemInfo.supportsComputeShaders &&
-                    !Application.isMobilePlatform && Application.platform != RuntimePlatform.WebGLPlayer;
+                       SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLCore &&
+                       !Application.isMobilePlatform &&
+                       Application.platform != RuntimePlatform.WebGLPlayer;
             }
         }
 
             bool requiresDepthAttachment = requiresCameraDepth && !requiresDepthPrepass;
             bool requiresColorAttachment = RequiresIntermediateColorTexture(ref renderingData.cameraData, baseDescriptor, requiresDepthAttachment);
             int[] colorHandles = (requiresColorAttachment) ? new[] {RenderTargetHandles.Color} : null;
-            int depthHandle = (requiresColorAttachment) ? RenderTargetHandles.DepthAttachment : -1;
+            int depthHandle = (requiresDepthAttachment) ? RenderTargetHandles.DepthAttachment : -1;
             EnqueuePass(cmd, RenderPassHandles.ForwardLit, baseDescriptor, colorHandles, depthHandle, renderingData.cameraData.msaaSamples);
 
             context.ExecuteCommandBuffer(cmd);

com.unity.render-pipelines.lightweight/LWRP/LightweightPipeline.cs

                                               Math.Abs(cameraRect.width) < 1.0f || Math.Abs(cameraRect.height) < 1.0f));
 
             // Discard variations lesser than kRenderScaleThreshold.
-            // Scale is only enabled for gameview
-            // XR has it's own scaling mechanism.
-            cameraData.renderScale = (Mathf.Abs(1.0f - pipelineAsset.renderScale) < kRenderScaleThreshold) ? 1.0f : pipelineAsset.renderScale;
-            cameraData.renderScale = (camera.cameraType == CameraType.Game && !cameraData.isStereoEnabled) ? cameraData.renderScale : 1.0f;
+            // Scale is only enabled for gameview.
+            // In XR mode, grab renderScale from XRSettings instead of SRP asset for now.
+	    // This is just a temporary change pending full integration of XR with SRP
+
+            if (camera.cameraType == CameraType.Game)
+            {
+                if (cameraData.isStereoEnabled)
+                {
+                    cameraData.renderScale = XRSettings.eyeTextureResolutionScale;
+                } else {
+                    cameraData.renderScale = pipelineAsset.renderScale;
+                }
+            } else {
+                cameraData.renderScale = 1.0f;
+            }
+            
+            cameraData.renderScale = (Mathf.Abs(1.0f - cameraData.renderScale) < kRenderScaleThreshold) ? 1.0f : cameraData.renderScale;
 
             cameraData.requiresDepthTexture = pipelineAsset.supportsCameraDepthTexture || cameraData.postProcessEnabled || cameraData.isSceneViewCamera;
             cameraData.requiresSoftParticles = pipelineAsset.supportsSoftParticles;
             bool supportsScreenSpaceShadows = SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
 
             shadowData.renderDirectionalShadows = pipelineAsset.supportsDirectionalShadows && hasDirectionalShadowCastingLight;
-            shadowData.requiresScreenSpaceShadowResolve = shadowData.renderDirectionalShadows && supportsScreenSpaceShadows;
+
+            // we resolve shadows in screenspace when cascades are enabled to save ALU as computing cascade index + shadowCoord on fragment is expensive
+            shadowData.requiresScreenSpaceShadowResolve = shadowData.renderDirectionalShadows && supportsScreenSpaceShadows && pipelineAsset.cascadeCount > 1;
             shadowData.directionalLightCascadeCount = (shadowData.requiresScreenSpaceShadowResolve) ? pipelineAsset.cascadeCount : 1;
             shadowData.directionalShadowAtlasWidth = pipelineAsset.directionalShadowAtlasResolution;
             shadowData.directionalShadowAtlasHeight = pipelineAsset.directionalShadowAtlasResolution;

com.unity.render-pipelines.lightweight/LWRP/Passes/DirectionalShadowsPass.cs

                 if (success)
                 {
                     shadowQuality = (shadowData.supportsSoftShadows) ? light.shadows : LightShadows.Hard;
-
-                    // In order to avoid shader variants explosion we only do hard shadows when sampling shadowmap in the lit pass.
-                    // GLES2 platform is forced to hard single cascade shadows.
-                    if (!shadowData.requiresScreenSpaceShadowResolve)
-                        shadowQuality = LightShadows.Hard;
-
-                    SetupDirectionalShadowReceiverConstants(ref context, cmd, ref shadowData, shadowLight);
+                    SetupDirectionalShadowReceiverConstants(cmd, ref shadowData, shadowLight);
                 }
             }
             context.ExecuteCommandBuffer(cmd);
             shadowData.renderedDirectionalShadowQuality = shadowQuality;
         }
 
-        void SetupDirectionalShadowReceiverConstants(ref ScriptableRenderContext context, CommandBuffer cmd, ref ShadowData shadowData, VisibleLight shadowLight)
+        void SetupDirectionalShadowReceiverConstants(CommandBuffer cmd, ref ShadowData shadowData, VisibleLight shadowLight)
         {
             Light light = shadowLight.light;
 

com.unity.render-pipelines.lightweight/LWRP/Passes/ForwardLitPass.cs

             CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.DirectionalShadows, directionalShadowQuality != LightShadows.None);
             CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.LocalShadows, localShadowQuality != LightShadows.None);
             CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.SoftShadows, hasSoftShadows);
+            CoreUtils.SetKeyword(cmd, LightweightKeywordStrings.CascadeShadows, shadowData.directionalLightCascadeCount > 1);
 
             // TODO: Remove this. legacy particles support will be removed from Unity in 2018.3. This should be a shader_feature instead with prop exposed in the Standard particles shader.
             CoreUtils.SetKeyword(cmd, "SOFTPARTICLES_ON", cameraData.requiresSoftParticles);

com.unity.render-pipelines.lightweight/LWRP/ShaderLibrary/Input.hlsl

 // Must match check of use compute buffer in LightweightPipeline.cs
 // GLES check here because of WebGL 1.0 support
 // TODO: check performance of using StructuredBuffer on mobile as well
-#if defined(SHADER_API_MOBILE) || defined(SHADER_API_GLES)
+#if defined(SHADER_API_MOBILE) || defined(SHADER_API_GLES) || defined(SHADER_API_GLCORE)
 #define USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA 0
 #else
 #define USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA 1
 float4 _ScaledScreenParams;
 CBUFFER_END
 
+#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
+#endif
 
 #define UNITY_MATRIX_M     unity_ObjectToWorld
 #define UNITY_MATRIX_I_M   unity_WorldToObject

com.unity.render-pipelines.lightweight/LWRP/ShaderLibrary/InputSurfacePBR.hlsl

 half SampleOcclusion(float2 uv)
 {
 #ifdef _OCCLUSIONMAP
-#if (SHADER_TARGET < 30)
-    // SM20: instruction count limitation
-    // SM20: simpler occlusion
+// TODO: Controls things like these by exposing SHADER_QUALITY levels (low, medium, high)
+#if defined(SHADER_API_GLES)
     return SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, uv).g;
 #else
     half occ = SAMPLE_TEXTURE2D(_OcclusionMap, sampler_OcclusionMap, uv).g;

com.unity.render-pipelines.lightweight/LWRP/ShaderLibrary/Lighting.hlsl

 // If lightmap is not defined than we evaluate GI (ambient + probes) from SH
 // We might do it fully or partially in vertex to save shader ALU
 #if !defined(LIGHTMAP_ON)
-    #if defined(SHADER_API_GLES) || (SHADER_TARGET < 30) || !defined(_NORMALMAP)
+// TODO: Controls things like these by exposing SHADER_QUALITY levels (low, medium, high)
+    #if defined(SHADER_API_GLES) || !defined(_NORMALMAP)
         // Evaluates SH fully in vertex
         #define EVALUATE_SH_VERTEX
     #elif !SHADER_HINT_NICE_QUALITY
 
 half ReflectivitySpecular(half3 specular)
 {
-#if (SHADER_TARGET < 30)
-    // SM2.0: instruction count limitation
+#if defined(SHADER_API_GLES)
     return specular.r; // Red channel - because most metals are either monocrhome or with redish/yellowish tint
 #else
     return max(max(specular.r, specular.g), specular.b);

com.unity.render-pipelines.lightweight/LWRP/ShaderLibrary/Shadows.hlsl

 #define MAX_SHADOW_CASCADES 4
 
 #ifndef SHADOWS_SCREEN
-#ifdef SHADER_API_GLES
-#define SHADOWS_SCREEN 0
-#else
+#if defined(_SHADOWS_ENABLED) && defined(_SHADOWS_CASCADE) && !defined(SHADER_API_GLES)
+#else
+#define SHADOWS_SCREEN 0
 #endif
 #endif
 
     half shadowStrength = GetMainLightShadowStrength();
     return SampleShadowmap(shadowCoord, TEXTURE2D_PARAM(_DirectionalShadowmapTexture, sampler_DirectionalShadowmapTexture), shadowSamplingData, shadowStrength);
 #endif
-
 }
 
 half LocalLightRealtimeShadowAttenuation(int lightIndex, float3 positionWS)

com.unity.render-pipelines.lightweight/LWRP/Shaders/LightweightScreenSpaceShadows.shader

 
         HLSLINCLUDE
 
+        // Note: Screenspace shadow resolve is only performed when shadow cascades are enabled
+        // Shadow cascades require cascade index and shadowCoord to be computed on pixel.
+        #define _SHADOWS_CASCADE
+
         #pragma prefer_hlslcc gles
         #pragma exclude_renderers d3d11_9x
         //Keep compiler quiet about Shadows.hlsl.
             float3 wpos = mul(unity_CameraToWorld, float4(vpos, 1)).xyz;
 
             //Fetch shadow coordinates for cascade.
-            float4 coords  = TransformWorldToShadowCoord(wpos);
+            float4 coords = TransformWorldToShadowCoord(wpos);
 
             // Screenspace shadowmap is only used for directional lights which use orthogonal projection.
             ShadowSamplingData shadowSamplingData = GetMainLightShadowSamplingData();
 
             HLSLPROGRAM
             #pragma multi_compile _ _SHADOWS_SOFT
-            #pragma multi_compile _ _SHADOWS_CASCADE
 
             #pragma vertex   Vertex
             #pragma fragment Fragment

com.unity.render-pipelines.lightweight/LWRP/Shaders/LightweightStandard.shader

             #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
             #pragma multi_compile _ _SHADOWS_SOFT
+            #pragma multi_compile _ _SHADOWS_CASCADE
 
             // -------------------------------------
             // Unity defined keywords

com.unity.render-pipelines.lightweight/LWRP/Shaders/LightweightStandardSimpleLighting.shader

             #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
             #pragma multi_compile _ _SHADOWS_SOFT
+            #pragma multi_compile _ _SHADOWS_CASCADE
 
             // -------------------------------------
             // Unity defined keywords

com.unity.render-pipelines.lightweight/LWRP/Shaders/Terrain/LightweightStandardTerrain.shader

             #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
             #pragma multi_compile _ _SHADOWS_SOFT
+            #pragma multi_compile _ _SHADOWS_CASCADE
 
             // -------------------------------------
             // Unity defined keywords

com.unity.render-pipelines.lightweight/LWRP/Shaders/Terrain/LightweightStandardTerrainAddPass.shader

             #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
             #pragma multi_compile _ _SHADOWS_SOFT
+            #pragma multi_compile _ _SHADOWS_CASCADE
 
             // -------------------------------------
             // Unity defined keywords

com.unity.render-pipelines.lightweight/LWRP/Shaders/Terrain/LightweightStandardTerrainBase.shader

             #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
             #pragma multi_compile _ _SHADOWS_SOFT
+            #pragma multi_compile _ _SHADOWS_CASCADE
 
             // -------------------------------------
             // Unity defined keywords

com.unity.render-pipelines.lightweight/LWRP/Shaders/Terrain/LightweightWavingGrass.shader

             #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
             #pragma multi_compile _ _SHADOWS_SOFT
+            #pragma multi_compile _ _SHADOWS_CASCADE
 
             // -------------------------------------
             // Unity defined keywords

com.unity.render-pipelines.lightweight/LWRP/Shaders/Terrain/LightweightWavingGrassBillboard.shader

             #pragma multi_compile _ _SHADOWS_ENABLED
             #pragma multi_compile _ _LOCAL_SHADOWS_ENABLED
             #pragma multi_compile _ _SHADOWS_SOFT
+            #pragma multi_compile _ _SHADOWS_CASCADE
 
             // -------------------------------------
             // Unity defined keywords

com.unity.shadergraph/Editor/Data/Util/GraphUtil.cs

             }
         }
 
-        public static System.Text.StringBuilder PreprocessShaderCode(string code, HashSet<string> activeFields, Dictionary<string, string> namedFragments = null, System.Text.StringBuilder result = null)
+        // returns the offset of the first non-whitespace character, in the range [start, end] inclusive ... will return end if none found
+        private static int SkipWhitespace(string str, int start, int end)
+        {
+            int index = start;
+
+            while (index < end)
+            {
+                char c = str[index];
+                if (!Char.IsWhiteSpace(c))
+                {
+                    break;
+                }
+                index++;
+            }
+            return index;
+        }
+
+        public static System.Text.StringBuilder PreprocessShaderCode(string code, HashSet<string> activeFields, Dictionary<string, string> namedFragments, System.Text.StringBuilder result, bool debugOutput)
+
+            bool skipEndln = false;
 
             while (cur < end)
             {
                 {
                     // found $ escape sequence
 
-                    // first append everything before the beginning of the escape sequence
-                    AppendSubstring(result, code, cur, true, dollar, false);
-
-                    // next find the end of the line (or if none found, the end of the code)
+                    // find the end of the line (or if none found, the end of the code)
                     int endln = code.IndexOf('\n', dollar + 1);
                     if (endln < 0)
                     {
                         int nameLength = curlyend - dollar + 1;
                         if ((curlyend < 0) || (nameLength <= 0))
                         {
-                            // no } found, or zero length name
+                            // no } found, or zero length name                            
+
+                            // append everything before the beginning of the escape sequence
+                            AppendSubstring(result, code, cur, true, dollar, false);
+
                             if (curlyend < 0)
                             {
                                 result.Append("// ERROR: unterminated escape sequence ('${' and '}' must be matched)\n");
                             // ugh, this probably allocates memory -- wish we could do the name lookup direct from a substring
                             string name = code.Substring(dollar, nameLength);
 
+                            // append everything before the beginning of the escape sequence
+                            AppendSubstring(result, code, cur, true, dollar, false);
+
                             string fragment;
                             if ((namedFragments != null) && namedFragments.TryGetValue(name, out fragment))
                             {
                         if ((colon < 0) || (predicateLength <= 0))
                         {
                             // no colon found... error!  Spit out error and context
+
+                            // append everything before the beginning of the escape sequence
+                            AppendSubstring(result, code, cur, true, dollar, false);
+
                             if (colon < 0)
                             {
                                 result.Append("// ERROR: unterminated escape sequence ('$' and ':' must be matched)\n");
                             // colon found!
                             // ugh, this probably allocates memory -- wish we could do the field lookup direct from a substring
                             string predicate = code.Substring(dollar + 1, predicateLength);
-
+                            int nonwhitespace = SkipWhitespace(code, colon + 1, endln);
+                                // append everything before the beginning of the escape sequence
+                                AppendSubstring(result, code, cur, true, dollar, false);
+
-                                result.Append(' ', predicateLength + 2);
-                                AppendSubstring(result, code, colon, false, endln, false);
+                                AppendSubstring(result, code, nonwhitespace, true, endln, false);
-                                // predicate is not active -- comment out line
-                                result.Append("//");
-                                result.Append(' ', predicateLength);
-                                AppendSubstring(result, code, colon, false, endln, false);
+                                // predicate is not active
+                                if (debugOutput)
+                                {
+                                    // append everything before the beginning of the escape sequence
+                                    AppendSubstring(result, code, cur, true, dollar, false);
+                                    result.Append("// ");
+                                    AppendSubstring(result, code, nonwhitespace, true, endln, false);
+                                }
+                                else
+                                {
+                                    skipEndln = true;
+                                }
+            }
+
+            if (!skipEndln)
+            {
+                result.AppendLine();
             }
 
             return result;

com.unity.shadergraph/Editor/Drawing/Blackboard/BlackboardFieldPropertyView.cs

             m_Graph = graph;
             m_Property = property;
 
-            m_ExposedToogle = new Toggle(() =>
-                {
-                    property.generatePropertyBlock = m_ExposedToogle.value;
-                    DirtyNodes(ModificationScope.Graph);
-                });
+            m_ExposedToogle = new Toggle();
+            m_ExposedToogle.OnToggleChanged(evt =>
+            {
+                property.generatePropertyBlock = evt.newValue;
+                DirtyNodes(ModificationScope.Graph);
+            });
             m_ExposedToogle.value = property.generatePropertyBlock;
             AddRow("Exposed", m_ExposedToogle);
 
             else if (property is BooleanShaderProperty)
             {
                 var booleanProperty = (BooleanShaderProperty)property;
-                Action onBooleanChanged = () =>
+                EventCallback<ChangeEvent<bool>> onBooleanChanged = evt =>
-                        booleanProperty.value = !booleanProperty.value;
+                        booleanProperty.value = evt.newValue;
-                var field = new Toggle(onBooleanChanged);
+                var field = new Toggle();
+                field.OnToggleChanged(onBooleanChanged);
                 field.value = booleanProperty.value;
                 AddRow("Default", field);
             }

com.unity.shadergraph/Editor/Drawing/Controls/ToggleControl.cs

             var panel = new VisualElement { name = "togglePanel" };
             if (!string.IsNullOrEmpty(label))
                 panel.Add(new Label(label));
-            Action changedToggle = () => { OnChangeToggle(); };
-            m_Toggle = new UnityEngine.Experimental.UIElements.Toggle(changedToggle);
+            m_Toggle = new Toggle();
+            m_Toggle.OnToggleChanged(OnChangeToggle);
             m_Toggle.SetEnabled(value.isEnabled);
             m_Toggle.value = value.isOn;
             panel.Add(m_Toggle);
             }
         }
 
-        void OnChangeToggle()
+        void OnChangeToggle(ChangeEvent<bool> evt)
-            value.isOn = !value.isOn;
+            value.isOn = evt.newValue;
             m_PropertyInfo.SetValue(m_Node, value, null);
             this.MarkDirtyRepaint();
         }

com.unity.shadergraph/Editor/Drawing/Views/PBRSettingsView.cs

 
             ps.Add(new PropertyRow(new Label("Two Sided")), (row) =>
                 {
-                    row.Add(new Toggle(null), (toggle) =>
+                    row.Add(new Toggle(), (toggle) =>
-                        toggle.OnToggle(ChangeTwoSided);
+                        toggle.OnToggleChanged(ChangeTwoSided);
                     });
                 });
 
             m_Node.alphaMode = (AlphaMode)evt.newValue;
         }
 
-        void ChangeTwoSided()
+        void ChangeTwoSided(ChangeEvent<bool> evt)
-            td.isOn ^= true;
+            td.isOn = evt.newValue;
             m_Node.twoSided = td;
         }
     }

com.unity.shadergraph/Editor/Drawing/Views/Slots/BooleanSlotControlView.cs

         {
             AddStyleSheetPath("Styles/Controls/BooleanSlotControlView");
             m_Slot = slot;
-            Action changedToggle = () => { OnChangeToggle(); };
-            var toggleField = new UnityEngine.Experimental.UIElements.Toggle(changedToggle);
+            var toggleField = new Toggle();
+            toggleField.OnToggleChanged(OnChangeToggle);
-        void OnChangeToggle()
+        void OnChangeToggle(ChangeEvent<bool> evt)
-            value = !value;
+            value = evt.newValue;
             m_Slot.value = value;
             m_Slot.owner.Dirty(ModificationScope.Node);
         }

com.unity.shadergraph/Editor/Drawing/Views/UnlitSettingsView.cs

 
             ps.Add(new PropertyRow(new Label("Two Sided")), (row) =>
                 {
-                    row.Add(new Toggle(null), (toggle) =>
+                    row.Add(new Toggle(), (toggle) =>
-                        toggle.OnToggle(ChangeTwoSided);
+                        toggle.OnToggleChanged(ChangeTwoSided);
                     });
                 });
 
             m_Node.alphaMode = (AlphaMode)evt.newValue;
         }
 
-        void ChangeTwoSided()
+        void ChangeTwoSided(ChangeEvent<bool> evt)
-            td.isOn ^= true;
+            td.isOn = evt.newValue;
             m_Node.twoSided = td;
         }
     }

com.unity.shadergraph/Editor/Util/CompatibilityExtensions.cs

             element.ReleaseMouseCapture();
         }
 #endif
+
+        public static void OnToggleChanged(this Toggle toggle, EventCallback<ChangeEvent<bool>> callback)
+        {
+#if UNITY_2018_3_OR_NEWER
+            toggle.OnValueChanged(callback);
+#else
+            toggle.OnToggle(() => callback(ChangeEvent<bool>.GetPooled(!toggle.value, toggle.value)));
+#endif
+        }
     }
 
     static class TrickleDownEnum

com.unity.render-pipelines.high-definition/HDRP/Material/MaterialEvaluation.hlsl

+// This files include various function uses to evaluate material
+
+//-----------------------------------------------------------------------------
+// Lighting structure for light accumulation
+//-----------------------------------------------------------------------------
+
+// These structure allow to accumulate lighting accross the Lit material
+// AggregateLighting is init to zero and transfer to EvaluateBSDF, but the LightLoop can't access its content.
+struct DirectLighting
+{
+    float3 diffuse;
+    float3 specular;
+};
+
+struct IndirectLighting
+{
+    float3 specularReflected;
+    float3 specularTransmitted;
+};
+
+struct AggregateLighting
+{
+    DirectLighting   direct;
+    IndirectLighting indirect;
+};
+
+void AccumulateDirectLighting(DirectLighting src, inout AggregateLighting dst)
+{
+    dst.direct.diffuse += src.diffuse;
+    dst.direct.specular += src.specular;
+}
+
+void AccumulateIndirectLighting(IndirectLighting src, inout AggregateLighting dst)
+{
+    dst.indirect.specularReflected += src.specularReflected;
+    dst.indirect.specularTransmitted += src.specularTransmitted;
+}
+
+//-----------------------------------------------------------------------------
+// Ambient occlusion helper
+//-----------------------------------------------------------------------------
+
+// Ambient occlusion
+struct AmbientOcclusionFactor
+{
+    float3 indirectAmbientOcclusion;
+    float3 directAmbientOcclusion;
+    float3 indirectSpecularOcclusion;
+};
+
+void GetScreenSpaceAmbientOcclusion(float2 positionSS, float NdotV, float perceptualRoughness, float ambientOcclusionFromData, float specularOcclusionFromData, out AmbientOcclusionFactor aoFactor)
+{
+    // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
+    // We use this property to have a neutral value for AO that doesn't consume a sampler and work also with compute shader (i.e use ImageLoad)
+    // We store inverse AO so neutral is black. So either we sample inside or outside the texture it return 0 in case of neutral
+
+    // Ambient occlusion use for indirect lighting (reflection probe, baked diffuse lighting)
+#ifndef _SURFACE_TYPE_TRANSPARENT
+    float indirectAmbientOcclusion = 1.0 - LOAD_TEXTURE2D(_AmbientOcclusionTexture, positionSS).x;
+    // Ambient occlusion use for direct lighting (directional, punctual, area)
+    float directAmbientOcclusion = lerp(1.0, indirectAmbientOcclusion, _AmbientOcclusionParam.w);
+#else
+    float indirectAmbientOcclusion = 1.0;
+    float directAmbientOcclusion = 1.0;
+#endif
+
+    float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+    float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(NdotV), indirectAmbientOcclusion, roughness);
+
+    aoFactor.indirectSpecularOcclusion = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), min(specularOcclusionFromData, specularOcclusion));
+    aoFactor.indirectAmbientOcclusion = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), min(ambientOcclusionFromData, indirectAmbientOcclusion));
+    aoFactor.directAmbientOcclusion = lerp(_AmbientOcclusionParam.rgb, float3(1.0, 1.0, 1.0), directAmbientOcclusion);
+}
+
+void GetScreenSpaceAmbientOcclusionMultibounce(float2 positionSS, float NdotV, float perceptualRoughness, float ambientOcclusionFromData, float specularOcclusionFromData, float3 diffuseColor, float3 fresnel0, out AmbientOcclusionFactor aoFactor)
+{
+    // Use GTAOMultiBounce approximation for ambient occlusion (allow to get a tint from the diffuseColor)
+    // Note: When we ImageLoad outside of texture size, the value returned by Load is 0 (Note: On Metal maybe it clamp to value of texture which is also fine)
+    // We use this property to have a neutral value for AO that doesn't consume a sampler and work also with compute shader (i.e use ImageLoad)
+    // We store inverse AO so neutral is black. So either we sample inside or outside the texture it return 0 in case of neutral
+
+    // Ambient occlusion use for indirect lighting (reflection probe, baked diffuse lighting)
+#ifndef _SURFACE_TYPE_TRANSPARENT
+    float indirectAmbientOcclusion = 1.0 - LOAD_TEXTURE2D(_AmbientOcclusionTexture, positionSS).x;
+    // Ambient occlusion use for direct lighting (directional, punctual, area)
+    float directAmbientOcclusion = lerp(1.0, indirectAmbientOcclusion, _AmbientOcclusionParam.w);
+#else
+    float indirectAmbientOcclusion = 1.0;
+    float directAmbientOcclusion = 1.0;
+#endif
+
+    float roughness = PerceptualRoughnessToRoughness(perceptualRoughness);
+    float specularOcclusion = GetSpecularOcclusionFromAmbientOcclusion(ClampNdotV(NdotV), indirectAmbientOcclusion, roughness);
+
+    aoFactor.indirectSpecularOcclusion = GTAOMultiBounce(min(specularOcclusionFromData, specularOcclusion), fresnel0);
+    aoFactor.indirectAmbientOcclusion = GTAOMultiBounce(min(ambientOcclusionFromData, indirectAmbientOcclusion), diffuseColor);
+    aoFactor.directAmbientOcclusion = GTAOMultiBounce(directAmbientOcclusion, diffuseColor);
+}
+
+void ApplyAmbientOcclusionFactor(AmbientOcclusionFactor aoFactor, inout BakeLightingData bakeLightingData, inout AggregateLighting lighting)
+{
+    // Note: in case of Lit, bakeLightingData.bakeDiffuseLighting contain indirect diffuse + emissive,
+    // so Ambient occlusion is multiply by emissive which is wrong but not a big deal
+    bakeLightingData.bakeDiffuseLighting *= aoFactor.indirectAmbientOcclusion;
+    lighting.indirect.specularReflected *= aoFactor.indirectSpecularOcclusion;
+    lighting.direct.diffuse *= aoFactor.directAmbientOcclusion;
+}
+
+#ifdef DEBUG_DISPLAY
+// mipmapColor is color use to store texture streaming information in XXXData.hlsl (look for DEBUGMIPMAPMODE_NONE)
+void PostEvaluateBSDFDebugDisplay(  AmbientOcclusionFactor aoFactor, BakeLightingData bakeLightingData, AggregateLighting lighting, float3 mipmapColor,
+                                    inout float3 diffuseLighting, inout float3 specularLighting)
+{
+    if (_DebugLightingMode != 0)
+    {
+        // Caution: _DebugLightingMode is used in other part of the code, don't do anything outside of
+        // current cases
+        switch (_DebugLightingMode)
+        {
+        case DEBUGLIGHTINGMODE_LUX_METER:
+            diffuseLighting = lighting.direct.diffuse + bakeLightingData.bakeDiffuseLighting;
+
+            //Compress lighting values for color picker if enabled
+            if (_ColorPickerMode != COLORPICKERDEBUGMODE_NONE)
+                diffuseLighting = diffuseLighting / LUXMETER_COMPRESSION_RATIO;
+            
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            break;
+
+        case DEBUGLIGHTINGMODE_INDIRECT_DIFFUSE_OCCLUSION:
+            diffuseLighting = aoFactor.indirectAmbientOcclusion;
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            break;
+
+        case DEBUGLIGHTINGMODE_INDIRECT_SPECULAR_OCCLUSION:
+            diffuseLighting = aoFactor.indirectSpecularOcclusion;
+            specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+            break;
+
+        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFRACTION:
+            if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
+                diffuseLighting = lighting.indirect.specularTransmitted;
+            break;
+
+        case DEBUGLIGHTINGMODE_SCREEN_SPACE_TRACING_REFLECTION:
+            if (_DebugLightingSubMode != DEBUGSCREENSPACETRACING_COLOR)
+                diffuseLighting = lighting.indirect.specularReflected;
+            break;
+
+        case DEBUGLIGHTINGMODE_VISUALIZE_SHADOW_MASKS:
+            #ifdef SHADOWS_SHADOWMASK
+            diffuseLighting = float3(
+                bakeLightingData.bakeShadowMask.r / 2 + bakeLightingData.bakeShadowMask.g / 2,
+                bakeLightingData.bakeShadowMask.g / 2 + bakeLightingData.bakeShadowMask.b / 2,
+                bakeLightingData.bakeShadowMask.b / 2 + bakeLightingData.bakeShadowMask.a / 2
+            );
+            specularLighting = float3(0, 0, 0);
+            #endif
+            break ;
+        }
+    }
+    else if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)
+    {
+        diffuseLighting = mipmapColor;
+        specularLighting = float3(0.0, 0.0, 0.0); // Disable specular lighting
+    }
+}
+#endif

com.unity.render-pipelines.high-definition/HDRP/Material/MaterialEvaluation.hlsl.meta

+fileFormatVersion: 2
+guid: 3c80046db57367445b2a7c154c18879e
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/PreIntegratedFGD/preIntegratedFGD_CharlieClothLambert.shader.meta

+fileFormatVersion: 2
+guid: 3b3bf235775cf8b4baae7f3306787ab0
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

com.unity.render-pipelines.high-definition/HDRP/Material/PreIntegratedFGD/preIntegratedFGD_GGXDisneyDiffuse.shader

+Shader "Hidden/HDRenderPipeline/preIntegratedFGD_GGXDisneyDiffuse"
+{
+    SubShader
+    {
+        Tags{ "RenderPipeline" = "HDRenderPipeline" }
+        Pass
+        {
+            ZTest Always Cull Off ZWrite Off
+
+            HLSLPROGRAM
+            #pragma vertex Vert
+            #pragma fragment Frag
+            #pragma target 4.5
+            #pragma only_renderers d3d11 ps4 xboxone vulkan metal switch
+
+            #include "CoreRP/ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
+            #include "../../ShaderVariables.hlsl"
+
+            struct Attributes
+            {
+                uint vertexID : SV_VertexID;
+            };
+
+            struct Varyings
+            {
+                float4 positionCS : SV_POSITION;
+                float2 texCoord   : TEXCOORD0;
+            };
+
+            Varyings Vert(Attributes input)
+            {
+                Varyings output;
+
+                output.positionCS = GetFullScreenTriangleVertexPosition(input.vertexID);
+                output.texCoord   = GetFullScreenTriangleTexCoord(input.vertexID);
+
+                return output;
+            }
+
+            float4 Frag(Varyings input) : SV_Target
+            {
+                // These coordinate sampling must match the decoding in GetPreIntegratedDFG in lit.hlsl, i.e here we use perceptualRoughness, must be the same in shader
+                float NdotV                 = input.texCoord.x;
+                float perceptualRoughness   = input.texCoord.y;
+                float3 V                    = float3(sqrt(1 - NdotV * NdotV), 0, NdotV);
+                float3 N                    = float3(0.0, 0.0, 1.0);
+
+                // Pre integrate GGX with smithJoint visibility as well as DisneyDiffuse
+                float4 preFGD = IntegrateGGXAndDisneyDiffuseFGD(V, N, PerceptualRoughnessToRoughness(perceptualRoughness));
+
+                return float4(preFGD.xyz, 1.0);
+            }
+
+            ENDHLSL
+        }
+    }
+    Fallback Off
+}