Merge branch 'master' into feature/PlanarReflection

.gitignore

 *.aspx
 *.sdf
 *.userprefs
+*.npmrc

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Common.hlsl

     return faceID;
 }
 #endif // INTRINSIC_CUBEMAP_FACE_ID
+
+// Intrinsic isnan can't be used because it require /Gic to be enabled on fxc that we can't do. So use IsNAN instead
+bool IsNAN(float n)
+{
+    return (n < 0.0 || n > 0.0 || n == 0.0) ? false : true;
+}
+
+bool IsNAN(float2 v)
+{
+    return (IsNAN(v.x) || IsNAN(v.y)) ? true : false;
+}
+
+bool IsNAN(float3 v)
+{
+    return (IsNAN(v.x) || IsNAN(v.y) || IsNAN(v.z)) ? true : false;
+}
+
+bool IsNAN(float4 v)
+{
+    return (IsNAN(v.x) || IsNAN(v.y) || IsNAN(v.z) || IsNAN(v.w)) ? true : false;
+}
 
 // ----------------------------------------------------------------------------
 // Common math functions

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Debug.hlsl

     else if (index == 8)
         outColor = real3(0.75, 1.0, 0.25);
     else if (index == 9)
-        outColor = real3(0.75, 0.25, 1.0);
+        outColor = real3(0.75, 0.25, 1.0);
-        outColor = real3(0.25, 1.0, 0.75);
+        outColor = real3(0.25, 1.0, 0.75);
-        outColor = real3(0.75, 0.75, 0.25);
+        outColor = real3(0.75, 0.75, 0.25);
-        outColor = real3(0.75, 0.25, 0.75);
+        outColor = real3(0.75, 0.25, 0.75);
-        outColor = real3(0.25, 0.75, 0.75);
+        outColor = real3(0.25, 0.75, 0.75);
-        outColor = real3(0.25, 0.25, 0.75);
+        outColor = real3(0.25, 0.25, 0.75);
     else if (index == 15)
         outColor = real3(0.75, 0.25, 0.25);
 

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/Packing.hlsl

 }
 
 // Define various variante for ease of read
-real PackFloatUInt8bit(real f, uint i, real maxi)
+real PackFloatInt8bit(real f, uint i, real maxi)
-void UnpackFloatUInt8bit(real val, real maxi, out real f, out uint i)
+void UnpackFloatInt8bit(real val, real maxi, out real f, out uint i)
-real PackFloatUInt10bit(real f, uint i, real maxi)
+real PackFloatInt10bit(real f, uint i, real maxi)
-void UnpackFloatUInt10bit(real val, real maxi, out real f, out uint i)
+void UnpackFloatInt10bit(real val, real maxi, out real f, out uint i)
-real PackFloatUInt16bit(real f, uint i, real maxi)
+real PackFloatInt16bit(real f, uint i, real maxi)
-void UnpackFloatUInt16bit(real val, real maxi, out real f, out uint i)
+void UnpackFloatInt16bit(real val, real maxi, out real f, out uint i)
 {
     UnpackFloatInt(val, maxi, 65536.0, f, i);
 }

ScriptableRenderPipeline/Core/CoreRP/ShaderLibrary/VolumeRendering.hlsl

     return INV_FOUR_PI * (1 - g * g);
 }
 
-real HenyeyGreensteinPhasePartVarying(real asymmetry, real LdotD)
+real HenyeyGreensteinPhasePartVarying(real asymmetry, real cosTheta)
-    return pow(abs(1 + g * g - 2 * g * LdotD), -1.5);
+    return pow(abs(1 + g * g - 2 * g * cosTheta), -1.5);
-real HenyeyGreensteinPhaseFunction(real asymmetry, real LdotD)
+real HenyeyGreensteinPhaseFunction(real asymmetry, real cosTheta)
-           HenyeyGreensteinPhasePartVarying(asymmetry, LdotD);
+           HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+}
+
+real CornetteShanksPhasePartConstant(real asymmetry)
+{
+    real g = asymmetry;
+
+    return INV_FOUR_PI * 1.5 * (1 - g * g) / (2 + g * g);
+}
+
+real CornetteShanksPhasePartVarying(real asymmetry, real cosTheta)
+{
+    real g = asymmetry;
+
+    return (1 + cosTheta * cosTheta) * pow(abs(1 + g * g - 2 * g * cosTheta), -1.5);
+}
+
+// A better approximation of the Mie phase function.
+// Ref: Henyey–Greenstein and Mie phase functions in Monte Carlo radiative transfer computations
+real CornetteShanksPhaseFunction(real asymmetry, real cosTheta)
+{
+    return CornetteShanksPhasePartConstant(asymmetry) *
+           CornetteShanksPhasePartVarying(asymmetry, cosTheta);
 }
 
 // Samples the interval of homogeneous participating medium using the closed-form tracking approach

