Merge branch 'master' into integrate-sg-subshaders

README.md

 2. Navigate to ___Edit > Project Settings > Graphics___ and add the Lightweight Render Pipeline Asset you created to the __Render Pipeline Settings__ field.
 
 Note: Always store your new Render Pipeline Asset outside of the Scriptable Render Pipeline folder. This ensures that your Lightweight settings are not lost when merging new changes from the SRP repo.
+
+## Sample Scenes in ScriptableRenderPipelineData
+
+If you want some sample scenes to use with SRP, you can find them at the [ScriptableRenderPipelineData GitHub repository](https://github.com/Unity-Technologies/ScriptableRenderPipelineData).
+
+Clone the repo into your project's Assets\ folder, likely alongside your ScriptableRenderPipeline clone folder.  You can use the same cloning process as described above for the main ScriptableRenderPipeline repo.
+
+Previous iterations of the ScriptableRenderPipeline repo owned this sample scene data, in case you noticed it before, and wondered where it went.

ScriptableRenderPipeline/Core/CoreRP/CoreResources/EncodeBC6H.compute

 #include "CoreRP/ShaderLibrary/BC6H.hlsl"
 #include "CoreRP/ShaderLibrary/Sampling/Sampling.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 TextureCube<float4> _Source;
 RWTexture2DArray<uint4> _Target;
 int _MipIndex;

ScriptableRenderPipeline/Core/CoreRP/CoreResources/GPUCopy.compute

 
 #include "../ShaderLibrary/Common.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 RWTexture2D<float1> _Result1;
 
 Texture2D<float4> _Source4;

ScriptableRenderPipeline/Core/CoreRP/Debugging/DebugUI.Fields.cs

                 set
                 {
                     enumNames = Enum.GetNames(value).Select(x => new GUIContent(x)).ToArray();
-                    enumValues = Enum.GetValues(value).Cast<int>().ToArray();
+
+                    // Linq.Cast<T> on a typeless Array breaks the JIT on PS4/Mono so we have to do it manually
+                    //enumValues = Enum.GetValues(value).Cast<int>().ToArray();
+
+                    var values = Enum.GetValues(value);
+                    enumValues = new int[values.Length];
+                    for (int i = 0; i < values.Length; i++)
+                        enumValues[i] = (int)values.GetValue(i);
                 }
             }
         }

ScriptableRenderPipeline/Core/CoreRP/Editor/MaterialUpgrader.cs

         Dictionary<string, float> m_FloatPropertiesToSet = new Dictionary<string, float>();
         Dictionary<string, Color> m_ColorPropertiesToSet = new Dictionary<string, Color>();
         List<string> m_TexturesToRemove = new List<string>();
+        Dictionary<string, Texture> m_TexturesToSet = new Dictionary<string, Texture>();
 
 
         class KeywordFloatRename
             foreach (var prop in m_TexturesToRemove)
                 dstMaterial.SetTexture(prop, null);
 
+            foreach (var prop in m_TexturesToSet)
+                dstMaterial.SetTexture(prop.Key, prop.Value);
+
             foreach (var prop in m_FloatPropertiesToSet)
                 dstMaterial.SetFloat(prop.Key, prop.Value);
 
         public void SetColor(string propertyName, Color value)
         {
             m_ColorPropertiesToSet[propertyName] = value;
+        }
+
+        public void SetTexture(string propertyName, Texture value)
+        {
+            m_TexturesToSet[propertyName] = value;
         }
 
         public void RenameKeywordToFloat(string oldName, string newName, float setVal, float unsetVal)

ScriptableRenderPipeline/Core/CoreRP/Editor/Volume/VolumeProfileFactory.cs

             else
             {
                 var scenePath = Path.GetDirectoryName(scene.path);
-                var extPath = scene.name + "_Profiles";
+                var extPath = scene.name;
                 var profilePath = scenePath + "/" + extPath;
 
                 if (!AssetDatabase.IsValidFolder(profilePath))

ScriptableRenderPipeline/Core/CoreRP/Inputs/InputRegistering.cs

 using System.Collections.Generic;
-using UnityEngine;
+    using UnityEditor;
+
     public class InputManagerEntry
     {
         public enum Kind { KeyOrButton, Mouse, Axis }
     public class InputRegistering
     {
 
-        static bool InputAlreadyRegistered(string name, InputManagerEntry.Kind kind, UnityEditor.SerializedProperty spAxes)
+        static bool InputAlreadyRegistered(string name, InputManagerEntry.Kind kind, SerializedProperty spAxes)
         {
             for (var i = 0; i < spAxes.arraySize; ++i)
             {
             return false;
         }
 
-        static void WriteEntry(UnityEditor.SerializedProperty spAxes, InputManagerEntry entry)
+        static void WriteEntry(SerializedProperty spAxes, InputManagerEntry entry)
         {
             if (InputAlreadyRegistered(entry.name, entry.kind, spAxes))
                 return;
             spAxis.FindPropertyRelative("joyNum").intValue = (int)entry.joystick;
         }
 
-        static public void RegisterInputs(List<InputManagerEntry> entries)
+        public static void RegisterInputs(List<InputManagerEntry> entries)
-            var currentSelection = UnityEditor.Selection.activeObject;
-            UnityEditor.EditorApplication.ExecuteMenuItem("Edit/Project Settings/Input");
-            var inputManager = UnityEditor.Selection.activeObject;
+            var inputManager = AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/InputManager.asset")[0];
-            var soInputManager = new UnityEditor.SerializedObject(inputManager);
+            var soInputManager = new SerializedObject(inputManager);
             var spAxes = soInputManager.FindProperty("m_Axes");
 
             foreach(InputManagerEntry entry in entries)
 
             // Commit
             soInputManager.ApplyModifiedProperties();
-
-            UnityEditor.Selection.activeObject = currentSelection;
-}
+}

ScriptableRenderPipeline/Core/CoreRP/Shadow/AdditionalShadowData.cs

         [Range(0.0f, 1.0f)]
         public float shadowDimmer = 1.0f;
         public float shadowFadeDistance = 10000.0f;
-        // Contact shadows
-        public bool enableContactShadows = false;
-        [Range(0.0f, 1.0f)]
-        public float contactShadowLength = 0.0f;
-        [Range(0.0f, 1.0f)]
-        public float contactShadowDistanceScaleFactor = 0.5f;
-        public float contactShadowMaxDistance = 50.0f;
-        public float contactShadowFadeDistance = 5.0f;
-        [Range(4, 64)]
-        public uint contactShadowSampleCount = 8;
         // bias control
         public float viewBiasMin        = 0.5f;
         public float viewBiasMax        = 10.0f;

ScriptableRenderPipeline/Core/CoreRP/Shadow/Shadow.cs

             public VectorArray<ShadowPayload>   payloads     { get { return m_Payloads;    } set { m_Payloads = value;    } }
         }
 
+        public struct ShadowBudgets
+        {
+            public int maxPointLights;
+            public int maxSpotLights;
+            public int maxDirectionalLights;
+        }
+
         private const int           k_MaxShadowmapPerType = 4;
         private ShadowSettings      m_ShadowSettings;
         private ShadowmapBase[]     m_Shadowmaps;
             // and register itself
             AdditionalShadowDataEditor.SetRegistry( this );
 #endif
+        }
+
+        public ShadowManager(ShadowSettings shadowSettings, ref ShadowContext.CtxtInit ctxtInitializer, ref ShadowBudgets budgets, ShadowmapBase[] shadowmaps ) : this( shadowSettings, ref ctxtInitializer, shadowmaps )
+        {
+            SetPerFrameBudgets( ref budgets );
+        }
+
+        public void SetPerFrameBudgets( ref ShadowBudgets budgets )
+        {
+            m_MaxShadows[(int)GPUShadowType.Point      ,0] = m_MaxShadows[(int)GPUShadowType.Point        ,1] = budgets.maxPointLights;
+            m_MaxShadows[(int)GPUShadowType.Spot       ,0] = m_MaxShadows[(int)GPUShadowType.Spot         ,1] = budgets.maxSpotLights;
+            m_MaxShadows[(int)GPUShadowType.Directional,0] = m_MaxShadows[(int)GPUShadowType.Directional  ,1] = budgets.maxDirectionalLights;
         }
 
         public override void UpdateCullingParameters( ref ScriptableCullingParameters cullingParams )

ScriptableRenderPipeline/Core/CoreRP/Shadow/ShadowBlurMoments.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "CoreRP/ShaderLibrary/Shadow/ShadowMoments.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #if MAX_MSAA > 1
 Texture2DMS<float> depthTex;
 #else

ScriptableRenderPipeline/Core/CoreRP/TextureCache.cs

 using System;
-using UnityEngine;
 using System.Collections.Generic;
 using UnityEngine.Rendering;
 #if UNITY_EDITOR
 
         public void Release()
         {
-            Texture.DestroyImmediate(m_Cache);      // do I need this?
+            CoreUtils.Destroy(m_Cache);
         }
     }
 
                 {
                     m_CubeMipLevelPropName = Shader.PropertyToID("_cubeMipLvl");
                     m_cubeSrcTexPropName = Shader.PropertyToID("_srcCubeTexture");
+
                 }
             }
             else
         {
             if (m_CacheNoCubeArray)
             {
-                Texture.DestroyImmediate(m_CacheNoCubeArray);
+                CoreUtils.Destroy(m_CacheNoCubeArray);
-                if (m_CubeBlitMaterial) Material.DestroyImmediate(m_CubeBlitMaterial);
+                CoreUtils.Destroy(m_CubeBlitMaterial);
-            if (m_Cache)
-                Texture.DestroyImmediate(m_Cache);
+
+            CoreUtils.Destroy(m_Cache);
         }
 
         private void TransferToPanoCache(CommandBuffer cmd, int sliceIndex, Texture texture)

ScriptableRenderPipeline/Core/package.json

 {
     "name": "com.unity.render-pipelines.core",
     "description": "Core library for Unity render pipelines.",
-    "version": "0.1.32",
+    "version": "0.1.33",
-        "com.unity.postprocessing": "0.1.8"
+        "com.unity.postprocessing": "0.2.0"
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Camera/HDCamera.cs

 
         public Matrix4x4[] viewMatrixStereo;
         public Matrix4x4[] projMatrixStereo;
+        public Vector4 centerEyeTranslationOffset;
 
         // Non oblique projection matrix (RHS)
         public Matrix4x4 nonObliqueProjMatrix
                 // The scene view has no additional data so this will correctly pick the editor preference backround color here.
                 return camera.backgroundColor.linear;
             }
-        }        
+        }
 
         static Dictionary<Camera, HDCamera> s_Cameras = new Dictionary<Camera, HDCamera>();
         static List<Camera> s_Cleanup = new List<Camera>(); // Recycled to reduce GC pressure
             var gpuView = camera.worldToCameraMatrix;
             var gpuNonJitteredProj = GL.GetGPUProjectionMatrix(nonJitteredCameraProj, true);
 
+            // In stereo, this corresponds to the center eye position
-            var relPos = pos; // World-origin-relative
-                relPos = Vector3.zero; // Camera-relative
             }
 
             var gpuVP = gpuNonJitteredProj * gpuView;
                 isFirstFrame = false;
             }
 
-            // TEMP: Re-enable this code once we bump the postprocessing package to 0.1.19 (or above)
-            // current package 0.1.8 don't have the .sampleIndex and it fail with template...
-            // taaFrameIndex = taaEnabled ? (uint)postProcessLayer.temporalAntialiasing.sampleIndex : 0;
-            const uint taaFrameCount = 8;
-            taaFrameIndex = taaEnabled ? (uint)Time.renderedFrameCount % taaFrameCount : 0;
-            // END TEMP
+            taaFrameIndex = taaEnabled ? (uint)postProcessLayer.temporalAntialiasing.sampleIndex : 0;
             taaFrameRotation = new Vector2(Mathf.Sin(taaFrameIndex * (0.5f * Mathf.PI)),
                                            Mathf.Cos(taaFrameIndex * (0.5f * Mathf.PI)));
 
             screenSize = new Vector4(screenWidth, screenHeight, 1.0f / screenWidth, 1.0f / screenHeight);
         }
 
+        // Stopgap method used to extract stereo combined matrix state.
+        public void UpdateStereoDependentState(FrameSettings frameSettings, ref ScriptableCullingParameters cullingParams)
+        {
+            if (!frameSettings.enableStereo)
+                return;
+
+            // What constants in UnityPerPass need updating for stereo considerations?
+            // _ViewProjMatrix - It is used directly for generating tesselation factors. This should be the same
+            //                   across both eyes for consistency, and to keep shadow-generation eye-independent
+            // _ViewParam -      Used for isFrontFace determination, should be the same for both eyes. There is the scenario
+            //                   where there might be multi-eye sets that are divergent enough where this assumption is not valid,
+            //                   but that's a future problem
+            // _InvProjParam -   Intention was for generating linear depths, but not currently used.  Will need to be stereo-ized if
+            //                   actually needed.
+            // _FrustumPlanes -  Also used for generating tesselation factors.  Should be fine to use the combined stereo VP
+            //                   to calculate frustum planes.
+
+            // TODO: Would it be worth calculating my own combined view/proj matrix in Update?
+            // In engine, we modify the view and proj matrices accordingly in order to generate the single cull
+            // * Get the center eye view matrix, and pull it back to cover both eyes
+            // * Generated an expanded projection matrix (one method - max bound of left/right proj matrices)
+            //   and move near/far planes to match near/far locations of proj matrices located at eyes.
+            // I think using the cull matrices is valid, as long as I only use them for tess factors in shader.
+            // Using them for other calculations (like light list generation) could be problematic.
+
+            var stereoCombinedViewMatrix = cullingParams.cullStereoView;
+
+            if (ShaderConfig.s_CameraRelativeRendering != 0)
+            {
+                // This is pulled back from the center eye, so set the offset
+                var translation = stereoCombinedViewMatrix.GetColumn(3);
+                translation += centerEyeTranslationOffset;
+                stereoCombinedViewMatrix.SetColumn(3, translation);
+            }
+
+            viewMatrix = stereoCombinedViewMatrix;
+            var stereoCombinedProjMatrix = cullingParams.cullStereoProj;
+            projMatrix = GL.GetGPUProjectionMatrix(stereoCombinedProjMatrix, true);
+
+            viewParam = new Vector4(viewMatrix.determinant, 0.0f, 0.0f, 0.0f);
+
+            frustum = Frustum.Create(viewProjMatrix, true, true);
+
+            // Left, right, top, bottom, near, far.
+            for (int i = 0; i < 6; i++)
+            {
+                frustumPlaneEquations[i] = new Vector4(frustum.planes[i].normal.x, frustum.planes[i].normal.y, frustum.planes[i].normal.z, frustum.planes[i].distance);
+            }
+        }
+
         void ConfigureStereoMatrices()
         {
             for (uint eyeIndex = 0; eyeIndex < 2; eyeIndex++)
                 projMatrixStereo[eyeIndex] = camera.GetStereoProjectionMatrix((Camera.StereoscopicEye)eyeIndex);
                 projMatrixStereo[eyeIndex] = GL.GetGPUProjectionMatrix(projMatrixStereo[eyeIndex], true);
+            }
+
+            if (ShaderConfig.s_CameraRelativeRendering != 0)
+            {
+                var leftTranslation = viewMatrixStereo[0].GetColumn(3);
+                var rightTranslation = viewMatrixStereo[1].GetColumn(3);
+                var centerTranslation = (leftTranslation + rightTranslation) / 2;
+                var centerOffset = -centerTranslation;
+                centerOffset.w = 0;
+
+                // TODO: Grabbing the CenterEye transform would be preferable, but XRNode.CenterEye
+                // doesn't always seem to be valid.
+
+                for (uint eyeIndex = 0; eyeIndex < 2; eyeIndex++)
+                {
+                    var translation = viewMatrixStereo[eyeIndex].GetColumn(3);
+                    translation += centerOffset;
+                    viewMatrixStereo[eyeIndex].SetColumn(3, translation);
+                }
+
+                centerEyeTranslationOffset = centerOffset;
             }
 
             // TODO: Fetch the single cull matrix stuff
 
         public void SetupGlobalStereoParams(CommandBuffer cmd)
         {
+            var viewProjStereo = new Matrix4x4[2];
+            var invViewStereo = new Matrix4x4[2];
             var invProjStereo = new Matrix4x4[2];
             var invViewProjStereo = new Matrix4x4[2];
 
                 invProjStereo[eyeIndex] = proj.inverse;
 
-                var vp = proj * viewMatrixStereo[eyeIndex];
-                invViewProjStereo[eyeIndex] = vp.inverse;
+                var view = viewMatrixStereo[eyeIndex];
+                invViewStereo[eyeIndex] = view.inverse;
+
+                viewProjStereo[eyeIndex] = proj * view;
+                invViewProjStereo[eyeIndex] = viewProjStereo[eyeIndex].inverse;
+            cmd.SetGlobalMatrixArray(HDShaderIDs._ViewMatrixStereo, viewMatrixStereo);
+            cmd.SetGlobalMatrixArray(HDShaderIDs._ViewProjMatrixStereo, viewProjStereo);
+            cmd.SetGlobalMatrixArray(HDShaderIDs._InvViewMatrixStereo, invViewStereo);
             cmd.SetGlobalMatrixArray(HDShaderIDs._InvProjMatrixStereo, invProjStereo);
             cmd.SetGlobalMatrixArray(HDShaderIDs._InvViewProjMatrixStereo, invViewProjStereo);
         }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Decal/DecalSystem.cs

         // Core\CoreRP\ShaderLibrary\UnityInstancing.hlsl
         // #if defined(SHADER_API_VULKAN) && defined(SHADER_API_MOBILE)
         //      #define UNITY_INSTANCED_ARRAY_SIZE  250
-        private const int kDrawIndexedBatchSize = 250; 
+        private const int kDrawIndexedBatchSize = 250;
 
         // cube mesh bounds for decal
         static Vector4 kMin = new Vector4(-0.5f, -1.0f, -0.5f, 1.0f);
                 m_DiffuseTexture = m_Material.GetTexture("_BaseColorMap");
                 m_NormalTexture = m_Material.GetTexture("_NormalMap");
                 m_MaskTexture = m_Material.GetTexture("_MaskMap");
-                m_Blend = m_Material.GetFloat("_DecalBlend");                
+                m_Blend = m_Material.GetFloat("_DecalBlend");
             }
 
             public DecalSet(Material material)
                         normalToWorldBatch[instanceCount].m23 = m_NormalTexIndex;
                         normalToWorldBatch[instanceCount].m33 = m_MaskTexIndex;
 
-                        
-                        // clustered forward data                        
-                        m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse; 
+
+                        // clustered forward data
+                        m_DecalDatas[m_DecalDatasCount].worldToDecal = decalToWorldBatch[instanceCount].inverse;
-                        
+
                         instanceCount++;
                         if (instanceCount == kDrawIndexedBatchSize)
                         {
                 InitializeMaterialValues(); // refresh in case they changed in the UI
                 UpdateTextureCache(cmd);
             }
-      
+
             public void RenderIntoDBuffer(CommandBuffer cmd)
             {
                 if(m_NumResults == 0)
                 {
                     m_PropertyBlock.SetMatrixArray(HDShaderIDs._NormalToWorldID, m_NormalToWorld[batchIndex]);
                     cmd.DrawMeshInstanced(m_DecalMesh, 0, KeyMaterial, 0, m_DecalToWorld[batchIndex], totalToDraw, m_PropertyBlock);
-                }                
+                }
-           
+
             public Material KeyMaterial
             {
                 get
             private int m_NormalTexIndex = -1;
             private int m_MaskTexIndex = -1;
         }