ScriptableRenderPipeline/Core/package.json

 {
     "name": "com.unity.render-pipelines.core",
     "description": "Core library for Unity render pipelines.",
-    "version": "0.1.25",
+    "version": "0.1.26",
     "unity": "2018.1",
     "dependencies": {
         "com.unity.postprocessing": "0.1.7"

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

             renderTextureDesc = tempDesc;
         }
 
+        // Warning: different views can use the same camera!
+        public int GetViewID()
+        {
+            if (camera.cameraType == CameraType.Game)
+            {
+                int viewID = camera.GetInstanceID();
+                Debug.Assert(viewID > 0);
+                return viewID;
+            }
+            else
+            {
+                return 0;
+            }
+        }
+
         public void Reset()
         {
             m_LastFrameActive = -1;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugColorPicker.shader

             int _ColorPickerMode;
             float3 _ColorPickerFontColor;
             float _ApplyLinearToSRGB;
+            float _RequireToFlipInputTexture;
 
             struct Attributes
             {
                 return output;
             }
 
-            float4 DisplayPixelInformationAtMousePosition(Varyings input, float4 result, float4 mouseResult)
+            float4 DisplayPixelInformationAtMousePosition(Varyings input, float4 result, float4 mouseResult, float4 mousePixelCoord)
-                if (_MousePixelCoord.z >= 0.0 && _MousePixelCoord.z <= 1.0 && _MousePixelCoord.w >= 0 && _MousePixelCoord.w <= 1.0)
+                bool flipY = _RequireToFlipInputTexture > 0.0;
+
+                if (mousePixelCoord.z >= 0.0 && mousePixelCoord.z <= 1.0 && mousePixelCoord.w >= 0 && mousePixelCoord.w <= 1.0)
                 {
                     // As when we read with the color picker we don't go through the final blit (that current hardcode a conversion to sRGB)
                     // and as our material debug take it into account, we need to a transform here.
 
                     // Display message offset:
                     int displayTextOffsetX = 1.5 * DEBUG_FONT_TEXT_WIDTH;
-                    #if UNITY_UV_STARTS_AT_TOP
-                    int displayTextOffsetY = -DEBUG_FONT_TEXT_HEIGHT;
-                    #else
-                    int displayTextOffsetY = DEBUG_FONT_TEXT_HEIGHT;
-                    #endif
+                    int displayTextOffsetY;
+                    if (flipY)
+                    {
+                        displayTextOffsetY = DEBUG_FONT_TEXT_HEIGHT;
+                    }
+                    else
+                    {
+                        displayTextOffsetY = -DEBUG_FONT_TEXT_HEIGHT;
+                    }
-                    uint2 displayUnormCoord = uint2(_MousePixelCoord.x + displayTextOffsetX, _MousePixelCoord.y + displayTextOffsetY);
+                    uint2 displayUnormCoord = uint2(mousePixelCoord.x + displayTextOffsetX, mousePixelCoord.y + displayTextOffsetY);
                     uint2 unormCoord = input.positionCS.xy;
 
                     if (_ColorPickerMode == COLORPICKERDEBUGMODE_BYTE || _ColorPickerMode == COLORPICKERDEBUGMODE_BYTE4)
-                        DrawCharacter('R', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                        DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                        DrawInteger(mouseValue.x, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                        DrawCharacter('R', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                        DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                        DrawInteger(mouseValue.x, _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
-                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            displayUnormCoord.x = mousePixelCoord.x + displayTextOffsetX;
-                            DrawCharacter('G', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawInteger(mouseValue.y, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            DrawCharacter('G', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawInteger(mouseValue.y, _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            displayUnormCoord.x = mousePixelCoord.x + displayTextOffsetX;
-                            DrawCharacter('B', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawInteger(mouseValue.z, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            DrawCharacter('B', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawInteger(mouseValue.z, _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            displayUnormCoord.x = mousePixelCoord.x + displayTextOffsetX;
-                            DrawCharacter('A', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawInteger(mouseValue.w, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                            DrawCharacter('A', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawInteger(mouseValue.w, _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
-                        DrawCharacter('X', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                        DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                        DrawFloat(mouseResult.x, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                        DrawCharacter('X', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                        DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                        DrawFloat(mouseResult.x, _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
-                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            displayUnormCoord.x = mousePixelCoord.x + displayTextOffsetX;
-                            DrawCharacter('Y', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawFloat(mouseResult.y, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            DrawCharacter('Y', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawFloat(mouseResult.y, _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            displayUnormCoord.x = mousePixelCoord.x + displayTextOffsetX;
-                            DrawCharacter('Z', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawFloat(mouseResult.z, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            displayUnormCoord.x = _MousePixelCoord.x + displayTextOffsetX;
+                            DrawCharacter('Z', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawFloat(mouseResult.z, _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            displayUnormCoord.x = mousePixelCoord.x + displayTextOffsetX;
-                            DrawCharacter('W', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
-                            DrawFloat(mouseResult.w, _ColorPickerFontColor, unormCoord, displayUnormCoord, result.rgb);
+                            DrawCharacter('W', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawCharacter(':', _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
+                            DrawFloat(mouseResult.w, _ColorPickerFontColor, unormCoord, displayUnormCoord, flipY, result.rgb);
                         }
                     }
                 }
 
             float4 Frag(Varyings input) : SV_Target
             {
+                if (_RequireToFlipInputTexture > 0.0)
+                {
+                    input.texcoord.y = 1.0 - input.texcoord.y;
+                }
+
-                float4 mouseResult = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, _MousePixelCoord.zw);
+
+                float4 mousePixelCoord = _MousePixelCoord;
+                if (_RequireToFlipInputTexture > 0.0)
+                {
+                    mousePixelCoord.y = _ScreenParams.y - mousePixelCoord.y;
+                    // Note: We must not flip the mousePixelCoord.w coordinate
+                }
-                return DisplayPixelInformationAtMousePosition(input, result, mouseResult);
+                float4 mouseResult = SAMPLE_TEXTURE2D(_DebugColorPickerTexture, sampler_DebugColorPickerTexture, mousePixelCoord.zw);
+
+                float4 finalResult = DisplayPixelInformationAtMousePosition(input, result, mouseResult, mousePixelCoord);
+                return finalResult;
             }
 
             ENDHLSL

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugDisplay.hlsl

 // color is current screen color
 // color of the font to use
 // direction is 1 or -1 and indicate fixedUnormCoord block shift
-void DrawCharacter(uint asciiValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, inout float3 color, int direction)
+void DrawCharacter(uint asciiValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, bool flipY, inout float3 color, int direction)
-        #if UNITY_UV_STARTS_AT_TOP
-        localCharCoord.y = DEBUG_FONT_TEXT_HEIGHT - localCharCoord.y;
-        #endif
+        if (!flipY)
+            localCharCoord.y = DEBUG_FONT_TEXT_HEIGHT - localCharCoord.y;
 
         asciiValue -= DEBUG_FONT_TEXT_ASCII_START; // Our font start at ASCII table 32;
         uint2 asciiCoord = uint2(asciiValue % DEBUG_FONT_TEXT_COUNT_X, asciiValue / DEBUG_FONT_TEXT_COUNT_X);
 }
 
 // Shortcut to not have to file direction
-void DrawCharacter(uint asciiValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, inout float3 color)
+void DrawCharacter(uint asciiValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, bool flipY, inout float3 color)
-    DrawCharacter(asciiValue, fontColor, currentUnormCoord, fixedUnormCoord, color, 1);
+    DrawCharacter(asciiValue, fontColor, currentUnormCoord, fixedUnormCoord, flipY, color, 1);
-void DrawInteger(int intValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, inout float3 color)
+void DrawInteger(int intValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, bool flipY, inout float3 color)
 {
     const uint maxStringSize = 16;
 
     for (uint i = 0; i < maxStringSize; ++i)
     {
         // Numeric value incurrent font start on the second row at 0
-        DrawCharacter((absIntValue % 10) + '0', fontColor, currentUnormCoord, fixedUnormCoord, color, -1);
+        DrawCharacter((absIntValue % 10) + '0', fontColor, currentUnormCoord, fixedUnormCoord, flipY, color, -1);
         if (absIntValue  < 10)
             break;
         absIntValue /= 10;
     if (intValue < 0)
     {
-        DrawCharacter('-', fontColor, currentUnormCoord, fixedUnormCoord, color, -1);
+        DrawCharacter('-', fontColor, currentUnormCoord, fixedUnormCoord, flipY, color, -1);
     }
 
     // 5. Reset cursor at end location
-void DrawFloat(float floatValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, inout float3 color)
+void DrawFloat(float floatValue, float3 fontColor, uint2 currentUnormCoord, inout uint2 fixedUnormCoord, bool flipY, inout float3 color)
-    DrawInteger(intValue, fontColor, currentUnormCoord, fixedUnormCoord, color);
-    DrawCharacter('.', fontColor, currentUnormCoord, fixedUnormCoord, color);
+    DrawInteger(intValue, fontColor, currentUnormCoord, fixedUnormCoord, flipY, color);
+    DrawCharacter('.', fontColor, currentUnormCoord, fixedUnormCoord, flipY, color);
-    DrawInteger(fracValue, fontColor, currentUnormCoord, fixedUnormCoord, color);
+    DrawInteger(fracValue, fontColor, currentUnormCoord, fixedUnormCoord, flipY, color);
 }
 
 #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Debug/DebugFullScreen.shader

             #pragma fragment Frag
 
             #include "CoreRP/ShaderLibrary/Common.hlsl"
+            #include "CoreRP/ShaderLibrary/Color.hlsl"
             #include "../ShaderVariables.hlsl"
             #include "../Debug/DebugDisplay.cs.hlsl"
 
+            float _RequireToFlipInputTexture;
 
             struct Attributes
             {
             }
 
             // Motion vector debug utilities
-            // >>>
             float DistanceToLine(float2 p, float2 p1, float2 p2)
             {
                 float2 center = (p1 + p2) * 0.5;
 
             float2 SampleMotionVectors(float2 coords)
             {
-            #if UNITY_UV_STARTS_AT_TOP
-                coords.y = 1.0 - coords.y;
-            #endif
-
-                float2 mv = SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, coords).xy;
-
-            #if UNITY_UV_STARTS_AT_TOP
-                mv.y *= -1.0;
-            #endif
-
-                return mv;
+                return SAMPLE_TEXTURE2D(_DebugFullScreenTexture, sampler_DebugFullScreenTexture, coords).xy;
-            // <<<
+            // end motion vector utilties
+                if (_RequireToFlipInputTexture > 0.0)
+                {
+                    input.texcoord.y = 1.0 - input.texcoord.y;
+                }
+
                 // SSAO
                 if (_FullScreenDebugMode == FULLSCREENDEBUGMODE_SSAO)
                 {
                 {
-                    #if UNITY_UV_STARTS_AT_TOP
-                    input.texcoord.y = 1.0 - input.texcoord.y;
-                    #endif
-
-
-                    if (any(isnan(color)) || any(isinf(color)))
+                    
+                    if (IsNAN(color) || any(isinf(color)))
-                        color = float4(1.0, 0.0, 1.0, 1.0);
+                        color = float4(1.0, 0.0, 0.0, 1.0);
-                        // Dim the color buffer so we can see NaNs & Infs better
-                        color.rgb *= 0.25;
+                        color.rgb = Luminance(color.rgb).xxx;
                     }
 
                     return color;
                     float rows = floor(kGrid * _ScreenParams.y / _ScreenParams.x);
                     float cols = kGrid;
                     float2 size = _ScreenParams.xy / float2(cols, rows);
-                    float body = min(size.x, size.y) / 1.4142135623730951; // sqrt(2)
+                    float body = min(size.x, size.y) / sqrt(2.0);
                     float2 texcoord = input.positionCS.xy;
                     float2 center = (floor(texcoord / size) + 0.5) * size;
                     texcoord -= center;
+
+                    if (_RequireToFlipInputTexture > 0.0)
+                    {
+                        arrow_coord.y = 1.0 - arrow_coord.y;
+                    }
+
+
+                    if (_RequireToFlipInputTexture == 0.0)
+                    {
+                        mv_arrow.y *= -1;
+                    }
 
                     // Skip empty motion
                     float d = 0.0;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalProjectorComponent.cs

 using System;
 using UnityEditor;
 using UnityEngine;
+using UnityEngine.Rendering;
 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
         public Material m_Material = null;
         private Material m_OldMaterial = null;
-        public const int kInvalidIndex = -1;
+        public const int kInvalidIndex = -1;  
         private int m_CullIndex = kInvalidIndex;
 
         public int CullIndex
             }
         }
 
+        public Material Mat
+        {
+            get { return this.m_Material; }
+        }
+
+            if (m_Material == null)
+            {
+                var hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
+                m_Material = hdrp != null ? hdrp.GetDefaultDecalMaterial() : null;
+            }
+
             DecalSystem.instance.AddDecal(this);
         }
 
             DecalSystem.instance.UpdateBoundingSphere(this);
         }
 
+        public void OnDrawGizmos()
+        {
+            DrawGizmo(false);
+        }
+
-
-            if (!m_Material.GetTexture("_BaseColorMap") && !m_Material.GetTexture("_NormalMap") &&
-                !m_Material.GetTexture("_MaskMap"))
-                return false;
-
             return true;
         }
     }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalProjectorComponent.cs.meta

   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
-  icon: {instanceID: 0}
+  icon: {fileID: 2800000, guid: b057b73ec5a603e4aa80ccf4b34db0d3, type: 3}
   userData: 
   assetBundleName: 
   assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs

             }
         }
 
+        private static readonly int m_NormalToWorldID = Shader.PropertyToID("normalToWorld");
+        private static MaterialPropertyBlock m_PropertyBlock = new MaterialPropertyBlock();
+
         private const int kDecalBlockSize = 128;
 
         // to work on Vulkan Mobile?
 
         static public Mesh m_DecalMesh = null;
         static public Matrix4x4[] m_InstanceMatrices = new Matrix4x4[kDrawIndexedBatchSize];
+        static public Matrix4x4[] m_InstanceNormalToWorld = new Matrix4x4[kDrawIndexedBatchSize];
 
         private Dictionary<int, DecalSet> m_DecalSets = new Dictionary<int, DecalSet>();
 
             public void UpdateBoundingSphere(DecalProjectorComponent decal)
             {
                 m_CachedTransforms[decal.CullIndex] = decal.transform.localToWorldMatrix;
+
+                Matrix4x4 decalRotation = Matrix4x4.Rotate(decal.transform.rotation);
+                // z/y axis swap for normal to decal space, Unity is column major
+				float y0 = decalRotation.m01;
+				float y1 = decalRotation.m11;
+				float y2 = decalRotation.m21;
+				decalRotation.m01 = decalRotation.m02;
+				decalRotation.m11 = decalRotation.m12;
+				decalRotation.m21 = decalRotation.m22;
+				decalRotation.m02 = y0;
+				decalRotation.m12 = y1;
+				decalRotation.m22 = y2;
+                m_CachedNormalToWorld[decal.CullIndex] = decalRotation;
+
                 m_BoundingSpheres[decal.CullIndex] = GetDecalProjectBoundingSphere(m_CachedTransforms[decal.CullIndex]);
             }
 
                     DecalProjectorComponent[] newDecals = new DecalProjectorComponent[m_DecalsCount + kDecalBlockSize];
                     BoundingSphere[] newSpheres = new BoundingSphere[m_DecalsCount + kDecalBlockSize];
                     Matrix4x4[] newCachedTransforms = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
+                    Matrix4x4[] newCachedNormalToWorld = new Matrix4x4[m_DecalsCount + kDecalBlockSize];
+                    m_CachedNormalToWorld.CopyTo(newCachedNormalToWorld, 0);
+                    m_CachedNormalToWorld = newCachedNormalToWorld;
                 }
 
                 m_Decals[m_DecalsCount] = decal;
                 // update the bounding spheres array
                 m_BoundingSpheres[removeAtIndex] = m_BoundingSpheres[m_DecalsCount - 1];
                 m_CachedTransforms[removeAtIndex] = m_CachedTransforms[m_DecalsCount - 1];
+                m_CachedNormalToWorld[removeAtIndex] = m_CachedNormalToWorld[m_DecalsCount - 1];
                 m_DecalsCount--;
                 decal.CullIndex = DecalProjectorComponent.kInvalidIndex;
             }
                     int decalIndex = m_ResultIndices[resultIndex];
 
                     m_InstanceMatrices[instanceCount] = m_CachedTransforms[decalIndex];
+                    m_InstanceNormalToWorld[instanceCount] = m_CachedNormalToWorld[decalIndex];
-                        cmd.DrawMeshInstanced(m_DecalMesh, 0, m_Decals[0].m_Material, 0, m_InstanceMatrices, kDrawIndexedBatchSize);
+                        m_PropertyBlock.SetMatrixArray(m_NormalToWorldID, m_InstanceNormalToWorld);
+                        cmd.DrawMeshInstanced(m_DecalMesh, 0, KeyMaterial, 0, m_InstanceMatrices, kDrawIndexedBatchSize, m_PropertyBlock);
-                    cmd.DrawMeshInstanced(m_DecalMesh, 0, m_Decals[0].m_Material, 0, m_InstanceMatrices, instanceCount);
+                    m_PropertyBlock.SetMatrixArray(m_NormalToWorldID, m_InstanceNormalToWorld);
+                    cmd.DrawMeshInstanced(m_DecalMesh, 0, KeyMaterial, 0, m_InstanceMatrices, instanceCount, m_PropertyBlock);                    
                 }
             }
 
             private int m_NumResults = 0;
             private int m_DecalsCount = 0;
             private Matrix4x4[] m_CachedTransforms = new Matrix4x4[kDecalBlockSize];
+            private Matrix4x4[] m_CachedNormalToWorld = new Matrix4x4[kDecalBlockSize];
             private Material m_Material;
         }
         

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Camera/HDCameraEditor.Handlers.cs

         {
             m_PreviewCamera.CopyFrom(c);
             EditorUtility.CopySerialized(c, m_PreviewCamera);
-            EditorUtility.CopySerialized(c.GetComponent<HDAdditionalCameraData>(), m_PreviewAdditionalCameraData);
+            var cameraData = c.GetComponent<HDAdditionalCameraData>();
+            EditorUtility.CopySerialized(cameraData, m_PreviewAdditionalCameraData);
+
+            // We need to call UpdateDirtyFrameSettings to update the dirty flags that was set in the CopySerialized call
+            m_PreviewAdditionalCameraData.UpdateDirtyFrameSettings(true, cameraData.GetFrameSettings());
+            // And then to copy the runtime frame settings
+            // So this includes the runtime frame settings properly
+            cameraData.GetFrameSettings().CopyTo(m_PreviewAdditionalCameraData.GetFrameSettings());
             m_PreviewHDCamera.Update(m_PreviewPostProcessLayer, m_PreviewAdditionalCameraData.GetFrameSettings());
 
             var previewTexture = GetPreviewTextureWithSize((int)previewSize.x, (int)previewSize.y);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDAssetFactory.cs

                 string CorePath = HDEditorUtils.GetCorePath();
 
                 newAsset.defaultDiffuseMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDMaterial.mat");
+                newAsset.defaultDecalMaterial = Load<Material>(HDRenderPipelinePath + "RenderPipelineResources/DefaultHDDecalMaterial.mat");
                 newAsset.defaultShader = Load<Shader>(HDRenderPipelinePath + "Material/Lit/Lit.shader");
 
                 newAsset.debugFontTexture = Load<Texture2D>(HDRenderPipelinePath + "RenderPipelineResources/DebugFont.tga");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/BaseLitUI.cs

             public static GUIContent windDragText = new GUIContent("Drag");
             public static GUIContent windShiverDragText = new GUIContent("Shiver Drag");
             public static GUIContent windShiverDirectionalityText = new GUIContent("Shiver Directionality");
+
+            public static GUIContent supportDBufferText = new GUIContent("Enable Decal", "Allow to specify if the material can receive decal or not");
         }
 
         public enum DoubleSidedNormalMode
         protected MaterialProperty tessellationBackFaceCullEpsilon = null;
         protected const string kTessellationBackFaceCullEpsilon = "_TessellationBackFaceCullEpsilon";
 
+        // Decal
+        protected MaterialProperty supportDBuffer = null;
+        protected const string kSupportDBuffer = "_SupportDBuffer";
+
+
         protected override void FindBaseMaterialProperties(MaterialProperty[] props)
         {
             base.FindBaseMaterialProperties(props);
             windDrag = FindProperty(kWindDrag, props);
             windShiverDrag = FindProperty(kWindShiverDrag, props);
             windShiverDirectionality = FindProperty(kWindShiverDirectionality, props);
+
+            // Decal
+            supportDBuffer = FindProperty(kSupportDBuffer, props);
         }
 
         void TessellationModePopup()
             }
 
             m_MaterialEditor.ShaderProperty(materialID, StylesBaseLit.materialIDText);
+
+            m_MaterialEditor.ShaderProperty(supportDBuffer, StylesBaseLit.supportDBufferText);
 
             m_MaterialEditor.ShaderProperty(enableMotionVectorForVertexAnimation, StylesBaseLit.enableMotionVectorForVertexAnimationText);
 
             }
 
             SetupMainTexForAlphaTestGI("_BaseColorMap", "_BaseColor", material);
+
+            // Use negation so we don't create keyword by default
+            CoreUtils.SetKeyword(material, "_DISABLE_DBUFFER", material.GetFloat(kSupportDBuffer) == 0.0);
         }
 
         static public void SetupBaseLitMaterialPass(Material material)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Unlit/BaseUnlitUI.cs

             public static GUIContent transparentDepthPrepassEnableText = new GUIContent("Enable transparent depth prepass", "It allow to to fill depth buffer to improve sorting");
             public static GUIContent transparentDepthPostpassEnableText = new GUIContent("Enable transparent depth postpass", "It allow to fill depth buffer for postprocess effect like DOF");
             public static GUIContent transparentBackfaceEnableText = new GUIContent("Enable back then front rendering", "It allow to better sort transparent mesh by first rendering back faces then front faces in two separate drawcall");
+
+            public static GUIContent transparentSortPriorityText = new GUIContent("Transparent Sort Priority", "Allow to define priority (from -100 to +100) to solve sorting issue with transparent");
             public static GUIContent enableTransparentFogText = new GUIContent("Enable fog", "Enable fog on transparent material");
             public static GUIContent enableBlendModePreserveSpecularLightingText = new GUIContent("Blend preserve specular lighting", "Blend mode will only affect diffuse lighting, allowing correct specular lighting (reflection) on transparent object");
 
         protected const string kTransparentDepthPostpassEnable = "_TransparentDepthPostpassEnable";
         protected MaterialProperty transparentBackfaceEnable = null;
         protected const string kTransparentBackfaceEnable = "_TransparentBackfaceEnable";
+        protected MaterialProperty transparentSortPriority = null;
+        protected const string kTransparentSortPriority = "_TransparentSortPriority";
         protected MaterialProperty doubleSidedEnable = null;
         protected const string kDoubleSidedEnable = "_DoubleSidedEnable";
         protected MaterialProperty blendMode = null;
             transparentDepthPostpassEnable = FindProperty(kTransparentDepthPostpassEnable, props, false);
             transparentBackfaceEnable = FindProperty(kTransparentBackfaceEnable, props, false);
 
+            transparentSortPriority = FindProperty(kTransparentSortPriority, props, false);
+
             doubleSidedEnable = FindProperty(kDoubleSidedEnable, props, false);
             blendMode = FindProperty(kBlendMode, props, false);
 
             if (transparentBackfaceEnable != null && ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent))
                 m_MaterialEditor.ShaderProperty(transparentBackfaceEnable, StylesBaseUnlit.transparentBackfaceEnableText);
 
+            if (transparentSortPriority != null && ((SurfaceType)surfaceType.floatValue == SurfaceType.Transparent))
+            {
+                EditorGUI.BeginChangeCheck();
+                m_MaterialEditor.ShaderProperty(transparentSortPriority, StylesBaseUnlit.transparentSortPriorityText);
+                if (EditorGUI.EndChangeCheck())
+                {
+                    transparentSortPriority.floatValue = Mathf.Clamp((int)transparentSortPriority.floatValue, -(int)HDRenderQueue.k_TransparentPriorityQueueRange, (int)HDRenderQueue.k_TransparentPriorityQueueRange);
+                }
+            }
+
             // This function must finish with double sided option (see LitUI.cs)
             if (doubleSidedEnable != null)
             {
                 material.SetInt("_SrcBlend", (int)UnityEngine.Rendering.BlendMode.One);
                 material.SetInt("_DstBlend", (int)UnityEngine.Rendering.BlendMode.Zero);
                 material.SetInt("_ZWrite", 1);
-                material.renderQueue = alphaTestEnable ? (int)HDRenderQueue.AlphaTest : -1;
+                material.renderQueue = alphaTestEnable ? (int)HDRenderQueue.Priority.OpaqueAlphaTest : (int)HDRenderQueue.Priority.Opaque;
             }
             else
             {
-                material.renderQueue = (int)(isPrepass ? HDRenderQueue.PreRefraction : HDRenderQueue.Transparent);
+                material.renderQueue = (int)(isPrepass ? HDRenderQueue.Priority.PreRefraction : HDRenderQueue.Priority.Transparent) + (int)material.GetFloat(kTransparentSortPriority);
 
                 if (material.HasProperty(kBlendMode))
                 {

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             return m_ColorMRTs;
         }
 
+		public void ClearNormalTarget(Color clearColor, CommandBuffer cmd)
+		{
+			// index 1 is normals
+			CoreUtils.SetRenderTarget(cmd, m_ColorMRTs[1], ClearFlag.Color, clearColor);
+		}
+
         public void PushGlobalParams(CommandBuffer cmd)
         {
             cmd.SetGlobalInt(HDShaderIDs._EnableDBuffer, vsibleDecalCount > 0 ? 1 : 0);
 
-    public partial class HDRenderPipeline : RenderPipeline
+    public class HDRenderPipeline : RenderPipeline
     {
         enum ForwardPass
         {
             "Forward PreRefraction",
             "Forward Transparent"
         };
-
-        static readonly RenderQueueRange k_RenderQueue_PreRefraction = new RenderQueueRange { min = (int)HDRenderQueue.PreRefraction, max = (int)HDRenderQueue.Transparent - 1 };
-        static readonly RenderQueueRange k_RenderQueue_Transparent = new RenderQueueRange { min = (int)HDRenderQueue.Transparent, max = (int)HDRenderQueue.Overlay - 1 };
-        static readonly RenderQueueRange k_RenderQueue_AllTransparent = new RenderQueueRange { min = (int)HDRenderQueue.PreRefraction, max = (int)HDRenderQueue.Overlay - 1 };
 
         readonly HDRenderPipelineAsset m_Asset;
 
         readonly SkyManager m_SkyManager = new SkyManager();
         readonly LightLoop m_LightLoop = new LightLoop();
         readonly ShadowSettings m_ShadowSettings = new ShadowSettings();
+        readonly VolumetricLightingModule m_VolumetricLightingModule = new VolumetricLightingModule();
 
         // Debugging
         MaterialPropertyBlock m_SharedPropertyBlock = new MaterialPropertyBlock();
 
             m_SkyManager.Build(asset, m_IBLFilterGGX);
 
+            m_VolumetricLightingModule.Build(asset);
+
             m_DebugDisplaySettings.RegisterDebug();
             FrameSettings.RegisterDebug("Default Camera", m_Asset.GetFrameSettings());
 
 
             m_SSSBufferManager.Cleanup();
             m_SkyManager.Cleanup();
+            m_VolumetricLightingModule.Cleanup();
 
             SupportedRenderingFeatures.active = new SupportedRenderingFeatures();
         }
                 m_LightLoop.AllocResolutionDependentBuffers(texWidth, texHeight);
             }
 
-            int viewId = hdCamera.camera.GetInstanceID(); // Warning: different views can use the same camera
-
-            if (m_VolumetricLightingPreset != VolumetricLightingPreset.Off)
-                ResizeVBuffer(viewId, texWidth, texHeight);
+            m_VolumetricLightingModule.ResizeVBuffer(hdCamera, texWidth, texHeight);
 
             // update recorded window resolution
             m_CurrentWidth = texWidth;
 
                 m_DbufferManager.PushGlobalParams(cmd);
 
-                if (m_VolumetricLightingPreset != VolumetricLightingPreset.Off)
-                {
-                    SetVolumetricLightingData(hdCamera, cmd);
-                }
+                m_VolumetricLightingModule.PushGlobalParams(hdCamera, cmd);
             }
         }
 
                     // TODO: Try to arrange code so we can trigger this call earlier and use async compute here to run sky convolution during other passes (once we move convolution shader to compute).
                     UpdateSkyEnvironment(hdCamera, cmd);
 
-                    RenderPyramidDepth(camera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
+                    RenderPyramidDepth(hdCamera, cmd, renderContext, FullScreenDebugMode.DepthPyramid);
 
 
                     if (m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled())
 
                         // Render the volumetric lighting.
                         // The pass requires the volume properties, the light list and the shadows, and can run async.
-                        VolumetricLightingPass(hdCamera, cmd);
+                        m_VolumetricLightingModule.VolumetricLightingPass(hdCamera, cmd, m_FrameSettings);
 
                         RenderDeferredLighting(hdCamera, cmd);
 
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.PreRefraction);
                         RenderForwardError(m_CullResults, camera, renderContext, cmd, ForwardPass.PreRefraction);
 
-                        RenderGaussianPyramidColor(camera, cmd, renderContext, true);
+                        RenderGaussianPyramidColor(hdCamera, cmd, renderContext, true);
 
                         // Render all type of transparent forward (unlit, lit, complex (hair...)) to keep the sorting between transparent objects.
                         RenderForward(m_CullResults, hdCamera, renderContext, cmd, ForwardPass.Transparent);
                         RenderTransparentDepthPostpass(m_CullResults, camera, renderContext, cmd, ForwardPass.Transparent);
 
-                        PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, hdCamera, FullScreenDebugMode.NanTracker);
-
-                        RenderGaussianPyramidColor(camera, cmd, renderContext, false);
+                        RenderGaussianPyramidColor(hdCamera, cmd, renderContext, false);
+                        PushFullScreenDebugTexture(cmd, m_CameraColorBuffer, hdCamera, FullScreenDebugMode.NanTracker);
+                        // The final pass either postprocess of Blit will flip the screen (as it is reverse by default due to Unity openGL legacy)
+                        // Postprocess system (that doesn't use cmd.Blit) handle it with configuration (and do not flip in SceneView) or it is automatically done in Blit
+
                         // Final blit
                         if (m_FrameSettings.enablePostprocess && CoreUtils.IsPostProcessingActive(postProcessLayer))
                         {
                         {
                             using (new ProfilingSample(cmd, "Blit to final RT", CustomSamplerId.BlitToFinalRT.GetSampler()))
                             {
+                                // This Blit will flip the screen anything other than openGL
                                 // Simple blit
                                 cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
                             }
+                    // Caution: RenderDebug need to take into account that we have flip the screen (so anything capture before the flip will be flipped)
                     RenderDebug(hdCamera, cmd);
 
                     // Make sure to unbind every render texture here because in the next iteration of the loop we might have to reallocate render texture (if the camera size is different)
 
             var filterSettings = new FilterRenderersSettings(true)
             {
-                renderQueueRange = inRenderQueueRange == null ? RenderQueueRange.opaque : inRenderQueueRange.Value
+                renderQueueRange = inRenderQueueRange == null ? HDRenderQueue.k_RenderQueue_AllOpaque : inRenderQueueRange.Value
             };
 
             if (stateBlock == null)
 
             var filterSettings = new FilterRenderersSettings(true)
             {
-                renderQueueRange = inRenderQueueRange == null ? k_RenderQueue_AllTransparent : inRenderQueueRange.Value
+                renderQueueRange = inRenderQueueRange == null ? HDRenderQueue.k_RenderQueue_AllTransparent : inRenderQueueRange.Value
             };
 
             if (stateBlock == null)
                 {
                     // We render first the opaque object as opaque alpha tested are more costly to render and could be reject by early-z (but not Hi-z as it is disable with clip instruction)
                     // This is handled automatically with the RenderQueue value (OpaqueAlphaTested have a different value and thus are sorted after Opaque)
-                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_DepthOnlyAndDepthForwardOnlyPassNames, 0, RenderQueueRange.opaque, m_DepthStateOpaque);
+                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_DepthOnlyAndDepthForwardOnlyPassNames, 0, HDRenderQueue.k_RenderQueue_AllOpaque, m_DepthStateOpaque);
-                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_DepthForwardOnlyPassNames, 0, RenderQueueRange.opaque, m_DepthStateOpaque);
+                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, m_DepthForwardOnlyPassNames, 0, HDRenderQueue.k_RenderQueue_AllOpaque, m_DepthStateOpaque);
 
                     // Render Alpha test only if requested
                     if (addAlphaTestedOnly)
                 if (m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled())
                 {
                     // When doing debug display, the shader has the clip instruction regardless of the depth prepass so we can use regular depth test.
-                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferDebugDisplayName, m_currentRendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
+                    RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferDebugDisplayName, m_currentRendererConfigurationBakedLighting, HDRenderQueue.k_RenderQueue_AllOpaque, m_DepthStateOpaque);
-                        var rangeOpaqueNoAlphaTest = new RenderQueueRange { min = (int)RenderQueue.Geometry, max = (int)RenderQueue.AlphaTest - 1 };
-                        var rangeOpaqueAlphaTest = new RenderQueueRange { min = (int)RenderQueue.AlphaTest, max = (int)RenderQueue.GeometryLast - 1 };
-
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, rangeOpaqueNoAlphaTest, m_FrameSettings.enableAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, HDRenderQueue.k_RenderQueue_OpaqueNoAlphaTest, m_FrameSettings.enableAlphaTestOnlyInDeferredPrepass ? m_DepthStateOpaque : m_DepthStateOpaqueWithPrepass);
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferWithPrepassName, m_currentRendererConfigurationBakedLighting, rangeOpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferWithPrepassName, m_currentRendererConfigurationBakedLighting, HDRenderQueue.k_RenderQueue_OpaqueAlphaTest, m_DepthStateOpaqueWithPrepass);
-                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, RenderQueueRange.opaque, m_DepthStateOpaque);
+                        RenderOpaqueRenderList(cull, camera, renderContext, cmd, HDShaderPassNames.s_GBufferName, m_currentRendererConfigurationBakedLighting, HDRenderQueue.k_RenderQueue_AllOpaque, m_DepthStateOpaque);
                     }
                 }
             }
                 // Depth texture is now ready, bind it.
                 cmd.SetGlobalTexture(HDShaderIDs._MainDepthTexture, GetDepthTexture());
 
-                CoreUtils.SetRenderTarget(cmd, m_DbufferManager.GetDBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.Color, CoreUtils.clearColorAllBlack);
+				// for alpha compositing, color is cleared to 0, alpha to 1
+				// https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+
+				Color clearColor = new Color(0.0f, 0.0f, 0.0f, 1.0f);
+				CoreUtils.SetRenderTarget(cmd, m_DbufferManager.GetDBuffers(), m_CameraDepthStencilBufferRT, ClearFlag.Color, clearColor);
+
+				// we need to do a separate clear for normals, because they are cleared to a different color
+				Color clearColorNormal = new Color(0.5f, 0.5f, 0.5f, 1.0f); // for normals 0.5 is neutral
+				m_DbufferManager.ClearNormalTarget(clearColorNormal, cmd);
+
+				CoreUtils.SetRenderTarget(cmd, m_DbufferManager.GetDBuffers(), m_CameraDepthStencilBufferRT); // do not clear anymore
                 DecalSystem.instance.Render(renderContext, camera, cmd);
             }
         }
             {
                 using (new ProfilingSample(cmd, "Blit DebugView Material Debug", CustomSamplerId.BlitDebugViewMaterialDebug.GetSampler()))
                 {
+                    // This Blit will flip the screen anything other than openGL
                     cmd.Blit(m_CameraColorBufferRT, BuiltinRenderTextureType.CameraTarget);
                 }
             }
 
             m_SkyManager.RenderSky(hdCamera, m_LightLoop.GetCurrentSunLight(), m_CameraColorBufferRT, m_CameraDepthStencilBufferRT, cmd);
 
-            if (visualEnv.fogType != FogType.None || m_VolumetricLightingPreset != VolumetricLightingPreset.Off)
+            if (visualEnv.fogType != FogType.None || m_VolumetricLightingModule.preset != VolumetricLightingModule.VolumetricLightingPreset.Off)
                 m_SkyManager.RenderOpaqueAtmosphericScattering(cmd);
         }
 
                     CoreUtils.SetRenderTarget(cmd, m_CameraColorBufferRT, m_CameraDepthStencilBufferRT);
 
                     var passNames = m_CurrentDebugDisplaySettings.IsDebugDisplayEnabled() ? m_AllTransparentDebugDisplayPassNames : m_AllTransparentPassNames;
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, passNames, m_currentRendererConfigurationBakedLighting, pass == ForwardPass.PreRefraction ? k_RenderQueue_PreRefraction : k_RenderQueue_Transparent);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, passNames, m_currentRendererConfigurationBakedLighting, pass == ForwardPass.PreRefraction ? HDRenderQueue.k_RenderQueue_PreRefraction : HDRenderQueue.k_RenderQueue_Transparent);
                 }
             }
         }
                 }
                 else
                 {
-                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardErrorPassNames, 0, pass == ForwardPass.PreRefraction ? k_RenderQueue_PreRefraction : k_RenderQueue_Transparent, null, m_ErrorMaterial);
+                    RenderTransparentRenderList(cullResults, camera, renderContext, cmd, m_ForwardErrorPassNames, 0, pass == ForwardPass.PreRefraction ? HDRenderQueue.k_RenderQueue_PreRefraction : HDRenderQueue.k_RenderQueue_Transparent, null, m_ErrorMaterial);
                 }
             }
         }
             }
         }
 
-        void RenderGaussianPyramidColor(Camera camera, CommandBuffer cmd, ScriptableRenderContext renderContext, bool isPreRefraction)
+        void RenderGaussianPyramidColor(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, bool isPreRefraction)
         {
             if (isPreRefraction)
             {
                     last = HDShaderIDs._GaussianPyramidColorMips[i + 1];
                 }
 
-                PushFullScreenDebugTextureMip(cmd, m_GaussianPyramidColorBufferRT, lodCount, m_GaussianPyramidColorBufferDesc, isPreRefraction ? FullScreenDebugMode.PreRefractionColorPyramid : FullScreenDebugMode.FinalColorPyramid);
+                PushFullScreenDebugTextureMip(cmd, m_GaussianPyramidColorBufferRT, lodCount, m_GaussianPyramidColorBufferDesc, hdCamera, isPreRefraction ? FullScreenDebugMode.PreRefractionColorPyramid : FullScreenDebugMode.FinalColorPyramid);
 
                 cmd.SetGlobalTexture(HDShaderIDs._GaussianPyramidColorTexture, m_GaussianPyramidColorBuffer);
 
             }
         }
 
-        void RenderPyramidDepth(Camera camera, CommandBuffer cmd, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
+        void RenderPyramidDepth(HDCamera hdCamera, CommandBuffer cmd, ScriptableRenderContext renderContext, FullScreenDebugMode debugMode)
         {
             using (new ProfilingSample(cmd, "Pyramid Depth", CustomSamplerId.PyramidDepth.GetSampler()))
             {
                     cmd.CopyTexture(HDShaderIDs._DepthPyramidMips[i + 1], 0, 0, m_DepthPyramidBufferRT, 0, i + 1);
                 }
 
-                PushFullScreenDebugDepthMip(cmd, m_DepthPyramidBufferRT, lodCount, m_DepthPyramidBufferDesc, debugMode);
+                PushFullScreenDebugDepthMip(cmd, m_DepthPyramidBufferRT, lodCount, m_DepthPyramidBufferDesc, hdCamera, debugMode);
 
                 cmd.SetGlobalTexture(HDShaderIDs._DepthPyramidTexture, m_DepthPyramidBuffer);
 
             }
         }
 
+        // allowFlip is false if we call the function after the FinalPass or cmd.Blit that flip the screen
         public void PushColorPickerDebugTexture(CommandBuffer cmd, RenderTargetIdentifier textureID, HDCamera hdCamera)
         {
             if (m_CurrentDebugDisplaySettings.colorPickerDebugSettings.colorPickerMode != ColorPickerDebugMode.None)
             }
         }
 
-        void PushFullScreenDebugTextureMip(CommandBuffer cmd, RenderTargetIdentifier textureID, int lodCount, RenderTextureDescriptor desc, FullScreenDebugMode debugMode)
+        void PushFullScreenDebugTextureMip(CommandBuffer cmd, RenderTargetIdentifier textureID, int lodCount, RenderTextureDescriptor desc, HDCamera hdCamera, FullScreenDebugMode debugMode)
         {
             if (debugMode == m_CurrentDebugDisplaySettings.fullScreenDebugMode)
             {
             }
         }
 
-        void PushFullScreenDebugDepthMip(CommandBuffer cmd, RenderTargetIdentifier textureID, int lodCount, RenderTextureDescriptor desc, FullScreenDebugMode debugMode)
+        void PushFullScreenDebugDepthMip(CommandBuffer cmd, RenderTargetIdentifier textureID, int lodCount, RenderTextureDescriptor desc, HDCamera hdCamera, FullScreenDebugMode debugMode)
         {
             if (debugMode == m_CurrentDebugDisplaySettings.fullScreenDebugMode)
             {
                     cmd.SetGlobalTexture(HDShaderIDs._DebugFullScreenTexture, m_DebugFullScreenTempRT);
                     // TODO: Replace with command buffer call when available
                     m_DebugFullScreen.SetFloat(HDShaderIDs._FullScreenDebugMode, (float)m_CurrentDebugDisplaySettings.fullScreenDebugMode);
+                    // Everything we have capture is flipped (as it happen before FinalPass/postprocess/Blit. So if we are not in SceneView
+                    // (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);
                     CoreUtils.DrawFullScreen(cmd, m_DebugFullScreen, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
 
                     PushColorPickerDebugTexture(cmd, m_DebugFullScreenTempRT, hdCamera);
                     // 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,
                     // we perform it inside the color picker shader. But we shouldn't do it for HDR buffer.
                     m_DebugColorPicker.SetFloat(HDShaderIDs._ApplyLinearToSRGB, m_CurrentDebugDisplaySettings.IsDebugMaterialDisplayEnabled() ? 1.0f : 0.0f);
-
+                    // Everything we have capture is flipped (as it happen before FinalPass/postprocess/Blit. So if we are not in SceneView
+                    // (i.e. we have perform a flip, we need to flip the input texture) + we need to handle the case were we debug a fullscreen pass that have already perform the flip
+                    m_DebugColorPicker.SetFloat(HDShaderIDs._RequireToFlipInputTexture, hdCamera.camera.cameraType != CameraType.SceneView ? 1.0f : 0.0f);
                     CoreUtils.DrawFullScreen(cmd, m_DebugColorPicker, (RenderTargetIdentifier)BuiltinRenderTextureType.CameraTarget);
                 }
             }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipelineAsset.cs

             return m_RenderPipelineResources.defaultDiffuseMaterial;
         }
 
+        // Note: This function is HD specific
+        public Material GetDefaultDecalMaterial()
+        {
+            return m_RenderPipelineResources.defaultDecalMaterial;
+        }
+
         public override Material GetDefaultParticleMaterial()
         {
             return null;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderQueue.cs

 
 namespace UnityEngine.Experimental.Rendering.HDPipeline
 {
-    public enum HDRenderQueue
+    // In HD we don't expose HDRenderQueue instead we create as much value as needed in the enum for our different pass
+    // and use inspector to manipulate the value.
+    // In the case of transparent we want to use RenderQueue to help with sorting. We define a neutral value for the RenderQueue and priority going from -X to +X
+    // going from -X to +X instead of 0 to +X as builtin Unity is better for artists as they can decide late to sort behind or in front of the scene.
+
+    public class HDRenderQueue
-        Background = UnityEngine.Rendering.RenderQueue.Background,
-        Geometry = UnityEngine.Rendering.RenderQueue.Geometry,
-        AlphaTest = UnityEngine.Rendering.RenderQueue.AlphaTest,
-        GeometryLast = UnityEngine.Rendering.RenderQueue.GeometryLast,
-        PreRefraction = 2750,
-        Transparent = UnityEngine.Rendering.RenderQueue.Transparent,
-        Overlay = UnityEngine.Rendering.RenderQueue.Overlay
+        public const int k_TransparentPriorityQueueRange = 100;
+
+        public enum Priority
+        {
+            Background = UnityEngine.Rendering.RenderQueue.Background,
+            Opaque = UnityEngine.Rendering.RenderQueue.Geometry,
+            OpaqueAlphaTest = UnityEngine.Rendering.RenderQueue.AlphaTest,
+            // Warning: we must not change Geometry last value to stay compatible with occlusion
+            OpaqueLast = UnityEngine.Rendering.RenderQueue.GeometryLast,
+            // For transparent pass we define a range of 200 value to define the priority
+            // Warning: Be sure no range are overlapping
+            PreRefractionFirst = 2750 - k_TransparentPriorityQueueRange,
+            PreRefraction = 2750,
+            PreRefractionLast = 2750 + k_TransparentPriorityQueueRange,
+            TransparentFirst = UnityEngine.Rendering.RenderQueue.Transparent - k_TransparentPriorityQueueRange,
+            Transparent = UnityEngine.Rendering.RenderQueue.Transparent,
+            TransparentLast = UnityEngine.Rendering.RenderQueue.Transparent + k_TransparentPriorityQueueRange,
+            Overlay = UnityEngine.Rendering.RenderQueue.Overlay
+        }
+
+        public static readonly RenderQueueRange k_RenderQueue_OpaqueNoAlphaTest = new RenderQueueRange { min = (int)Priority.Opaque, max = (int)Priority.OpaqueAlphaTest - 1 };
+        public static readonly RenderQueueRange k_RenderQueue_OpaqueAlphaTest = new RenderQueueRange { min = (int)Priority.OpaqueAlphaTest, max = (int)Priority.OpaqueLast };
+        public static readonly RenderQueueRange k_RenderQueue_AllOpaque = new RenderQueueRange { min = (int)Priority.Opaque, max = (int)Priority.OpaqueLast };
+
+        public static readonly RenderQueueRange k_RenderQueue_PreRefraction = new RenderQueueRange { min = (int)Priority.PreRefractionFirst, max = (int)Priority.PreRefractionLast };
+        public static readonly RenderQueueRange k_RenderQueue_Transparent = new RenderQueueRange { min = (int)Priority.TransparentFirst, max = (int)Priority.TransparentLast };
+        public static readonly RenderQueueRange k_RenderQueue_AllTransparent = new RenderQueueRange { min = (int)Priority.PreRefractionFirst, max = (int)Priority.TransparentLast };
+
+        public static readonly RenderQueueRange k_RenderQueue_All = new RenderQueueRange { min = 0, max = 5000 };
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int _ColorPickerMode = Shader.PropertyToID("_ColorPickerMode");
         public static readonly int _ApplyLinearToSRGB = Shader.PropertyToID("_ApplyLinearToSRGB");
         public static readonly int _ColorPickerFontColor = Shader.PropertyToID("_ColorPickerFontColor");
+        public static readonly int _RequireToFlipInputTexture = Shader.PropertyToID("_RequireToFlipInputTexture");
 
         public static readonly int _DebugFullScreenTexture = Shader.PropertyToID("_DebugFullScreenTexture");
         public static readonly int _BlitTexture = Shader.PropertyToID("_BlitTexture");
 
         public static readonly int _GlobalFog_Extinction       = Shader.PropertyToID("_GlobalFog_Extinction");
         public static readonly int _GlobalFog_Scattering       = Shader.PropertyToID("_GlobalFog_Scattering");
+        public static readonly int _GlobalFog_Asymmetry        = Shader.PropertyToID("_GlobalFog_Asymmetry");
         public static readonly int _VBufferResolution          = Shader.PropertyToID("_VBufferResolution");
         public static readonly int _VBufferScaleAndSliceCount  = Shader.PropertyToID("_VBufferScaleAndSliceCount");
         public static readonly int _VBufferDepthEncodingParams = Shader.PropertyToID("_VBufferDepthEncodingParams");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/HomogeneousFog.cs

                 Gizmos.DrawWireCube(volumeParameters.bounds.center, volumeParameters.bounds.size);
             }
         }
+
+        // Returns NULL if a global fog component does not exist, or is not enabled.
+        public static HomogeneousFog GetGlobalFogComponent()
+        {
+            HomogeneousFog globalFogComponent = null;
+
+            HomogeneousFog[] fogComponents = FindObjectsOfType(typeof(HomogeneousFog)) as HomogeneousFog[];
+
+            foreach (HomogeneousFog fogComponent in fogComponents)
+            {
+                if (fogComponent.enabled && fogComponent.volumeParameters.IsVolumeUnbounded())
+                {
+                    globalFogComponent = fogComponent;
+                    break;
+                }
+            }
+
+            return globalFogComponent;
+        }
     }
 } // UnityEngine.Experimental.Rendering.HDPipeline

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/Resources/VolumetricLighting.compute

 // Implementation
 //--------------------------------------------------------------------------------------------------
 
+#define HG 0
+
 struct Ray
 {
     float3 originWS;
 // Computes the light integral (in-scattered radiance) within the voxel.
 // Multiplication by the scattering coefficient and the phase function is performed outside.
 float3 EvaluateVoxelLighting(LightLoopContext context, uint featureFlags, PositionInputs posInput,
-                             Ray ray, float t0, float t1, float dt, float rndVal, float extinction
+                             Ray ray, float t0, float t1, float dt, float rndVal, float extinction, float asymmetry
                          #ifdef LIGHTLOOP_TILE_PASS
                            , uint clusterIndices[2], float clusterDepths[2])
                          #else
             EvaluateLight_Directional(context, posInput, light, unused, 0, L,
                                       color, attenuation);
 
+            float cosTheta = dot(L, ray.directionWS);
+        #if HG
+            float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+        #else
+            float phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
+        #endif
+
-            float intensity = attenuation * weight;
+            float intensity = attenuation * (phase * weight);
 
             // Compute the amount of in-scattered radiance.
             voxelRadiance += intensity * color;
                         EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
                                                distances, color, attenuation);
 
-                        float intensity = attenuation * rcpPdf;
+                        float cosTheta = dot(L, ray.directionWS);
+                    #if HG
+                        float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+                    #else
+                        float phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
+                    #endif
+
+                        float intensity = attenuation * (phase * rcpPdf);
 
                         // Compute transmittance from 't0' to 't'.
                         intensity *= TransmittanceHomogeneousMedium(extinction, t - t0);
                         EvaluateLight_Punctual(context, posInput, light, unused, 0, L, lightToSample,
                                                distances, color, attenuation);
 
+                        float cosTheta = dot(L, ray.directionWS);
+                    #if HG
+                        float phase    = HenyeyGreensteinPhasePartVarying(asymmetry, cosTheta);
+                    #else
+                        float phase    = CornetteShanksPhasePartVarying(asymmetry, cosTheta);
+                    #endif
+
-                        float intensity = attenuation * weight;
+                        float intensity = attenuation * (phase * weight);
 
                         // Compute transmittance from 't0' to 'tEntr'.
                         intensity *= TransmittanceHomogeneousMedium(extinction, tEntr - t0);
         // TODO: piecewise linear.
         float3 scattering = _GlobalFog_Scattering;
         float  extinction = _GlobalFog_Extinction;
+        float  asymmetry  = _GlobalFog_Asymmetry;
         
         // TODO: define a function ComputeGlobalFogCoefficients(float3 centerWS),
         // which allows procedural definition of extinction and scattering.
     #endif
 
         float3 voxelRadiance = EvaluateVoxelLighting(context, featureFlags, posInput,
-                                                     ray, t0, t1, dt, rndVal, extinction
+                                                     ray, t0, t1, dt, rndVal, extinction, asymmetry
                                                 #ifdef LIGHTLOOP_TILE_PASS
                                                    , clusterIndices, clusterDepths);
                                                 #else
         // Compute the transmittance from the camera to 't0'.
         float transmittance = Transmittance(opticalDepth);
 
+    #if HG
+        float phase = HenyeyGreensteinPhasePartConstant(asymmetry);
+    #else
+        float phase = CornetteShanksPhasePartConstant(asymmetry);
+    #endif
+
-        totalRadiance += (transmittance * IsotropicPhaseFunction()) * scattering * blendedRadiance;
+        totalRadiance += (transmittance * phase) * scattering * blendedRadiance;
 
         // Compute the optical depth up to the center of the interval.
         opticalDepth += 0.5 * extinction * dt;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Volumetrics/VolumetricLighting.cs

 using System;
 using UnityEngine.Rendering;
+using System.Collections.Generic;
-
 [GenerateHLSL]
 public struct VolumeProperties
 {
     public Bounds bounds;       // Position and dimensions in meters
     public Color  albedo;       // Single scattering albedo [0, 1]
     public float  meanFreePath; // In meters [1, inf]. Should be chromatic - this is an optimization!
+    public float  asymmetry;    // Single global parameter for all volumes. TODO: UX
 
     public VolumeParameters()
     {
+        asymmetry    = 0.0f;
     }
 
     public bool IsVolumeUnbounded()
         albedo.b = Mathf.Clamp01(albedo.b);
 
         meanFreePath = Mathf.Max(meanFreePath, 1.0f);
+
+        asymmetry = Mathf.Clamp(asymmetry, -1.0f, 1.0f);
     }
 
     public VolumeProperties GetProperties()
     }
 } // class VolumeParameters
 