-        
+
         public void AddDecal(DecalProjectorComponent decal)
         {
 			if (decal.CullIndex != DecalProjectorComponent.kInvalidIndex) //do not add the same decal more than once
             foreach (var pair in m_DecalSets)
             {
                 pair.Value.RenderIntoDBuffer(cmd);
-            }            
+            }
         }
 
         public void SetAtlas(CommandBuffer cmd)
 
         public void CreateDrawData()
         {
-            m_DecalDatasCount = 0;           
+            m_DecalDatasCount = 0;
             // reallocate if needed
             if (m_DecalsVisibleThisFrame > m_DecalDatas.Length)
             {
             {
                 pair.Value.CreateDrawData();
             }
+        }
+
+        public void Cleanup()
+        {
+            if (m_DecalAtlas != null)
+                m_DecalAtlas.Release();
+            CoreUtils.Destroy(m_DecalMesh);
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDAssetFactory.cs

                 newAsset.debugColorPickerShader = Load<Shader>(HDRenderPipelinePath + "Debug/DebugColorPicker.Shader");
 
                 newAsset.deferredShader = Load<Shader>(HDRenderPipelinePath + "Lighting/Deferred.Shader");
-                newAsset.gaussianPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/ColorPyramid.compute");
+                newAsset.colorPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/ColorPyramid.compute");
                 newAsset.depthPyramidCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/DepthPyramid.compute");
                 newAsset.copyChannelCS = Load<ComputeShader>(CorePath + "CoreResources/GPUCopy.compute");
                 newAsset.applyDistortionCS = Load<ComputeShader>(HDRenderPipelinePath + "RenderPipelineResources/ApplyDistorsion.compute");

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/HDRenderPipelineMenuItems.cs

 
     public class HDRenderPipelineMenuItems
     {
+        [MenuItem("Internal/HDRenderPipeline/Upgrade Scene Light Intensity to physical light unit", priority = CoreUtils.editMenuPriority2)]
+        static void UpgradeLightsPLU()
+        {
+            Light[] lights = Resources.FindObjectsOfTypeAll<Light>();
+
+            foreach (var l in lights)
+            {
+                var add = l.GetComponent<HDAdditionalLightData>();
+
+                if (add == null)
+                {
+                    continue;
+                }
+
+                // We only need to update the new intensity parameters on additional data, no need to change intensity
+                if (add.lightTypeExtent == LightTypeExtent.Punctual)
+                {
+                    switch (l.type)
+                    {
+                        case LightType.Point:
+                            add.punctualIntensity = l.intensity / LightUtils.ConvertPointLightIntensity(1.0f);
+                            break;
+
+                        case LightType.Spot:
+                            add.punctualIntensity = l.intensity / LightUtils.ConvertPointLightIntensity(1.0f);
+                            break;
+
+                        case LightType.Directional:
+                            add.directionalIntensity = l.intensity;
+                            break;
+                    }
+                }
+                else if (add.lightTypeExtent == LightTypeExtent.Rectangle)
+                {
+                    add.areaIntensity = l.intensity / LightUtils.ConvertRectLightIntensity(1.0f, add.shapeWidth, add.shapeHeight);
+                }
+                else if (add.lightTypeExtent == LightTypeExtent.Line)
+                {
+                    add.areaIntensity = l.intensity / LightUtils.calculateLineLightArea(1.0f, add.shapeWidth);
+                }
+            }
+
+            var scene = SceneManager.GetActiveScene();
+            EditorSceneManager.MarkSceneDirty(scene);
+        }
+
         [MenuItem("Internal/HDRenderPipeline/Add \"Additional Light-shadow Data\" (if not present)")]
         static void AddAdditionalLightData()
         {

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

             public readonly GUIContent indirectBounceShadowWarning = new GUIContent("Realtime indirect bounce shadowing is not supported for Spot and Point lights.");
 
             // Additional light data
+            public readonly GUIContent directionalIntensity = new GUIContent("Intensity (Lux)", "");
+            public readonly GUIContent punctualIntensity = new GUIContent("Intensity (Lumen)", "");
+            public readonly GUIContent areaIntensity = new GUIContent("Intensity (Lumen)", "");
 
             public readonly GUIContent maxSmoothness = new GUIContent("Max Smoothness", "Very low cost way of faking spherical area lighting. This will modify the roughness of the material lit. This is useful when the specular highlight is too small or too sharp.");
             public readonly GUIContent affectDiffuse = new GUIContent("Affect Diffuse", "This will disable diffuse lighting for this light. Doesn't save performance, diffuse lighting is still computed.");
             public readonly GUIContent[] shapeNames;
 
             // Additional shadow data
-            public readonly GUIContent shadowCascades = new GUIContent("Cascades", "");
-            public readonly GUIContent shadowCascadeCount = new GUIContent("Cascade Count", "");
-            public readonly GUIContent[] shadowCascadeRatios = { new GUIContent("Cascade 1"), new GUIContent("Cascade 2"), new GUIContent("Cascade 3") };
-            public readonly GUIContent contactShadow = new GUIContent("Contact Shadows");
-            public readonly GUIContent contactShadowLength = new GUIContent("Length", "Length of rays used to gather contact shadows in world units.\nZero will disable the feature.");
-            public readonly GUIContent contactShadowDistanceScaleFactor = new GUIContent("Distance Scale Factor", "Contact Shadows are scaled up with distance. Use this parameter to dampen this effect.");
-            public readonly GUIContent contactShadowMaxDistance = new GUIContent("Max Distance", "Distance from the camera in world units at which contact shadows are faded out to zero.");
-            public readonly GUIContent contactShadowFadeDistance = new GUIContent("Fade Distance", "Distance in world units over which the contact shadows are faded out (see Max Distance).");
-            public readonly GUIContent contactShadowSampleCount = new GUIContent("Sample Count", "Number of samples when ray casting.");
 
             // Bias control
             public readonly GUIContent viewBiasMin = new GUIContent("View Bias");

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

     {
         sealed class SerializedLightData
         {
+            public SerializedProperty directionalIntensity;
+            public SerializedProperty punctualIntensity;
+            public SerializedProperty areaIntensity;
             public SerializedProperty spotInnerPercent;
             public SerializedProperty lightDimmer;
             public SerializedProperty fadeDistance;
         {
             public SerializedProperty dimmer;
             public SerializedProperty fadeDistance;
-            public SerializedProperty cascadeCount;
-            public SerializedProperty cascadeRatios;
-            public SerializedProperty cascadeBorders;
-            public SerializedProperty enableContactShadows;
-            public SerializedProperty contactShadowLength;
-            public SerializedProperty contactShadowDistanceScaleFactor;
-            public SerializedProperty contactShadowMaxDistance;
-            public SerializedProperty contactShadowFadeDistance;
-            public SerializedProperty contactShadowSampleCount;
-
             // Bias control
             public SerializedProperty viewBiasMin;
             public SerializedProperty viewBiasMax;
             //Disc,
         }
 
+        const float k_MinAreaWidth = 0.01f; // Provide a small size of 1cm for line light
+
         // Used for UI only; the processing code must use LightTypeExtent and LightType
         LightShape m_LightShape;
 
             using (var o = new PropertyFetcher<HDAdditionalLightData>(m_SerializedAdditionalLightData))
             m_AdditionalLightData = new SerializedLightData
             {
+                directionalIntensity = o.Find(x => x.directionalIntensity),
+                punctualIntensity = o.Find(x => x.punctualIntensity),
+                areaIntensity = o.Find(x => x.areaIntensity),
                 spotInnerPercent = o.Find(x => x.m_InnerSpotPercent),
                 lightDimmer = o.Find(x => x.lightDimmer),
                 fadeDistance = o.Find(x => x.fadeDistance),
             {
                 dimmer = o.Find(x => x.shadowDimmer),
                 fadeDistance = o.Find(x => x.shadowFadeDistance),
-                cascadeCount = o.Find("shadowCascadeCount"),
-                cascadeRatios = o.Find("shadowCascadeRatios"),
-                cascadeBorders = o.Find("shadowCascadeBorders"),
-                enableContactShadows = o.Find(x => x.enableContactShadows),
-                contactShadowLength = o.Find(x => x.contactShadowLength),
-                contactShadowDistanceScaleFactor = o.Find(x => x.contactShadowDistanceScaleFactor),
-                contactShadowMaxDistance = o.Find(x => x.contactShadowMaxDistance),
-                contactShadowFadeDistance = o.Find(x => x.contactShadowFadeDistance),
-                contactShadowSampleCount = o.Find(x => x.contactShadowSampleCount),
 
                 viewBiasMin = o.Find(x => x.viewBiasMin),
                 viewBiasMax = o.Find(x => x.viewBiasMax),
             {
                 bool shadowsEnabled = EditorGUILayout.Toggle(CoreEditorUtils.GetContent("Enable Shadows"), settings.shadowsType.enumValueIndex != 0);
                 settings.shadowsType.enumValueIndex = shadowsEnabled ? (int)LightShadows.Hard : (int)LightShadows.None;
-                if (settings.lightType.enumValueIndex == (int)LightType.Directional)
-                {
-                    EditorGUILayout.PropertyField(m_AdditionalShadowData.enableContactShadows, CoreEditorUtils.GetContent("Enable Contact Shadows"));
-                }
             }
 
             EditorGUILayout.PropertyField(m_AdditionalLightData.showAdditionalSettings);
         {
+            EditorGUI.BeginChangeCheck(); // For GI we need to detect any change on additional data and call SetLightDirty + For intensity we need to detect light shape change
+
-            EditorGUI.BeginChangeCheck(); // For GI we need to detect any change on additional data and call SetLightDirty
-
             // LightShape is HD specific, it need to drive LightType from the original LightType
             // when it make sense, so the GI is still in sync with the light shape
             switch (m_LightShape)
                     m_AdditionalLightData.lightTypeExtent.enumValueIndex = (int)LightTypeExtent.Rectangle;
                     EditorGUILayout.PropertyField(m_AdditionalLightData.shapeWidth, s_Styles.shapeWidthRect);
                     EditorGUILayout.PropertyField(m_AdditionalLightData.shapeHeight, s_Styles.shapeHeightRect);
+                    m_AdditionalLightData.shapeWidth.floatValue = Mathf.Max(m_AdditionalLightData.shapeWidth.floatValue, k_MinAreaWidth);
+                    m_AdditionalLightData.shapeHeight.floatValue = Mathf.Max(m_AdditionalLightData.shapeHeight.floatValue, k_MinAreaWidth);
                     settings.areaSizeX.floatValue = m_AdditionalLightData.shapeWidth.floatValue;
                     settings.areaSizeY.floatValue = m_AdditionalLightData.shapeHeight.floatValue;
                     settings.shadowsType.enumValueIndex = (int)LightShadows.None;
                     settings.lightType.enumValueIndex = (int)LightType.Point;
                     m_AdditionalLightData.lightTypeExtent.enumValueIndex = (int)LightTypeExtent.Line;
                     EditorGUILayout.PropertyField(m_AdditionalLightData.shapeWidth, s_Styles.shapeWidthLine);
+                    m_AdditionalLightData.shapeWidth.floatValue = Mathf.Max(m_AdditionalLightData.shapeWidth.floatValue, k_MinAreaWidth);
+                    m_AdditionalLightData.shapeHeight.floatValue = Mathf.Max(m_AdditionalLightData.shapeHeight.floatValue, k_MinAreaWidth);
-                    settings.areaSizeY.floatValue = 0.01f;
+                    settings.areaSizeY.floatValue = k_MinAreaWidth;
                     settings.shadowsType.enumValueIndex = (int)LightShadows.None;
                     break;
 
 
             if (EditorGUI.EndChangeCheck())
             {
+                UpdateLightIntensity();
+        void UpdateLightIntensity()
+        {
+            switch (m_LightShape)
+            {
+                case LightShape.Directional:
+                    settings.intensity.floatValue = m_AdditionalLightData.directionalIntensity.floatValue;
+                    break;
+
+                case LightShape.Point:
+                    settings.intensity.floatValue = LightUtils.ConvertPointLightIntensity(m_AdditionalLightData.punctualIntensity.floatValue);
+                    break;
+
+                case LightShape.Spot:
+                    // Spot should used conversion which take into account the angle, and thus the intensity vary with angle.
+                    // This is not easy to manipulate for lighter, so we simply consider any spot light as just occluded point light. So reuse the same code.
+                    settings.intensity.floatValue = LightUtils.ConvertPointLightIntensity(m_AdditionalLightData.punctualIntensity.floatValue);
+                    // TODO: What to do with box shape ?
+                    // var spotLightShape = (SpotLightShape)m_AdditionalLightData.spotLightShape.enumValueIndex;
+                    break;
+
+                case LightShape.Rectangle:
+                    settings.intensity.floatValue = LightUtils.ConvertRectLightIntensity(m_AdditionalLightData.areaIntensity.floatValue, m_AdditionalLightData.shapeWidth.floatValue, m_AdditionalLightData.shapeHeight.floatValue);
+                    break;
+
+                case LightShape.Line:
+                    settings.intensity.floatValue = LightUtils.calculateLineLightArea(m_AdditionalLightData.areaIntensity.floatValue, m_AdditionalLightData.shapeWidth.floatValue);
+                    break;
+            }
+        }
+
-            settings.DrawIntensity();
-            settings.DrawBounceIntensity();
+
+            EditorGUI.BeginChangeCheck();
+
+            switch (m_LightShape)
+            {
+                case LightShape.Directional:
+                    EditorGUILayout.PropertyField(m_AdditionalLightData.directionalIntensity, s_Styles.directionalIntensity);
+                    break;
+
+                case LightShape.Point:
+                case LightShape.Spot:
+                    EditorGUILayout.PropertyField(m_AdditionalLightData.punctualIntensity, s_Styles.punctualIntensity);
+                    break;
+
+                case LightShape.Rectangle:
+                case LightShape.Line:
+                    EditorGUILayout.PropertyField(m_AdditionalLightData.areaIntensity, s_Styles.areaIntensity);
+                    break;
+            }
+
+            if (EditorGUI.EndChangeCheck())
+            {
+                UpdateLightIntensity();
+            }
+
             settings.DrawLightmapping();
 
             EditorGUI.BeginChangeCheck(); // For GI we need to detect any change on additional data and call SetLightDirty
             EditorGUILayout.Slider(m_AdditionalShadowData.viewBiasScale, 0.0f, 15.0f, s_Styles.viewBiasScale);
             EditorGUILayout.Slider(settings.shadowsNearPlane, 0.01f, 10f, s_Styles.shadowNearPlane);
 
-            if (settings.lightType.enumValueIndex == (int)LightType.Directional)
-            {
-                using (var scope = new EditorGUI.ChangeCheckScope())
-                {
-                    EditorGUILayout.IntSlider(m_AdditionalShadowData.cascadeCount, 1, 4, s_Styles.shadowCascadeCount);
-
-                    if (scope.changed)
-                    {
-                        int len = m_AdditionalShadowData.cascadeCount.intValue;
-                        m_AdditionalShadowData.cascadeRatios.arraySize = len - 1;
-                        m_AdditionalShadowData.cascadeBorders.arraySize = len;
-                    }
-                }
-
-                EditorGUI.indentLevel++;
-                int arraySize = m_AdditionalShadowData.cascadeRatios.arraySize;
-                for (int i = 0; i < arraySize; i++)
-                    EditorGUILayout.Slider(m_AdditionalShadowData.cascadeRatios.GetArrayElementAtIndex(i), 0f, 1f, s_Styles.shadowCascadeRatios[i]);
-                EditorGUI.indentLevel--;
-
-                if(!m_AdditionalShadowData.enableContactShadows.hasMultipleDifferentValues && m_AdditionalShadowData.enableContactShadows.boolValue)
-                {
-                    EditorGUILayout.Space();
-                    EditorGUILayout.LabelField(s_Styles.contactShadow, EditorStyles.boldLabel);
-
-                    EditorGUI.indentLevel++;
-                    EditorGUILayout.PropertyField(m_AdditionalShadowData.contactShadowLength, s_Styles.contactShadowLength);
-                    EditorGUILayout.PropertyField(m_AdditionalShadowData.contactShadowDistanceScaleFactor, s_Styles.contactShadowDistanceScaleFactor);
-                    EditorGUILayout.PropertyField(m_AdditionalShadowData.contactShadowMaxDistance, s_Styles.contactShadowMaxDistance);
-                    EditorGUILayout.PropertyField(m_AdditionalShadowData.contactShadowFadeDistance, s_Styles.contactShadowFadeDistance);
-                    EditorGUILayout.PropertyField(m_AdditionalShadowData.contactShadowSampleCount, s_Styles.contactShadowSampleCount);
-                    EditorGUI.indentLevel--;
-                }
-            }
-
             if (settings.isBakedOrMixed)
                 DrawBakedShadowParameters();
 
                 EditorGUILayout.Slider(m_AdditionalShadowData.normalBiasMin, 0.0f, 5.0f, s_Styles.normalBiasMin);
                 if (EditorGUI.EndChangeCheck())
                 {
-                    // Link min to max and don't expose normalBiasScale (useless when min == max)                    
+                    // Link min to max and don't expose normalBiasScale (useless when min == max)
                     m_AdditionalShadowData.normalBiasMax = m_AdditionalShadowData.normalBiasMin;
                 }
                 //EditorGUILayout.PropertyField(m_AdditionalShadowData.normalBiasMax, s_Styles.normalBiasMax);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Sky/ProceduralSky/ProceduralSkyEditor.cs

 
             EditorGUILayout.Space();
 
-            base.CommonSkySettingsGUI();
+            base.CommonSkySettingsGUI(false);
         }
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Sky/SkySettingsEditor.cs

         SerializedDataParameter m_EnvUpdateMode;
         SerializedDataParameter m_EnvUpdatePeriod;
 
-        SerializedProperty      m_UseForBaking;
-
         public override void OnEnable()
         {
             var o = new PropertyFetcher<SkySettings>(serializedObject);
             m_EnvUpdatePeriod = Unpack(o.Find(x => x.updatePeriod));
         }
 
-        protected void CommonSkySettingsGUI()
+        protected void CommonSkySettingsGUI(bool enableRotation = true)
-            PropertyField(m_SkyRotation);
+            if(enableRotation)
+                PropertyField(m_SkyRotation);
 
             PropertyField(m_EnvUpdateMode);
             if (!m_EnvUpdateMode.value.hasMultipleDifferentValues && m_EnvUpdateMode.value.intValue == (int)EnvironementUpdateMode.Realtime)

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/UpgradeStandardShaderMaterials.cs

         static List<MaterialUpgrader> GetHDUpgraders()
         {
             var upgraders = new List<MaterialUpgrader>();
-            upgraders.Add(new StandardToHDLitMaterialUpgrader("Standard", "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass));
-            upgraders.Add(new StandardSpecularToHDLitMaterialUpgrader("Standard (Specular setup)", "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass));
+            upgraders.Add(new StandardsToHDLitMaterialUpgrader("Standard", "HDRenderPipeline/Lit"));
+            upgraders.Add(new StandardsToHDLitMaterialUpgrader("Standard (Specular setup)", "HDRenderPipeline/Lit"));
+            upgraders.Add(new StandardsToHDLitMaterialUpgrader("Standard (Roughness setup)", "HDRenderPipeline/Lit"));
+
+            upgraders.Add(new UnlitsToHDUnlitUpgrader("Unlit/Color", "HDRenderPipeline/Unlit"));
+            upgraders.Add(new UnlitsToHDUnlitUpgrader("Unlit/Texture", "HDRenderPipeline/Unlit"));
+            upgraders.Add(new UnlitsToHDUnlitUpgrader("Unlit/Transparent", "HDRenderPipeline/Unlit"));
+            upgraders.Add(new UnlitsToHDUnlitUpgrader("Unlit/Transparent Cutout", "HDRenderPipeline/Unlit"));
             return upgraders;
         }
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDRenderPipeline.cs

             m_Asset = asset;
             m_GPUCopy = new GPUCopy(asset.renderPipelineResources.copyChannelCS);
             m_BufferPyramid = new BufferPyramid(
-                asset.renderPipelineResources.gaussianPyramidCS,
+                asset.renderPipelineResources.colorPyramidCS,
                 asset.renderPipelineResources.depthPyramidCS,
                 m_GPUCopy);
 
 
             // For debugging
             MousePositionDebug.instance.Cleanup();
+
+            DecalSystem.instance.Cleanup();
 
             m_MaterialList.ForEach(material => material.Cleanup());
 
                 if (m_CurrentWidth > 0 && m_CurrentHeight > 0)
                     m_LightLoop.ReleaseResolutionDependentBuffers();
 
-                m_LightLoop.AllocResolutionDependentBuffers(hdCamera.actualWidth, hdCamera.actualHeight);
+                m_LightLoop.AllocResolutionDependentBuffers((int)hdCamera.screenSize.x, (int)hdCamera.screenSize.y, m_FrameSettings.enableStereo);
             }
 
             // Warning: (resolutionChanged == false) if you open a new Editor tab of the same size!
                     UpdateShadowSettings();
                     m_SkyManager.UpdateCurrentSkySettings(hdCamera);
 
-                    // TODO: Float HDCamera setup higher in order to pass stereo into GetCullingParameters
                     ScriptableCullingParameters cullingParams;
                     if (!CullResults.GetCullingParameters(camera, m_FrameSettings.enableStereo, out cullingParams))
                     {
 
                     m_LightLoop.UpdateCullingParameters(ref cullingParams);
+                    hdCamera.UpdateStereoDependentState(m_FrameSettings, ref cullingParams);
 
 #if UNITY_EDITOR
                     // emit scene view UI

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDStringConstants.cs

         public static readonly int g_vBoundsBuffer = Shader.PropertyToID("g_vBoundsBuffer");
         public static readonly int _LightVolumeData = Shader.PropertyToID("_LightVolumeData");
         public static readonly int g_data = Shader.PropertyToID("g_data");
-        public static readonly int g_mProjection = Shader.PropertyToID("g_mProjection");
-        public static readonly int g_mInvProjection = Shader.PropertyToID("g_mInvProjection");
+        public static readonly int g_mProjectionArr = Shader.PropertyToID("g_mProjectionArr");
+        public static readonly int g_mInvProjectionArr = Shader.PropertyToID("g_mInvProjectionArr");
         public static readonly int g_viDimensions = Shader.PropertyToID("g_viDimensions");
         public static readonly int g_vLightList = Shader.PropertyToID("g_vLightList");
 
         public static readonly int _TaaFrameIndex    = Shader.PropertyToID("_TaaFrameIndex");
         public static readonly int _TaaFrameRotation = Shader.PropertyToID("_TaaFrameRotation");
 
+        public static readonly int _ViewMatrixStereo = Shader.PropertyToID("_ViewMatrixStereo");
+        public static readonly int _ViewProjMatrixStereo = Shader.PropertyToID("_ViewProjMatrixStereo");
+        public static readonly int _InvViewMatrixStereo = Shader.PropertyToID("_InvViewMatrixStereo");
         public static readonly int _InvProjMatrixStereo = Shader.PropertyToID("_InvProjMatrixStereo");
         public static readonly int _InvViewProjMatrixStereo = Shader.PropertyToID("_InvViewProjMatrixStereo");
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/HDUtils.cs

             cmd.Blit(source, destination, new Vector2(camera.scaleBias.x, camera.scaleBias.y), Vector2.zero);
         }
 
-        // This particular case is for blitting a camera-scaled texture into a non scaling texture. So we setup the full viewport (implicit in cmd.Blit) but have to scale the input UVs.
+        // This particular case is for blitting a non-scaled texture into a scaled texture. So we setup the partial viewport but don't scale the input UVs.
         public static void BlitCameraTexture(CommandBuffer cmd, HDCamera camera, RenderTargetIdentifier source, RTHandle destination)
         {
             // Will set the correct camera viewport as well.

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/DeferredDirectionalShadow.compute

 #include "../ShaderVariables.hlsl"
 #include "Lighting.hlsl" 
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //#pragma enable_d3d11_debug_symbols
 
 RWTexture2D<float4> _DeferredShadowTextureUAV;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Light/HDAdditionalLightData.cs

         float m_Version = 1.0f;
  #pragma warning restore 414
 
+        // To be able to have correct default values for our lights and to also control the conversion of intensity from the light editor (so it is compatible with GI)
+        // we add intensity (for each type of light we want to manage).
+        public float directionalIntensity   = Mathf.PI; // In Lux
+        public float punctualIntensity      = 600.0f;   // Light default to 600 lumen, i.e ~48 candela
+        public float areaIntensity          = 200.0f;   // Light default to 200 lumen to better match point light
+
         [Range(0.0f, 100.0f)]
         public float m_InnerSpotPercent = 0.0f; // To display this field in the UI this need to be public
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/Light/HDLightEditorUtilities.cs

         {
 
             var RectangleSize = new Vector3(arealight.areaSize.x, arealight.areaSize.y, 0);
-            Gizmos.matrix = arealight.transform.localToWorldMatrix;
+            // Remove scale for light, not take into account
+            var localToWorldMatrix = Matrix4x4.TRS(arealight.transform.position, arealight.transform.rotation, Vector3.one);
+            Gizmos.matrix = localToWorldMatrix;
             Gizmos.DrawWireCube(Vector3.zero, RectangleSize);
             Gizmos.matrix = Matrix4x4.identity;
             Gizmos.DrawWireSphere(arealight.transform.position, arealight.range);

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

 #include "../../Debug/DebugDisplay.hlsl"
 #include "../../Lighting/Lighting.hlsl" // This include Material.hlsl
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //-------------------------------------------------------------------------------------
 // variable declaration
 //-------------------------------------------------------------------------------------

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

             scInit.dataSyncer                        = syncer;
             scInit.resourceBinder                    = binder;
 
-            m_ShadowMgr = new ShadowManager(shadowSettings, ref scInit, m_Shadowmaps);
+            ShadowManager.ShadowBudgets budgets;
+            budgets.maxPointLights       = 6;
+            budgets.maxSpotLights        = 12;
+            budgets.maxDirectionalLights = 1;
+
+            m_ShadowMgr = new ShadowManager(shadowSettings, ref scInit, ref budgets, m_Shadowmaps);
             // set global overrides - these need to match the override specified in LightLoop/Shadow.hlsl
             bool useGlobalOverrides = true;
             m_ShadowMgr.SetGlobalShadowOverride( GPUShadowType.Point        , ShadowAlgorithm.PCF, ShadowVariant.V2, ShadowPrecision.High, useGlobalOverrides );
         public const int k_MaxEnvLightsOnScreen = 64;
         public const int k_MaxShadowOnScreen = 16;
         public const int k_MaxCascadeCount = 4; //Should be not less than m_Settings.directionalLightCascadeCount;
+        public const int k_MaxStereoEyes = 2;
         public static readonly Vector3 k_BoxCullingExtentThreshold = Vector3.one * 0.01f;
 
         // Static keyword is required here else we get a "DestroyBuffer can only be called from the main thread"
 
             public List<SFiniteLightBound> bounds;
             public List<LightVolumeData> lightVolumes;
-           
+            public List<SFiniteLightBound> rightEyeBounds;
+            public List<LightVolumeData> rightEyeLightVolumes;
 
             public void Clear()
             {
 
                 bounds.Clear();
                 lightVolumes.Clear();
+                rightEyeBounds.Clear();
+                rightEyeLightVolumes.Clear();
             }
 
             public void Allocate()
 
                 bounds = new List<SFiniteLightBound>();
                 lightVolumes = new List<LightVolumeData>();
+
+                rightEyeBounds = new List<SFiniteLightBound>();
+                rightEyeLightVolumes = new List<LightVolumeData>();
             }
         }
 
 
         int GetNumTileFtplX(HDCamera hdCamera)
         {
-            return (hdCamera.actualWidth + (LightDefinitions.s_TileSizeFptl - 1)) / LightDefinitions.s_TileSizeFptl;
+            return ((int)hdCamera.screenSize.x + (LightDefinitions.s_TileSizeFptl - 1)) / LightDefinitions.s_TileSizeFptl;
-            return (hdCamera.actualHeight + (LightDefinitions.s_TileSizeFptl - 1)) / LightDefinitions.s_TileSizeFptl;
+            return ((int)hdCamera.screenSize.y + (LightDefinitions.s_TileSizeFptl - 1)) / LightDefinitions.s_TileSizeFptl;
-            return (hdCamera.actualWidth + (LightDefinitions.s_TileSizeClustered - 1)) / LightDefinitions.s_TileSizeClustered;
+            return ((int)hdCamera.screenSize.x + (LightDefinitions.s_TileSizeClustered - 1)) / LightDefinitions.s_TileSizeClustered;
-            return (hdCamera.actualHeight + (LightDefinitions.s_TileSizeClustered - 1)) / LightDefinitions.s_TileSizeClustered;
+            return ((int)hdCamera.screenSize.y + (LightDefinitions.s_TileSizeClustered - 1)) / LightDefinitions.s_TileSizeClustered;
         }
 
         public bool GetFeatureVariantsEnabled()
 
             s_GenAABBKernel = buildScreenAABBShader.FindKernel("ScreenBoundsAABB");
 
-            s_AABBBoundsBuffer = new ComputeBuffer(2 * k_MaxLightsOnScreen, 3 * sizeof(float));
-            s_ConvexBoundsBuffer = new ComputeBuffer(k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SFiniteLightBound)));
-            s_LightVolumeDataBuffer = new ComputeBuffer(k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightVolumeData)));
+            // The bounds and light volumes are view-dependent, and AABB is additionally projection dependent.
+            // The view and proj matrices are per eye in stereo. This means we have to double the size of these buffers.
+            // TODO: Maybe in stereo, we will only support half as many lights total, in order to minimize buffer size waste.
+            // Alternatively, we could re-size these buffers if any stereo camera is active, instead of unilaterally increasing buffer size.
+            // TODO: I don't think k_MaxLightsOnScreen corresponds to the actual correct light count for cullable light types (punctual, area, env, decal)
+            s_AABBBoundsBuffer = new ComputeBuffer(k_MaxStereoEyes * 2 * k_MaxLightsOnScreen, 3 * sizeof(float));
+            s_ConvexBoundsBuffer = new ComputeBuffer(k_MaxStereoEyes* k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(SFiniteLightBound)));
+            s_LightVolumeDataBuffer = new ComputeBuffer(k_MaxStereoEyes* k_MaxLightsOnScreen, System.Runtime.InteropServices.Marshal.SizeOf(typeof(LightVolumeData)));
             s_DispatchIndirectBuffer = new ComputeBuffer(LightDefinitions.s_NumFeatureVariants * 3, sizeof(uint), ComputeBufferType.IndirectArguments);
 
             // Cluster
             return 8 * (1 << k_Log2NumClusters);       // total footprint for all layers of the tile (measured in light index entries)
         }
 
-        // TODO: Add proper stereo support
-        public void AllocResolutionDependentBuffers(int width, int height)
+        public void AllocResolutionDependentBuffers(int width, int height, bool stereoEnabled)
+            var nrStereoLayers = stereoEnabled ? 2 : 1;
+
-            var nrTiles = nrTilesX * nrTilesY;
+            var nrTiles = nrTilesX * nrTilesY * nrStereoLayers;
-            s_TileFeatureFlags = new ComputeBuffer(nrTilesX * nrTilesY, sizeof(uint));
+            s_TileFeatureFlags = new ComputeBuffer(nrTiles, sizeof(uint));
-                var nrClusterTiles = nrClustersX * nrClustersY;
+                var nrClusterTiles = nrClustersX * nrClustersY * nrStereoLayers;
 
                 s_PerVoxelOffset = new ComputeBuffer((int)LightCategory.Count * (1 << k_Log2NumClusters) * nrClusterTiles, sizeof(uint));
                 s_PerVoxelLightLists = new ComputeBuffer(NumLightIndicesPerClusteredTile() * nrClusterTiles, sizeof(uint));
             {
                 var nrBigTilesX = (width + 63) / 64;
                 var nrBigTilesY = (height + 63) / 64;
-                var nrBigTiles = nrBigTilesX * nrBigTilesY;
+                var nrBigTiles = nrBigTilesX * nrBigTilesY * nrStereoLayers;
                 s_BigTileLightList = new ComputeBuffer(LightDefinitions.s_MaxNrBigTileLightsPlusOne * nrBigTiles, sizeof(uint));
             }
         }
             // camera.worldToCameraMatrix is RHS and Unity's transforms are LHS
             // We need to flip it to work with transforms
             return Matrix4x4.Scale(new Vector3(1, 1, -1)) * camera.worldToCameraMatrix;
+        }
+
+        static Matrix4x4 WorldToViewStereo(Camera camera, Camera.StereoscopicEye eyeIndex)
+        {
+            return Matrix4x4.Scale(new Vector3(1, 1, -1)) * camera.GetStereoViewMatrix(eyeIndex);
         }
 
         // For light culling system, we need non oblique projection matrices
             // We need to flip it to work with transforms
             return camera.nonObliqueProjMatrix * Matrix4x4.Scale(new Vector3(1, 1, -1));
+        }
+
+        static Matrix4x4 CameraProjectionStereoLHS(Camera camera, Camera.StereoscopicEye eyeIndex)
+        {
+            return camera.GetStereoProjectionMatrix(eyeIndex) * Matrix4x4.Scale(new Vector3(1, 1, -1));
         }
 
         public Vector3 GetLightColor(VisibleLight light)
                 directionalLightData.dynamicShadowCasterOnly = 0;
             }
 
+            // Fallback to the first non shadow casting directional light.
             m_CurrentSunLight = m_CurrentSunLight == null ? light.light : m_CurrentSunLight;
 
             m_lightList.directionalLights.Add(directionalLightData);
 
         // TODO: we should be able to do this calculation only with LightData without VisibleLight light, but for now pass both
         public void GetLightVolumeDataAndBound(LightCategory lightCategory, GPULightType gpuLightType, LightVolumeType lightVolumeType,
-                                               VisibleLight light, LightData lightData, Vector3 lightDimensions, Matrix4x4 worldToView)
+                                               VisibleLight light, LightData lightData, Vector3 lightDimensions, Matrix4x4 worldToView,
+                                               Camera.StereoscopicEye eyeIndex = Camera.StereoscopicEye.Left)
         {
             // Then Culling side
             var range = lightDimensions.z;
                 Debug.Assert(false, "TODO: encountered an unknown GPULightType.");
             }
 
-            m_lightList.bounds.Add(bound);
-            m_lightList.lightVolumes.Add(lightVolumeData);
+            if (eyeIndex == Camera.StereoscopicEye.Left)
+            {
+                m_lightList.bounds.Add(bound);
+                m_lightList.lightVolumes.Add(lightVolumeData);
+            }
+            else
+            {
+                m_lightList.rightEyeBounds.Add(bound);
+                m_lightList.rightEyeLightVolumes.Add(lightVolumeData);
+            }
         }
 
 
             m_lightList.envLights.Add(envLightData);
             return true;
         }