-public partial class HDRenderPipeline : RenderPipeline
+public class VolumetricLightingModule
 {
     public enum VolumetricLightingPreset
     {
         Count
-    };
+    }
+    class VBuffer
+    {
+        public int                      viewID       =   -1; // -1 is invalid; positive for Game Views, 0 otherwise
+        public RenderTexture[]          lightingRTEX = null;
+        public RenderTargetIdentifier[] lightingRTID = null;
-    VolumetricLightingPreset m_VolumetricLightingPreset
-    { get { return (VolumetricLightingPreset)Math.Min(ShaderConfig.s_VolumetricLightingPreset, (int)VolumetricLightingPreset.Count); } }
+        public RenderTargetIdentifier GetLightingIntegralBuffer() // Of the current frame
+        {
+            Debug.Assert(viewID >= 0);
+            return lightingRTID[0];
+        }
-    ComputeShader            m_VolumetricLightingCS { get { return m_Asset.renderPipelineResources.volumetricLightingCS; } }
+        public RenderTargetIdentifier GetLightingHistoryBuffer() // From the previous frame
+        {
+            Debug.Assert(viewID > 0); // Game View only
+            return lightingRTID[1 + ((Time.renderedFrameCount + 0) & 1)];
+        }
-    float                    m_VBufferNearPlane  = 0.5f;  // Distance in meters; dynamic modifications not handled by reprojection
-    float                    m_VBufferFarPlane   = 64.0f; // Distance in meters; dynamic modifications not handled by reprojection
-    const int                k_VBufferCount      = 3;     // 0 and 1 - history (prev) and feedback (next), 2 - integral (curr)
+        public RenderTargetIdentifier GetLightingFeedbackBuffer() // For the next frame
+        {
+            Debug.Assert(viewID > 0); // Game View only
+            return lightingRTID[1 + ((Time.renderedFrameCount + 1) & 1)];
+        }
-    RenderTexture[]          m_VBufferLighting   = null;
-    RenderTargetIdentifier[] m_VBufferLightingRT = null;
+        public void Create(int viewID, int w, int h, int d)
+        {
+            Debug.Assert(viewID >= 0);
+            Debug.Assert(w > 0 && h > 0 && d > 0);
+
+            // Clean up first.
+            Destroy();
+
+            // The required number of buffers depends on the view type.
+            bool isGameView = viewID > 0;
+            int  n = isGameView ? 3 : 1;
-    int                      m_ViewCount         = 0;
-    int[]                    m_ViewIdArray       = new int[8]; // TODO: account for the CameraType
+            this.viewID       = viewID;
+            this.lightingRTEX = new RenderTexture[n];
+            this.lightingRTID = new RenderTargetIdentifier[n];
-    int ViewOffsetFromViewId(int viewId)
-    {
-        int viewOffset = -1;
+            for (int i = 0; i < n; i++)
+            {
+                this.lightingRTEX[i] = new RenderTexture(w, h, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
+                this.lightingRTEX[i].filterMode        = FilterMode.Trilinear;   // Custom
+                this.lightingRTEX[i].dimension         = TextureDimension.Tex3D; // TODO: request the thick 3D tiling layout
+                this.lightingRTEX[i].volumeDepth       = d;
+                this.lightingRTEX[i].enableRandomWrite = true;
+                this.lightingRTEX[i].Create();
-        Debug.Assert(m_ViewCount == 0 || m_ViewIdArray != null);
+                this.lightingRTID[i] = new RenderTargetIdentifier(this.lightingRTEX[i]);
+            }
+        }
-        for (int i = 0; i < m_ViewCount; i++)
+        public void Destroy()
-            if (m_ViewIdArray[i] == viewId)
+            if (this.lightingRTEX != null)
-                viewOffset = i;
+                for (int i = 0, n = this.lightingRTEX.Length; i < n; i++)
+                {
+                    this.lightingRTEX[i].Release();
+                }
+
+            this.viewID       =   -1;
+            this.lightingRTEX = null;
+            this.lightingRTID = null;
+    } // class VBuffer
-        return viewOffset;
-    }
+    public VolumetricLightingPreset preset { get { return (VolumetricLightingPreset)Math.Min(ShaderConfig.s_VolumetricLightingPreset, (int)VolumetricLightingPreset.Count); } }
+
+    ComputeShader m_VolumetricLightingCS = null;
+
+    List<VBuffer> m_VBuffers         = null;
+    float         m_VBufferNearPlane = 0.5f;  // Distance in meters; dynamic modifications not handled by reprojection
+    float         m_VBufferFarPlane  = 64.0f; // Distance in meters; dynamic modifications not handled by reprojection
-    public static int ComputeVBufferTileSize(VolumetricLightingPreset preset)
+    public void Build(HDRenderPipelineAsset asset)
-        switch (preset)
-        {
-            case VolumetricLightingPreset.Normal:
-                return 8;
-            case VolumetricLightingPreset.Ultra:
-                return 4;
-            case VolumetricLightingPreset.Off:
-                return 0;
-            default:
-                Debug.Assert(false, "Encountered an unexpected VolumetricLightingPreset.");
-                return 0;
-        }
+        if (preset == VolumetricLightingPreset.Off) return;
+
+        m_VolumetricLightingCS = asset.renderPipelineResources.volumetricLightingCS;
+        m_VBuffers = new List<VBuffer>(1);
-    public static int ComputeVBufferSliceCount(VolumetricLightingPreset preset)
+    public void Cleanup()
-        switch (preset)
+        if (preset == VolumetricLightingPreset.Off) return;
+
+        m_VolumetricLightingCS = null;
+
+        for (int i = 0, n = m_VBuffers.Count; i < n; i++)
-            case VolumetricLightingPreset.Normal:
-                return 128;
-            case VolumetricLightingPreset.Ultra:
-                return 256;
-            case VolumetricLightingPreset.Off:
-                return 0;
-            default:
-                Debug.Assert(false, "Encountered an unexpected VolumetricLightingPreset.");
-                return 0;
+            m_VBuffers[i].Destroy();
+
+        m_VBuffers = null;
-    // Since a single voxel corresponds to a tile (e.g. 8x8) of pixels,
-    // the VBuffer can potentially extend past the boundaries of the viewport.
-    // The function returns the fraction of the {width, height} of the VBuffer visible on screen.
-    Vector2 ComputeVBufferResolutionAndScale(float screenWidth, float screenHeight,
-                                             ref int w, ref int h, ref int d)
+    public void ResizeVBuffer(HDCamera camera, int screenWidth, int screenHeight)
-        int t = ComputeVBufferTileSize(m_VolumetricLightingPreset);
+        if (preset == VolumetricLightingPreset.Off) return;
-        // Ceil(ScreenSize / TileSize).
-        w = ((int)screenWidth  + t - 1) / t;
-        h = ((int)screenHeight + t - 1) / t;
-        d = ComputeVBufferSliceCount(m_VolumetricLightingPreset);
+        int viewID = camera.GetViewID();
+
+        Debug.Assert(viewID >= 0);
-        return new Vector2(screenWidth / (w * t), screenHeight / (h * t));
-    }
+        int w = 0, h = 0, d = 0;
+        ComputeVBufferResolutionAndScale(preset, screenWidth, screenHeight, ref w, ref h, ref d);
-    void ResizeVBuffer(int viewId, int screenWidth, int screenHeight)
-    {
-        int viewOffset = ViewOffsetFromViewId(viewId);
+        VBuffer vBuffer = FindVBuffer(viewID);
-        if (viewOffset >= 0)
+        if (vBuffer != null)
-            // Found, check resolution.
-            int w = 0, h = 0, d = 0;
-            ComputeVBufferResolutionAndScale(screenWidth, screenHeight, ref w, ref h, ref d);
+            Debug.Assert(vBuffer.lightingRTEX    != null);
+            Debug.Assert(vBuffer.lightingRTEX[0] != null);
+            Debug.Assert(vBuffer.lightingRTID    != null);
-            Debug.Assert(m_VBufferLighting != null);
-            Debug.Assert(m_VBufferLighting.Length >= (viewOffset + 1) * k_VBufferCount);
-            Debug.Assert(m_VBufferLighting[viewOffset * k_VBufferCount] != null);
-
-            if (w == m_VBufferLighting[viewOffset * k_VBufferCount].width  &&
-                h == m_VBufferLighting[viewOffset * k_VBufferCount].height &&
-                d == m_VBufferLighting[viewOffset * k_VBufferCount].volumeDepth)
+            // Found, check resolution.
+            if (w == vBuffer.lightingRTEX[0].width  &&
+                h == vBuffer.lightingRTEX[0].height &&
+                d == vBuffer.lightingRTEX[0].volumeDepth)
+        else
+        {
+            // Not found - grow the array.
+            vBuffer = new VBuffer();
+            m_VBuffers.Add(vBuffer);
+        }
-        // Otherwise, we have to recreate the VBuffer.
-        CreateVBuffer(viewId, screenWidth, screenHeight);
+        vBuffer.Create(viewID, w, h, d);
-    void CreateVBuffer(int viewId, int screenWidth, int screenHeight)
+    VBuffer FindVBuffer(int viewID)
-        // Clean up first.
-        DestroyVBuffer(viewId);
+        Debug.Assert(viewID >= 0);
-        int viewOffset = ViewOffsetFromViewId(viewId);
+        VBuffer vBuffer = null;
-        if (viewOffset < 0)
+        if (m_VBuffers != null)
-            // Not found. Push back.
-            viewOffset = m_ViewCount++;
-            Debug.Assert(viewOffset < 8);
-            m_ViewIdArray[viewOffset] = viewId;
+            int n = m_VBuffers.Count;
-            if (m_VBufferLighting == null)
-            {
-                // Lazy initialize.
-                m_VBufferLighting   = new RenderTexture[k_VBufferCount];
-                m_VBufferLightingRT = new RenderTargetIdentifier[k_VBufferCount];
-            }
-            else if (m_VBufferLighting.Length < m_ViewCount * k_VBufferCount)
+            for (int i = 0; i < n; i++)
-                // Grow by reallocation and copy.
-                RenderTexture[]          newArray   = new RenderTexture[m_ViewCount * k_VBufferCount];
-                RenderTargetIdentifier[] newArrayRT = new RenderTargetIdentifier[m_ViewCount * k_VBufferCount];
-                
-                for (int i = 0, n = m_VBufferLighting.Length; i < n; i++)
+                if (viewID == m_VBuffers[i].viewID)
-                    newArray[i]   = m_VBufferLighting[i];
-                    newArrayRT[i] = m_VBufferLightingRT[i];
+                    vBuffer = m_VBuffers[i];
-
-                // Reassign and release memory.
-                m_VBufferLighting   = newArray;
-                m_VBufferLightingRT = newArrayRT;
-        Debug.Assert(m_VBufferLighting != null);
-
-        int w = 0, h = 0, d = 0;
-        ComputeVBufferResolutionAndScale(screenWidth, screenHeight, ref w, ref h, ref d);
+        return vBuffer;
+    }
-        for (int i = viewOffset * k_VBufferCount,
-                 n = viewOffset * k_VBufferCount + k_VBufferCount; i < n; i++)
+    static int ComputeVBufferTileSize(VolumetricLightingPreset preset)
+    {
+        switch (preset)
-            m_VBufferLighting[i] = new RenderTexture(w, h, 0, RenderTextureFormat.ARGBHalf, RenderTextureReadWrite.Linear);
-            m_VBufferLighting[i].filterMode        = FilterMode.Trilinear;   // Custom
-            m_VBufferLighting[i].dimension         = TextureDimension.Tex3D; // TODO: request the thick 3D tiling layout
-            m_VBufferLighting[i].volumeDepth       = d;
-            m_VBufferLighting[i].enableRandomWrite = true;
-            m_VBufferLighting[i].Create();
-
-            m_VBufferLightingRT[i] = new RenderTargetIdentifier(m_VBufferLighting[i]);
+            case VolumetricLightingPreset.Normal:
+                return 8;
+            case VolumetricLightingPreset.Ultra:
+                return 4;
+            case VolumetricLightingPreset.Off:
+                return 0;
+            default:
+                Debug.Assert(false, "Encountered an unexpected VolumetricLightingPreset.");
+                return 0;
-    void DestroyVBuffer(int viewId)
+    static int ComputeVBufferSliceCount(VolumetricLightingPreset preset)
-        int viewOffset = ViewOffsetFromViewId(viewId);
-
-        if (viewOffset < 0)
+        switch (preset)
-            // Not found.
-            return;
+            case VolumetricLightingPreset.Normal:
+                return 128;
+            case VolumetricLightingPreset.Ultra:
+                return 256;
+            case VolumetricLightingPreset.Off:
+                return 0;
+            default:
+                Debug.Assert(false, "Encountered an unexpected VolumetricLightingPreset.");
+                return 0;
+    }
-        int lastOffset = m_ViewCount - 1;
-        Debug.Assert(lastOffset >= 0);
-
-        if (m_VBufferLighting != null)
-        {
-            Debug.Assert(m_VBufferLighting.Length >= m_ViewCount * k_VBufferCount);
-
-            for (int i = 0; i < k_VBufferCount; i++)
-            {
-                int viewBuffer = viewOffset * k_VBufferCount + i;
-                int lastBuffer = lastOffset * k_VBufferCount + i;
-
-                // Release the memory.
-                if (m_VBufferLighting[viewBuffer] != null)
-                {
-                    m_VBufferLighting[viewBuffer].Release();
-                }
+    // Since a single voxel corresponds to a tile (e.g. 8x8) of pixels,
+    // the VBuffer can potentially extend past the boundaries of the viewport.
+    // The function returns the fraction of the {width, height} of the VBuffer visible on screen.
+    static Vector2 ComputeVBufferResolutionAndScale(VolumetricLightingPreset preset,
+                                                    int screenWidth, int screenHeight,
+                                                    ref int w, ref int h, ref int d)
+    {
+        int t = ComputeVBufferTileSize(preset);
-                // Swap with the last element.
-                m_VBufferLighting[viewBuffer]   = m_VBufferLighting[lastBuffer];
-                m_VBufferLightingRT[viewBuffer] = m_VBufferLightingRT[lastBuffer];
-            }
-        }
+        // Ceil(ScreenSize / TileSize).
+        w = (screenWidth  + t - 1) / t;
+        h = (screenHeight + t - 1) / t;
+        d = ComputeVBufferSliceCount(preset);
-        // Swap with the last element and shrink the array.
-        m_ViewIdArray[viewOffset] = m_ViewIdArray[lastOffset];
-        m_ViewCount--;
+        return new Vector2((float)screenWidth / (float)(w * t), (float)screenHeight / (float)(h * t));
-    public static Vector4 ComputeLogarithmicDepthEncodingParams(float nearPlane, float farPlane)
+    static Vector4 ComputeLogarithmicDepthEncodingParams(float nearPlane, float farPlane)
     {
         Vector4 depthParams = new Vector4();
 
 
         return depthParams;
     }
-    
-    // Returns NULL if a global fog component does not exist, or is not enabled.
-    public static HomogeneousFog GetGlobalFogComponent()
-    {
-        HomogeneousFog globalFogComponent = null;
-
-        HomogeneousFog[] fogComponents = Object.FindObjectsOfType(typeof(HomogeneousFog)) as HomogeneousFog[];
-        foreach (HomogeneousFog fogComponent in fogComponents)
-        {
-            if (fogComponent.enabled && fogComponent.volumeParameters.IsVolumeUnbounded())
-            {
-                globalFogComponent = fogComponent;
-                break;
-            }
-        }
-
-        return globalFogComponent;
-    }
-
-    RenderTargetIdentifier GetVBufferLightingHistory(int viewOffset) // From the previous frame
+    public void PushGlobalParams(HDCamera camera, CommandBuffer cmd)
-        return m_VBufferLightingRT[viewOffset * k_VBufferCount + ((Time.renderedFrameCount + 0) & 1)]; // Does not work in the Scene view
-    }
+        if (preset == VolumetricLightingPreset.Off) return;
-    RenderTargetIdentifier GetVBufferLightingFeedback(int viewOffset) // For the next frame
-    {
-        return m_VBufferLightingRT[viewOffset * k_VBufferCount + ((Time.renderedFrameCount + 1) & 1)]; // Does not work in the Scene view
-    }
-
-    RenderTargetIdentifier GetVBufferLightingIntegral(int viewOffset) // Of the current frame
-    {
-        return m_VBufferLightingRT[viewOffset * k_VBufferCount + 2];
-    }
-
-    public void SetVolumetricLightingData(HDCamera camera, CommandBuffer cmd)
-    {
-        HomogeneousFog globalFogComponent = GetGlobalFogComponent();
+        HomogeneousFog globalFogComponent = HomogeneousFog.GetGlobalFogComponent();
 
         // TODO: may want to cache these results somewhere.
         VolumeProperties globalFogProperties = (globalFogComponent != null) ? globalFogComponent.volumeParameters.GetProperties()
         cmd.SetGlobalFloat( HDShaderIDs._GlobalFog_Extinction, globalFogProperties.extinction);
+        cmd.SetGlobalFloat( HDShaderIDs._GlobalFog_Asymmetry,  globalFogComponent != null ? globalFogComponent.volumeParameters.asymmetry : 0);
-        Vector2 scale = ComputeVBufferResolutionAndScale(camera.screenSize.x, camera.screenSize.y, ref w, ref h, ref d);
-
-        int viewId     = camera.camera.GetInstanceID();
-        int viewOffset = ViewOffsetFromViewId(viewId);
+        Vector2 scale = ComputeVBufferResolutionAndScale(preset, (int)camera.screenSize.x, (int)camera.screenSize.y, ref w, ref h, ref d);
-        Debug.Assert(viewOffset >= 0 && viewOffset < 8);
+        VBuffer vBuffer = FindVBuffer(camera.GetViewID());
+        Debug.Assert(vBuffer != null);
-        cmd.SetGlobalTexture(HDShaderIDs._VBufferLighting,            GetVBufferLightingIntegral(viewOffset));
+        cmd.SetGlobalTexture(HDShaderIDs._VBufferLighting,            vBuffer.GetLightingIntegralBuffer());
     }
 
     // Ref: https://en.wikipedia.org/wiki/Close-packing_of_equal_spheres
-    Vector2[] GetHexagonalClosePackedSpheres7()
+    static Vector2[] GetHexagonalClosePackedSpheres7()
     {
         Vector2[] coords = new Vector2[7];
 
         return coords;
     }
 
-    void VolumetricLightingPass(HDCamera camera, CommandBuffer cmd)
+    public void VolumetricLightingPass(HDCamera camera, CommandBuffer cmd, FrameSettings frameSettings)
-        if (m_VolumetricLightingPreset == VolumetricLightingPreset.Off) return;
+        if (preset == VolumetricLightingPreset.Off) return;
-            int viewId     = camera.camera.GetInstanceID(); // Warning: different views can use the same camera
-            int viewOffset = ViewOffsetFromViewId(viewId);
-
-            Debug.Assert(viewOffset >= 0 && viewOffset < 8);
+            VBuffer vBuffer = FindVBuffer(camera.GetViewID());
+            Debug.Assert(vBuffer != null);
-            if (GetGlobalFogComponent() == null)
+            if (HomogeneousFog.GetGlobalFogComponent() == null)
             {
                 // Clear the render target instead of running the shader.
                 // CoreUtils.SetRenderTarget(cmd, GetVBufferLightingIntegral(viewOffset), ClearFlag.Color, CoreUtils.clearColorAllBlack);
                 // Use the workaround by running the full shader with no volume.
             }
 
-            bool enableClustered    = m_FrameSettings.lightLoopSettings.enableTileAndCluster;
+            bool enableClustered    = frameSettings.lightLoopSettings.enableTileAndCluster;
             bool enableReprojection = Application.isPlaying && camera.camera.cameraType == CameraType.Game;
 
             int kernel;
             }
 
             int w = 0, h = 0, d = 0;
-            Vector2 scale = ComputeVBufferResolutionAndScale(camera.screenSize.x, camera.screenSize.y, ref w, ref h, ref d);
+            Vector2 scale = ComputeVBufferResolutionAndScale(preset, (int)camera.screenSize.x, (int)camera.screenSize.y, ref w, ref h, ref d);
             float   vFoV  = camera.camera.fieldOfView * Mathf.Deg2Rad;
 
             // Compose the matrix which allows us to compute the world space view direction.
             // TODO: set 'm_VolumetricLightingPreset'.
             cmd.SetComputeVectorParam( m_VolumetricLightingCS,         HDShaderIDs._VBufferSampleOffset,     offset);
             cmd.SetComputeMatrixParam( m_VolumetricLightingCS,         HDShaderIDs._VBufferCoordToViewDirWS, transform);
-            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingHistory,  GetVBufferLightingHistory(viewOffset));  // Read
-            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingFeedback, GetVBufferLightingFeedback(viewOffset)); // Write
-            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingIntegral, GetVBufferLightingIntegral(viewOffset)); // Write
+            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingIntegral, vBuffer.GetLightingIntegralBuffer()); // Write
+            if (enableReprojection)
+            {
+            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingFeedback, vBuffer.GetLightingFeedbackBuffer()); // Write
+            cmd.SetComputeTextureParam(m_VolumetricLightingCS, kernel, HDShaderIDs._VBufferLightingHistory,  vBuffer.GetLightingHistoryBuffer());  // Read
+            }
-} // class HDRenderPipeline
+} // class VolumetricLightingModule
 } // namespace UnityEngine.Experimental.Rendering.HDPipeline

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.hlsl

 	uint _EnableDBuffer;
 CBUFFER_END
 
+UNITY_INSTANCING_BUFFER_START(Decal)      
+	UNITY_DEFINE_INSTANCED_PROP(float4x4, normalToWorld)
+UNITY_INSTANCING_BUFFER_END(matrix)       
+
+
 // Must be in sync with RT declared in HDRenderPipeline.cs ::Rebuild
 void EncodeIntoDBuffer( DecalSurfaceData surfaceData,
                         out DBufferType0 outDBuffer0,

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/Decal.shader

             Name "DBuffer"  // Name is not used
             Tags { "LightMode" = "DBuffer" } // This will be only for opaque object based on the RenderQueue index
 
-			// need to optimize this and use proper Cull and ZTest modes for cases when decal geometry is clipped by camera 
-            Cull Off
+			// back faces with zfail, for cases when camera is inside the decal volume
+            Cull Front
-			ZTest Always
+			ZTest Greater
+			// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+			Blend SrcAlpha OneMinusSrcAlpha, Zero OneMinusSrcAlpha
 
 			HLSLPROGRAM
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalData.hlsl

 #endif
 #if _MASKMAP
 	surfaceData.mask = SAMPLE_TEXTURE2D(_MaskMap, sampler_MaskMap, texCoordDS.xy); 
-	surfaceData.mask.z = totalBlend;
+	surfaceData.mask.z = surfaceData.mask.w;
+	surfaceData.mask.w = totalBlend;
 #endif
 
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalProperties.hlsl

 #ifndef UNITY_DECALPROPERTIES_INCLUDED
 #define UNITY_DECALPROPERTIES_INCLUDED
 
-
 TEXTURE2D(_BaseColorMap);
 SAMPLER(sampler_BaseColorMap);
 TEXTURE2D(_NormalMap);
 
 float _DecalBlend;
-
-CBUFFER_START(Decal)
-float4x4 _WorldToDecal;
-float4x4 _DecalToWorldR;
-CBUFFER_END
 
 #endif 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/DecalUtilities.hlsl

 		DecalSurfaceData decalSurfaceData;
 		DECODE_FROM_DBUFFER(DBuffer, decalSurfaceData);
 
-		surfaceData.baseColor.xyz = lerp(surfaceData.baseColor.xyz, decalSurfaceData.baseColor.xyz, decalSurfaceData.baseColor.w);
-		surfaceData.normalWS.xyz = normalize(lerp(surfaceData.normalWS.xyz, decalSurfaceData.normalWS.xyz, decalSurfaceData.normalWS.w));
-		surfaceData.metallic = lerp(surfaceData.metallic, decalSurfaceData.mask.x, decalSurfaceData.mask.z);
-		surfaceData.ambientOcclusion = lerp(surfaceData.ambientOcclusion, decalSurfaceData.mask.y, decalSurfaceData.mask.z);
-		surfaceData.perceptualSmoothness = lerp(surfaceData.perceptualSmoothness, decalSurfaceData.mask.w, decalSurfaceData.mask.z);
+		// using alpha compositing https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+		surfaceData.baseColor.xyz = surfaceData.baseColor.xyz * decalSurfaceData.baseColor.w + decalSurfaceData.baseColor.xyz;
+		surfaceData.normalWS.xyz = normalize(surfaceData.normalWS.xyz * decalSurfaceData.normalWS.w + decalSurfaceData.normalWS.xyz);
+		surfaceData.metallic = surfaceData.metallic * decalSurfaceData.mask.w + decalSurfaceData.mask.x;
+		surfaceData.ambientOcclusion = surfaceData.ambientOcclusion * decalSurfaceData.mask.w + decalSurfaceData.mask.y;
+		surfaceData.perceptualSmoothness = surfaceData.perceptualSmoothness * decalSurfaceData.mask.w + decalSurfaceData.mask.z;
 	}
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Decal/ShaderPass/DecalSharePass.hlsl

 #error Undefine_SHADERPASS
 #endif
 
-// need 3 x float3 interpolators...
-#define VARYINGS_NEED_POSITION_WS
-#define VARYINGS_NEED_TANGENT_TO_WORLD
-
 // This include will define the various Attributes/Varyings structure
 #include "../../ShaderPass/VaryingMesh.hlsl"

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

         [ToggleUI] _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
 
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+        _TransparentSortPriority("_TransparentSortPriority", Float) = 0
 
         // Stencil state
         [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting
         _MainTex("Albedo", 2D) = "white" {}
         _Color("Color", Color) = (1,1,1,1)
         _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+
+        [ToggleUI] _SupportDBuffer("Support DBuffer", Float) = 1.0
     }
 
     HLSLINCLUDE
     #pragma shader_feature _DENSITY_MODE
     #pragma shader_feature _HEIGHT_BASED_BLEND
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
+
+    #pragma shader_feature _DISABLE_DBUFFER
 
     // Keyword for transparent
     #pragma shader_feature _SURFACE_TYPE_TRANSPARENT

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

 #else
     surfaceData.specularOcclusion = 1.0;
 #endif
-
-    AddDecalContribution(posInput.positionSS, surfaceData);
+
+#ifndef _DISABLE_DBUFFER
+    AddDecalContribution(posInput.positionSS, surfaceData);
+#endif
 
 #if defined(DEBUG_DISPLAY)
     if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)

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

         [ToggleUI] _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
 
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+        _TransparentSortPriority("_TransparentSortPriority", Float) = 0
 
         // Stencil state
         [HideInInspector] _StencilRef("_StencilRef", Int) = 2 // StencilLightingUsage.RegularLighting
         _MainTex("Albedo", 2D) = "white" {}
         _Color("Color", Color) = (1,1,1,1)
         _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+
+        [ToggleUI] _SupportDBuffer("Support DBuffer", Float) = 1.0
     }
 
     HLSLINCLUDE
     #pragma shader_feature _DENSITY_MODE
     #pragma shader_feature _HEIGHT_BASED_BLEND
     #pragma shader_feature _ _LAYEREDLIT_3_LAYERS _LAYEREDLIT_4_LAYERS
+
+    #pragma shader_feature _DISABLE_DBUFFER
 
     // Keyword for transparent
     #pragma shader_feature _SURFACE_TYPE_TRANSPARENT

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/Lit/Lit.cs

             // SpecularColor fold into fresnel0
 
             // SSS
-            public int diffusionProfile;
+            public uint diffusionProfile;
             public float subsurfaceMask;
 
             // Transmission

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

 
     // In forward everything is statically know and we could theorically cumulate all the material features. So the code reflect it.
     // However in practice we keep parity between deferred and forward, so we should constrain the various features.
-    // The UI is in charge of setuping the constrain, not the code. So if users is forward only and want unlish power, it is easy to unleash by some UI change
+    // The UI is in charge of setuping the constrain, not the code. So if users is forward only and want unleash power, it is easy to unleash by some UI change
 
     if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_SUBSURFACE_SCATTERING))
     {
 
         outGBuffer2.rgb = float3(surfaceData.anisotropy * 0.5 + 0.5,
                                  sinOrCos,
-                                 PackFloatUInt8bit(surfaceData.metallic, storeSin | quadrant, 8));
+                                 PackFloatInt8bit(surfaceData.metallic, storeSin | quadrant, 8));
     }
     else if (HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_IRIDESCENCE))
     {
-                                 PackFloatUInt8bit(surfaceData.metallic, 0, 8));
+                                 PackFloatInt8bit(surfaceData.metallic, 0, 8));
-        // In the case of standard or specular color we always uncompress before encoding, so decoding is more efficient (it allow better optimization for the compiler and save VGPR)
+        // In the case of standard or specular color we always convert to specular color parametrization before encoding, 
+        // so decoding is more efficient (it allow better optimization for the compiler and save VGPR)
         // This mean that on the decode side, MATERIALFEATUREFLAGS_LIT_SPECULAR_COLOR doesn't exist anymore
         materialFeatureId = GBUFFER_LIT_STANDARD;
 
     // Ensure that surfaceData.coatMask is 0 if the feature is not enabled
     float coatMask = HasFeatureFlag(surfaceData.materialFeatures, MATERIALFEATUREFLAGS_LIT_CLEAR_COAT) ? surfaceData.coatMask : 0.0;
     // Note: no need to store MATERIALFEATUREFLAGS_LIT_STANDARD, always present