-        
-             
-        public void GetEnvLightVolumeDataAndBound(ProbeWrapper probe, LightVolumeType lightVolumeType, Matrix4x4 worldToView)
+
+        public void GetEnvLightVolumeDataAndBound(ProbeWrapper probe, LightVolumeType lightVolumeType, Matrix4x4 worldToView, Camera.StereoscopicEye eyeIndex = Camera.StereoscopicEye.Left)
         {
             var bound = new SFiniteLightBound();
             var lightVolumeData = new LightVolumeData();
                 }
             }
 
-            m_lightList.bounds.Add(bound);
-            m_lightList.lightVolumes.Add(lightVolumeData);
+            if (eyeIndex == Camera.StereoscopicEye.Left)
+            {
+                m_lightList.bounds.Add(bound);
+                m_lightList.lightVolumes.Add(lightVolumeData);
+            }
+            else
+            {
+                m_lightList.rightEyeBounds.Add(bound);
+                m_lightList.rightEyeLightVolumes.Add(lightVolumeData);
+            }
         }
 
         public int GetCurrentShadowCount()
 
                 m_lightList.Clear();
 
-                Vector3 camPosWS = camera.transform.position;
-
+
+                var stereoEnabled = m_FrameSettings.enableStereo;
 
                 // Note: Light with null intensity/Color are culled by the C++, no need to test it here
                 if (cullResults.visibleLights.Count != 0 || cullResults.visibleReflectionProbes.Count != 0)
 
                             AdditionalShadowData asd = vl.light.GetComponent<AdditionalShadowData>();
                             if (asd != null && asd.shadowDimmer > 0.0f)
+                            {
+
+                                // Discover sun light and update cascade info from Volumes
+                                // TODO: This should be moved to GetDirectionalLightData when we merge the two loops here.
+                                // Careful it must still be done BEFORE the call to ProcessShadowRequests
+                                if (vl.lightType == LightType.Directional && m_CurrentSunLight == null)
+                                {
+                                    var hdShadowSettings = VolumeManager.instance.stack.GetComponent<HDShadowSettings>();
+                                    asd.SetShadowCascades(hdShadowSettings.cascadeShadowSplitCount, hdShadowSettings.cascadeShadowSplits, hdShadowSettings.cascadeShadowBorders );
+                                }
+                            }
-                        uint    shadowRequestCount = (uint)m_ShadowRequests.Count;
+                        uint shadowRequestCount = (uint)m_ShadowRequests.Count;
+
                         m_ShadowMgr.ProcessShadowRequests(m_FrameId, cullResults, camera, ShaderConfig.s_CameraRelativeRendering != 0, cullResults.visibleLights,
                             ref shadowRequestCount, shadowRequests, out shadowDataIndices);
 
                     // For now we will still apply the maximum of shadow here but we don't apply the sorting by priority + slot allocation yet
 
                     // 2. Go through all lights, convert them to GPU format.
-                    // Create simultaneously data for culling (LigthVolumeData and rendering)
+                    // Simultaneously create data for culling (LightVolumeData and SFiniteLightBound)
+                    Vector3 camPosWS = camera.transform.position;
+
+                    var rightEyeWorldToView = Matrix4x4.identity;
+                    if (stereoEnabled)
+                    {
+                        worldToView = WorldToViewStereo(camera, Camera.StereoscopicEye.Left);
+                        rightEyeWorldToView = WorldToViewStereo(camera, Camera.StereoscopicEye.Right);
+                    }
 
                     for (int sortIndex = 0; sortIndex < sortCount; ++sortIndex)
                     {
 
                             // Then culling side. Must be call in this order as we pass the created Light data to the function
                             GetLightVolumeDataAndBound(lightCategory, gpuLightType, lightVolumeType, light, m_lightList.lights[m_lightList.lights.Count - 1], lightDimensions, worldToView);
+                            if (stereoEnabled)
+                                GetLightVolumeDataAndBound(lightCategory, gpuLightType, lightVolumeType, light, m_lightList.lights[m_lightList.lights.Count - 1], lightDimensions, rightEyeWorldToView, Camera.StereoscopicEye.Right);
 
                             // We make the light position camera-relative as late as possible in order
                             // to allow the preceding code to work with the absolute world space coordinates.
                         if (GetEnvLightData(cmd, camera, probeWrapper))
                         {
                             GetEnvLightVolumeDataAndBound(probeWrapper, lightVolumeType, worldToView);
+                            if (stereoEnabled)
+                                GetEnvLightVolumeDataAndBound(probeWrapper, lightVolumeType, rightEyeWorldToView, Camera.StereoscopicEye.Right);
 
                             // We make the light position camera-relative as late as possible in order
                             // to allow the preceding code to work with the absolute world space coordinates.
                 Debug.Assert(m_lightList.bounds.Count == m_lightCount);
                 Debug.Assert(m_lightList.lightVolumes.Count == m_lightCount);
 
-                m_lightList.bounds.AddRange(DecalSystem.m_Bounds);
-                m_lightList.lightVolumes.AddRange(DecalSystem.m_LightVolumes);
-                m_lightCount += DecalSystem.m_DecalDatasCount;
+                int decalDatasCount = Math.Min(DecalSystem.m_DecalDatasCount, k_MaxDecalsOnScreen);
+                if (decalDatasCount > 0)
+                {
+                    for (int i = 0; i < decalDatasCount; i++)
+                    {
+                        m_lightList.bounds.Add(DecalSystem.m_Bounds[i]);
+                        m_lightList.lightVolumes.Add(DecalSystem.m_LightVolumes[i]);
+                    }
+                    m_lightCount += decalDatasCount;
+                }
+                if (stereoEnabled)
+                {
+                    // TODO: Proper decal + stereo cull management
+
+                    Debug.Assert(m_lightList.rightEyeBounds.Count == m_lightCount);
+                    Debug.Assert(m_lightList.rightEyeLightVolumes.Count == m_lightCount);
+
+                    // TODO: GC considerations?
+                    m_lightList.bounds.AddRange(m_lightList.rightEyeBounds);
+                    m_lightList.lightVolumes.AddRange(m_lightList.rightEyeLightVolumes);
+                }
+                
                 UpdateDataBuffers();
 
                 m_maxShadowDistance = shadowSettings.maxShadowDistance;
             var camera = hdCamera.camera;
             cmd.BeginSample("Build Light List");
 
-            var w = camera.pixelWidth;
-            var h = camera.pixelHeight;
+            var w = (int)hdCamera.screenSize.x;
+            var h = (int)hdCamera.screenSize.y;
-            // camera to screen matrix (and it's inverse)
-            var proj = CameraProjectionNonObliqueLHS(hdCamera);
-            var projscr = temp * proj;
-            var invProjscr = projscr.inverse;
+            // camera to screen matrix (and it's inverse)
+            var projArr = new Matrix4x4[2];
+            var projscrArr = new Matrix4x4[2];
+            var invProjscrArr = new Matrix4x4[2];
+            if (m_FrameSettings.enableStereo)
+            {
+                for (int eyeIndex = 0; eyeIndex < 2; eyeIndex++)
+                {
+                    projArr[eyeIndex] = CameraProjectionStereoLHS(hdCamera.camera, (Camera.StereoscopicEye)eyeIndex);
+                    projscrArr[eyeIndex] = temp * projArr[eyeIndex];
+                    invProjscrArr[eyeIndex] = projscrArr[eyeIndex].inverse;
+                }
+            }
+            else
+            {
+                projArr[0] = CameraProjectionNonObliqueLHS(hdCamera);
+                projscrArr[0] = temp * projArr[0];
+                invProjscrArr[0] = projscrArr[0].inverse;
+            }
+
+
             // generate screen-space AABBs (used for both fptl and clustered).
             if (m_lightCount != 0)
             {
                 temp.SetRow(3, new Vector4(0.0f, 0.0f, 0.0f, 1.0f));
-                var projh = temp * proj;
-                var invProjh = projh.inverse;
+
+                var projhArr = new Matrix4x4[2];
+                var invProjhArr = new Matrix4x4[2];
+                if (m_FrameSettings.enableStereo)
+                {
+                    for (int eyeIndex = 0; eyeIndex < 2; eyeIndex++)
+                    {
+                        projhArr[eyeIndex] = temp * projArr[eyeIndex];
+                        invProjhArr[eyeIndex] = projhArr[eyeIndex].inverse;
+                    }
+                }
+                else
+                {
+                    projhArr[0] = temp * projArr[0];
+                    invProjhArr[0] = projhArr[0].inverse;
+                }
+
+                // In the stereo case, we have two sets of light bounds to iterate over (bounds are in per-eye view space)
-                cmd.SetComputeMatrixParam(buildScreenAABBShader, HDShaderIDs.g_mProjection, projh);
-                cmd.SetComputeMatrixParam(buildScreenAABBShader, HDShaderIDs.g_mInvProjection, invProjh);
+                cmd.SetComputeMatrixArrayParam(buildScreenAABBShader, HDShaderIDs.g_mProjectionArr, projhArr);
+                cmd.SetComputeMatrixArrayParam(buildScreenAABBShader, HDShaderIDs.g_mInvProjectionArr, invProjhArr);
+
+                // In stereo, we output two sets of AABB bounds
-                cmd.DispatchCompute(buildScreenAABBShader, s_GenAABBKernel, (m_lightCount + 7) / 8, 1, 1);
+
+                int tgY = m_FrameSettings.enableStereo ? 2 : 1;
+                cmd.DispatchCompute(buildScreenAABBShader, s_GenAABBKernel, (m_lightCount + 7) / 8, tgY, 1);
             }
 
             // enable coarse 2D pass on 64x64 tiles (used for both fptl and clustered).
                 cmd.SetComputeIntParam(buildPerBigTileLightListShader, HDShaderIDs._EnvLightIndexShift, m_lightList.lights.Count);
                 cmd.SetComputeIntParam(buildPerBigTileLightListShader, HDShaderIDs._DecalIndexShift, m_lightList.lights.Count + m_lightList.envLights.Count);
                 cmd.SetComputeIntParam(buildPerBigTileLightListShader, HDShaderIDs.g_iNrVisibLights, m_lightCount);
-                cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, HDShaderIDs.g_mScrProjection, projscr);
-                cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscr);
+
+                cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, HDShaderIDs.g_mScrProjection, projscrArr[0]);
+                cmd.SetComputeMatrixParam(buildPerBigTileLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscrArr[0]);
+
                 cmd.SetComputeFloatParam(buildPerBigTileLightListShader, HDShaderIDs.g_fNearPlane, camera.nearClipPlane);
                 cmd.SetComputeFloatParam(buildPerBigTileLightListShader, HDShaderIDs.g_fFarPlane, camera.farClipPlane);
                 cmd.SetComputeBufferParam(buildPerBigTileLightListShader, s_GenListPerBigTileKernel, HDShaderIDs.g_vLightList, s_BigTileLightList);
                 cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs._LightVolumeData, s_LightVolumeDataBuffer);
                 cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_data, s_ConvexBoundsBuffer);
 
-                cmd.SetComputeMatrixParam(buildPerTileLightListShader, HDShaderIDs.g_mScrProjection, projscr);
-                cmd.SetComputeMatrixParam(buildPerTileLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscr);
+                cmd.SetComputeMatrixParam(buildPerTileLightListShader, HDShaderIDs.g_mScrProjection, projscrArr[0]);
+                cmd.SetComputeMatrixParam(buildPerTileLightListShader, HDShaderIDs.g_mInvScrProjection, invProjscrArr[0]);
+
                 cmd.SetComputeTextureParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_depth_tex, cameraDepthBufferRT);
                 cmd.SetComputeBufferParam(buildPerTileLightListShader, s_GenListPerTileKernel, HDShaderIDs.g_vLightList, s_LightList);
                 if (m_FrameSettings.lightLoopSettings.enableBigTilePrepass)
             }
 
             // Cluster