-    outGBuffer2.a  = PackFloatUInt8bit(coatMask, materialFeatureId, 8);
+    outGBuffer2.a  = PackFloatInt8bit(coatMask, materialFeatureId, 8);
 
     // RT3 - 11f:11f:10f
     outGBuffer3 = float4(bakeDiffuseLighting, 0.0);
 // from the contents of the G-buffer, which can be used by the feature classification system.
-// Note that return type is not part of the MACRO DECODE_FROM_GBUFFER, so it is sage to use return value for our need
+// Note that return type is not part of the MACRO DECODE_FROM_GBUFFER, so it is safe to use return value for our need
 // 'tileFeatureFlags' are compile-time flags provided by the feature classification system.
 // If you're not using the feature classification system, pass UINT_MAX.
 // Also, see comment in TileVariantToFeatureFlags. When we are the worse case (i.e last variant), we read the featureflags
     // Material classification only uses the G-Buffer 2.
     float coatMask;
     uint materialFeatureId;
-    UnpackFloatUInt8bit(inGBuffer2.a, 8, coatMask, materialFeatureId);
+    UnpackFloatInt8bit(inGBuffer2.a, 8, coatMask, materialFeatureId);
 
     uint pixelFeatureFlags    = MATERIALFEATUREFLAGS_LIT_STANDARD; // Only sky/background do not have the Standard flag.
     bool pixelHasSubsurface   = materialFeatureId == GBUFFER_LIT_TRANSMISSION_SSS || materialFeatureId == GBUFFER_LIT_SSS;
     {
         float metallic;
         uint unused;
-        UnpackFloatUInt8bit(inGBuffer2.b, 8, metallic, unused);
+        UnpackFloatInt8bit(inGBuffer2.b, 8, metallic, unused);
 
         bsdfData.diffuseColor = ComputeDiffuseColor(baseColor, metallic);
         bsdfData.fresnel0     = ComputeFresnel0(baseColor, metallic, DEFAULT_SPECULAR_VALUE);
         // We must do this so the compiler can optimize away the read from the G-Buffer 0 to the very end (in PostEvaluateBSDF)
         // Note that we don't use sssData.subsurfaceMask here. But it is still assign so we can have the information in the 
         // material debug view + If we require it in the future. 
-        UnpackFloatUInt8bit(inGBuffer2.b, 16, sssData.subsurfaceMask, sssData.diffusionProfile);
+        UnpackFloatInt8bit(inGBuffer2.b, 16, sssData.subsurfaceMask, sssData.diffusionProfile);
 
         // Reminder: when using SSS we exchange specular occlusion and subsurfaceMask/profileID
         bsdfData.specularOcclusion = inGBuffer2.r;
 
             float unused;
             uint tangentFlags;
-            UnpackFloatUInt8bit(inGBuffer2.b, 8, unused, tangentFlags);
+            UnpackFloatInt8bit(inGBuffer2.b, 8, unused, tangentFlags);
 
             // Get the rotation angle of the actual tangent frame with respect to the default one.
             uint  quadrant = tangentFlags;

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

         [ToggleUI] _TransparentDepthPrepassEnable("_TransparentDepthPrepassEnable", Float) = 0.0
         [ToggleUI] _TransparentBackfaceEnable("_TransparentBackfaceEnable", Float) = 0.0
         [ToggleUI] _TransparentDepthPostpassEnable("_TransparentDepthPostpassEnable", Float) = 0.0
+        _TransparentSortPriority("_TransparentSortPriority", Float) = 0
 
         // Transparency
         [Enum(None, 0, Plane, 1, Sphere, 2)]_RefractionMode("Refraction Mode", Int) = 0
         _MainTex("Albedo", 2D) = "white" {}
         _Color("Color", Color) = (1,1,1,1)
         _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+
+        [ToggleUI] _SupportDBuffer("Support DBuffer", Float) = 1.0
     }
 
     HLSLINCLUDE
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _TRANSMITTANCECOLORMAP
+
+    #pragma shader_feature _DISABLE_DBUFFER
 
     // Keyword for transparent
     #pragma shader_feature _SURFACE_TYPE_TRANSPARENT

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

     // This is use with anisotropic material
     surfaceData.tangentWS = Orthonormalize(surfaceData.tangentWS, surfaceData.normalWS);
 
+#ifndef _DISABLE_DBUFFER
+#endif
 
 #if defined(DEBUG_DISPLAY)
     if (_DebugMipMapMode != DEBUGMIPMAPMODE_NONE)

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

         [ToggleUI] _TransparentDepthPrepassEnable("_TransparentDepthPrepassEnable", Float) = 0.0
         [ToggleUI] _TransparentBackfaceEnable("_TransparentBackfaceEnable", Float) = 0.0
         [ToggleUI] _TransparentDepthPostpassEnable("_TransparentDepthPostpassEnable", Float) = 0.0
+        _TransparentSortPriority("_TransparentSortPriority", Float) = 0
 
         // Transparency
         [Enum(None, 0, Plane, 1, Sphere, 2)]_RefractionMode("Refraction Mode", Int) = 0
         _MainTex("Albedo", 2D) = "white" {}
         _Color("Color", Color) = (1,1,1,1)
         _Cutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+
+        [ToggleUI] _SupportDBuffer("Support DBuffer", Float) = 1.0
     }
 
     HLSLINCLUDE
     #pragma shader_feature _THICKNESSMAP
     #pragma shader_feature _SPECULARCOLORMAP
     #pragma shader_feature _TRANSMITTANCECOLORMAP
+
+    #pragma shader_feature _DISABLE_DBUFFER
 
     // Keyword for transparent
     #pragma shader_feature _SURFACE_TYPE_TRANSPARENT

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

 // Note: The SSS buffer used here is sRGB
 void EncodeIntoSSSBuffer(SSSData sssData, uint2 positionSS, out SSSBufferType0 outSSSBuffer0)
 {
-    outSSSBuffer0 = float4(sssData.diffuseColor, PackFloatUInt8bit(sssData.subsurfaceMask, sssData.diffusionProfile, 16));
+    outSSSBuffer0 = float4(sssData.diffuseColor, PackFloatInt8bit(sssData.subsurfaceMask, sssData.diffusionProfile, 16));
 }
 
 // Note: The SSS buffer used here is sRGB
-    UnpackFloatUInt8bit(sssBuffer.a, 16, sssData.subsurfaceMask, sssData.diffusionProfile);
+    UnpackFloatInt8bit(sssBuffer.a, 16, sssData.subsurfaceMask, sssData.diffusionProfile);
 }
 
 void DecodeFromSSSBuffer(uint2 positionSS, out SSSData sssData)

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

 
         [ToggleUI]  _AlphaCutoffEnable("Alpha Cutoff Enable", Float) = 0.0
         _AlphaCutoff("Alpha Cutoff", Range(0.0, 1.0)) = 0.5
+        _TransparentSortPriority("_TransparentSortPriority", Float) = 0
 
         // Blending state
         [HideInInspector] _SurfaceType("__surfacetype", Float) = 0.0

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/CameraMotionVectors.shader

             float2 previousPositionCS = (prevHPos + 1.0) / 2.0;
             float2 positionCS = (curHPos + 1.0) / 2.0;
 
-        #if !UNITY_UV_STARTS_AT_TOP
+        #if UNITY_UV_STARTS_AT_TOP
             previousPositionCS.y = 1.0 - previousPositionCS.y;
             positionCS.y = 1.0 - positionCS.y;
         #endif

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

   m_EditorClassIdentifier: 
   defaultDiffuseMaterial: {fileID: 2100000, guid: 73c176f402d2c2f4d929aa5da7585d17,
     type: 2}
+  defaultDecalMaterial: {fileID: 2100000, guid: 500e733574922d04ea961553b1b26a63,
+    type: 2}
   defaultShader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   debugFontTexture: {fileID: 2800000, guid: a3ad2df0e49aaa341a3b3a80f93b3f66, type: 3}
   debugDisplayLatlongShader: {fileID: 4800000, guid: c1d1d149a043a5349ba367da6c2051ba,
   cameraMotionVectors: {fileID: 4800000, guid: 035941b63024d1943af48811c1db20d9, type: 3}
   copyStencilBuffer: {fileID: 4800000, guid: 3d1574f1cdfa0ce4995f9bc79ed7f8ec, type: 3}
   blit: {fileID: 4800000, guid: 370f7a9cc4e362d488af024d371091e8, type: 3}
+  blitFlipMip: {fileID: 4800000, guid: ef092fc4aaa1bb546a9ab4e457c4b07a, type: 3}
   blitCubemap: {fileID: 4800000, guid: d05913e251bed7a4992c921c62e1b647, type: 3}
   buildProbabilityTables: {fileID: 7200000, guid: b9f26cf340afe9145a699753531b2a4c,
     type: 3}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/RenderPipelineResources.cs

     {
         // Default Material / Shader
         public Material defaultDiffuseMaterial;
+        public Material defaultDecalMaterial;
         public Shader defaultShader;
 
         // Debug

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/ShaderPassDBuffer.hlsl

 
 #include "VertMesh.hlsl"
 
-float3 RemoveScale(float3 val)
-{
-	return normalize(val / length(val));
-}
-
-VaryingsMeshType Transform(AttributesMesh input)
-{
-    VaryingsMeshType output;
-
-	UNITY_SETUP_INSTANCE_ID(input)
-	UNITY_TRANSFER_INSTANCE_ID(input, output);
-
-    float3 positionWS = TransformObjectToWorld(input.positionOS);
-	positionWS = GetCameraRelativePositionWS(positionWS);
-	output.positionCS = TransformWorldToHClip(positionWS);
-
-	float3x3 decalRotation;
-	decalRotation[0] = RemoveScale(float3(UNITY_MATRIX_M[0][0], UNITY_MATRIX_M[0][1], UNITY_MATRIX_M[0][2]));
-	decalRotation[2] = RemoveScale(float3(UNITY_MATRIX_M[1][0], UNITY_MATRIX_M[1][1], UNITY_MATRIX_M[1][2]));
-	decalRotation[1] = RemoveScale(float3(UNITY_MATRIX_M[2][0], UNITY_MATRIX_M[2][1], UNITY_MATRIX_M[2][2]));
-
-	decalRotation = transpose(decalRotation);
-
-	output.positionWS = decalRotation[0];
-    output.normalWS = decalRotation[1];
-    output.tangentWS = float4(decalRotation[2], 0.0);
-
-    return output;
-}
-    varyingsType.vmesh = Transform(inputMesh);
+    varyingsType.vmesh = VertMesh(inputMesh);
     return PackVaryingsType(varyingsType);
 }
 
 	clip(1.0 - positionDS); // Clip value above one
 
     DecalSurfaceData surfaceData;
-	float3x3 decalToWorld;
-	// using the interpolators directly, because UnpackVaryingsMeshToFragInputs does some tangent space manipulations
-	decalToWorld[0] = packedInput.vmesh.interpolators0;
-	decalToWorld[1] = packedInput.vmesh.interpolators1;
-	decalToWorld[2] = packedInput.vmesh.interpolators2.xyz;
-
+	float3x3 decalToWorld = (float3x3)UNITY_ACCESS_INSTANCED_PROP(matrix, normalToWorld);
     GetSurfaceData(positionDS.xz, decalToWorld, surfaceData);
 
 	ENCODE_INTO_DBUFFER(surfaceData, outDBuffer);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderPass/VertMesh.hlsl

     float3 normalWS = float3(0.0, 0.0, 0.0); // We need this case to be able to compile ApplyVertexModification that doesn't use normal.
 #endif
 
-	float4 tangentWS = float4(0.0, 0.0, 0.0, 0.0);
-    tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
+     float4 tangentWS = float4(TransformObjectToWorldDir(input.tangentOS.xyz), input.tangentOS.w);
 #endif
 
     // TODO: deal with camera center rendering and instancing (This is the reason why we always perform two  steps transform to clip space + instancing matrix)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

     float4 unity_ShadowColor;
     float2 _TaaFrameRotation; // {x = sin(_TaaFrameIndex * PI/2), y = cos(_TaaFrameIndex * PI/2), z = unused}
     uint   _TaaFrameIndex;    // [0, 7]
-    uint   _Align128;         // Pad for 128-bit alignment
-    // Volumetric lighting. Should be a struct in 'UnityPerFrame'.
-    // Unfortunately, structures inside constant buffers are not supported by Unity.
+    // Volumetric lighting.
+    float  _GlobalFog_Asymmetry;
     float3 _GlobalFog_Scattering;
     float  _GlobalFog_Extinction;
     float4 _VBufferResolution;          // { w, h, 1/w, 1/h }

ScriptableRenderPipeline/HDRenderPipeline/package.json

 {
     "name": "com.unity.render-pipelines.high-definition",
     "description": "HD Render Pipeline for Unity.",
-    "version": "0.1.25",
+    "version": "0.1.26",
-        "com.unity.render-pipelines.core": "0.1.25"
+        "com.unity.render-pipelines.core": "0.1.26"
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineAsset.cs

 #if UNITY_EDITOR
+using System;
 using UnityEditor;
 using UnityEditor.ProjectWindowCallback;
 #endif
         [SerializeField] private ShadowCascades m_ShadowCascades = ShadowCascades.FOUR_CASCADES;
         [SerializeField] private float m_Cascade2Split = 0.25f;
         [SerializeField] private Vector3 m_Cascade4Split = new Vector3(0.067f, 0.2f, 0.467f);
+        
+        [SerializeField]
+        private LightweightPipelineResources m_ResourcesAsset;
-        // Resources
-        [SerializeField] private Shader m_BlitShader;
-        [SerializeField] private Shader m_CopyDepthShader;
-        private LightweightPipelineResource m_ResourceAsset;
+        private LightweightPipelineEditorResources m_EditorResourcesAsset;
 
         [MenuItem("Assets/Create/Render Pipeline/Lightweight/Pipeline Asset", priority = CoreUtils.assetCreateMenuPriority1)]
         static void CreateLightweightPipeline()
         }
 
+
+        //[MenuItem("Assets/Create/Render Pipeline/Lightweight/Pipeline Resources", priority = CoreUtils.assetCreateMenuPriority1)]
+        static void CreateLightweightPipelineResources()
+        {
+            var instance = CreateInstance<LightweightPipelineResources>();
+            AssetDatabase.CreateAsset(instance, string.Format("Assets/{0}.asset", typeof(LightweightPipelineResources).Name));
+        }
+
+        //[MenuItem("Assets/Create/Render Pipeline/Lightweight/Pipeline Editor Resources", priority = CoreUtils.assetCreateMenuPriority1)]
+        static void CreateLightweightPipelineEditorResources()
+        {
+            var instance = CreateInstance<LightweightPipelineEditorResources>();
+            AssetDatabase.CreateAsset(instance, string.Format("Assets/{0}.asset", typeof(LightweightPipelineEditorResources).Name));
+        }
+
+
-                instance.m_BlitShader = Shader.Find(LightweightShaderUtils.GetShaderPath(ShaderPathID.HIDDEN_BLIT));
-                instance.m_CopyDepthShader = Shader.Find(LightweightShaderUtils.GetShaderPath(ShaderPathID.HIDDEN_DEPTH_COPY));
-
+                instance.m_EditorResourcesAsset = LoadResourceFile<LightweightPipelineEditorResources>();
+                instance.m_ResourcesAsset = LoadResourceFile<LightweightPipelineResources>();
-        private void LoadResourceFile()
+        private static T LoadResourceFile<T>() where T : ScriptableObject
-            string[] guids = AssetDatabase.FindAssets("LightweightPipelineResource t:scriptableobject", m_SearchPaths);
-            LightweightPipelineResource resourceAsset = null;
+            T resourceAsset = null;
+            var guids = AssetDatabase.FindAssets(typeof(T).Name + " t:scriptableobject", m_SearchPaths);
-                m_ResourceAsset = AssetDatabase.LoadAssetAtPath<LightweightPipelineResource>(path);
-                if (m_ResourceAsset != null)
+                resourceAsset = AssetDatabase.LoadAssetAtPath<T>(path);
+                if (resourceAsset != null)
-            if (m_ResourceAsset == null)
+            if (resourceAsset == null)
+            {
+                string path = m_SearchPaths[PACKAGE_MANAGER_PATH_INDEX] + "/LWRP/Data/" + typeof(T).Name + ".asset";
+                resourceAsset = AssetDatabase.LoadAssetAtPath<T>(path);
+            }
+            return resourceAsset;
+        }
+
+        LightweightPipelineEditorResources editorResources
+        {
+            get
-                string path = m_SearchPaths[PACKAGE_MANAGER_PATH_INDEX] + "/LWRP/Data/LightweightPipelineResource.asset";
-                m_ResourceAsset = AssetDatabase.LoadAssetAtPath<LightweightPipelineResource>(path);
+                if (m_EditorResourcesAsset == null)
+                    m_EditorResourcesAsset = LoadResourceFile<LightweightPipelineEditorResources>();
+
+                return m_EditorResourcesAsset;
+        LightweightPipelineResources resources
+        {
+            get
+            {
+#if UNITY_EDITOR
+                if (m_ResourcesAsset == null)
+                    m_ResourcesAsset = LoadResourceFile<LightweightPipelineResources>();
+#endif
+                return m_ResourcesAsset;
+            }
+        }
 
         protected override IRenderPipeline InternalCreatePipeline()
         {
         private Material GetMaterial(DefaultMaterialType materialType)
         {
 #if UNITY_EDITOR
-            if (m_ResourceAsset == null)
-                LoadResourceFile();
-
+            
-                    return m_ResourceAsset.DefaultMaterial;
+                    return editorResources.DefaultMaterial;
-                    return m_ResourceAsset.DefaultParticleMaterial;
+                    return editorResources.DefaultParticleMaterial;
-                    return m_ResourceAsset.DefaultTerrainMaterial;
+                    return editorResources.DefaultTerrainMaterial;
 
                 // Unity Builtin Default
                 default:
 
         public Shader BlitShader
         {
-            get { return m_BlitShader; }
+            get { return resources != null ? resources.BlitShader : null; }
-            get { return m_CopyDepthShader; }
+            get { return resources != null ? resources.CopyDepthShader : null; }
         }
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineEditorResources.cs.meta

 fileFormatVersion: 2
-guid: eb91b173ce266e040aa972ca9a561308
+guid: 76e49a5b88430df478c504fe5a5c1a62
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

ScriptableRenderPipeline/LightweightPipeline/package.json

 {
     "name": "com.unity.render-pipelines.lightweight",
     "description": "Lightweight Render Pipeline for Unity.",
-    "version": "0.1.25",
+    "version": "0.1.26",
-        "com.unity.render-pipelines.core": "0.1.25"
+        "com.unity.render-pipelines.core": "0.1.26"
     }
 }

ScriptableRenderPipeline/master-package.json

 {
-    "version": "0.1.25",
+    "version": "0.1.26",
     "unity": "2018.1",
     "dependencies": {
         "com.unity.postprocessing": "0.1.7"

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/3DObjects/PerryHead/Head.fbx.meta

     secondaryUVAreaDistortion: 15.000001
     secondaryUVHardAngle: 88
     secondaryUVPackMargin: 4
-    useFileScale: 0
+    useFileScale: 1
   tangentSpace:
     normalSmoothAngle: 60
     normalImportMode: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/3DObjects/PerryHead/Head.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: HEAD
+  m_Name: Head
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _MATERIAL_FEATURE_SUBSURFACE_SCATTERING _MATERIAL_FEATURE_TRANSMISSION
     _NORMALMAP _NORMALMAP_TANGENT_SPACE _THICKNESSMAP

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/HDRP_GraphicTests_Asset.asset

     supportSubsurfaceScattering: 1
     supportDBuffer: 1
     supportMSAA: 0
-    supportAsyncCompute: 0
     lightLoopSettings:
       spotCookieSize: 128
       cookieTexArraySize: 16

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/SkySettings/HDRP_Black_Sky_Shadow50.asset

     m_OverrideState: 0
     m_Value: 0
     min: 0
-  useForBaking: 1
   skyHDRI:
     m_OverrideState: 1
     m_Value: {fileID: 8900000, guid: 75f8ba90acb52d14d9ead53b2a9e4190, type: 3}

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/Tests_Diffusion_Profile_Settings.asset

   m_EditorClassIdentifier: 
   profiles:
   - name: Skin
-    scatteringDistance: {r: 0.7568628, g: 0.32156864, b: 0.20000002, a: 1}
+    scatteringDistance: {r: 0.75686276, g: 0.32156864, b: 0.2, a: 1}
     transmissionTint: {r: 0.7568628, g: 0.32156864, b: 0.20000002, a: 1}
     texturingMode: 0
     transmissionMode: 2
     scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
     scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
     lerpWeight: 1
-  - name: Profile 7
-    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  - name: Layer_1
+    scatteringDistance: {r: 1, g: 0, b: 0, a: 1}
-    transmissionMode: 0
+    transmissionMode: 1
     thicknessRemap: {x: 0, y: 5}
     worldScale: 1
     ior: 1.4
-  - name: Profile 8
-    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  - name: Layer_2
+    scatteringDistance: {r: 0, g: 1, b: 0, a: 1}
-    transmissionMode: 0
+    transmissionMode: 1
     thicknessRemap: {x: 0, y: 5}
     worldScale: 1
     ior: 1.4
-  - name: Profile 9
-    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  - name: Layer_3
+    scatteringDistance: {r: 0, g: 0, b: 1, a: 1}
-    texturingMode: 0
-    transmissionMode: 0
+    texturingMode: 1
+    transmissionMode: 1
     thicknessRemap: {x: 0, y: 5}
     worldScale: 1
     ior: 1.4
-  - name: Layer_1
-    scatteringDistance: {r: 1, g: 0, b: 0, a: 1}
+  - name: Layer_Base
+    scatteringDistance: {r: 1, g: 1, b: 1, a: 1}
-    texturingMode: 0
+    texturingMode: 1
     transmissionMode: 1
     thicknessRemap: {x: 0, y: 5}
     worldScale: 1
     lerpWeight: 1
-  - name: Layer_2
-    scatteringDistance: {r: 0, g: 1, b: 0, a: 1}
+  - name: MaxRadius_1
+    scatteringDistance: {r: 0.09758736, g: 0, b: 0, a: 1}
-    transmissionMode: 1
+    transmissionMode: 0
     thicknessRemap: {x: 0, y: 5}
     worldScale: 1
     ior: 1.4
-  - name: Layer_3
-    scatteringDistance: {r: 0, g: 0, b: 1, a: 1}
+  - name: MaxRadius_5
+    scatteringDistance: {r: 0.48235294, g: 0, b: 0, a: 1}
-    texturingMode: 1
-    transmissionMode: 1
+    texturingMode: 0
+    transmissionMode: 0
     thicknessRemap: {x: 0, y: 5}
     worldScale: 1
     ior: 1.4
-  - name: Layer_Base
-    scatteringDistance: {r: 1, g: 1, b: 1, a: 1}
+  - name: MaxRadius_10
+    scatteringDistance: {r: 0.9646866, g: 0, b: 0, a: 1}
-    texturingMode: 1
-    transmissionMode: 1
+    texturingMode: 0
+    transmissionMode: 0
     thicknessRemap: {x: 0, y: 5}
     worldScale: 1
     ior: 1.4
-  - name: Profile 14
-    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  - name: MaxRadius_15
+    scatteringDistance: {r: 1.4491405, g: 0, b: 0, a: 1}
     transmissionTint: {r: 1, g: 1, b: 1, a: 1}
     texturingMode: 0
     transmissionMode: 0
     scatterDistance1: {r: 0.3, g: 0.3, b: 0.3, a: 0}
     scatterDistance2: {r: 0.5, g: 0.5, b: 0.5, a: 0}
     lerpWeight: 1
-  - name: Profile 15
-    scatteringDistance: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  - name: MaxRadius_20
+    scatteringDistance: {r: 1.9321873, g: 0, b: 0, a: 1}
     transmissionTint: {r: 1, g: 1, b: 1, a: 1}
     texturingMode: 0
     transmissionMode: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1301_SubSurfaceScattering.unity

       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 8
+      value: 7
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 2100000, guid: 5876c1ab9bf098845aa32568a6303963, type: 2}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.x
-      value: 2.8566823
+      value: 2.8566794
-      value: 2.8566825
+      value: 2.8566828
-      value: 2.8566825
+      value: 2.8566835
       objectReference: {fileID: 0}
     - target: {fileID: 100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_Name
       objectReference: {fileID: 0}
     - target: {fileID: 4295600896743834, guid: b186ef7597e8a464c9a4af7b87825a5f, type: 2}
       propertyPath: m_LocalRotation.x
-      value: 0
+      value: -0
-      value: 0
+      value: -0
-      value: 0
+      value: -0
       objectReference: {fileID: 0}
     - target: {fileID: 4295600896743834, guid: b186ef7597e8a464c9a4af7b87825a5f, type: 2}
       propertyPath: m_LocalRotation.w
       propertyPath: m_RootOrder
-      value: 1
+      value: 2
       objectReference: {fileID: 0}
     - target: {fileID: 114888363301181934, guid: b186ef7597e8a464c9a4af7b87825a5f,
         type: 2}
         type: 2}
+    - target: {fileID: 4295600896743834, guid: b186ef7597e8a464c9a4af7b87825a5f, type: 2}
+      propertyPath: m_LocalScale.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: b186ef7597e8a464c9a4af7b87825a5f, type: 2}
+      propertyPath: m_LocalScale.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: b186ef7597e8a464c9a4af7b87825a5f, type: 2}
+      propertyPath: m_LocalScale.z
+      value: 1
+      objectReference: {fileID: 0}
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: b186ef7597e8a464c9a4af7b87825a5f, type: 2}
   m_IsPrefabParent: 0
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 771994609}
-  m_RootOrder: 8
+  m_RootOrder: 6
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!102 &67174663
 TextMesh:
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 14
+      value: 13
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 2100000, guid: b4e22f165330abf4cad98aaea0356496, type: 2}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.x
-      value: 2.8566823
+      value: 2.8566794
-      value: 2.8566825
+      value: 2.8566828
-      value: 2.8566825
+      value: 2.8566835
       objectReference: {fileID: 0}
     - target: {fileID: 100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_Name
       objectReference: {fileID: 0}
     - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
       propertyPath: m_LocalRotation.x
-      value: 0
+      value: -0
-      value: 0
+      value: -0
-      value: 0
+      value: -0
       objectReference: {fileID: 0}
     - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
       propertyPath: m_LocalRotation.w
       propertyPath: m_RootOrder
-      value: 0
+      value: 1
       objectReference: {fileID: 0}
     - target: {fileID: 20109210616973140, guid: c07ace9ab142ca9469fa377877c2f1e7,
         type: 2}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalScale.x
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalScale.y
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalScale.z
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 20109210616973140, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: near clip plane
+      value: 0.5
+      objectReference: {fileID: 0}
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
   m_IsPrefabParent: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 220210439}
   m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