-            VoxelLightListGeneration(cmd, hdCamera, projscr, invProjscr, cameraDepthBufferRT);
+            VoxelLightListGeneration(cmd, hdCamera, projscrArr[0], invProjscrArr[0], cameraDepthBufferRT);
 
             if (enableFeatureVariants)
             {
             s_LightDatas.SetData(m_lightList.lights);
             s_EnvLightDatas.SetData(m_lightList.envLights);
             s_shadowDatas.SetData(m_lightList.shadows);
-            s_DecalDatas.SetData(DecalSystem.m_DecalDatas);
+            s_DecalDatas.SetData(DecalSystem.m_DecalDatas, 0, 0, Math.Min(DecalSystem.m_DecalDatasCount, k_MaxDecalsOnScreen)); // don't add more than the size of the buffer
 
             // These two buffers have been set in Rebuild()
             s_ConvexBoundsBuffer.SetData(m_lightList.bounds);
 
             using (new ProfilingSample(cmd, "Deferred Directional Shadow", CustomSamplerId.TPDeferredDirectionalShadow.GetSampler()))
             {
-                AdditionalShadowData asd = m_CurrentSunLight.GetComponent<AdditionalShadowData>();
+                ContactShadows contactShadows = VolumeManager.instance.stack.GetComponent<ContactShadows>();
-                bool enableContactShadows = m_FrameSettings.enableContactShadows && asd.enableContactShadows && asd.contactShadowLength > 0.0f;
+                bool enableContactShadows = m_FrameSettings.enableContactShadows && contactShadows.enable && contactShadows.length > 0.0f;
                 int kernel;
                 if (enableContactShadows)
                     kernel = m_FrameSettings.enableForwardRenderingOnly ? s_deferredDirectionalShadow_Contact_Kernel : s_deferredDirectionalShadow_Contact_Normals_Kernel;
 
                 if (enableContactShadows)
                 {
-                    float contactShadowRange = Mathf.Clamp(asd.contactShadowFadeDistance, 0.0f, asd.contactShadowMaxDistance);
-                    float contactShadowFadeEnd = asd.contactShadowMaxDistance;
+                    float contactShadowRange = Mathf.Clamp(contactShadows.fadeDistance, 0.0f, contactShadows.maxDistance);
+                    float contactShadowFadeEnd = contactShadows.maxDistance;
-                    Vector4 contactShadowParams = new Vector4(asd.contactShadowLength, asd.contactShadowDistanceScaleFactor, contactShadowFadeEnd, contactShadowOneOverFadeRange);
+                    Vector4 contactShadowParams = new Vector4(contactShadows.length, contactShadows.distanceScaleFactor, contactShadowFadeEnd, contactShadowOneOverFadeRange);
-                    cmd.SetComputeIntParam(deferredDirectionalShadowComputeShader, HDShaderIDs._DirectionalContactShadowSampleCount, (int)asd.contactShadowSampleCount);
+                    cmd.SetComputeIntParam(deferredDirectionalShadowComputeShader, HDShaderIDs._DirectionalContactShadowSampleCount, contactShadows.sampleCount);
                 }
 
                 cmd.SetComputeIntParam(deferredDirectionalShadowComputeShader, HDShaderIDs._DirectionalShadowIndex, m_CurrentSunLightShadowIndex);

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

 #pragma kernel BuildDispatchIndirect
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "LightLoop.cs.hlsl"

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

 #pragma kernel ClearDispatchIndirect
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
 
 RWBuffer<uint> g_DispatchIndirectBuffer : register( u0 );	// Indirect arguments have to be in a _buffer_, not a structured buffer
 

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

 #include "LightingConvexHullUtils.hlsl"
 #include "SortingComputeUtils.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #define EXACT_EDGE_TESTS
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 

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

 #include "SortingComputeUtils.hlsl"
 #endif
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //#define EXACT_EDGE_TESTS
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 #define CONV_HULL_TEST_ENABLED
 		InterlockedAdd(g_LayeredSingleIdxBuffer[0], (uint) iSpaceAvail, start);		// alloc list memory
 	}
 
-	// All our cull data are in the same list, but at render time envLights are separated so we need to shit the index
+	// All our cull data are in the same list, but at render time envLights are separated so we need to shift the index
 	// to make it work correctly
 	int shiftIndex[LIGHTCATEGORY_COUNT];
 	ZERO_INITIALIZE_ARRAY(int, shiftIndex, LIGHTCATEGORY_COUNT);

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

 #include "SortingComputeUtils.hlsl"
 #endif
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #define FINE_PRUNING_ENABLED
 #define PERFORM_SPHERICAL_INTERSECTION_TESTS
 
 	int localOffs=0;
 	int offs = tileIDX.y*nrTilesX + tileIDX.x;
 
-	// All our cull data are in the same list, but at render time envLights are separated so we need to shit the index
+	// All our cull data are in the same list, but at render time envLights are separated so we need to shift the index
 	// to make it work correctly
 	int shiftIndex[LIGHTCATEGORY_COUNT];
 	ZERO_INITIALIZE_ARRAY(int, shiftIndex, LIGHTCATEGORY_COUNT);

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

 #include "../../Material/Material.hlsl" // This includes Material.hlsl
 #include "../../Lighting/LightDefinition.cs.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #define USE_MATERIAL_FEATURE_FLAGS
 #define NR_THREADS	64
 

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

 #include "CoreRP/ShaderLibrary/common.hlsl"
 #include "LightLoop.cs.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
-uniform float4x4 g_mInvProjection;
-uniform float4x4 g_mProjection;
+
+uniform float4x4 g_mInvProjectionArr[2];
+uniform float4x4 g_mProjectionArr[2];
 
 StructuredBuffer<SFiniteLightBound> g_data : register( t0 );
 
 void ScreenBoundsAABB(uint threadID : SV_GroupIndex, uint3 u3GroupID : SV_GroupID)
 {
 	uint groupID = u3GroupID.x;
+    uint eyeIndex = u3GroupID.y; // currently, can only be 0 or 1
+
+    // The g_ is preserved in order to make cross-pipeline (FPTL) updates easier
+    float4x4 g_mInvProjection = g_mInvProjectionArr[eyeIndex];
+    float4x4 g_mProjection = g_mProjectionArr[eyeIndex];
 
 	//uint vindex = groupID * NR_THREADS + threadID;
 	unsigned int g = groupID;
 	const int lgtIndex = subLigt+(int) g*8;
 	const int sideIndex = (int) (t%8);
 
-	SFiniteLightBound lgtDat = g_data[lgtIndex];
+    const int eyeAdjustedLgtIndex = lgtIndex + (eyeIndex * g_iNrVisibLights);
+    SFiniteLightBound lgtDat = g_data[eyeAdjustedLgtIndex];
 
 	const float3 boxX = lgtDat.boxAxisX.xyz;
 	const float3 boxY = lgtDat.boxAxisY.xyz;
 			//g_vBoundsBuffer[lgtIndex+g_iNrVisibLights] = float3(0.5*vMax.x+0.5, -0.5*vMin.y+0.5, vMax.z*VIEWPORT_SCALE_Z);
 
 			// changed for unity
-			g_vBoundsBuffer[lgtIndex+0] = float3(0.5*vMin.x+0.5, 0.5*vMin.y+0.5, vMin.z*VIEWPORT_SCALE_Z);
-			g_vBoundsBuffer[lgtIndex+(int) g_iNrVisibLights] = float3(0.5*vMax.x+0.5, 0.5*vMax.y+0.5, vMax.z*VIEWPORT_SCALE_Z);
+
+            // Each light's AABB is represented by two float3s, the min and max of the box.
+            // And for stereo, we have two sets of lights.  Therefore, each eye has a set of mins, followed by
+            // a set of maxs, and each set is equal to g_iNrVisibLights.
+            const int eyeBaseIndex = eyeIndex * g_iNrVisibLights * 2;
+            const int minIndex = eyeBaseIndex + lgtIndex + 0;
+            const int maxIndex = eyeBaseIndex + lgtIndex + (int)g_iNrVisibLights;
+            g_vBoundsBuffer[minIndex] = float3(0.5*vMin.x + 0.5, 0.5*vMin.y + 0.5, vMin.z*VIEWPORT_SCALE_Z);
+            g_vBoundsBuffer[maxIndex] = float3(0.5*vMax.x + 0.5, 0.5*vMax.y + 0.5, vMax.z*VIEWPORT_SCALE_Z);
 		}
 	}
 }

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

 #include "../../Lighting.hlsl" // Includes Material.hlsl
 #include "../../LightEvaluation.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs
 //--------------------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GGXConvolution/BuildProbabilityTables.compute

 #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 #include "../../ShaderVariables.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 /* --- Input --- */
 
 #define TEXTURE_HEIGHT 256                // Equiareal texture map: cos(theta) = 1.0 - 2.0 * v

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Material/GGXConvolution/ComputeGgxIblSampleData.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "CoreRP/ShaderLibrary/ImageBasedLighting.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 #ifdef SHADER_API_MOBILE
 #define MAX_IBL_SAMPLE_CNT 34
 #else

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

     // Save ALU by applying 'lightData.color' only once.
     lighting.diffuse *= lightData.color;
     lighting.specular *= lightData.color;
-#endif // LIT_DISPLAY_REFERENCE_AREA
 
 #ifdef DEBUG_DISPLAY
     if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
         lighting.diffuse *= PI * lightData.diffuseScale;
     }
 #endif
+
+#endif // LIT_DISPLAY_REFERENCE_AREA
 
     return lighting;
 }
     // Save ALU by applying 'lightData.color' only once.
     lighting.diffuse *= lightData.color;
     lighting.specular *= lightData.color;
-#endif // LIT_DISPLAY_REFERENCE_AREA
 
 #ifdef DEBUG_DISPLAY
     if (_DebugLightingMode == DEBUGLIGHTINGMODE_LUX_METER)
         lighting.diffuse *= PI * lightData.diffuseScale;
     }
 #endif
+
+#endif // LIT_DISPLAY_REFERENCE_AREA
 
     return lighting;
 }

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

 #include "../../Lighting/LightDefinition.cs.hlsl"
 #include "SubsurfaceScattering.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 //--------------------------------------------------------------------------------------------------
 // Inputs & outputs
 //--------------------------------------------------------------------------------------------------

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/ApplyDistorsion.compute

 #include "CoreRP/ShaderLibrary/Common.hlsl"
 #include "../Material/Builtin/BuiltinData.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 TEXTURE2D(_DistortionTexture);
 TEXTURE2D(_GaussianPyramidColorTexture);
 RW_TEXTURE2D(float4, _CameraColorTexture);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/ColorPyramid.compute

 
 #include "CoreRP/ShaderLibrary/Common.hlsl"
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 Texture2D<float4> _Source;
 RWTexture2D<float4> _Result;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/DepthPyramid.compute

 #pragma kernel KMain_8                KERNEL_SIZE=8     KERNEL_NAME=KMain_8
 #pragma kernel KMain_1                KERNEL_SIZE=1     KERNEL_NAME=KMain_1
 
+#pragma only_renderers d3d11 ps4 xboxone vulkan metal
+
 Texture2D<float> _Source;
 RWTexture2D<float> _Result;
 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/HDRenderPipelineResources.asset

   debugColorPickerShader: {fileID: 4800000, guid: 8137b807709e178498f22ed710864bb0,
     type: 3}
   deferredShader: {fileID: 4800000, guid: 00dd221e34a6ab349a1196b0f2fab693, type: 3}
-  gaussianPyramidCS: {fileID: 7200000, guid: 4e3267a1135742441a14298d8dcac04a, type: 3}
+  colorPyramidCS: {fileID: 7200000, guid: 4e3267a1135742441a14298d8dcac04a, type: 3}
   depthPyramidCS: {fileID: 7200000, guid: 64a553bb564274041906f78ffba955e4, type: 3}
   copyChannelCS: {fileID: 7200000, guid: a4d45eda75e8e474dbe24a31f741f3b4, type: 3}
   applyDistortionCS: {fileID: 7200000, guid: 2fa6c0e3fe6dc3145a4156f21913fe5c, type: 3}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/RenderPipelineResources/RenderPipelineResources.cs

 
         // Lighting resources
         public Shader deferredShader;
-        public ComputeShader gaussianPyramidCS;
+        public ComputeShader colorPyramidCS;
         public ComputeShader depthPyramidCS;
         public ComputeShader copyChannelCS;
         public ComputeShader applyDistortionCS;

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariables.hlsl

 #if defined(USING_STEREO_MATRICES)
 
 CBUFFER_START(UnityPerPassStereo)
+float4x4 _ViewMatrixStereo[2];
+// Proj not needed...yet?
+float4x4 _ViewProjMatrixStereo[2];
+float4x4 _InvViewMatrixStereo[2];
 float4x4 _InvProjMatrixStereo[2];
 float4x4 _InvViewProjMatrixStereo[2];
 CBUFFER_END

ScriptableRenderPipeline/HDRenderPipeline/HDRP/ShaderVariablesMatrixDefsHDCamera.hlsl

 
 #define UNITY_MATRIX_M     unity_ObjectToWorld
 #define UNITY_MATRIX_I_M   unity_WorldToObject
-#define UNITY_MATRIX_V     unity_StereoMatrixV[unity_StereoEyeIndex]
-#define UNITY_MATRIX_I_V   unity_StereoMatrixInvV[unity_StereoEyeIndex]
+#define UNITY_MATRIX_V     _ViewMatrixStereo[unity_StereoEyeIndex]
+#define UNITY_MATRIX_I_V   _InvViewMatrixStereo[unity_StereoEyeIndex]
-#define UNITY_MATRIX_VP    unity_StereoMatrixVP[unity_StereoEyeIndex]
+#define UNITY_MATRIX_VP    _ViewProjMatrixStereo[unity_StereoEyeIndex]
 #define UNITY_MATRIX_I_VP  _InvViewProjMatrixStereo[unity_StereoEyeIndex]
 
 #else

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Shadows/HDShadowSettings.cs

     [Serializable]
     public class HDShadowSettings : VolumeComponent
     {
-        public NoInterpMinFloatParameter maxShadowDistance = new NoInterpMinFloatParameter(500.0f, 0.0f);
+        float[] m_CascadeShadowSplits = new float[3];
+        float[] m_CascadeShadowBorders = new float[4];
+
+        public float[] cascadeShadowSplits
+        {
+            get 
+            {
+                m_CascadeShadowSplits[0] = cascadeShadowSplit0;
+                m_CascadeShadowSplits[1] = cascadeShadowSplit1;
+                m_CascadeShadowSplits[2] = cascadeShadowSplit2;
+                return m_CascadeShadowSplits;
+            }
+        }
+
+        public float[] cascadeShadowBorders
+        {
+            get
+            {
+                m_CascadeShadowBorders[0] = cascadeShadowBorder0;
+                m_CascadeShadowBorders[1] = cascadeShadowBorder1;
+                m_CascadeShadowBorders[2] = cascadeShadowBorder2;
+                m_CascadeShadowBorders[3] = cascadeShadowBorder3;
+                return m_CascadeShadowBorders;
+            }
+        }
+
+        [Tooltip("Maximum shadow distance for all light types.")]
+        public NoInterpMinFloatParameter        maxShadowDistance = new NoInterpMinFloatParameter(500.0f, 0.0f);
+
+        [Tooltip("Number of splits for cascaded shadow maps.")]
+        public NoInterpClampedIntParameter      cascadeShadowSplitCount = new NoInterpClampedIntParameter(4, 1, 4);
+        [Tooltip("Ratio of the first split against max shadow distance.")]
+        public NoInterpClampedFloatParameter    cascadeShadowSplit0 = new NoInterpClampedFloatParameter(0.05f, 0.0f, 1.0f);
+        [Tooltip("Ratio of the second split against max shadow distance.")]
+        public NoInterpClampedFloatParameter    cascadeShadowSplit1 = new NoInterpClampedFloatParameter(0.15f, 0.0f, 1.0f);
+        [Tooltip("Ratio of the third split against max shadow distance.")]
+        public NoInterpClampedFloatParameter    cascadeShadowSplit2 = new NoInterpClampedFloatParameter(0.3f, 0.0f, 1.0f);
+        [Tooltip("Border size between first and second split.")]
+        public NoInterpMinFloatParameter        cascadeShadowBorder0 = new NoInterpMinFloatParameter(0.0f, 0.0f);
+        [Tooltip("Border size between second and third split.")]
+        public NoInterpMinFloatParameter        cascadeShadowBorder1 = new NoInterpMinFloatParameter(0.0f, 0.0f);
+        [Tooltip("Border size between third and last split.")]
+        public NoInterpMinFloatParameter        cascadeShadowBorder2 = new NoInterpMinFloatParameter(0.0f, 0.0f);
+        [Tooltip("Border size at the end of last split.")]
+        public NoInterpMinFloatParameter        cascadeShadowBorder3 = new NoInterpMinFloatParameter(0.0f, 0.0f);
     }
 }

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/HDRISky/HDRISkyRenderer.cs

         public override void RenderSky(BuiltinSkyParameters builtinParams, bool renderForCubemap)
         {
             m_SkyHDRIMaterial.SetTexture(HDShaderIDs._Cubemap, m_HdriSkyParams.skyHDRI);
-            m_SkyHDRIMaterial.SetVector(HDShaderIDs._SkyParam, new Vector4(m_HdriSkyParams.exposure, m_HdriSkyParams.multiplier, m_HdriSkyParams.rotation, 0.0f));
+            m_SkyHDRIMaterial.SetVector(HDShaderIDs._SkyParam, new Vector4(m_HdriSkyParams.exposure, m_HdriSkyParams.multiplier, -m_HdriSkyParams.rotation, 0.0f)); // -rotation to match Legacy...
 
             // This matrix needs to be updated at the draw call frequency.
             m_PropertyBlock.SetMatrix(HDShaderIDs._PixelCoordToViewDirWS, builtinParams.pixelCoordToViewDirMatrix);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/ProceduralSky/ProceduralSkyRenderer.cs

                 sunDirection = -builtinParams.sunLight.transform.forward;
             }
 
-            m_SkyProceduralMaterial.SetVector(HDShaderIDs._SkyParam, new Vector4(m_ProceduralSkyParams.exposure, m_ProceduralSkyParams.multiplier, m_ProceduralSkyParams.rotation, 0.0f));
+            m_SkyProceduralMaterial.SetVector(HDShaderIDs._SkyParam, new Vector4(m_ProceduralSkyParams.exposure, m_ProceduralSkyParams.multiplier, 0.0f, 0.0f));
             m_SkyProceduralMaterial.SetFloat(_SunSizeParam, m_ProceduralSkyParams.sunSize);
             m_SkyProceduralMaterial.SetFloat(_SunSizeConvergenceParam, m_ProceduralSkyParams.sunSizeConvergence);
             m_SkyProceduralMaterial.SetFloat(_AtmoshpereThicknessParam, m_ProceduralSkyParams.atmosphereThickness);

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Sky/SkyManager.cs

             result.Apply();
 
             UnityEngine.Graphics.SetRenderTarget(null);
-            Object.DestroyImmediate(temp);
-            Object.DestroyImmediate(tempRT);
+            CoreUtils.Destroy(temp);
+            CoreUtils.Destroy(tempRT);
 
             return result;
         }