---- !u!1 &230844047
-GameObject:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 230844048}
-  - component: {fileID: 230844050}
-  - component: {fileID: 230844049}
-  m_Layer: 0
-  m_Name: New Text (7)
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &230844048
-Transform:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 230844047}
-  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
-  m_LocalPosition: {x: 2, y: -1, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 771994609}
-  m_RootOrder: 7
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!102 &230844049
-TextMesh:
-  serializedVersion: 3
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 230844047}
-  m_Text: 'Skin
-
-    post
-
-    scatter'
-  m_OffsetZ: 0
-  m_CharacterSize: 0.2
-  m_LineSpacing: 1
-  m_Anchor: 7
-  m_Alignment: 1
-  m_TabSize: 4
-  m_FontSize: 0
-  m_FontStyle: 0
-  m_RichText: 1
-  m_Font: {fileID: 12800000, guid: 306d620c715872046bf76568b7f382d4, type: 3}
-  m_Color:
-    serializedVersion: 2
-    rgba: 4294967295
---- !u!23 &230844050
-MeshRenderer:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 230844047}
-  m_Enabled: 1
-  m_CastShadows: 1
-  m_ReceiveShadows: 1
-  m_DynamicOccludee: 1
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_RenderingLayerMask: 4294967295
-  m_Materials:
-  - {fileID: 2100000, guid: 306d620c715872046bf76568b7f382d4, type: 3}
-  m_StaticBatchInfo:
-    firstSubMesh: 0
-    subMeshCount: 0
-  m_StaticBatchRoot: {fileID: 0}
-  m_ProbeAnchor: {fileID: 0}
-  m_LightProbeVolumeOverride: {fileID: 0}
-  m_ScaleInLightmap: 1
-  m_PreserveUVs: 0
-  m_IgnoreNormalsForChartDetection: 0
-  m_ImportantGI: 0
-  m_StitchLightmapSeams: 0
-  m_SelectedEditorRenderState: 3
-  m_MinimumChartSize: 4
-  m_AutoUVMaxDistance: 0.5
-  m_AutoUVMaxAngle: 89
-  m_LightmapParameters: {fileID: 0}
-  m_SortingLayerID: 0
-  m_SortingLayer: 0
-  m_SortingOrder: 0
 --- !u!1 &250393684
 GameObject:
   m_ObjectHideFlags: 0
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 771994609}
-  m_RootOrder: 9
+  m_RootOrder: 7
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!102 &277866573
 TextMesh:
   serializedVersion: 8
   m_Type: 1
   m_Color: {r: 1, g: 1, b: 1, a: 1}
-  m_Intensity: 10
+  m_Intensity: 8
   m_Range: 10
   m_SpotAngle: 30
   m_CookieSize: 10
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 381281792}
-  m_LocalRotation: {x: 0, y: 1, z: 0, w: 0}
+  m_LocalRotation: {x: -0, y: 1, z: -0, w: 0}
-  m_RootOrder: 3
+  m_RootOrder: 4
   m_LocalEulerAnglesHint: {x: 0, y: 180, z: 0}
 --- !u!21 &409538476
 Material:
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 771994608}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
   m_LocalPosition: {x: 0, y: 0, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children:
   - {fileID: 912967532}
   - {fileID: 671230715}
   - {fileID: 604442199}
-  - {fileID: 1269136090}
-  - {fileID: 230844048}
-  m_RootOrder: 2
+  m_RootOrder: 3
---- !u!1001 &810285752
-Prefab:
-  m_ObjectHideFlags: 0
-  serializedVersion: 2
-  m_Modification:
-    m_TransformParent: {fileID: 0}
-    m_Modifications:
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalPosition.x
-      value: 2
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalPosition.y
-      value: -2.25
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalPosition.z
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalRotation.x
-      value: 1.5099031e-14
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalRotation.y
-      value: -1
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalRotation.z
-      value: 0.000000081460335
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalRotation.w
-      value: 0.00000017881392
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_RootOrder
-      value: 6
-      objectReference: {fileID: 0}
-    - target: {fileID: 1792460656933372, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_Name
-      value: Head (1)
-      objectReference: {fileID: 0}
-    - target: {fileID: 23113962114029628, guid: f2effce216eb4e643a653d29bfa79bf0,
-        type: 2}
-      propertyPath: m_Materials.Array.data[0]
-      value: 
-      objectReference: {fileID: 2100000, guid: 918541971114bf14780a1d8792060868, type: 2}
-    m_RemovedComponents: []
-  m_ParentPrefab: {fileID: 100100000, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-  m_IsPrefabParent: 0
 --- !u!1001 &836803415
 Prefab:
   m_ObjectHideFlags: 0
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 15
+      value: 14
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 2100000, guid: b4e22f165330abf4cad98aaea0356496, type: 2}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.x
-      value: 2.8566823
+      value: 2.8566911
-      value: 2.8566825
+      value: 2.8566914
-      value: 2.8566825
+      value: 2.856683
       objectReference: {fileID: 0}
     - target: {fileID: 100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_Name
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 13
+      value: 12
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.y
-      value: 2.8566825
+      value: 2.8566835
-      value: 2.8566825
+      value: 2.8566835
       objectReference: {fileID: 0}
     - target: {fileID: 100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_Name
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1000486591}
-  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
   m_LocalPosition: {x: -8.5, y: 5, z: 0}
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children:
   - {fileID: 917736090}
   - {fileID: 145388030}
   m_Father: {fileID: 0}
-  m_RootOrder: 16
+  m_RootOrder: 15
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!21 &1048812613
 Material:
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 7
+      value: 6
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.y
-      value: 2.8566825
+      value: 2.8566835
-      value: 2.8566825
+      value: 2.8566835
       objectReference: {fileID: 0}
     m_RemovedComponents: []
   m_ParentPrefab: {fileID: 100100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 11
+      value: 10
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 2100000, guid: 717c824a0250ad24c8da9ec3eebe8fcc, type: 2}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.x
-      value: 2.8566823
+      value: 2.8566794
-      value: 2.8566825
+      value: 2.8566828
-      value: 2.8566825
+      value: 2.8566835
       objectReference: {fileID: 0}
     - target: {fileID: 100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_Name
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
---- !u!1 &1269136089
-GameObject:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  serializedVersion: 5
-  m_Component:
-  - component: {fileID: 1269136090}
-  - component: {fileID: 1269136092}
-  - component: {fileID: 1269136091}
-  m_Layer: 0
-  m_Name: New Text (6)
-  m_TagString: Untagged
-  m_Icon: {fileID: 0}
-  m_NavMeshLayer: 0
-  m_StaticEditorFlags: 0
-  m_IsActive: 1
---- !u!4 &1269136090
-Transform:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 1269136089}
-  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
-  m_LocalPosition: {x: 2, y: 4.5, z: 0}
-  m_LocalScale: {x: 1, y: 1, z: 1}
-  m_Children: []
-  m_Father: {fileID: 771994609}
-  m_RootOrder: 6
-  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
---- !u!102 &1269136091
-TextMesh:
-  serializedVersion: 3
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 1269136089}
-  m_Text: 'Skin
-
-    pre + post
-
-    scatter'
-  m_OffsetZ: 0
-  m_CharacterSize: 0.2
-  m_LineSpacing: 1
-  m_Anchor: 7
-  m_Alignment: 1
-  m_TabSize: 4
-  m_FontSize: 0
-  m_FontStyle: 0
-  m_RichText: 1
-  m_Font: {fileID: 12800000, guid: 306d620c715872046bf76568b7f382d4, type: 3}
-  m_Color:
-    serializedVersion: 2
-    rgba: 4294967295
---- !u!23 &1269136092
-MeshRenderer:
-  m_ObjectHideFlags: 0
-  m_PrefabParentObject: {fileID: 0}
-  m_PrefabInternal: {fileID: 0}
-  m_GameObject: {fileID: 1269136089}
-  m_Enabled: 1
-  m_CastShadows: 1
-  m_ReceiveShadows: 1
-  m_DynamicOccludee: 1
-  m_MotionVectors: 1
-  m_LightProbeUsage: 1
-  m_ReflectionProbeUsage: 1
-  m_RenderingLayerMask: 4294967295
-  m_Materials:
-  - {fileID: 2100000, guid: 306d620c715872046bf76568b7f382d4, type: 3}
-  m_StaticBatchInfo:
-    firstSubMesh: 0
-    subMeshCount: 0
-  m_StaticBatchRoot: {fileID: 0}
-  m_ProbeAnchor: {fileID: 0}
-  m_LightProbeVolumeOverride: {fileID: 0}
-  m_ScaleInLightmap: 1
-  m_PreserveUVs: 0
-  m_IgnoreNormalsForChartDetection: 0
-  m_ImportantGI: 0
-  m_StitchLightmapSeams: 0
-  m_SelectedEditorRenderState: 3
-  m_MinimumChartSize: 4
-  m_AutoUVMaxDistance: 0.5
-  m_AutoUVMaxAngle: 89
-  m_LightmapParameters: {fileID: 0}
-  m_SortingLayerID: 0
-  m_SortingLayer: 0
-  m_SortingOrder: 0
 --- !u!1 &1302942539
 GameObject:
   m_ObjectHideFlags: 0
   m_LocalScale: {x: 4, y: 4, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 17
+  m_RootOrder: 16
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: -360}
 --- !u!1 &1340200588
 GameObject:
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1340200588}
   m_LocalRotation: {x: -0, y: -0, z: -0.00000016391276, w: -1}
-  m_LocalPosition: {x: -5.56, y: -1.56, z: 0}
+  m_LocalPosition: {x: -5.56, y: -1.5600001, z: 0}
-  m_RootOrder: 18
+  m_RootOrder: 17
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: -360}
 --- !u!1001 &1441359452
 Prefab:
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 10
+      value: 9
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.y
-      value: 2.8566825
+      value: 2.8566835
-      value: 2.8566825
+      value: 2.8566835
       objectReference: {fileID: 0}
     - target: {fileID: 100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_Name
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 771994609}
-  m_RootOrder: 10
+  m_RootOrder: 8
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!102 &1531165764
 TextMesh:
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 9
+      value: 8
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 2100000, guid: 5876c1ab9bf098845aa32568a6303963, type: 2}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.x
-      value: 2.8566823
+      value: 2.8566911
-      value: 2.8566825
+      value: 2.8566914
-      value: 2.8566825
+      value: 2.856683
       objectReference: {fileID: 0}
     - target: {fileID: 100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_Name
     - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
     - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
---- !u!1001 &1838000653
-Prefab:
+--- !u!1 &1893962181
+GameObject:
-  serializedVersion: 2
-  m_Modification:
-    m_TransformParent: {fileID: 0}
-    m_Modifications:
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalPosition.x
-      value: 2
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalPosition.y
-      value: 3.25
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalPosition.z
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalRotation.x
-      value: 1.5099031e-14
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalRotation.y
-      value: -1
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalRotation.z
-      value: 0.000000081460335
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_LocalRotation.w
-      value: 0.00000017881392
-      objectReference: {fileID: 0}
-    - target: {fileID: 4961272497354926, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-      propertyPath: m_RootOrder
-      value: 5
-      objectReference: {fileID: 0}
-    m_RemovedComponents: []
-  m_ParentPrefab: {fileID: 100100000, guid: f2effce216eb4e643a653d29bfa79bf0, type: 2}
-  m_IsPrefabParent: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1893962182}
+  m_Layer: 0
+  m_Name: GameObject (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1893962182
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1893962181}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 10, y: 10, z: 10}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1925246179
 GameObject:
   m_ObjectHideFlags: 0
   m_LocalScale: {x: 1, y: 1, z: 1}
   m_Children: []
   m_Father: {fileID: 0}
-  m_RootOrder: 4
+  m_RootOrder: 5
   m_LocalEulerAnglesHint: {x: 50, y: -30, z: 0}
 --- !u!1001 &1957283786
 Prefab:
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_RootOrder
-      value: 12
+      value: 11
       objectReference: {fileID: 0}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalEulerAnglesHint.x
       objectReference: {fileID: 2100000, guid: 717c824a0250ad24c8da9ec3eebe8fcc, type: 2}
     - target: {fileID: 400000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_LocalScale.x
-      value: 2.8566823
+      value: 2.8566911
-      value: 2.8566825
+      value: 2.8566914
-      value: 2.8566825
+      value: 2.856683
       objectReference: {fileID: 0}
     - target: {fileID: 100000, guid: b579c7fa4fa7b4b41aad9c740d4c6c79, type: 3}
       propertyPath: m_Name

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1301_SubSurfaceScattering/SSS_Layered.mat

     - _DetailSmoothnessScale2: 1
     - _DetailSmoothnessScale3: 1
     - _DiffusionProfile: 3
-    - _DiffusionProfile0: 13
-    - _DiffusionProfile1: 10
-    - _DiffusionProfile2: 11
-    - _DiffusionProfile3: 12
+    - _DiffusionProfile0: 10
+    - _DiffusionProfile1: 7
+    - _DiffusionProfile2: 8
+    - _DiffusionProfile3: 9
     - _DisplacementLockObjectScale: 1
     - _DisplacementLockTilingScale: 1
     - _DisplacementMode: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1301_SubSurfaceScattering/ThicknessTest.MAT

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: FLATSKIN
+  m_Name: ThicknessTest
   m_Shader: {fileID: 4800000, guid: 6e4ae4064600d784cac1e41a9e6f2e59, type: 3}
   m_ShaderKeywords: _MATERIAL_FEATURE_SUBSURFACE_SCATTERING _MATERIAL_FEATURE_TRANSMISSION
     _NORMALMAP_TANGENT_SPACE

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1301_SubSurfaceScattering/LayerRef.mat

   m_ObjectHideFlags: 0
   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
-  m_Name: LAYERREF
+  m_Name: LayerRef
   m_Shader: {fileID: 4800000, guid: c4edd00ff2db5b24391a4fcb1762e459, type: 3}
   m_ShaderKeywords: _LAYEREDLIT_4_LAYERS _MATERIAL_FEATURE_SUBSURFACE_SCATTERING _MATERIAL_FEATURE_TRANSMISSION
     _NORMALMAP _NORMALMAP_TANGENT_SPACE _NORMALMAP_TANGENT_SPACE0 _NORMALMAP_TANGENT_SPACE1

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask.unity

   m_ReflectionIntensity: 1
   m_CustomReflection: {fileID: 0}
   m_Sun: {fileID: 0}
-  m_IndirectSpecularColor: {r: 0.018302627, g: 0.019231804, b: 0.021260915, a: 1}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
   m_UseRadianceAmbientProbe: 0
 --- !u!157 &3
 LightmapSettings:
   shadowResolution: 256
   shadowDimmer: 0.5
   shadowFadeDistance: 20
+  enableContactShadows: 0
+  contactShadowLength: 0
+  contactShadowDistanceScaleFactor: 0.5
+  contactShadowMaxDistance: 50
+  contactShadowFadeDistance: 5
+  contactShadowSampleCount: 8
   shadowCascadeCount: 4
   shadowCascadeRatios:
   - 0.05
   volumeLayerMask:
     serializedVersion: 2
     m_Bits: 4294967295
-  serializedFrameSettings:
+  m_FrameSettings:
+    enableContactShadows: 1
-    enableSSSAndTransmission: 1
+    enableSubsurfaceScattering: 1
+    enableTransmission: 1
     diffuseGlobalDimmer: 1
     specularGlobalDimmer: 1
     enableForwardRenderingOnly: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 815655995}
   m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