ScriptableRenderPipeline/HDRenderPipeline/package.json

 {
     "name": "com.unity.render-pipelines.high-definition",
     "description": "HD Render Pipeline for Unity.",
-    "version": "0.1.32",
+    "version": "0.1.33",
-        "com.unity.postprocessing": "0.1.8",
-        "com.unity.render-pipelines.core": "0.1.32"
+        "com.unity.postprocessing": "0.2.0",
+        "com.unity.render-pipelines.core": "0.1.33"
     }
 }

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipeline.cs

                 // SdotL * invAngleRange + (-cosOuterAngle * invAngleRange)
                 // If we precompute the terms in a MAD instruction
                 float cosOuterAngle = Mathf.Cos(Mathf.Deg2Rad * lightData.spotAngle * 0.5f);
-                float cosInneAngle = Mathf.Cos(LightmapperUtils.ExtractInnerCone(lightData.light) * 0.5f);
-                float smoothAngleRange = Mathf.Max(0.001f, cosInneAngle - cosOuterAngle);
+                // We neeed to do a null check for particle lights
+                // This should be changed in the future
+                // Particle lights will use an inline function
+                float cosInnerAngle;
+                if (lightData.light != null)
+                    cosInnerAngle = Mathf.Cos(LightmapperUtils.ExtractInnerCone(lightData.light) * 0.5f);
+                else
+                    cosInnerAngle = Mathf.Cos((2.0f * Mathf.Atan(Mathf.Tan(lightData.spotAngle * 0.5f * Mathf.Deg2Rad) * (64.0f - 18.0f) / 64.0f)) * 0.5f);
+                float smoothAngleRange = Mathf.Max(0.001f, cosInnerAngle - cosOuterAngle);
                 float invAngleRange = 1.0f / smoothAngleRange;
                 float add = -cosOuterAngle * invAngleRange;
                 lightSpotAttenuation = new Vector4(invAngleRange, add, 0.0f);

ScriptableRenderPipeline/LightweightPipeline/LWRP/LightweightPipelineUtils.cs

     {
         public bool Equals(VisibleLight x, VisibleLight y)
         {
+            if (x.light == null && y.light == null)
+                return true;
+
+            if (x.light == null || y.light == null)
+                return false;
+
+            if (obj.light == null) // Particle light weirdness
+                return obj.GetHashCode();
+
             return obj.light.GetInstanceID();
         }
     }

ScriptableRenderPipeline/LightweightPipeline/LWRP/Materials/Lightweight-DefaultParticle.mat

   m_PrefabParentObject: {fileID: 0}
   m_PrefabInternal: {fileID: 0}
   m_Name: Lightweight-DefaultParticle
-  m_Shader: {fileID: 4800000, guid: b7839dad95683814aa64166edc107ae2, type: 3}
-  m_ShaderKeywords: 
+  m_Shader: {fileID: 4800000, guid: 0406db5a14f94604a8c57ccfbc9f3b46, type: 3}
+  m_ShaderKeywords: _ALPHABLEND_ON
-  m_CustomRenderQueue: -1
-  stringTagMap: {}
+  m_CustomRenderQueue: 3000
+  stringTagMap:
+    RenderType: Transparent
   disabledShaderPasses:
   - ALWAYS
   m_SavedProperties:
     - _CameraFadingEnabled: 0
     - _CameraFarFadeDistance: 2
     - _CameraNearFadeDistance: 1
+    - _ColorMode: 0
     - _Cull: 2
     - _Cutoff: 0.5
     - _DetailNormalMapScale: 1
     - _DistortionStrengthScaled: 0
-    - _DstBlend: 0
+    - _DstBlend: 10
     - _EmissionEnabled: 0
     - _FlipbookMode: 0
     - _GlossMapScale: 1
-    - _LightingEnabled: 1
+    - _LightingEnabled: 0
-    - _Mode: 0
+    - _Mode: 2
     - _OcclusionStrength: 1
     - _Parallax: 0.02
     - _SmoothnessTextureChannel: 0
     - _SpecularHighlights: 1
-    - _SrcBlend: 1
+    - _SrcBlend: 5
-    - _ZWrite: 1
+    - _ZWrite: 0
+    - _ColorAddSubDiff: {r: 0, g: 0, b: 0, a: 0}
     - _EmissionColor: {r: 0, g: 0, b: 0, a: 1}
     - _SoftParticleFadeParams: {r: 0, g: 0, b: 0, a: 0}

ScriptableRenderPipeline/LightweightPipeline/LWRP/Shaders/LightweightStandardUnlit.shader

             #pragma shader_feature _ _ALPHATEST_ON _ALPHABLEND_ON
             #pragma multi_compile_instancing
 
+            // -------------------------------------
+            // Unity defined keywords
+            #pragma multi_compile _ DIRLIGHTMAP_COMBINED
+            #pragma multi_compile _ LIGHTMAP_ON
+
             // Lighting include is needed because of GI
             #include "LWRP/ShaderLibrary/Lighting.hlsl"
             #include "LWRP/ShaderLibrary/InputSurface.hlsl"
 
 #if _SAMPLE_GI
                 OUTPUT_NORMAL(v, o);
-                half3 normalWS = o.normal;
-                OUTPUT_SH(normalWS, o.lightmapOrVertexSH);
+                OUTPUT_SH(o.normal, o.lightmapOrVertexSH);
 #endif
                 return o;
             }
     #else
                 half3 normalWS = normalize(IN.normal);
     #endif
-                color += SampleGI(IN.lightmapOrVertexSH, normalWS);
+                color *= SampleGI(IN.lightmapOrVertexSH, normalWS);
 #endif
                 ApplyFog(color, IN.uv0AndFogCoord.z);
 

ScriptableRenderPipeline/LightweightPipeline/package.json

 {
     "name": "com.unity.render-pipelines.lightweight",
     "description": "Lightweight Render Pipeline for Unity.",
-    "version": "0.1.32",
+    "version": "0.1.33",
-        "com.unity.postprocessing": "0.1.8",
-        "com.unity.render-pipelines.core": "0.1.32"
+        "com.unity.postprocessing": "0.2.0",
+        "com.unity.render-pipelines.core": "0.1.33"
     }
 }