---- !u!1001 &911408450
-Prefab:
-  m_ObjectHideFlags: 0
-  serializedVersion: 2
-  m_Modification:
-    m_TransformParent: {fileID: 0}
-    m_Modifications:
-    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-      propertyPath: m_LocalPosition.x
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-      propertyPath: m_LocalPosition.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-      propertyPath: m_LocalPosition.z
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-      propertyPath: m_LocalRotation.x
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-      propertyPath: m_LocalRotation.y
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-      propertyPath: m_LocalRotation.z
-      value: 0
-      objectReference: {fileID: 0}
-    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-      propertyPath: m_LocalRotation.w
-      value: 1
-      objectReference: {fileID: 0}
-    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-      propertyPath: m_RootOrder
-      value: 1
-      objectReference: {fileID: 0}
-    m_RemovedComponents: []
-  m_ParentPrefab: {fileID: 100100000, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
-  m_IsPrefabParent: 0
 --- !u!1 &929288949
 GameObject:
   m_ObjectHideFlags: 0
   shadowResolution: 512
   shadowDimmer: 0.5
   shadowFadeDistance: 20
+  enableContactShadows: 0
+  contactShadowLength: 0
+  contactShadowDistanceScaleFactor: 0.5
+  contactShadowMaxDistance: 50
+  contactShadowFadeDistance: 5
+  contactShadowSampleCount: 8
   shadowCascadeCount: 4
   shadowCascadeRatios:
   - 0.05
   m_Father: {fileID: 522989562}
   m_RootOrder: 1
   m_LocalEulerAnglesHint: {x: 0, y: 0, z: -90.00001}
+--- !u!1 &1783632093
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 1673868521865844, guid: 7dde90a97c3ee4d4da77e66970eb07eb,
+    type: 2}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1783632096}
+  - component: {fileID: 1783632095}
+  - component: {fileID: 1783632094}
+  m_Layer: 0
+  m_Name: HDRP_Black_Sky
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1783632094
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 114663566010530930, guid: 7dde90a97c3ee4d4da77e66970eb07eb,
+    type: 2}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1783632093}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 441482e8936e35048a1dffac814e3ef8, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Profile: {fileID: 11400000, guid: 0d615c3f4f4e27d44af6c4fed3bb683c, type: 2}
+  m_BakingSkyUniqueID: 1
+--- !u!114 &1783632095
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 114888363301181934, guid: 7dde90a97c3ee4d4da77e66970eb07eb,
+    type: 2}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1783632093}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 172515602e62fb746b5d573b38a5fe58, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  isGlobal: 1
+  priority: 0
+  blendDistance: 0
+  weight: 1
+  sharedProfile: {fileID: 11400000, guid: 3f489ba750e903447b0e64a9a0927b48, type: 2}
+--- !u!4 &1783632096
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb,
+    type: 2}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1783632093}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
 --- !u!1 &1838647969
 GameObject:
   m_ObjectHideFlags: 0
   m_PrefabInternal: {fileID: 0}
   m_GameObject: {fileID: 1894174326}
   m_Mesh: {fileID: 10202, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!1 &1978415242
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1978415246}
+  - component: {fileID: 1978415245}
+  - component: {fileID: 1978415244}
+  - component: {fileID: 1978415243}
+  m_Layer: 0
+  m_Name: Quad
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 0
+--- !u!64 &1978415243
+MeshCollider:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1978415242}
+  m_Material: {fileID: 0}
+  m_IsTrigger: 0
+  m_Enabled: 1
+  serializedVersion: 3
+  m_Convex: 0
+  m_CookingOptions: 14
+  m_SkinWidth: 0.01
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!23 &1978415244
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1978415242}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 3bcb0652d6d34764b958e6c0a44fb35b, type: 2}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!33 &1978415245
+MeshFilter:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1978415242}
+  m_Mesh: {fileID: 10210, guid: 0000000000000000e000000000000000, type: 0}
+--- !u!4 &1978415246
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1978415242}
+  m_LocalRotation: {x: 0.7071068, y: 0, z: 0, w: 0.7071068}
+  m_LocalPosition: {x: 0, y: 0.01, z: -7.76}
+  m_LocalScale: {x: 12.537164, y: 12.537165, z: 12.537165}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 7
+  m_LocalEulerAnglesHint: {x: 90, y: 0, z: 0}
 --- !u!1 &1998959825
 GameObject:
   m_ObjectHideFlags: 0
   shadowResolution: 512
   shadowDimmer: 1
   shadowFadeDistance: 10000
+  enableContactShadows: 0
+  contactShadowLength: 0
+  contactShadowDistanceScaleFactor: 0.5
+  contactShadowMaxDistance: 50
+  contactShadowFadeDistance: 5
+  contactShadowSampleCount: 8
   shadowCascadeCount: 4
   shadowCascadeRatios:
   - 0.05

Tests/GraphicsTests/RenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset

   m_ShadowCascades: 2
   m_Cascade2Split: 0.25
   m_Cascade4Split: {x: 0.067, y: 0.2, z: 0.467}
-  m_BlitShader: {fileID: 4800000, guid: c17132b1f77d20942aa75f8429c0f8bc, type: 3}
-  m_CopyDepthShader: {fileID: 4800000, guid: d6dae50ee9e1bfa4db75f19f99355220, type: 3}
+  m_ResourcesAsset: {fileID: 11400000, guid: aac5a08c32552a14c89394b703f1978a, type: 2}

Tests/Scripts/Editor/GraphicTests/Framework/TestFramework.cs

         [OneTimeSetUp]
         public void OneTimeSetUp()
         {
+            BackupSceneManagerSetup();
             SetupRenderPipeAsset();
         }
 
+            Debug.Log("OnTimeTearDown");
+            RestoreSceneManagerSetup();
         }
 
         public static RenderPipelineAsset GetRenderPipelineAsset(string _SRP_ID)
             string filePath = Path.Combine(absolutePath, TestFrameworkTools.renderPipelineAssets[_SRP_ID] );
 
+            filePath = filePath.Replace(Application.dataPath, "");
+
+            filePath = filePath.Remove(0, 1);
+
+            //Debug.Log("Before combine: " + filePath);
+
+            filePath = Path.Combine("Assets", filePath);
+
+            //Debug.Log("RP Asset is at : " + filePath);
+
             return (RenderPipelineAsset)AssetDatabase.LoadAssetAtPath(filePath, typeof(RenderPipelineAsset));
         }
 
         public void SetupRenderPipeAsset()
         {
-            Debug.Log("Set " + _SRP_ID + " render pipeline.");
+            //Debug.Log("Set " + _SRP_ID + " render pipeline. Previous was "+ ( (UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset == null)? "null":UnityEngine.Rendering.GraphicsSettings.renderPipelineAsset.name) );
+
+            //Debug.Log("RestoreRenderPipeAsset from " + wantedTestsRenderPipeAsset.name + " to " + ((beforeTestsRenderPipeAsset == null)?"null":beforeTestsRenderPipeAsset.name));
+            {
+                //Debug.Log("RestoreRenderPipeAsset -> Actual restore");
+            }
+        }
+
+        public static SceneSetup[] sceneManagerSetupBeforeTest;
+
+        public void BackupSceneManagerSetup()
+        {
+            sceneManagerSetupBeforeTest = EditorSceneManager.GetSceneManagerSetup();
+        }
+
+        public void RestoreSceneManagerSetup()
+        {
+            if ( (sceneManagerSetupBeforeTest == null) || ( sceneManagerSetupBeforeTest.Length == 0 ) )
+            {
+                EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
+            }
+            else
+            {
+                EditorSceneManager.RestoreSceneManagerSetup(sceneManagerSetupBeforeTest);
+            }
         }
 
 

Tests/Scripts/GraphicTests/Framework/SetupSceneForRenderPipelineTest.cs

 
 		public void TearDown()
 		{
-			if ( GraphicsSettings.renderPipelineAsset != m_OriginalAsset ) GraphicsSettings.renderPipelineAsset = m_OriginalAsset;
+            if (GraphicsSettings.renderPipelineAsset != m_OriginalAsset)
+            {
+                GraphicsSettings.renderPipelineAsset = m_OriginalAsset;
+            }
 
             //EditorApplication.isPaused = false;
             //EditorApplication.isPlaying = false;

Tests/Scripts/GraphicTests/Framework/TestFrameworkTools.cs

 
         public static Dictionary<string, string> renderPipelineAssets = new Dictionary<string, string>()
         {
-            { "HDRP", "Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/HDRP_GraphicTests_Asset.asset" },
-            { "LWRP", "Tests/GraphicsTests/RenderPipeline/LightweightPipeline/LightweightPipelineAsset.asset" }
+            { "HDRP", "HDRenderPipeline/CommonAssets/HDRP_GraphicTests_Asset.asset" },
+            { "LWRP", "LightweightPipeline/LightweightPipelineAsset.asset" }
         };
 
         // Renderpipeline assets used for the tests

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1302_SSS_MaxRadius.unity.png.meta

+fileFormatVersion: 2
+guid: 028296c146042674a951d36197a18eed
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ImageTemplates/HDRenderPipeline/Scenes/1xxx_Materials/1303_SSS_Pre-Post.unity.png.meta

+fileFormatVersion: 2
+guid: 98adc67a9af53d245a90790b07e16b11
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 0
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Decal/DecalProjectorComponentEditor.cs

+using System;
+using UnityEngine;
+using UnityEngine.Rendering;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Experimental.Rendering.HDPipeline;
+using UnityEditor;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+    [CustomEditor(typeof(DecalProjectorComponent))]
+    public class DecalProjectorComponentEditor : Editor
+    {
+        private MaterialEditor m_MaterialEditor = null;
+        private DecalProjectorComponent m_DecalProjectorComponent = null;
+
+        private void OnEnable()
+        {
+            // Create an instance of the MaterialEditor
+            m_DecalProjectorComponent = (DecalProjectorComponent)target;
+            m_MaterialEditor = (MaterialEditor)CreateEditor(m_DecalProjectorComponent.Mat);
+        }
+
+        public override void OnInspectorGUI()
+        {
+            EditorGUI.BeginChangeCheck();
+
+            base.OnInspectorGUI();
+            if (EditorGUI.EndChangeCheck())
+            {
+                serializedObject.ApplyModifiedProperties();
+            }
+
+            if (m_MaterialEditor != null)
+            {
+                // Draw the material's foldout and the material shader field
+                // Required to call m_MaterialEditor.OnInspectorGUI ();
+                m_MaterialEditor.DrawHeader();
+
+                // We need to prevent the user to edit default decal materials
+                bool isDefaultMaterial = false;
+                var hdrp = GraphicsSettings.renderPipelineAsset as HDRenderPipelineAsset;
+                if (hdrp != null)
+                {
+                    isDefaultMaterial = m_DecalProjectorComponent.Mat == hdrp.GetDefaultDecalMaterial();
+                }
+                using (new EditorGUI.DisabledGroupScope(isDefaultMaterial))
+                {
+                    // Draw the material properties
+                    // Works only if the foldout of m_MaterialEditor.DrawHeader () is open
+                    m_MaterialEditor.OnInspectorGUI();
+                }
+            }
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Decal/DecalProjectorComponentEditor.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DecalGizmo.png.meta

+fileFormatVersion: 2
+guid: b057b73ec5a603e4aa80ccf4b34db0d3
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 1
+    sRGBTexture: 1
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 1
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DefaultHDDecalMaterial.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: DefaultHDDecalMaterial
+  m_Shader: {fileID: 4800000, guid: 1d64af84bdc970c4fae0c1e06dd95b73, type: 3}
+  m_ShaderKeywords: _NORMALMAP_TANGENT_SPACE
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 1
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: -1
+  stringTagMap: {}
+  disabledShaderPasses:
+  - DistortionVectors
+  - TransparentDepthPrepass
+  - TransparentDepthPostpass
+  - TransparentBackface
+  - TransparentBackfaceDebugDisplay
+  - MOTIONVECTORS
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BumpMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailAlbedoMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMask:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MetallicGlossMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _OcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ParallaxMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularOcclusionMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceRadiusMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.5
+    - _AlphaCutoffEnable: 0
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _BumpScale: 1
+    - _CoatCoverage: 1
+    - _CoatIOR: 0.5
+    - _CoatMask: 1
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.5
+    - _DecalBlend: 0.5
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalMapScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DistortionBlendMode: 0
+    - _DistortionBlurBlendMode: 0
+    - _DistortionBlurDstBlend: 1
+    - _DistortionBlurRemapMax: 1
+    - _DistortionBlurRemapMin: 0
+    - _DistortionBlurScale: 1
+    - _DistortionBlurSrcBlend: 1
+    - _DistortionDepthTest: 0
+    - _DistortionDstBlend: 1
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 1
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedMirrorEnable: 1
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnableBlendModeAccurateLighting: 1
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableMotionVectorForVertexAnimation: 0
+    - _EnablePerPixelDisplacement: 0
+    - _EnableSpecularOcclusion: 0
+    - _EnableTransparentFog: 1
+    - _EnableWind: 0
+    - _EnergyConservingSpecularColor: 1
+    - _GlossMapScale: 1
+    - _Glossiness: 0.5
+    - _GlossyReflections: 1
+    - _HeightAmplitude: 0.01
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 1
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _HorizonFade: 1
+    - _IOR: 1.097
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metallic: 0
+    - _Mode: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1.088
+    - _OcclusionStrength: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _Parallax: 0.02
+    - _PreRefractionPass: 0
+    - _RefractionMode: 0
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 0.712
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _SmoothnessTextureChannel: 0
+    - _SpecularHighlights: 1
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _StencilRefMV: 128
+    - _StencilWriteMask: 7
+    - _StencilWriteMaskMV: 128
+    - _Stiffness: 1
+    - _SubsurfaceMask: 1
+    - _SubsurfaceProfile: 0
+    - _SubsurfaceRadius: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThicknessMultiplier: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _UVSec: 0
+    - _ZTestMode: 8
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 0.72794116, g: 0.72794116, b: 0.72794116, a: 1}
+    - _Color: {r: 0.72794116, g: 0.72794116, b: 0.72794116, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
+    - _EmissiveColor: {r: 0, g: 0, b: 0, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DefaultHDDecalMaterial.mat.meta

+fileFormatVersion: 2
+guid: 500e733574922d04ea961553b1b26a63
+timeCreated: 1494511160
+licenseType: Pro
+NativeFormatImporter:
+  mainObjectFileID: 2100000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineEditorResources.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 76e49a5b88430df478c504fe5a5c1a62, type: 3}
+  m_Name: LightweightPipelineEditorResources
+  m_EditorClassIdentifier: 
+  DefaultMaterial: {fileID: 2100000, guid: 31321ba15b8f8eb4c954353edc038b1d, type: 2}
+  DefaultParticleMaterial: {fileID: 2100000, guid: e823cd5b5d27c0f4b8256e7c12ee3e6d,
+    type: 2}
+  DefaultTerrainMaterial: {fileID: 2100000, guid: 594ea882c5a793440b60ff72d896021e,
+    type: 2}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineEditorResources.asset.meta

+fileFormatVersion: 2
+guid: a3d8d823eedde654bb4c11a1cfaf1abb
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineEditorResources.cs

+using System;
+using UnityEngine;
+
+public class LightweightPipelineEditorResources : ScriptableObject
+{
+    public Material DefaultMaterial;
+    public Material DefaultParticleMaterial;
+    public Material DefaultTerrainMaterial;
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineResources.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: cc1f30932f41a6a4d8c53677788dd8aa, type: 3}
+  m_Name: LightweightPipelineResources
+  m_EditorClassIdentifier: 
+  BlitShader: {fileID: 4800000, guid: c17132b1f77d20942aa75f8429c0f8bc, type: 3}
+  CopyDepthShader: {fileID: 4800000, guid: d6dae50ee9e1bfa4db75f19f99355220, type: 3}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineResources.asset.meta

+fileFormatVersion: 2
+guid: aac5a08c32552a14c89394b703f1978a
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineResources.cs

+using UnityEngine;
+
+public class LightweightPipelineResources : ScriptableObject
+{
+    public Shader BlitShader;
+    public Shader CopyDepthShader;
+}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Data/LightweightPipelineResources.cs.meta

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

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/CommonAssets/Textures/DFCircle.tga.meta

+fileFormatVersion: 2
+guid: d796dfaab3f6ba945a9f8e90cac49c50
+TextureImporter:
+  fileIDToRecycleName: {}
+  externalObjects: {}
+  serializedVersion: 5
+  mipmaps:
+    mipMapMode: 0
+    enableMipMap: 0
+    sRGBTexture: 0
+    linearTexture: 0
+    fadeOut: 0
+    borderMipMap: 0
+    mipMapsPreserveCoverage: 0
+    alphaTestReferenceValue: 0.5
+    mipMapFadeDistanceStart: 1
+    mipMapFadeDistanceEnd: 3
+  bumpmap:
+    convertToNormalMap: 0
+    externalNormalMap: 0
+    heightScale: 0.25
+    normalMapFilter: 0
+  isReadable: 0
+  grayScaleToAlpha: 0
+  generateCubemap: 6
+  cubemapConvolution: 0
+  seamlessCubemap: 0
+  textureFormat: 1
+  maxTextureSize: 2048
+  textureSettings:
+    serializedVersion: 2
+    filterMode: -1
+    aniso: -1
+    mipBias: -1
+    wrapU: -1
+    wrapV: -1
+    wrapW: -1
+  nPOTScale: 1
+  lightmap: 0
+  compressionQuality: 50
+  spriteMode: 0
+  spriteExtrude: 1
+  spriteMeshType: 1
+  alignment: 0
+  spritePivot: {x: 0.5, y: 0.5}
+  spriteBorder: {x: 0, y: 0, z: 0, w: 0}
+  spritePixelsToUnits: 100
+  alphaUsage: 1
+  alphaIsTransparency: 0
+  spriteTessellationDetail: -1
+  textureType: 0
+  textureShape: 1
+  singleChannelComponent: 0
+  maxTextureSizeSet: 0
+  compressionQualitySet: 0
+  textureFormatSet: 0
+  platformSettings:
+  - serializedVersion: 2
+    buildTarget: DefaultTexturePlatform
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  - serializedVersion: 2
+    buildTarget: Standalone
+    maxTextureSize: 2048
+    resizeAlgorithm: 0
+    textureFormat: -1
+    textureCompression: 2
+    compressionQuality: 50
+    crunchedCompression: 0
+    allowsAlphaSplitting: 0
+    overridden: 0
+    androidETC2FallbackOverride: 0
+  spriteSheet:
+    serializedVersion: 2
+    sprites: []
+    outline: []
+    physicsShape: []
+    bones: []
+    spriteID: 
+    vertices: []
+    indices: 
+    edges: []
+    weights: []
+  spritePackingTag: 
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1302_SSS_MaxRadius.meta

+fileFormatVersion: 2
+guid: 2934d9a46741d8f47a35f945aaa54ead
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1302_SSS_MaxRadius.unity.meta

+fileFormatVersion: 2
+guid: 0277520b19264c24eac3041bd22ae564
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1303_SSS_Pre-Post.meta

+fileFormatVersion: 2
+guid: e00751ea3b3fd7448816f9dae583059c
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1303_SSS_Pre-Post.unity

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!29 &1
+OcclusionCullingSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_OcclusionBakeSettings:
+    smallestOccluder: 5
+    smallestHole: 0.25
+    backfaceThreshold: 100
+  m_SceneGUID: 00000000000000000000000000000000
+  m_OcclusionCullingData: {fileID: 0}
+--- !u!104 &2
+RenderSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 9
+  m_Fog: 0
+  m_FogColor: {r: 0.5, g: 0.5, b: 0.5, a: 1}
+  m_FogMode: 3
+  m_FogDensity: 0.01
+  m_LinearFogStart: 0
+  m_LinearFogEnd: 300
+  m_AmbientSkyColor: {r: 0.212, g: 0.227, b: 0.259, a: 1}
+  m_AmbientEquatorColor: {r: 0.114, g: 0.125, b: 0.133, a: 1}
+  m_AmbientGroundColor: {r: 0.047, g: 0.043, b: 0.035, a: 1}
+  m_AmbientIntensity: 1
+  m_AmbientMode: 0
+  m_SubtractiveShadowColor: {r: 0.42, g: 0.478, b: 0.627, a: 1}
+  m_SkyboxMaterial: {fileID: 0}
+  m_HaloStrength: 0.5
+  m_FlareStrength: 1
+  m_FlareFadeSpeed: 3
+  m_HaloTexture: {fileID: 0}
+  m_SpotCookie: {fileID: 10001, guid: 0000000000000000e000000000000000, type: 0}
+  m_DefaultReflectionMode: 0
+  m_DefaultReflectionResolution: 128
+  m_ReflectionBounces: 1
+  m_ReflectionIntensity: 1
+  m_CustomReflection: {fileID: 0}
+  m_Sun: {fileID: 0}
+  m_IndirectSpecularColor: {r: 0, g: 0, b: 0, a: 1}
+  m_UseRadianceAmbientProbe: 0
+--- !u!157 &3
+LightmapSettings:
+  m_ObjectHideFlags: 0
+  serializedVersion: 11
+  m_GIWorkflowMode: 0
+  m_GISettings:
+    serializedVersion: 2
+    m_BounceScale: 1
+    m_IndirectOutputScale: 1
+    m_AlbedoBoost: 1
+    m_TemporalCoherenceThreshold: 1
+    m_EnvironmentLightingMode: 0
+    m_EnableBakedLightmaps: 1
+    m_EnableRealtimeLightmaps: 1
+  m_LightmapEditorSettings:
+    serializedVersion: 10
+    m_Resolution: 2
+    m_BakeResolution: 40
+    m_AtlasSize: 1024
+    m_AO: 0
+    m_AOMaxDistance: 1
+    m_CompAOExponent: 1
+    m_CompAOExponentDirect: 0
+    m_Padding: 2
+    m_LightmapParameters: {fileID: 0}
+    m_LightmapsBakeMode: 1
+    m_TextureCompression: 1
+    m_FinalGather: 0
+    m_FinalGatherFiltering: 1
+    m_FinalGatherRayCount: 256
+    m_ReflectionCompression: 2
+    m_MixedBakeMode: 2
+    m_BakeBackend: 0
+    m_PVRSampling: 1
+    m_PVRDirectSampleCount: 32
+    m_PVRSampleCount: 500
+    m_PVRBounces: 2
+    m_PVRFilterTypeDirect: 0
+    m_PVRFilterTypeIndirect: 0
+    m_PVRFilterTypeAO: 0
+    m_PVRFilteringMode: 1
+    m_PVRCulling: 1
+    m_PVRFilteringGaussRadiusDirect: 1
+    m_PVRFilteringGaussRadiusIndirect: 5
+    m_PVRFilteringGaussRadiusAO: 2
+    m_PVRFilteringAtrousPositionSigmaDirect: 0.5
+    m_PVRFilteringAtrousPositionSigmaIndirect: 2
+    m_PVRFilteringAtrousPositionSigmaAO: 1
+    m_ShowResolutionOverlay: 1
+  m_LightingDataAsset: {fileID: 0}
+  m_UseShadowmask: 1
+--- !u!196 &4
+NavMeshSettings:
+  serializedVersion: 2
+  m_ObjectHideFlags: 0
+  m_BuildSettings:
+    serializedVersion: 2
+    agentTypeID: 0
+    agentRadius: 0.5
+    agentHeight: 2
+    agentSlope: 45
+    agentClimb: 0.4
+    ledgeDropHeight: 0
+    maxJumpAcrossDistance: 0
+    minRegionArea: 2
+    manualCellSize: 0
+    cellSize: 0.16666667
+    manualTileSize: 0
+    tileSize: 256
+    accuratePlacement: 0
+    debug:
+      m_Flags: 0
+  m_NavMeshData: {fileID: 0}
+--- !u!1001 &90138402
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalPosition.x
+      value: 0.05
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalRotation.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalRotation.y
+      value: -0.9396926
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalRotation.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalRotation.w
+      value: 0.34202018
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_RootOrder
+      value: 6
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalScale.x
+      value: -1
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalScale.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalScale.z
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: -140
+      objectReference: {fileID: 0}
+    - target: {fileID: 2300000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_Materials.Array.data[0]
+      value: 
+      objectReference: {fileID: 2100000, guid: 918541971114bf14780a1d8792060868, type: 2}
+    - target: {fileID: 100000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_Name
+      value: Post_Scatter
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+  m_IsPrefabParent: 0
+--- !u!1001 &189121542
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalPosition.z
+      value: -0.05
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalRotation.y
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalRotation.z
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_RootOrder
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 20109210616973140, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: far clip plane
+      value: 2
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalScale.x
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalScale.y
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 4209882255362944, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+      propertyPath: m_LocalScale.z
+      value: 10
+      objectReference: {fileID: 0}
+    - target: {fileID: 20109210616973140, guid: c07ace9ab142ca9469fa377877c2f1e7,
+        type: 2}
+      propertyPath: near clip plane
+      value: 0.01
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: c07ace9ab142ca9469fa377877c2f1e7, type: 2}
+  m_IsPrefabParent: 0
+--- !u!1001 &214624064
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+      propertyPath: m_LocalPosition.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+      propertyPath: m_LocalRotation.x
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+      propertyPath: m_LocalRotation.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+      propertyPath: m_LocalRotation.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+      propertyPath: m_LocalRotation.w
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 4295600896743834, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+      propertyPath: m_RootOrder
+      value: 1
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: 7dde90a97c3ee4d4da77e66970eb07eb, type: 2}
+  m_IsPrefabParent: 0
+--- !u!1 &356560303
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 356560304}
+  - component: {fileID: 356560306}
+  - component: {fileID: 356560305}
+  m_Layer: 0
+  m_Name: New Text (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &356560304
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 356560303}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0.0356, y: 0.0276, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 771994609}
+  m_RootOrder: 1
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!102 &356560305
+TextMesh:
+  serializedVersion: 3
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 356560303}
+  m_Text: Post-Scatter
+  m_OffsetZ: 0
+  m_CharacterSize: 0.0015
+  m_LineSpacing: 1
+  m_Anchor: 1
+  m_Alignment: 0
+  m_TabSize: 4
+  m_FontSize: 0
+  m_FontStyle: 0
+  m_RichText: 1
+  m_Font: {fileID: 12800000, guid: 306d620c715872046bf76568b7f382d4, type: 3}
+  m_Color:
+    serializedVersion: 2
+    rgba: 4294967295
+--- !u!23 &356560306
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 356560303}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 306d620c715872046bf76568b7f382d4, type: 3}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0
+--- !u!1 &381281792
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 381281796}
+  - component: {fileID: 381281795}
+  - component: {fileID: 381281794}
+  - component: {fileID: 381281793}
+  m_Layer: 0
+  m_Name: Directional Light
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &381281793
+MonoBehaviour:
+  m_ObjectHideFlags: 2
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 381281792}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c6c2871f720b2af4e9210febdac74517, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Version: 1
+  shadowResolution: 512
+  shadowDimmer: 1
+  shadowFadeDistance: 10000
+  enableContactShadows: 0
+  contactShadowLength: 0
+  contactShadowDistanceScaleFactor: 0.5
+  contactShadowMaxDistance: 50
+  contactShadowFadeDistance: 5
+  contactShadowSampleCount: 8
+  shadowCascadeCount: 4
+  shadowCascadeRatios:
+  - 0.05
+  - 0.05
+  - 0.05
+  shadowCascadeBorders:
+  - 0.2
+  - 0.2
+  - 0.2
+  - 0.2
+  shadowAlgorithm: 0
+  shadowVariant: 3
+  shadowPrecision: 0
+  shadowData:
+    format: 3
+    data: 0bd7a33b0000803f
+  shadowDatas:
+  - format: 3
+    data: 0bd7a33b0000803f
+--- !u!114 &381281794
+MonoBehaviour:
+  m_ObjectHideFlags: 2
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 381281792}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Version: 1
+  m_InnerSpotPercent: 0
+  lightDimmer: 1
+  fadeDistance: 10000
+  affectDiffuse: 1
+  affectSpecular: 1
+  lightTypeExtent: 0
+  spotLightShape: 0
+  shapeWidth: 0.5
+  shapeHeight: 0.5
+  aspectRatio: 1
+  shapeRadius: 0
+  maxSmoothness: 1
+  applyRangeAttenuation: 1
+  useOldInspector: 0
+  featuresFoldout: 1
+  showAdditionalSettings: 0
+--- !u!108 &381281795
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 381281792}
+  m_Enabled: 1
+  serializedVersion: 8
+  m_Type: 1
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 10
+  m_Range: 10
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &381281796
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 381281792}
+  m_LocalRotation: {x: -0, y: 1, z: -0, w: 0}
+  m_LocalPosition: {x: 0, y: 0, z: 1}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 3
+  m_LocalEulerAnglesHint: {x: 0, y: 180, z: 0}
+--- !u!1 &771994608
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 771994609}
+  m_Layer: 0
+  m_Name: UI
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &771994609
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 771994608}
+  m_LocalRotation: {x: -0, y: -0, z: -0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children:
+  - {fileID: 1982433798}
+  - {fileID: 356560304}
+  m_Father: {fileID: 0}
+  m_RootOrder: 2
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!1001 &1897272364
+Prefab:
+  m_ObjectHideFlags: 0
+  serializedVersion: 2
+  m_Modification:
+    m_TransformParent: {fileID: 0}
+    m_Modifications:
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalPosition.x
+      value: -0.05
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalPosition.y
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalPosition.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalRotation.x
+      value: -0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalRotation.y
+      value: -0.9396927
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalRotation.z
+      value: 0
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalRotation.w
+      value: -0.34202012
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_RootOrder
+      value: 5
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalScale.x
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalScale.y
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalScale.z
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 400000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_LocalEulerAnglesHint.y
+      value: -220
+      objectReference: {fileID: 0}
+    - target: {fileID: 2300000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_Materials.Array.data[0]
+      value: 
+      objectReference: {fileID: 2100000, guid: f7f23f7e601fd0d4d8a290d91be59d02, type: 2}
+    - target: {fileID: 2300000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_DynamicOccludee
+      value: 1
+      objectReference: {fileID: 0}
+    - target: {fileID: 100000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+      propertyPath: m_Name
+      value: Pre-Post_Scatter
+      objectReference: {fileID: 0}
+    m_RemovedComponents: []
+  m_ParentPrefab: {fileID: 100100000, guid: 003b412a0b1ef1e4c9038104f29ee2d4, type: 3}
+  m_IsPrefabParent: 0
+--- !u!1 &1925246179
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1925246183}
+  - component: {fileID: 1925246182}
+  - component: {fileID: 1925246181}
+  - component: {fileID: 1925246180}
+  m_Layer: 0
+  m_Name: Directional Light (1)
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!114 &1925246180
+MonoBehaviour:
+  m_ObjectHideFlags: 2
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1925246179}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: c6c2871f720b2af4e9210febdac74517, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Version: 1
+  shadowResolution: 512
+  shadowDimmer: 1
+  shadowFadeDistance: 10000
+  enableContactShadows: 0
+  contactShadowLength: 0
+  contactShadowDistanceScaleFactor: 0.5
+  contactShadowMaxDistance: 50
+  contactShadowFadeDistance: 5
+  contactShadowSampleCount: 8
+  shadowCascadeCount: 4
+  shadowCascadeRatios:
+  - 0.05
+  - 0.2
+  - 0.3
+  shadowCascadeBorders:
+  - 0.2
+  - 0.2
+  - 0.2
+  - 0.2
+  shadowAlgorithm: 0
+  shadowVariant: 3
+  shadowPrecision: 0
+  shadowData:
+    format: 3
+    data: 0bd7a33b0000803f
+  shadowDatas:
+  - format: 3
+    data: 0bd7a33b0000803f
+--- !u!114 &1925246181
+MonoBehaviour:
+  m_ObjectHideFlags: 2
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1925246179}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7a68c43fe1f2a47cfa234b5eeaa98012, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
+  m_Version: 1
+  m_InnerSpotPercent: 0
+  lightDimmer: 1
+  fadeDistance: 10000
+  affectDiffuse: 1
+  affectSpecular: 1
+  lightTypeExtent: 0
+  spotLightShape: 0
+  shapeWidth: 0.5
+  shapeHeight: 0.5
+  aspectRatio: 1
+  shapeRadius: 0
+  maxSmoothness: 1
+  applyRangeAttenuation: 1
+  useOldInspector: 0
+  featuresFoldout: 1
+  showAdditionalSettings: 0
+--- !u!108 &1925246182
+Light:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1925246179}
+  m_Enabled: 1
+  serializedVersion: 8
+  m_Type: 1
+  m_Color: {r: 1, g: 1, b: 1, a: 1}
+  m_Intensity: 1
+  m_Range: 10
+  m_SpotAngle: 30
+  m_CookieSize: 10
+  m_Shadows:
+    m_Type: 0
+    m_Resolution: -1
+    m_CustomResolution: -1
+    m_Strength: 1
+    m_Bias: 0.05
+    m_NormalBias: 0.4
+    m_NearPlane: 0.2
+  m_Cookie: {fileID: 0}
+  m_DrawHalo: 0
+  m_Flare: {fileID: 0}
+  m_RenderMode: 0
+  m_CullingMask:
+    serializedVersion: 2
+    m_Bits: 4294967295
+  m_Lightmapping: 4
+  m_AreaSize: {x: 1, y: 1}
+  m_BounceIntensity: 1
+  m_ColorTemperature: 6570
+  m_UseColorTemperature: 0
+  m_ShadowRadius: 0
+  m_ShadowAngle: 0
+--- !u!4 &1925246183
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1925246179}
+  m_LocalRotation: {x: 0.42261827, y: 0, z: 0, w: 0.9063079}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 4
+  m_LocalEulerAnglesHint: {x: 50, y: 0, z: 0}
+--- !u!1 &1982433797
+GameObject:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  serializedVersion: 5
+  m_Component:
+  - component: {fileID: 1982433798}
+  - component: {fileID: 1982433800}
+  - component: {fileID: 1982433799}
+  m_Layer: 0
+  m_Name: New Text
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &1982433798
+Transform:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1982433797}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: -0.0345, y: 0.0276, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 771994609}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!102 &1982433799
+TextMesh:
+  serializedVersion: 3
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1982433797}
+  m_Text: 'Pre- and
+
+    Post-Scatter'
+  m_OffsetZ: 0
+  m_CharacterSize: 0.0015
+  m_LineSpacing: 1
+  m_Anchor: 1
+  m_Alignment: 0
+  m_TabSize: 4
+  m_FontSize: 0
+  m_FontStyle: 0
+  m_RichText: 1
+  m_Font: {fileID: 12800000, guid: 306d620c715872046bf76568b7f382d4, type: 3}
+  m_Color:
+    serializedVersion: 2
+    rgba: 4294967295
+--- !u!23 &1982433800
+MeshRenderer:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 1982433797}
+  m_Enabled: 1
+  m_CastShadows: 1
+  m_ReceiveShadows: 1
+  m_DynamicOccludee: 1
+  m_MotionVectors: 1
+  m_LightProbeUsage: 1
+  m_ReflectionProbeUsage: 1
+  m_RenderingLayerMask: 4294967295
+  m_Materials:
+  - {fileID: 2100000, guid: 306d620c715872046bf76568b7f382d4, type: 3}
+  m_StaticBatchInfo:
+    firstSubMesh: 0
+    subMeshCount: 0
+  m_StaticBatchRoot: {fileID: 0}
+  m_ProbeAnchor: {fileID: 0}
+  m_LightProbeVolumeOverride: {fileID: 0}
+  m_ScaleInLightmap: 1
+  m_PreserveUVs: 0
+  m_IgnoreNormalsForChartDetection: 0
+  m_ImportantGI: 0
+  m_StitchLightmapSeams: 0
+  m_SelectedEditorRenderState: 3
+  m_MinimumChartSize: 4
+  m_AutoUVMaxDistance: 0.5
+  m_AutoUVMaxAngle: 89
+  m_LightmapParameters: {fileID: 0}
+  m_SortingLayerID: 0
+  m_SortingLayer: 0
+  m_SortingOrder: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/1xxx_Materials/1303_SSS_Pre-Post.unity.meta