ScriptableRenderPipeline/master-package.json

 {
-    "version": "0.1.32",
+    "version": "0.1.33",
-        "com.unity.postprocessing": "0.1.8"
+        "com.unity.postprocessing": "0.2.0"
     },
     "subPackages": [
         "Core",

ScriptableRenderPipeline/Core/CoreRP/Editor/TextureCombiner.meta

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

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

+using UnityEngine;
+using System.Collections.Generic;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+	public class StandardsToHDLitMaterialUpgrader : MaterialUpgrader
+	{
+        static readonly string Standard = "Standard";
+        static readonly string Standard_Spec = "Standard (Specular setup)";
+        static readonly string Standard_Rough = "Standard (Roughness setup)";
+
+		public StandardsToHDLitMaterialUpgrader(string sourceShaderName, string destShaderName, MaterialFinalizer finalizer = null)
+        {
+            RenameShader(sourceShaderName, destShaderName, finalizer);
+
+            RenameTexture("_MainTex", "_BaseColorMap");
+            RenameColor("_Color", "_BaseColor");
+            RenameFloat("_Glossiness", "_Smoothness");
+            RenameTexture("_BumpMap", "_NormalMap");
+            RenameFloat("_BumpScale", "_NormalScale");
+            RenameTexture("_ParallaxMap", "_HeightMap");
+            RenameTexture("_EmissionMap", "_EmissiveColorMap");
+            RenameTexture("_DetailAlbedoMap", "_DetailMap");
+            RenameFloat("_UVSec", "_UVDetail");
+            SetFloat("_LinkDetailsWithBase", 0);
+            RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
+            RenameFloat("_Cutoff", "_AlphaCutoff");
+            RenameKeywordToFloat("_ALPHATEST_ON", "_AlphaCutoffEnable", 1f, 0f);
+
+
+            if (sourceShaderName == Standard)
+            {
+                SetFloat("_MaterialID", 1f);
+            }
+
+            if (sourceShaderName == Standard_Spec)
+            {
+                SetFloat("_MaterialID", 4f);
+
+                RenameColor("_SpecColor", "_SpecularColor");
+                RenameTexture("_SpecGlossMap", "_SpecularColorMap");
+            }
+        }
+        
+        public override void Convert(Material srcMaterial, Material dstMaterial)
+        {
+            dstMaterial.hideFlags = HideFlags.DontUnloadUnusedAsset;
+
+            base.Convert(srcMaterial, dstMaterial);
+
+            // ---------- Mask Map ----------
+
+            // Metallic
+            bool hasMetallic = false;
+            Texture metallicMap;
+            if ( (srcMaterial.shader.name == Standard) || (srcMaterial.shader.name == Standard_Rough) )
+            {
+                hasMetallic = srcMaterial.GetTexture("_MetallicGlossMap") != null;
+                if (hasMetallic) metallicMap = TextureCombiner.GetTextureSafe(srcMaterial, "_MetallicGlossMap", Color.white);
+            }
+            else
+                metallicMap = Texture2D.blackTexture;
+
+            // Occlusion
+            bool hasOcclusion = srcMaterial.GetTexture("_OcclusionMap") != null;
+            Texture occlusionMap;
+            if (hasOcclusion) occlusionMap = TextureCombiner.GetTextureSafe(srcMaterial, "_OcclusionMap", Color.white);
+
+            // Detail Mask
+            bool hasDetailMask = srcMaterial.GetTexture("_DetailMask") != null;
+            Texture detailMaskMap;
+            if (hasDetailMask) detailMaskMap = TextureCombiner.GetTextureSafe(srcMaterial, "_DetailMask", Color.white);
+
+            // Smoothness
+            bool hasSmoothness = false;
+            Texture2D smoothnessMap = TextureCombiner.TextureFromColor(Color.grey);
+
+            if (srcMaterial.shader.name == Standard_Rough)
+                hasSmoothness = srcMaterial.GetTexture("_SpecGlossMap")!=null;
+            else
+            {
+                string smoothnessTextureChannel = "_MainTex";
+
+                if (srcMaterial.shader.name == Standard_Rough)
+                    smoothnessMap = (Texture2D) TextureCombiner.GetTextureSafe(srcMaterial, "_SpecGlossMap", Color.grey);
+                else
+                {
+                    if ( srcMaterial.GetFloat("_SmoothnessTextureChannel") == 0 )
+                    {
+                        if (srcMaterial.shader.name == Standard) smoothnessTextureChannel = "_MetallicGlossMap";
+                        if (srcMaterial.shader.name == Standard_Spec) smoothnessTextureChannel = "_SpecGlossMap";
+                    }
+
+                    smoothnessMap = (Texture2D) srcMaterial.GetTexture( smoothnessTextureChannel );
+                    if (smoothnessMap == null || !TextureCombiner.TextureHasAlpha(smoothnessMap))
+                    {
+                        hasSmoothness = true;
+                        smoothnessMap = TextureCombiner.TextureFromColor(Color.white * srcMaterial.GetFloat("_Glossiness"));
+                    }
+                }
+            }
+
+            // Build the mask map
+            if ( hasMetallic || hasOcclusion || hasDetailMask || hasSmoothness )
+            {
+                Texture2D maskMap;
+
+                TextureCombiner maskMapCombiner = new TextureCombiner(
+                    TextureCombiner.GetTextureSafe(srcMaterial, "_MetallicGlossMap", Color.white), 4,   // Metallic
+                    TextureCombiner.GetTextureSafe(srcMaterial, "_OcclusionMap", Color.white), 4,       // Occlusion
+                    TextureCombiner.GetTextureSafe(srcMaterial, "_DetailMask", Color.white), 4,         // Detail Mask
+                    smoothnessMap, (srcMaterial.shader.name == Standard_Rough)?-4:3                  // Smoothness Texture
+                );
+
+                string maskMapPath = AssetDatabase.GetAssetPath(srcMaterial);
+                maskMapPath = maskMapPath.Remove(maskMapPath.Length-4) + "_MaskMap.png";
+                maskMap = maskMapCombiner.Combine( maskMapPath );
+                dstMaterial.SetTexture("_MaskMap", maskMap);
+            }
+
+            dstMaterial.SetFloat("_AORemapMin", 1f - srcMaterial.GetFloat("_OcclusionStrength"));
+
+            // Specular Setup Specific
+            if (srcMaterial.shader.name == Standard_Spec)
+            {
+                // if there is a specular map, change the specular color to white
+                if (srcMaterial.GetTexture("_SpecGlossMap") != null ) dstMaterial.SetColor("_SpecularColor", Color.white);
+            }
+
+            // ---------- Height Map ----------
+            bool hasHeightMap = srcMaterial.GetTexture("_ParallaxMap") != null;
+            if (hasHeightMap) // Enable Parallax Occlusion Mapping
+            {
+                dstMaterial.SetFloat("_DisplacementMode", 2);
+                dstMaterial.SetFloat("_HeightPoMAmplitude", srcMaterial.GetFloat("_Parallax") * 2f);
+            }
+
+            // ---------- Detail Map ----------
+            bool hasDetailAlbedo = srcMaterial.GetTexture("_DetailAlbedoMap") != null;
+            bool hasDetailNormal = srcMaterial.GetTexture("_DetailNormalMap") != null;
+            if ( hasDetailAlbedo || hasDetailNormal )
+            {
+                Texture2D detailMap;
+                TextureCombiner detailCombiner = new TextureCombiner(
+                    TextureCombiner.GetTextureSafe(srcMaterial, "_DetailAlbedoMap", Color.grey), 4,     // Albedo (overlay)
+                    TextureCombiner.GetTextureSafe(srcMaterial, "_DetailNormalMap", Color.grey), 1,     // Normal Y
+                    TextureCombiner.midGrey, 1,                                                         // Smoothness
+                    TextureCombiner.GetTextureSafe(srcMaterial, "_DetailNormalMap", Color.grey), 0      // Normal X
+                );
+                string detailMapPath = AssetDatabase.GetAssetPath(srcMaterial);
+                detailMapPath = detailMapPath.Remove(detailMapPath.Length-4) + "_DetailMap.png";
+                detailMap = detailCombiner.Combine( detailMapPath );
+                dstMaterial.SetTexture("_DetailMap", detailMap);
+            }
+
+
+            // Blend Mode
+            int previousBlendMode = srcMaterial.GetInt("_Mode");
+            switch (previousBlendMode)
+            {
+                case 0: // Opaque
+                    dstMaterial.SetFloat("_SurfaceType", 0);
+                    dstMaterial.SetFloat("_BlendMode", 0);
+                    dstMaterial.SetFloat("_AlphaCutoffEnable", 0);
+                    dstMaterial.SetFloat("_EnableBlendModePreserveSpecularLighting", 1);
+                    break;
+                case 1: // Cutout
+                    dstMaterial.SetFloat("_SurfaceType", 0);
+                    dstMaterial.SetFloat("_BlendMode", 0);
+                    dstMaterial.SetFloat("_AlphaCutoffEnable", 1);
+                    dstMaterial.SetFloat("_EnableBlendModePreserveSpecularLighting", 1);
+                    break;
+                case 2: // Fade -> Alpha + Disable preserve specular
+                    dstMaterial.SetFloat("_SurfaceType", 1);
+                    dstMaterial.SetFloat("_BlendMode", 0);
+                    dstMaterial.SetFloat("_AlphaCutoffEnable", 0);
+                    dstMaterial.SetFloat("_EnableBlendModePreserveSpecularLighting", 0);
+                    break;
+                case 3: // Transparent -> Alpha 
+                    dstMaterial.SetFloat("_SurfaceType", 1);
+                    dstMaterial.SetFloat("_BlendMode", 0);
+                    dstMaterial.SetFloat("_AlphaCutoffEnable", 0);
+                    dstMaterial.SetFloat("_EnableBlendModePreserveSpecularLighting", 1);
+                    break;
+            }
+
+            // Emission: Convert the HDR emissive color to ldr color + intensity
+            Color hdrEmission = srcMaterial.GetColor("_EmissionColor");
+            float intensity = Mathf.Max(hdrEmission.r, Mathf.Max(hdrEmission.g, hdrEmission.b));
+            
+            if (intensity > 1f)
+            {
+                hdrEmission.r /= intensity;
+                hdrEmission.g /= intensity;
+                hdrEmission.b /= intensity;
+            }
+            else
+                intensity = 1f;
+
+            intensity = Mathf.Pow(intensity, 2.2f); // Gamma to Linear conversion
+            
+            dstMaterial.SetColor("_EmissiveColor", hdrEmission);
+            dstMaterial.SetFloat("_EmissiveIntensity", intensity);
+            
+            HDEditorUtils.ResetMaterialKeywords(dstMaterial);
+        }
+	}
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/StandardsToHDLitMaterialUpgrader.cs.meta

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

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

+using UnityEngine;
+using System.Collections.Generic;
+
+namespace UnityEditor.Experimental.Rendering.HDPipeline
+{
+	public class UnlitsToHDUnlitUpgrader : MaterialUpgrader
+	{
+		string Unlit_Color = "Unlit/Color";
+		string Unlit_Texture = "Unlit/Texture";
+		string Unlit_Transparent = "Unlit/Transparent";
+		string Unlit_Cutout = "Unlit/Transparent Cutout";
+
+		public UnlitsToHDUnlitUpgrader(string sourceShaderName, string destShaderName, MaterialFinalizer finalizer = null)
+        {
+            RenameShader(sourceShaderName, destShaderName, finalizer);
+
+			if (sourceShaderName == Unlit_Color)
+            	RenameColor("_Color", "_UnlitColor");
+			else // all other unlit have a texture
+            	RenameTexture("_MainTex", "_UnlitColorMap");
+
+			if (sourceShaderName == Unlit_Cutout)
+			{
+            	RenameFloat("_Cutoff", "_AlphaCutoff");
+				SetFloat("_AlphaCutoffEnable", 1f);
+			}
+			else
+				SetFloat("_AlphaCutoffEnable", 0f);
+
+
+			SetFloat("_SurfaceType", (sourceShaderName == Unlit_Transparent)? 1f : 0f );
+
+		}
+
+		public override void Convert(Material srcMaterial, Material dstMaterial)
+        {
+            //dstMaterial.hideFlags = HideFlags.DontUnloadUnusedAsset;
+
+            base.Convert(srcMaterial, dstMaterial);
+            
+            HDEditorUtils.ResetMaterialKeywords(dstMaterial);
+		}
+	}
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Unlit/UnlitsToHDUnlitUpgrader.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Shadows.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightUtils.cs

+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    public class LightUtils
+    {
+        // Physical light unit helper
+        // All light unit are in lumen (Luminous power)
+        // Punctual light (point, spot) are convert to candela (cd = lumens / steradian)
+        // Area light are convert to luminance (cd/(m^2*steradian)) with the following formulation: Luminous Power / (Area * PI * steradian)
+
+        // Ref: Moving Frostbite to PBR
+        // Also good ref: https://www.radiance-online.org/community/workshops/2004-fribourg/presentations/Wandachowicz_paper.pdf
+
+        // convert intensity (lumen) to candela
+        public static float ConvertPointLightIntensity(float intensity)
+        {
+            return intensity / (4.0f * Mathf.PI);
+        }
+
+        // angle is the full angle, not the half angle in radiant
+        // convert intensity (lumen) to candela
+        public static float ConvertSpotLightIntensity(float intensity, float angle, bool exact)
+        {
+            return exact ? intensity / (2.0f * (1.0f - Mathf.Cos(angle / 2.0f)) * Mathf.PI) : intensity / Mathf.PI;
+        }
+
+        // angleA and angleB are the full opening angle, not half angle
+        // convert intensity (lumen) to candela
+        public static float ConvertFrustrumLightIntensity(float intensity, float angleA, float angleB)
+        {
+            return intensity / (4.0f * Mathf.Asin(Mathf.Sin(angleA / 2.0f) * Mathf.Sin(angleB / 2.0f)));
+        }
+
+        // convert intensity (lumen) to nits
+        public static float ConvertSphereLightIntensity(float intensity, float sphereRadius)
+        {
+            return intensity / ((4.0f * Mathf.PI * sphereRadius * sphereRadius) * Mathf.PI);
+        }
+
+        // convert intensity (lumen) to nits
+        public static float ConvertDiscLightIntensity(float intensity, float discRadius)
+        {
+            return intensity / ((discRadius * discRadius * Mathf.PI) * Mathf.PI);
+        }
+
+        // convert intensity (lumen) to nits
+        public static float ConvertRectLightIntensity(float intensity, float width, float height)
+        {
+            return intensity / ((width * height) * Mathf.PI);
+        }
+
+        // convert intensity (lumen) to nits
+        public static float calculateLineLightArea(float intensity, float lineWidth)
+        {
+            // The area of a cylinder is this:
+            // float lineRadius = 0.01f; // 1cm
+            //return intensity / (2.0f * Mathf.PI * lineRadius * lineWidth * Mathf.PI);
+            // But with our current line light algorithm we get an insane gap in intensity
+            // following formula (fully empirical) give a better match to a rect light of 1cm of width.
+            // It is basically point light intensity / line width.
+            return intensity / (4.0f * Mathf.PI * lineWidth);
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Lighting/LightUtils.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Shadows/ContactShadows.cs

+using System;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [Serializable]
+    public class ContactShadows : VolumeComponent
+    {
+        // Contact shadows
+        public BoolParameter                enable = new BoolParameter(false);
+        public ClampedFloatParameter        length = new ClampedFloatParameter(0.15f, 0.0f, 1.0f);
+        public ClampedFloatParameter        distanceScaleFactor = new ClampedFloatParameter(0.5f, 0.0f, 1.0f);
+        public MinFloatParameter            maxDistance = new MinFloatParameter(50.0f, 0.0f);
+        public MinFloatParameter            fadeDistance = new MinFloatParameter(5.0f, 0.0f);
+        public NoInterpClampedIntParameter  sampleCount = new NoInterpClampedIntParameter(8, 4, 64);
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Shadows/ContactShadows.cs.meta

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

ScriptableRenderPipeline/Core/CoreRP/Editor/TextureCombiner/TextureCombiner.cs.meta

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

ScriptableRenderPipeline/Core/CoreRP/Editor/TextureCombiner/TextureCombiner.shader.meta

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

ScriptableRenderPipeline/Core/CoreRP/Editor/TextureCombiner/TextureCombiner.cs

+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEditor;
+using System.IO;
+
+public class TextureCombiner
+{
+	public static Texture2D _midGrey;
+	public static Texture2D midGrey
+	{
+		get
+		{
+			if (_midGrey == null)
+				_midGrey = 	TextureFromColor(Color.grey);
+
+			return _midGrey;
+		}
+	}
+
+	private static Dictionary<Color, Texture2D> singleColorTextures = new Dictionary<Color, Texture2D>();
+
+	public static Texture2D TextureFromColor(Color color)
+	{
+		if (color == Color.white) return Texture2D.whiteTexture;
+		if (color == Color.black) return Texture2D.blackTexture;
+
+		bool makeTexture = !singleColorTextures.ContainsKey(color);
+		if (!makeTexture)
+			makeTexture = (singleColorTextures[color] == null);
+
+		if (makeTexture)
+		{
+			Texture2D tex = new Texture2D(1,1, TextureFormat.ARGB32, false, true);
+			tex.SetPixel(0,0,color);
+			tex.Apply();
+
+			singleColorTextures[color] = tex;
+		}
+		
+		return singleColorTextures[color];
+	}
+
+	public static Texture GetTextureSafe( Material srcMaterial, string propertyName, Color fallback)
+	{
+		return GetTextureSafe( srcMaterial, propertyName, TextureFromColor(fallback) );
+	}
+
+	public static Texture GetTextureSafe( Material srcMaterial, string propertyName, Texture fallback)
+	{
+		if (!srcMaterial.HasProperty(propertyName))
+			return fallback;
+
+		Texture tex = srcMaterial.GetTexture(propertyName);
+		if (tex == null)
+			return fallback;
+		else
+			return tex;
+	}
+
+	public static TextureFormat[] TextureFormatsWithouthAlpha = new TextureFormat[]{
+	 TextureFormat.ASTC_RGB_10x10 ,
+	 TextureFormat.ASTC_RGB_12x12 ,
+	 TextureFormat.ASTC_RGB_4x4 ,
+	 TextureFormat.ASTC_RGB_5x5 ,
+	 TextureFormat.ASTC_RGB_6x6 ,
+	 TextureFormat.ASTC_RGB_8x8 ,
+	 TextureFormat.BC4 ,
+	 TextureFormat.BC5 ,
+	 TextureFormat.DXT1 ,
+	 TextureFormat.DXT1Crunched ,
+	 TextureFormat.EAC_R ,
+	 TextureFormat.EAC_R_SIGNED ,
+	 TextureFormat.EAC_RG ,
+	 TextureFormat.EAC_RG_SIGNED ,
+	 TextureFormat.ETC2_RGB ,
+	 TextureFormat.ETC_RGB4 ,
+	 TextureFormat.ETC_RGB4_3DS ,
+	 TextureFormat.ETC_RGB4Crunched ,
+	 TextureFormat.PVRTC_RGB2 ,
+	 TextureFormat.PVRTC_RGB4 ,
+	 TextureFormat.R16 ,
+	 TextureFormat.R8 ,
+	 TextureFormat.RFloat ,
+	 TextureFormat.RG16 ,
+	 TextureFormat.RGB24 ,
+	 TextureFormat.RGB565 ,
+	 TextureFormat.RGB9e5Float ,
+	 TextureFormat.RGFloat ,
+	 TextureFormat.RGHalf ,
+	 TextureFormat.RHalf ,
+	 TextureFormat.YUY2
+	 };
+
+	public static bool TextureHasAlpha ( Texture2D tex )
+	{
+		if (tex == null) return false;
+
+		bool o = true;
+		int i=0;
+
+		while ( i < TextureFormatsWithouthAlpha.Length && o)
+		{
+			o = tex.format != TextureFormatsWithouthAlpha[i];
+			++i;
+		}
+
+		return o;
+	}
+
+	private Texture m_rSource;
+	private Texture m_gSource;
+	private Texture m_bSource;
+	private Texture m_aSource;
+
+	// Chanels are : r=0, g=1, b=2, a=3, greyscale from rgb = 4
+	// If negative, the chanel is inverted
+	private int m_rChanel;
+	private int m_gChanel;
+	private int m_bChanel;
+	private int m_aChanel;
+
+	// Chanels remaping
+	private Vector4[] m_remapings = new Vector4[]{
+		new Vector4(0f, 1f, 0f, 0f),
+		new Vector4(0f, 1f, 0f, 0f),
+		new Vector4(0f, 1f, 0f, 0f),
+		new Vector4(0f, 1f, 0f, 0f)
+	};
+
+	private bool m_bilinearFilter;
+
+	private Dictionary<Texture, Texture> m_RawTextures;
+
+	public TextureCombiner( Texture rSource, int rChanel, Texture gSource, int gChanel, Texture bSource, int bChanel, Texture aSource, int aChanel, bool bilinearFilter = true )
+	{
+		m_rSource = rSource;
+		m_gSource = gSource;
+		m_bSource = bSource;
+		m_aSource = aSource;
+		m_rChanel = rChanel;
+		m_gChanel = gChanel;
+		m_bChanel = bChanel;
+		m_aChanel = aChanel;
+		m_bilinearFilter = bilinearFilter;
+	}
+
+	public void SetRemapping( int channel, float min, float max)
+	{
+		if (channel > 3 || channel < 0) return;
+
+		m_remapings[channel].x = min;
+		m_remapings[channel].y = max;
+	}
+
+	public Texture2D Combine( string savePath )
+	{
+		int xMin = int.MaxValue;
+		int yMin = int.MaxValue;
+
+		if (m_rSource.width > 4 && m_rSource.width < xMin) xMin = m_rSource.width;
+		if (m_gSource.width > 4 && m_gSource.width < xMin) xMin = m_gSource.width;
+		if (m_bSource.width > 4 && m_bSource.width < xMin) xMin = m_bSource.width;
+		if (m_aSource.width > 4 && m_aSource.width < xMin) xMin = m_aSource.width;
+		if (xMin == int.MaxValue) xMin = 4;
+		
+		if (m_rSource.height > 4 && m_rSource.height < yMin) yMin = m_rSource.height;
+		if (m_gSource.height > 4 && m_gSource.height < yMin) yMin = m_gSource.height;
+		if (m_bSource.height > 4 && m_bSource.height < yMin) yMin = m_bSource.height;
+		if (m_aSource.height > 4 && m_aSource.height < yMin) yMin = m_aSource.height;
+		if (yMin == int.MaxValue) yMin = 4;
+
+		Texture2D combined = new Texture2D(xMin, yMin, TextureFormat.RGBAFloat, true, true);
+		combined.hideFlags = HideFlags.DontUnloadUnusedAsset;
+
+		Material combinerMaterial = new Material(Shader.Find("Hidden/SRP_Core/TextureCombiner"));
+		combinerMaterial.hideFlags = HideFlags.DontUnloadUnusedAsset;
+
+		combinerMaterial.SetTexture("_RSource", GetRawTexture(m_rSource));
+		combinerMaterial.SetTexture("_GSource", GetRawTexture(m_gSource));
+		combinerMaterial.SetTexture("_BSource", GetRawTexture(m_bSource));
+		combinerMaterial.SetTexture("_ASource", GetRawTexture(m_aSource));
+
+		combinerMaterial.SetFloat("_RChannel", m_rChanel);
+		combinerMaterial.SetFloat("_GChannel", m_gChanel);
+		combinerMaterial.SetFloat("_BChannel", m_bChanel);
+		combinerMaterial.SetFloat("_AChannel", m_aChanel);
+
+		combinerMaterial.SetVector("_RRemap", m_remapings[0]);
+		combinerMaterial.SetVector("_GRemap", m_remapings[1]);
+		combinerMaterial.SetVector("_BRemap", m_remapings[2]);
+		combinerMaterial.SetVector("_ARemap", m_remapings[3]);
+
+		RenderTexture combinedRT =  new RenderTexture(xMin, yMin, 0, RenderTextureFormat.ARGBFloat, RenderTextureReadWrite.sRGB);
+
+		Graphics.Blit(Texture2D.whiteTexture, combinedRT, combinerMaterial);
+
+		// Readback the render texture
+		RenderTexture previousActive = RenderTexture.active;
+		RenderTexture.active = combinedRT;
+		combined.ReadPixels(new Rect(0, 0, xMin, yMin), 0, 0, false);
+		combined.Apply();
+		RenderTexture.active = previousActive;
+
+		byte[] bytes = new byte[0];
+
+		if (savePath.EndsWith("png"))
+			bytes = ImageConversion.EncodeToPNG(combined);
+		if (savePath.EndsWith("exr"))
+			bytes = ImageConversion.EncodeToEXR(combined);
+		if (savePath.EndsWith("jpg"))
+			bytes = ImageConversion.EncodeToJPG(combined);
+
+		string systemPath = Path.Combine(Application.dataPath.Remove(Application.dataPath.Length-6), savePath);
+		File.WriteAllBytes(systemPath, bytes);
+
+		Object.DestroyImmediate(combined);
+
+		AssetDatabase.ImportAsset(savePath);
+
+		TextureImporter combinedImporter = (TextureImporter) AssetImporter.GetAtPath(savePath);
+		combinedImporter.sRGBTexture = false;
+		combinedImporter.SaveAndReimport();
+
+		if (savePath.EndsWith("exr"))
+		{
+			// The options for the platform string are: "Standalone", "iPhone", "Android", "WebGL", "Windows Store Apps", "PSP2", "PS4", "XboxOne", "Nintendo 3DS", "WiiU", "tvOS".
+			combinedImporter.SetPlatformTextureSettings(new TextureImporterPlatformSettings(){name = "Standalone", format = TextureImporterFormat.DXT5, overridden = true });
+		}
+
+		combined = AssetDatabase.LoadAssetAtPath<Texture2D>(savePath);
+
+		//cleanup "raw" textures
+		foreach( KeyValuePair<Texture, Texture> prop in m_RawTextures )
+		{
+			if (AssetDatabase.Contains(prop.Value))
+				AssetDatabase.DeleteAsset(AssetDatabase.GetAssetPath(prop.Value));
+		}
+		Object.DestroyImmediate(combinerMaterial);
+
+		m_RawTextures.Clear();
+
+		return combined;
+	}
+
+	private Texture GetRawTexture (Texture original, bool sRGB = false)
+	{
+		if (m_RawTextures == null) m_RawTextures = new Dictionary<Texture, Texture>();
+		if (!m_RawTextures.ContainsKey(original))
+		{
+			if ( AssetDatabase.Contains(original))
+			{
+				string path = AssetDatabase.GetAssetPath(original);
+				string rawPath = "Assets/raw_"+Path.GetFileName(path);
+
+				AssetDatabase.CopyAsset(path, rawPath);
+
+				AssetDatabase.ImportAsset(rawPath);
+
+				TextureImporter rawImporter = (TextureImporter) TextureImporter.GetAtPath(rawPath);
+				rawImporter.textureType = TextureImporterType.Default;
+				rawImporter.mipmapEnabled = false;
+				rawImporter.isReadable = true;
+				rawImporter.filterMode = m_bilinearFilter? FilterMode.Bilinear : FilterMode.Point;
+				rawImporter.npotScale = TextureImporterNPOTScale.None;
+				rawImporter.wrapMode = TextureWrapMode.Clamp;
+				rawImporter.sRGBTexture = sRGB;
+				rawImporter.maxTextureSize = 8192;
+
+				rawImporter.textureCompression = TextureImporterCompression.Uncompressed;
+				
+				rawImporter.SaveAndReimport();
+
+				m_RawTextures.Add(original, AssetDatabase.LoadAssetAtPath<Texture>(rawPath));
+			}
+			else
+				m_RawTextures.Add(original, original);
+		}
+
+		return m_RawTextures[original];
+	}
+}

ScriptableRenderPipeline/Core/CoreRP/Editor/TextureCombiner/TextureCombiner.shader

+Shader "Hidden/SRP_Core/TextureCombiner"
+{
+	Properties
+	{
+		// Chanels are : r=0, g=1, b=2, a=3, greyscale from rgb = 4
+		// If the chanel value is negative, we invert the value
+
+		[Linear][NoScaleOffset] _RSource ("R Source", 2D) = "white" {}
+		_RChannel ("R Channel", float) = 0
+		_RRemap ("R Remap", Vector) = (0, 1, 0, 0)
+		
+		[Linear][NoScaleOffset] _GSource ("G Source", 2D) = "white" {}
+		_GChannel ("G Channel", float) = 1
+		_GRemap ("G Remap", Vector) = (0, 1, 0, 0)
+		
+		[Linear][NoScaleOffset] _BSource ("B Source", 2D) = "white" {}
+		_BChannel ("B Channel", float) = 2
+		_BRemap ("B Remap", Vector) = (0, 1, 0, 0)
+		
+		[Linear][NoScaleOffset] _ASource ("A Source", 2D) = "white" {}
+		_AChannel ("A Channel", float) = 3
+		_ARemap ("A Remap", Vector) = (0, 1, 0, 0)
+	}
+	SubShader
+	{
+		Tags { "RenderType"="Opaque" }
+		LOD 100
+
+		Pass
+		{
+			CGPROGRAM
+			#pragma vertex vert
+			#pragma fragment frag
+			
+			#include "UnityCG.cginc"
+
+			struct appdata
+			{
+				float4 vertex : POSITION;
+				float2 uv : TEXCOORD0;
+			};
+
+			struct v2f
+			{
+				float2 uv : TEXCOORD0;
+				float4 vertex : SV_POSITION;
+			};
+
+			sampler2D _RSource, _GSource, _BSource, _ASource;
+			float _RChannel, _GChannel, _BChannel, _AChannel;
+			float4 _RRemap, _GRemap, _BRemap, _ARemap;
+			
+			v2f vert (appdata v)
+			{
+				v2f o;
+				o.vertex = UnityObjectToClipPos(v.vertex);
+				o.uv = v.uv;
+				return o;
+			}
+
+			float PlotSourcetoChanel(float4 source, float param, float2 remap)
+			{
+				if (param < 0 )
+				{
+					param = -param;
+					source = float4(1,1,1,1) - source;
+				}
+
+				float o;
+
+				if (param >= 4)
+					o = source.r * 0.3 + source.g * 0.59 + source.b * 0.11; // Photoshop desaturation : G*.59+R*.3+B*.11
+				else
+					o =  source[param];
+
+				return o * ( remap.y - remap.x) + remap.x ;
+			}
+
+			float PlotSourcetoChanel(float4 source, float param)
+			{
+				return PlotSourcetoChanel(source, param, float2(0,1) );
+			}
+			
+			float4 frag (v2f i) : SV_Target
+			{
+				float4 col = float4(0,0,0,0);
+
+				col.r = PlotSourcetoChanel( tex2D(_RSource, i.uv), _RChannel, _RRemap );
+				col.g = PlotSourcetoChanel( tex2D(_GSource, i.uv), _GChannel, _GRemap );
+				col.b = PlotSourcetoChanel( tex2D(_BSource, i.uv), _BChannel, _BRemap );
+				col.a = PlotSourcetoChanel( tex2D(_ASource, i.uv), _AChannel, _ARemap );
+
+				return col;
+			}
+			ENDCG
+		}
+	}
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Shadows/HDShadowSettingsEditor.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Shadows/HDShadowSettingsEditor.cs

+using System.Collections;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Experimental.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [CanEditMultipleObjects]
+    [VolumeComponentEditor(typeof(HDShadowSettings))]
+    public class HDShadowSettingsEditor : VolumeComponentEditor
+    {
+        SerializedDataParameter m_MaxShadowDistance;
+
+        SerializedDataParameter m_CascadeShadowSplitCount;
+
+        SerializedDataParameter[] m_CascadeShadowSplits = new SerializedDataParameter[3];
+        SerializedDataParameter[] m_CascadeShadowBorders = new SerializedDataParameter[4];
+
+        // For now we don't use borders so we hide the UI.
+        bool m_bShowBorders = false;
+
+        public override void OnEnable()
+        {
+            var o = new PropertyFetcher<HDShadowSettings>(serializedObject);
+
+            m_MaxShadowDistance = Unpack(o.Find(x => x.maxShadowDistance));
+            m_CascadeShadowSplitCount = Unpack(o.Find(x => x.cascadeShadowSplitCount));
+            m_CascadeShadowSplits[0] = Unpack(o.Find(x => x.cascadeShadowSplit0));
+            m_CascadeShadowSplits[1] = Unpack(o.Find(x => x.cascadeShadowSplit1));
+            m_CascadeShadowSplits[2] = Unpack(o.Find(x => x.cascadeShadowSplit2));
+            m_CascadeShadowBorders[0] = Unpack(o.Find(x => x.cascadeShadowBorder0));
+            m_CascadeShadowBorders[1] = Unpack(o.Find(x => x.cascadeShadowBorder1));
+            m_CascadeShadowBorders[2] = Unpack(o.Find(x => x.cascadeShadowBorder2));
+            m_CascadeShadowBorders[3] = Unpack(o.Find(x => x.cascadeShadowBorder3));
+        }
+
+        public override void OnInspectorGUI()
+        {
+            PropertyField(m_MaxShadowDistance, CoreEditorUtils.GetContent("Max Distance"));
+
+            EditorGUILayout.Space();
+            PropertyField(m_CascadeShadowSplitCount, CoreEditorUtils.GetContent("Cascade Count"));
+
+            if (!m_CascadeShadowSplitCount.value.hasMultipleDifferentValues)
+            {
+                EditorGUI.indentLevel++;
+                int splitCount = m_CascadeShadowSplitCount.value.intValue;
+                for (int i = 0; i < splitCount - 1; i++)
+                {
+                    PropertyField(m_CascadeShadowSplits[i], CoreEditorUtils.GetContent(string.Format("Split {0}", i + 1)));
+                }
+
+                if(m_bShowBorders)
+                {
+                    EditorGUILayout.Space();
+
+                    for (int i = 0; i < splitCount; i++)
+                    {
+                        PropertyField(m_CascadeShadowBorders[i], CoreEditorUtils.GetContent(string.Format("Border {0}", i + 1)));
+                    }
+                }
+                EditorGUI.indentLevel--;
+            }
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Shadows/ContactShadowsEditor.cs.meta

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

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Shadows/ContactShadowsEditor.cs

+using System.Collections;
+using UnityEngine;
+using UnityEditor;
+using UnityEditor.Experimental.Rendering;
+
+namespace UnityEngine.Experimental.Rendering.HDPipeline
+{
+    [CanEditMultipleObjects]
+    [VolumeComponentEditor(typeof(ContactShadows))]
+    public class ContactShadowsEditor : VolumeComponentEditor
+    {
+        public readonly GUIContent contactShadow = new GUIContent("Contact Shadows");
+        public readonly GUIContent contactShadowLength = new GUIContent("Length", "Length of rays used to gather contact shadows in world units.\nZero will disable the feature.");
+        public readonly GUIContent contactShadowDistanceScaleFactor = new GUIContent("Distance Scale Factor", "Contact Shadows are scaled up with distance. Use this parameter to dampen this effect.");
+        public readonly GUIContent contactShadowMaxDistance = new GUIContent("Max Distance", "Distance from the camera in world units at which contact shadows are faded out to zero.");
+        public readonly GUIContent contactShadowFadeDistance = new GUIContent("Fade Distance", "Distance in world units over which the contact shadows are faded out (see Max Distance).");
+        public readonly GUIContent contactShadowSampleCount = new GUIContent("Sample Count", "Number of samples when ray casting.");
+
+
+        SerializedDataParameter m_Enable;
+        SerializedDataParameter m_Length;
+        SerializedDataParameter m_DistanceScaleFactor;
+        SerializedDataParameter m_MaxDistance;
+        SerializedDataParameter m_FadeDistance;
+        SerializedDataParameter m_SampleCount;
+
+
+        public override void OnEnable()
+        {
+            var o = new PropertyFetcher<ContactShadows>(serializedObject);
+
+            m_Enable = Unpack(o.Find(x => x.enable));
+            m_Length = Unpack(o.Find(x => x.length));
+            m_DistanceScaleFactor = Unpack(o.Find(x => x.distanceScaleFactor));
+            m_MaxDistance = Unpack(o.Find(x => x.maxDistance));
+            m_FadeDistance = Unpack(o.Find(x => x.fadeDistance));
+            m_SampleCount = Unpack(o.Find(x => x.sampleCount));
+        }
+
+        public override void OnInspectorGUI()
+        {
+            PropertyField(m_Enable, CoreEditorUtils.GetContent("Enable"));
+
+            if (!m_Enable.value.hasMultipleDifferentValues)
+            {
+                using (new EditorGUI.DisabledGroupScope(!m_Enable.value.boolValue))
+                {
+                    PropertyField(m_Length, CoreEditorUtils.GetContent("Length|Length of rays used to gather contact shadows in world units."));
+                    PropertyField(m_DistanceScaleFactor, CoreEditorUtils.GetContent("Distance Scale Factor|Contact Shadows are scaled up with distance. Use this parameter to dampen this effect."));
+                    PropertyField(m_MaxDistance, CoreEditorUtils.GetContent("Max Distance|Distance from the camera in world units at which contact shadows are faded out to zero."));
+                    PropertyField(m_FadeDistance, CoreEditorUtils.GetContent("Fade Distance|Distance in world units over which the contact shadows fade out (see Max Distance)."));
+                    PropertyField(m_SampleCount, CoreEditorUtils.GetContent("Sample Count|Number of samples when ray casting."));
+                }
+            }
+        }
+    }
+}

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/StandardSpecularToHDLitMaterialUpgrader.cs.meta

-fileFormatVersion: 2
-guid: 775bef174b1e2ed47972a143845e1191
-timeCreated: 1479911618
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

ScriptableRenderPipeline/HDRenderPipeline/HDRP/Editor/Material/Lit/StandardToHDLitMaterialUpgrader.cs.meta

-fileFormatVersion: 2
-guid: fedbd6bc5d95f4d768cb8077e8454b4e
-timeCreated: 1479851295
-licenseType: Pro
-MonoImporter:
-  serializedVersion: 2
-  defaultReferences: []
-  executionOrder: 0
-  icon: {instanceID: 0}
-  userData: 
-  assetBundleName: 
-  assetBundleVariant: 

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

-using UnityEngine;
-
-namespace UnityEditor.Experimental.Rendering.HDPipeline
-{
-    public class StandardToHDLitMaterialUpgrader : MaterialUpgrader
-    {
-        public StandardToHDLitMaterialUpgrader() : this("Standard", "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass) {}
-
-        public StandardToHDLitMaterialUpgrader(string sourceShaderName, string destShaderName, MaterialFinalizer finalizer)
-        {
-            RenameShader(sourceShaderName, destShaderName, finalizer);
-
-            RenameTexture("_MainTex", "_BaseColorMap");
-            RenameColor("_Color", "_BaseColor");
-            RenameFloat("_Glossiness", "_Smoothness");
-            RenameTexture("_BumpMap", "_NormalMap");
-            RenameFloat("_BumpScale", "_NormalScale");
-            RenameColor("_EmissionColor", "_EmissiveColor");
-            RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
-            RenameFloat("_Cutoff", "_AlphaCutoff");
-            RenameKeywordToFloat("_ALPHATEST_ON", "_AlphaCutoffEnable", 1f, 0f);
-
-            // the HD renderloop packs detail albedo and detail normals into a single texture.
-            // mapping the detail normal map, if any, to the detail map, should do the right thing if
-            // there is no detail albedo.
-            RenameTexture("_DetailNormalMap", "_DetailMap");
-
-            // Metallic uses [Gamma] attribute in standard shader but not in Lit.
-            // @Seb: Should we convert?
-            RenameFloat("_Metallic", "_Metallic");
-
-            //@TODO: Seb. Why do we multiply color by intensity
-            //       in shader when we can just store a color?
-            // builtinData.emissiveColor * builtinData.emissiveIntensity
-        }
-
-        public override void Convert(Material srcMaterial, Material dstMaterial)
-        {
-            base.Convert(srcMaterial, dstMaterial);
-            //@TODO: Find a good way of setting up keywords etc from properties.
-            // Code should be shared with material UI code.
-        }
-
-    }
-}

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

-using UnityEngine;
-
-namespace UnityEditor.Experimental.Rendering.HDPipeline
-{
-    public class StandardSpecularToHDLitMaterialUpgrader : MaterialUpgrader
-    {
-        public StandardSpecularToHDLitMaterialUpgrader() : this("Standard (Specular setup)", "HDRenderPipeline/Lit", LitGUI.SetupMaterialKeywordsAndPass) {}
-
-        public StandardSpecularToHDLitMaterialUpgrader(string sourceShaderName, string destShaderName, MaterialFinalizer finalizer)
-        {
-            RenameShader(sourceShaderName, destShaderName, finalizer);
-
-            RenameTexture("_MainTex", "_BaseColorMap");
-            RenameColor("_Color", "_BaseColor");
-            RenameFloat("_Glossiness", "_Smoothness");
-            RenameTexture("_BumpMap", "_NormalMap");
-            RenameFloat("_BumpScale", "_NormalScale");
-            RenameColor("_EmissionColor", "_EmissiveColor");
-            RenameFloat("_DetailNormalMapScale", "_DetailNormalScale");
-            RenameFloat("_Cutoff", "_AlphaCutoff");
-            RenameKeywordToFloat("_ALPHATEST_ON", "_AlphaCutoffEnable", 1f, 0f);
-
-            // the HD renderloop packs detail albedo and detail normals into a single texture.
-            // mapping the detail normal map, if any, to the detail map, should do the right thing if
-            // there is no detail albedo.
-            RenameTexture("_DetailNormalMap", "_DetailMap");
-
-            // Anything reasonable that can be done here?
-            //RenameFloat("_SpecColor", ...);
-
-            //@TODO: Seb. Why do we multiply color by intensity
-            //       in shader when we can just store a color?
-            // builtinData.emissiveColor * builtinData.emissiveIntensity
-        }
-
-        public override void Convert(Material srcMaterial, Material dstMaterial)
-        {
-            base.Convert(srcMaterial, dstMaterial);
-            //@TODO: Find a good way of setting up keywords etc from properties.
-            // Code should be shared with material UI code.
-        }
-    }
-}

Tests/Scripts/Editor/MaterialUpgraderTests.cs.meta

-fileFormatVersion: 2
-guid: 20d5442c0aea41919653fbc75ca174d1
-timeCreated: 1512986339

Tests/Scripts/Editor/MaterialUpgraderTests.cs

-using NUnit.Framework;
-using UnityEditor.Experimental.Rendering;
-using UnityEditor.Experimental.Rendering.HDPipeline;
-using UnityEngine;
-
-namespace ScriptableRenderPipeline.Tests.Editor
-{
-    public class MaterialUpgraderTests
-    {
-        [Test]
-        public void UpgradeStandardSpecularToHDLitMaterial()
-        {
-            var newShader = Shader.Find("HDRenderPipeline/Lit");
-            var mat = new Material(Shader.Find("Standard (Specular setup)"));
-            var albedo = new Texture2D(1, 1);
-            var normals = new Texture2D(1, 1);
-            var baseScale = new Vector2(1, 1);
-            var color = Color.red;
-            mat.mainTexture = albedo;
-            mat.SetTexture("_BumpMap", normals);
-            mat.color = color;
-            mat.SetTextureScale("_MainTex", baseScale);
-
-            var upgrader = new StandardSpecularToHDLitMaterialUpgrader();
-            MaterialUpgrader.Upgrade(mat, upgrader, MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
-
-            Assert.AreEqual(newShader, mat.shader);
-            Assert.AreEqual(albedo, mat.GetTexture("_BaseColorMap"));
-            Assert.AreEqual(color, mat.GetColor("_BaseColor"));
-            Assert.AreEqual(baseScale, mat.GetTextureScale("_BaseColorMap"));
-            Assert.AreEqual(normals, mat.GetTexture("_NormalMap"));
-            Assert.IsTrue(mat.IsKeywordEnabled("_NORMALMAP"));
-        }
-
-        [Test]
-        public void UpgradeStandardToHDLitMaterialUpgrader()
-        {
-            var newShader = Shader.Find("HDRenderPipeline/Lit");
-            var mat = new Material(Shader.Find("Standard"));
-            var albedo = new Texture2D(1, 1);
-            var normals = new Texture2D(1, 1);
-            var baseScale = new Vector2(1, 1);
-            var color = Color.red;
-            mat.mainTexture = albedo;
-            mat.SetTexture("_BumpMap", normals);
-            mat.color = color;
-            mat.SetTextureScale("_MainTex", baseScale);
-
-            var upgrader = new StandardToHDLitMaterialUpgrader();
-            MaterialUpgrader.Upgrade(mat, upgrader, MaterialUpgrader.UpgradeFlags.CleanupNonUpgradedProperties);
-
-            Assert.AreEqual(newShader, mat.shader);
-            Assert.AreEqual(albedo, mat.GetTexture("_BaseColorMap"));
-            Assert.AreEqual(color, mat.GetColor("_BaseColor"));
-            Assert.AreEqual(baseScale, mat.GetTextureScale("_BaseColorMap"));
-            Assert.AreEqual(normals, mat.GetTexture("_NormalMap"));
-            Assert.IsTrue(mat.IsKeywordEnabled("_NORMALMAP"));
-        }
-
-    }
-}