+fileFormatVersion: 2
+guid: 6f2bc3028f3daba46ab0447a3e25ebc6
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/HDRP_Black_Sky.asset

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!114 &11400000
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: d7fd9488000d3734a9e00ee676215985, type: 3}
+  m_Name: HDRP_Black_Sky
+  m_EditorClassIdentifier: 
+  components:
+  - {fileID: 114660440207994068}
+  - {fileID: 114436604167779146}
+  - {fileID: 114091020813512248}
+--- !u!114 &114091020813512248
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 59b6606ef2548734bb6d11b9d160bc7e, type: 3}
+  m_Name: HDRISky
+  m_EditorClassIdentifier: 
+  active: 1
+  rotation:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+    max: 360
+  exposure:
+    m_OverrideState: 0
+    m_Value: 0
+  multiplier:
+    m_OverrideState: 0
+    m_Value: 1
+    min: 0
+  updateMode:
+    m_OverrideState: 0
+    m_Value: 0
+  updatePeriod:
+    m_OverrideState: 0
+    m_Value: 0
+    min: 0
+  skyHDRI:
+    m_OverrideState: 1
+    m_Value: {fileID: 8900000, guid: 75f8ba90acb52d14d9ead53b2a9e4190, type: 3}
+--- !u!114 &114436604167779146
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 0d7593b3a9277ac4696b20006c21dde2, type: 3}
+  m_Name: VisualEnvironment
+  m_EditorClassIdentifier: 
+  active: 1
+  skyType:
+    m_OverrideState: 1
+    m_Value: 1
+  fogType:
+    m_OverrideState: 1
+    m_Value: 0
+--- !u!114 &114541335061622942
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7ddcec8a8eb2d684d833ac8f5d26aebd, type: 3}
+  m_Name: HDShadowSettings
+  m_EditorClassIdentifier: 
+  active: 1
+  maxShadowDistance:
+    m_OverrideState: 0
+    m_Value: 500
+    min: 0
+--- !u!114 &114660440207994068
+MonoBehaviour:
+  m_ObjectHideFlags: 3
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_GameObject: {fileID: 0}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: 7ddcec8a8eb2d684d833ac8f5d26aebd, type: 3}
+  m_Name: HDShadowSettings
+  m_EditorClassIdentifier: 
+  active: 1
+  maxShadowDistance:
+    m_OverrideState: 1
+    m_Value: 10
+    min: 0

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/HDRP_Black_Sky.asset.meta

+fileFormatVersion: 2
+guid: 3f489ba750e903447b0e64a9a0927b48
+NativeFormatImporter:
+  externalObjects: {}
+  mainObjectFileID: 11400000
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Tests/GraphicsTests/RenderPipeline/HDRenderPipeline/Scenes/2xxx_Lighting/2301_Shadow_Mask/TestCircle.mat

+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!21 &2100000
+Material:
+  serializedVersion: 6
+  m_ObjectHideFlags: 0
+  m_PrefabParentObject: {fileID: 0}
+  m_PrefabInternal: {fileID: 0}
+  m_Name: TestCircle
+  m_Shader: {fileID: 4800000, guid: c4edd00ff2db5b24391a4fcb1762e459, type: 3}
+  m_ShaderKeywords: _ALPHATEST_ON
+  m_LightmapFlags: 4
+  m_EnableInstancingVariants: 0
+  m_DoubleSidedGI: 0
+  m_CustomRenderQueue: 2450
+  stringTagMap:
+    RenderType: TransparentCutout
+  disabledShaderPasses:
+  - DistortionVectors
+  m_SavedProperties:
+    serializedVersion: 3
+    m_TexEnvs:
+    - _AnisotropyMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BaseColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _BentNormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DetailMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _DistortionVectorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _EmissiveColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _HeightMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MainTex:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _MaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _NormalMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SpecularColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _SubsurfaceMaskMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TangentMapOS:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _ThicknessMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _TransmittanceColorMap:
+        m_Texture: {fileID: 0}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    - _UnlitColorMap:
+        m_Texture: {fileID: 2800000, guid: d796dfaab3f6ba945a9f8e90cac49c50, type: 3}
+        m_Scale: {x: 1, y: 1}
+        m_Offset: {x: 0, y: 0}
+    m_Floats:
+    - _AORemapMax: 1
+    - _AORemapMin: 0
+    - _ATDistance: 1
+    - _AlbedoAffectEmissive: 0
+    - _AlphaCutoff: 0.995
+    - _AlphaCutoffEnable: 1
+    - _AlphaCutoffPostpass: 0.5
+    - _AlphaCutoffPrepass: 0.5
+    - _Anisotropy: 0
+    - _BlendMode: 0
+    - _CoatMask: 1
+    - _CullMode: 2
+    - _CullModeForward: 2
+    - _Cutoff: 0.995
+    - _DepthOffsetEnable: 0
+    - _DetailAlbedoScale: 1
+    - _DetailNormalScale: 1
+    - _DetailSmoothnessScale: 1
+    - _DiffusionProfile: 0
+    - _DisplacementLockObjectScale: 1
+    - _DisplacementLockTilingScale: 1
+    - _DisplacementMode: 0
+    - _DistortionBlendMode: 0
+    - _DistortionBlurBlendMode: 0
+    - _DistortionBlurDstBlend: 1
+    - _DistortionBlurRemapMax: 1
+    - _DistortionBlurRemapMin: 0
+    - _DistortionBlurScale: 1
+    - _DistortionBlurSrcBlend: 1
+    - _DistortionDepthTest: 1
+    - _DistortionDstBlend: 1
+    - _DistortionEnable: 0
+    - _DistortionOnly: 0
+    - _DistortionScale: 1
+    - _DistortionSrcBlend: 1
+    - _DistortionVectorBias: -1
+    - _DistortionVectorScale: 2
+    - _DoubleSidedEnable: 0
+    - _DoubleSidedNormalMode: 1
+    - _Drag: 1
+    - _DstBlend: 0
+    - _EmissiveColorMode: 1
+    - _EmissiveIntensity: 0
+    - _EnableBlendModePreserveSpecularLighting: 1
+    - _EnableFogOnTransparent: 1
+    - _EnableMotionVectorForVertexAnimation: 0
+    - _EnableSpecularOcclusion: 0
+    - _EnableWind: 0
+    - _EnergyConservingSpecularColor: 1
+    - _HeightAmplitude: 0.02
+    - _HeightCenter: 0.5
+    - _HeightMapParametrization: 0
+    - _HeightMax: 1
+    - _HeightMin: -1
+    - _HeightOffset: 0
+    - _HeightPoMAmplitude: 2
+    - _HeightTessAmplitude: 2
+    - _HeightTessCenter: 0.5
+    - _IOR: 1
+    - _InitialBend: 1
+    - _InvTilingScale: 1
+    - _LinkDetailsWithBase: 1
+    - _MaterialID: 1
+    - _Metallic: 0
+    - _NormalMapSpace: 0
+    - _NormalScale: 1
+    - _PPDLodThreshold: 5
+    - _PPDMaxSamples: 15
+    - _PPDMinSamples: 5
+    - _PPDPrimitiveLength: 1
+    - _PPDPrimitiveWidth: 1
+    - _PreRefractionPass: 0
+    - _RefractionMode: 0
+    - _ShiverDirectionality: 0.5
+    - _ShiverDrag: 0.2
+    - _Smoothness: 1
+    - _SmoothnessRemapMax: 1
+    - _SmoothnessRemapMin: 0
+    - _SrcBlend: 1
+    - _StencilRef: 2
+    - _StencilRefMV: 128
+    - _StencilWriteMask: 7
+    - _StencilWriteMaskMV: 128
+    - _Stiffness: 1
+    - _SubsurfaceMask: 1
+    - _SurfaceType: 0
+    - _TexWorldScale: 1
+    - _TexWorldScaleEmissive: 1
+    - _Thickness: 1
+    - _ThicknessMultiplier: 1
+    - _TransparentBackfaceEnable: 0
+    - _TransparentDepthPostpassEnable: 0
+    - _TransparentDepthPrepassEnable: 0
+    - _UVBase: 0
+    - _UVDetail: 0
+    - _UVEmissive: 0
+    - _Width: 0.01
+    - _ZTestMode: 4
+    - _ZWrite: 1
+    m_Colors:
+    - _BaseColor: {r: 1, g: 1, b: 1, a: 1}
+    - _Color: {r: 1, g: 1, b: 1, a: 1}
+    - _DoubleSidedConstants: {r: 1, g: 1, b: -1, a: 0}
+    - _EmissionColor: {r: 1, g: 1, b: 1, a: 1}
+    - _EmissiveColor: {r: 1, g: 1, b: 1, a: 1}
+    - _InvPrimScale: {r: 1, g: 1, b: 0, a: 0}
+    - _SpecularColor: {r: 1, g: 1, b: 1, a: 1}
+    - _ThicknessRemap: {r: 0, g: 1, b: 0, a: 0}
+    - _TransmittanceColor: {r: 1, g: 1, b: 1, a: 1}
+    - _UVDetailsMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMask: {r: 1, g: 0, b: 0, a: 0}
+    - _UVMappingMaskEmissive: {r: 1, g: 0, b: 0, a: 0}
+    - _UnlitColor: {r: 1, g: 1, b: 1, a: 1}