fix

CHANGELOG.md

@@ -4,91 +4,6 @@ All notable changes to this package will be documented in this file.
 The format is based on [Keep a Changelog](http://keepachangelog.com/en/1.0.0/)
 and this project adheres to [Semantic Versioning](http://semver.org/spec/v2.0.0.html).
 
-<<<<<<< HEAD
-## [10.8.0] - 2021-09-20
-
-Version Updated
-The version number for this package has increased due to a version update of a related graphics package.
-
-## [10.7.0] - 2021-07-02
-
-### Added
-- Added support for controlling Volume Framework Update Frequency in UI on Cameras and URP Asset as well as through scripting.
-- XR: Added Late Latching support to reduce VR latency (Quest).
-
-### Fixed
-- Fixed terrain hole shadowing [case 1349305]
-- Fixed artifacts in Speed Tree 8 billboard LODs due to SpeedTree LOD smoothing/crossfading [case 1348407]
-- Fixed an issue where the scene view would turn black when bloom was enabled. [case 1298790](https://issuetracker.unity3d.com/issues/urp-bloom-and-tonemapping-causes-the-screen-to-go-black-in-scene-mode), [case 1340848](https://issuetracker.unity3d.com/issues/urp-bloom-produces-visual-artifacts-when-color-slash-emission-are-not-clamped)
-- Fixed a case where camera dimension can be zero. [case 1321168](https://issuetracker.unity3d.com/issues/urp-attempting-to-get-camera-relative-temporary-rendertexture-is-thrown-when-tweening-the-viewport-rect-values-of-a-camera)
-- VFX: Fixed soft particles when HDR or Opaque texture isn't enabled
-- VFX: Fixed OpenGL soft particles fallback when depth texture isn't available
-- Fixed UniversalRenderPipelineAsset multi-edit.
-
-## [10.6.0] - 2021-04-29
-
-### Fixed
-- Fixed an issue where changing camera's position in the BeginCameraRendering do not apply properly. [case 1318629]
-- Fixed an issue where SMAA did not work for OpenGL [case 1336710](https://issuetracker.unity3d.com/issues/urp-there-is-no-effect-when-using-smaa-in-urp-with-opengles-api)
-- Fixed an issue where Particle Lit shader had an incorrect fallback shader [case 1331779]
-- Fixed SRP batcher not working on OpenGL.
-- Fixed an issue where the inspector of Renderer Data would break after adding RenderObjects renderer feature and then adding another renderer feature. [case 1323608](https://issuetracker.unity3d.com/product/unity/issues/guid/1323608/)
-- Fixed an issue with Transparency Sort Mode using the 2D Renderer Data [case 1310652](https://issuetracker.unity3d.com/product/unity/issues/guid/1310652/)
-- Fixed an issue with Transparency Sort Axis using the 2D Renderer Data [case 1312229](https://issuetracker.unity3d.com/product/unity/issues/guid/1312229/)
-
-## [10.5.0] - 2021-04-19
-
-### Added
-- Added a SpeedTree 8 Shader Graph but did not set it as the default for importing or upgrading Speed Tree 8 assets. Because URP doesn't yet support per-material culling, this Shader Graph does not yet behave in the same way as the existing handwritten SpeedTree 8 shader for URP.
-
-### Fixed
-- Fixed an issue where having "Opaque Texture" and MSAA enabled would cause the opaque texture to be rendered black on old Apple GPUs [case 1247423](https://issuetracker.unity3d.com/issues/urp-metal-opaque-objects-are-rendered-black-when-msaa-is-enabled)
-- Fixed errors when the Profiler is used with XR multipass. [case 1322918](https://issuetracker.unity3d.com/issues/xr-urp-profiler-spams-errors-in-the-console-upon-entering-play-mode)
-- Fixed ordering of subshaders in the Unlit Shader Graph, such that shader target 4.5 takes priority over 2.0. [case 1328636](https://issuetracker.unity3d.com/product/unity/issues/guid/1328636/)
-
-### Changed
-- Added subsurface scattering to handwritten SpeedTree 8 shader.
-
-## [10.4.0] - 2021-03-11
-
-### Changed
-- Opacity as Density blending feature for Terrain Lit Shader is now disabled when the Terrain has more than four Terrain Layers. This is now similar to the Height-blend feature for the Terrain Lit Shader.
-
-### Fixed
-- Fixed an issue where objects in motion might jitter when the Pixel Perfect Camera is used. [case 1300474](https://issuetracker.unity3d.com/issues/urp-characters-sprite-repeats-in-the-build-when-using-pixel-perfect-camera-and-2d-renderer)
-- Fixed an issue where the letter box/pillar box areas were not properly cleared when the Pixel Perfect Camera is used. [case 1291224](https://issuetracker.unity3d.com/issues/pixel-perfect-image-artifact-appear-between-the-reference-resolution-and-screen-resolution-borders-when-strech-fill-is-enabled)
-- Fixed an issue where the Cinemachine Pixel Perfect Extension might cause the Orthographic Size of the Camera to jump to 1 when the Scene is loaded. [case 1249076](https://issuetracker.unity3d.com/issues/cinemachine-pixel-perfect-camera-extension-causes-the-orthogonal-size-to-jump-to-1-when-the-scene-is-loaded)
-- Fixed an issue where no preview would show for the lit sprite master node in shadergraph
-- Fixed an issue where no shader was generated for unlit sprite shaders in shadergraph 
-- Fixed an issue where the scene view camera was not correctly cleared for the 2D Renderer. [case 1311377](https://issuetracker.unity3d.com/product/unity/issues/guid/1311377/)
-- Fixed an issue where bokeh dof is applied incorrectly when there is an overlay camera in the camera stack. [case 1303572](https://issuetracker.unity3d.com/issues/urp-bokeh-depth-of-field-is-applied-incorrectly-when-the-main-camera-has-an-overlay-camera-in-the-camera-stack)
-- Fixed a regression where the precision was changed. [case 1313942](https://issuetracker.unity3d.com/issues/urp-shader-precision-is-reduced-to-half-when-scriptablerenderfeature-class-is-in-the-project)
-- Fixed issue causing missing shaders on DirectX 11 feature level 10 GPUs. [case 1278390](https://issuetracker.unity3d.com/product/unity/issues/guid/1278390/)
-- Fixed an issue where modified splat weights for Terrain were  zero in some areas and greater than one in others when using the Opacity as Density blending feature.
-- Fixed a performance issue in Hololens when using renderer with custom render passes.
-
-## [10.3.1] - 2021-01-26
-
-Version Updated
-The version number for this package has increased due to a version update of a related graphics package.
-
-## [10.3.0] - 2020-11-16
-
-### Added
-- Added support for the PlayStation 5 platform.
-
-### Fixed
-- Transparent Lit ShaderGraph using Additive blending will now properly fade with alpha [1270344]
-- Fixed useless mip maps on temporary RTs/PostProcessing inherited from Main RT descriptor.
-- Fixed an issue in where all the entries in the Renderer List wasn't selectable and couldn't be deleted.
-- Fixed GC allocations from XR occlusion mesh when using multipass.
-- Fixed an issue where Universal Render Pipeline with disabled antiAliasing was overwriting QualitySettings.asset on frequent cases. [case 1219159](https://issuetracker.unity3d.com/issues/urp-qualitysettings-dot-asset-file-gets-overwritten-with-the-same-content-when-the-editor-is-closed)
-- Fixed a case where overlay camera with output texture caused base camera not to render to screen. [case 1283225](https://issuetracker.unity3d.com/issues/game-view-renders-a-black-view-when-having-an-overlay-camera-which-had-output-texture-assigned-in-the-camera-stack)
-- Fixed wrong shader / properties assignement to materials created from 3DsMax 2021 Physical Material. (case 1293576)
-- Fixed an issue so it is now possible to enqueue render passes at runtime.
-- Fixed an issue where render scale was breaking SSAO in scene view. [case 1296710](https://issuetracker.unity3d.com/issues/ssao-effect-floating-in-the-air-in-scene-view-when-2-objects-with-shadergraph-materials-are-on-top-of-each-other)
-- Fixed material upgrader to run in batch mode [case 1305402]
-=======
 ## [12.1.6] - 2022-02-09
 
 ### Fixed
@@ -457,51 +372,17 @@ The version number for this package has increased due to a version update of a r
 - Fixed SAMPLE_TEXTURECUBE_ARRAY_LOD macro when using OpenGL ES. [case 1285132](https://issuetracker.unity3d.com/issues/urp-android-error-sample-texturecube-array-lod-is-not-supported-on-gles-3-dot-0-when-using-cubemap-array-shader-shaders)
 - Fixed an issue such that it is now posible to enqueue render passes at runtime.
 - Fixed SpeedTree LOD fade functionality. [case 1198135]
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 ## [10.2.0] - 2020-10-19
 
-### Added
-- Added a supported MSAA samples count check, so the actual supported MSAA samples count value can be assigned to RenderTexture descriptors.
-
 ### Changed
 - Changed RenderObjectsFeature UI to only expose valid events. Previously, when selecting events before BeforeRenderingPrepasses objects would not be drawn correctly as stereo and camera setup only happens before rendering opaques objects.
-<<<<<<< HEAD
-- Shader functions SampleSH9, SampleSHPixel, SampleSHVertex are now gamma corrected in gamma space. As result LightProbes are gamma corrected too.
-- Bloom in Gamma color-space now more closely matches Linear color-space, this will mean project using Bloom and Gamma color-space may need to adjust Bloom Intensity to match previous look.
-=======
 - Transparent Lit ShaderGraph using Additive blending will now properly fade with alpha [1270344]
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 ### Fixed
 - Fixed the Unlit shader not being SRP Batcher compatible on OpenGLES/OpenGLCore. [case 1263720](https://issuetracker.unity3d.com/issues/urp-mobile-srp-batcher-is-not-visible-on-mobile-devices-in-frame-debugger)
 - Fixed an issue with soft particles not rendering correctly for overlay cameras with post processing. [case 1241626](https://issuetracker.unity3d.com/issues/soft-particles-does-not-fade-out-near-the-opaque-surfaces-when-post-processing-is-enabled-on-a-stacked-camera)
-<<<<<<< HEAD
-- Removed the warning about mis-matched vertex streams when creating a default Particle System. [case 1285272](https://issuetracker.unity3d.com/issues/particles-urp-default-material-shows-warning-in-inspector)
-- Fixed latest mockHMD renderviewport scale doesn't fill whole view after scaling. [case 1286161] (https://issuetracker.unity3d.com/issues/xr-urp-renderviewportscale-doesnt-fill-whole-view-after-scaling)
-- Fixed camera renders black in XR when user sets invalid MSAA value.
-- Fixed an issue causing additional lights to stop working when set as the sun source. [case 1278768](https://issuetracker.unity3d.com/issues/urp-every-light-type-is-rendered-as-directional-light-if-it-is-set-as-sun-source-of-the-environment)
-- Fixed an issue that caused a null reference when Lift Gamma Gain was being displayed in the Inspector and URP was upgraded to a newer version.  [case 1283588](https://issuetracker.unity3d.com/issues/argumentnullexception-is-thrown-when-upgrading-urp-package-and-volume-with-lift-gamma-gain-is-focused-in-inspector)
-- Fixed an issue where soft particles were not rendered when depth texture was disabled in the URP Asset. [case 1162556](https://issuetracker.unity3d.com/issues/lwrp-unlit-particles-shader-is-not-rendered-when-soft-particles-are-enabled-on-built-application)
-- Fixed an issue where soft particles were rendered opaque on OpenGL. [case 1226288](https://issuetracker.unity3d.com/issues/urp-objects-that-are-using-soft-particles-are-rendered-opaque-when-opengl-is-used)
-- Fixed an issue where the depth texture sample node used an incorrect texture in some frames. [case 1268079](https://issuetracker.unity3d.com/issues/urp-depth-texture-sample-node-does-not-use-correct-texture-in-some-frames)
-- Fixed MSAA on Metal MacOS and Editor.
-- Fixed an issue causing passthrough camera to not render. [case 1283894](https://issuetracker.unity3d.com/product/unity/issues/guid/1283894/) 
-- Fixed MSAA override on camera does not work in non-XR project if target eye is selected to both eye.
-- Fixed a compiler error in BakedLit shader when using Hybrid Renderer.
-- Fixed XR camera fov can be changed through camera inspector.
-- Fixed LightProbes to have gamma correct when using gamma color space. [case 1268911](https://issuetracker.unity3d.com/issues/urp-has-no-gamma-correction-for-lightprobes)
-- Fixed an issue causing materials to be upgraded multiple times.
-- Fixed an issue where the Camera inspector was grabbing the URP asset in Graphics Settings rather than the currently active.
-- Fixed an issue where the Light Explorer was grabbing the URP asset in Graphics Settings rather than the currently active.
-- Fixed an issue where the scene view camera ignored the pipeline assets HDR setting. [case 1284369](https://issuetracker.unity3d.com/issues/urp-scene-view-camera-ignores-pipeline-assets-hdr-settings-when-main-camera-uses-pipeline-settings)
-- Fixed bloom inconsistencies between Gamma and Linear color-spaces.
-- Fixed an issue with upgrading material set to cutout didn't properly set alpha clipping. [case 1235516](https://issuetracker.unity3d.com/issues/urp-upgrade-material-utility-does-not-set-the-alpha-clipping-when-material-was-using-a-shader-with-rendering-mode-set-to-cutout)
-- Fixed issue where selecting and deselecting Forward Renderer asset would leak memory [case 1290628](https://issuetracker.unity3d.com/issues/urp-scriptablerendererfeatureeditor-memory-leak-while-interacting-with-forward-renderer-in-the-project-window)
-- Fixed an error where multisampled texture being bound to a non-multisampled sampler in XR. 
-=======
 - Fixed MSAA override on camera does not work in non-XR project if target eye is selected to both eye.
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 ## [10.1.0] - 2020-10-12
 - Added support for the Shadowmask Mixed Lighting Mode (Forward only), which supports up to four baked-shadow Lights.

Editor/2D/ShaderGraph/Targets/UniversalSpriteUnlitSubTarget.cs

@@ -100,12 +100,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
             {
                 SubShaderDescriptor result = new SubShaderDescriptor()
                 {
-<<<<<<< HEAD:com.unity.render-pipelines.universal/Editor/ShaderGraph/Targets/UniversalSpriteUnlitSubTarget.cs
-                    { SpriteUnlitPasses.Unlit },
-                    { SpriteUnlitPasses.Forward },
-                },
-            };
-=======
                     pipelineTag = UniversalTarget.kPipelineTag,
                     customTags = UniversalTarget.kUnlitMaterialTypeTag,
                     renderType = $"{RenderType.Transparent}",
@@ -123,7 +117,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
                 };
                 return result;
             }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76:com.unity.render-pipelines.universal/Editor/2D/ShaderGraph/Targets/UniversalSpriteUnlitSubTarget.cs
         }
         #endregion
 
@@ -138,35 +131,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
                 lightMode = "Universal2D",
                 useInPreview = true,
 
-
-                // Template
-                passTemplatePath = GenerationUtils.GetDefaultTemplatePath("PassMesh.template"),
-                sharedTemplateDirectories = GenerationUtils.GetDefaultSharedTemplateDirectories(),
-
-                // Port Mask
-                validVertexBlocks = CoreBlockMasks.Vertex,
-                validPixelBlocks = SpriteUnlitBlockMasks.Fragment,
-
-                // Fields
-                structs = CoreStructCollections.Default,
-                requiredFields = SpriteUnlitRequiredFields.Unlit,
-                fieldDependencies = CoreFieldDependencies.Default,
-
-                // Conditional State
-                renderStates = CoreRenderStates.Default,
-                pragmas = CorePragmas._2DDefault,
-                includes = SpriteUnlitIncludes.Unlit,
-            };
-
-            public static PassDescriptor Forward = new PassDescriptor
-            {
-                // Definition
-                displayName = "Sprite Unlit",
-                referenceName = "SHADERPASS_SPRITEFORWARD",
-                lightMode = "UniversalForward",
-                useInPreview = true,
-
-
                 // Template
                 passTemplatePath = GenerationUtils.GetDefaultTemplatePath("PassMesh.template"),
                 sharedTemplateDirectories = GenerationUtils.GetDefaultSharedTemplateDirectories(),

Editor/AssetPostProcessors/MaterialPostprocessor.cs

@@ -103,11 +103,7 @@ namespace UnityEditor.Rendering.Universal
         internal static List<string> s_ImportedAssetThatNeedSaving = new List<string>();
         internal static bool s_NeedsSavingAssets = false;
 
-<<<<<<< HEAD
-        internal static readonly Action<Material, ShaderPathID>[] k_Upgraders = { UpgradeV1, UpgradeV2, UpgradeV3, UpgradeV4 };
-=======
         internal static readonly Action<Material, ShaderID>[] k_Upgraders = { UpgradeV1, UpgradeV2, UpgradeV3, UpgradeV4, UpgradeV5 };
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
         static internal void SaveAssetsToDisk()
         {
@@ -177,19 +173,11 @@ namespace UnityEditor.Rendering.Universal
                     {
                         assetVersion.version = k_Upgraders.Length;
                         s_CreatedAssets.Remove(asset);
-<<<<<<< HEAD
-                        InitializeLatest(material, id);
-=======
                         InitializeLatest(material, shaderID);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                         debug += " initialized.";
                     }
                     else
                     {
-<<<<<<< HEAD
-                        assetVersion.version = UniversalProjectSettings.materialVersionForUpgrade;
-                        debug += $" assumed to be version {UniversalProjectSettings.materialVersionForUpgrade} due to missing version.";
-=======
                         if (shaderID.IsShaderGraph())
                         {
                             // ShaderGraph materials NEVER had asset versioning applied prior to version 5.
@@ -202,7 +190,6 @@ namespace UnityEditor.Rendering.Universal
                             assetVersion.version = UniversalProjectSettings.materialVersionForUpgrade;
                             debug += $" assumed to be version {UniversalProjectSettings.materialVersionForUpgrade} due to missing version.";
                         }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                     }
 
                     assetVersion.hideFlags = HideFlags.HideInHierarchy | HideFlags.HideInInspector | HideFlags.NotEditable;
@@ -311,10 +298,6 @@ namespace UnityEditor.Rendering.Universal
             }
         }
 
-<<<<<<< HEAD
-        static void UpgradeV4(Material material, ShaderPathID shaderID)
-        {}
-=======
         static void UpgradeV4(Material material, ShaderID shaderID)
         { }
 
@@ -337,7 +320,6 @@ namespace UnityEditor.Rendering.Universal
                 }
             }
         }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     }
 
     // Upgraders v1

Editor/Overrides/ShadowsMidtonesHighlightsEditor.cs

@@ -35,15 +35,6 @@ namespace UnityEditor.Rendering.Universal
         {
             var o = new PropertyFetcher<ShadowsMidtonesHighlights>(serializedObject);
 
-<<<<<<< HEAD
-            m_Shadows         = Unpack(o.Find(x => x.shadows));
-            m_Midtones        = Unpack(o.Find(x => x.midtones));
-            m_Highlights      = Unpack(o.Find(x => x.highlights));
-            m_ShadowsStart    = Unpack(o.Find(x => x.shadowsStart));
-            m_ShadowsEnd      = Unpack(o.Find(x => x.shadowsEnd));
-            m_HighlightsStart = Unpack(o.Find(x => x.highlightsStart));
-            m_HighlightsEnd   = Unpack(o.Find(x => x.highlightsEnd));
-=======
             m_Shadows = Unpack(o.Find(x => x.shadows));
             m_Midtones = Unpack(o.Find(x => x.midtones));
             m_Highlights = Unpack(o.Find(x => x.highlights));
@@ -51,7 +42,6 @@ namespace UnityEditor.Rendering.Universal
             m_ShadowsEnd = Unpack(o.Find(x => x.shadowsEnd));
             m_HighlightsStart = Unpack(o.Find(x => x.highlightsStart));
             m_HighlightsEnd = Unpack(o.Find(x => x.highlightsEnd));
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
 
         public override void OnInspectorGUI()
@@ -99,12 +89,6 @@ namespace UnityEditor.Rendering.Universal
             PropertyField(m_ShadowsEnd, EditorGUIUtility.TrTextContent("End"));
             m_ShadowsEnd.value.floatValue = Mathf.Max(m_ShadowsStart.value.floatValue, m_ShadowsEnd.value.floatValue);
 
-<<<<<<< HEAD
-            EditorGUILayout.Space();
-
-            EditorGUILayout.LabelField("Highlight Limits", EditorStyles.miniLabel);
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             PropertyField(m_HighlightsStart, EditorGUIUtility.TrTextContent("Start"));
             m_HighlightsStart.value.floatValue = Mathf.Min(m_HighlightsStart.value.floatValue, m_HighlightsEnd.value.floatValue);
             PropertyField(m_HighlightsEnd, EditorGUIUtility.TrTextContent("End"));

Editor/RenderStateDataEditor.cs

@@ -90,16 +90,11 @@ namespace UnityEditor.Rendering.Universal
 
         public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
         {
-<<<<<<< HEAD
-            if (m_properties.Contains(property.serializedObject) && m_OverrideStencil != null && m_OverrideStencil.boolValue)
-                return EditorUtils.Styles.defaultLineSpace * 6;
-=======
             if (m_properties.Contains(property.serializedObject))
             {
                 if (m_OverrideStencil != null && m_OverrideStencil.boolValue)
                     return EditorUtils.Styles.defaultLineSpace * 6;
             }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             return EditorUtils.Styles.defaultLineSpace * 1;
         }
     }

Editor/ScriptableRendererDataEditor.cs

@@ -46,10 +46,6 @@ namespace UnityEditor.Rendering.Universal
             m_FalseBool = editorObj.FindProperty(nameof(falseBool));
             UpdateEditorList();
         }
-        private void OnDisable()
-        {
-            ClearEditorsList();
-        }
 
         private void OnDisable()
         {

Editor/ShaderGUI/ParticleGUI.cs

@@ -4,10 +4,6 @@ using System.Linq;
 using System.Collections.Generic;
 using UnityEngine.Rendering;
 using UnityEngine.Rendering.Universal;
-<<<<<<< HEAD
-using UnityEngine.Scripting.APIUpdating;
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 namespace UnityEditor.Rendering.Universal.ShaderGUI
 {
@@ -185,20 +181,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGUI
                             EditorGUILayout.HelpBox("Soft Particles require depth texture. Please enable \"Depth Texture\" in the Universal Render Pipeline settings.", MessageType.Warning);
                         }
 
-<<<<<<< HEAD
-                    if (enabled >= 0.5f)
-                    {
-                        UniversalRenderPipelineAsset urpAsset = UniversalRenderPipeline.asset;
-                        if (urpAsset != null && !urpAsset.supportsCameraDepthTexture)
-                        {
-                            GUIStyle warnStyle = new GUIStyle(GUI.skin.label);
-                            warnStyle.fontStyle = FontStyle.BoldAndItalic;
-                            warnStyle.wordWrap = true;
-                            EditorGUILayout.HelpBox("Soft Particles require depth texture. Please enable \"Depth Texture\" in the Universal Render Pipeline settings.", MessageType.Warning);
-                        }
-
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                         EditorGUI.indentLevel++;
                         BaseShaderGUI.TwoFloatSingleLine(Styles.softParticlesFadeText,
                             properties.softParticlesNearFadeDistance,

Editor/ShaderGraph/Includes/OculusMotionVectors.hlsl.meta

@@ -1,16 +1,7 @@
 fileFormatVersion: 2
-<<<<<<< HEAD
-guid: 720fc1c927efc8c498d7490c5eae148c
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  preprocessorOverride: 0
-=======
 guid: 46f1712c3d252384683d02ab9d357a54
 ShaderIncludeImporter:
   externalObjects: {}
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
   userData: 
   assetBundleName: 
   assetBundleVariant: 

Editor/ShaderGraph/Includes/ShaderPass.hlsl

@@ -13,9 +13,6 @@
 #define SHADERPASS_SPRITEFORWARD (9)
 #define SHADERPASS_SPRITEUNLIT (10)
 #define SHADERPASS_DEPTHNORMALSONLY (11)
-<<<<<<< HEAD
-#define SHADERPASS_MOTIONVECTORS (12)
-=======
 #define SHADERPASS_DBUFFER_PROJECTOR (12)
 #define SHADERPASS_DBUFFER_MESH (13)
 #define SHADERPASS_FORWARD_EMISSIVE_PROJECTOR (14)
@@ -27,5 +24,4 @@
 #define SHADERPASS_DECAL_GBUFFER_MESH (20)
 #define SHADERPASS_DEPTHNORMALS (21)
 #define SHADERPASS_MOTIONVECTORS (22)
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #endif

Editor/ShaderGraph/Includes/Varyings.hlsl

@@ -213,13 +213,6 @@ Varyings BuildVaryings(Attributes input)
         bool hasDeformation = unity_MotionVectorsParams.x > 0.0;
         float3 effectivePositionOS = (hasDeformation ? input.uv4.xyz : input.positionOS.xyz);
         float3 previousWS = TransformPreviousObjectToWorld(effectivePositionOS);
-<<<<<<< HEAD
-        output.prevPositionCS = TransformWorldToPrevHClip(previousWS);
-    }
-#endif
-
-#if defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
-=======
 
         float4x4 previousOTW = GetPrevObjectToWorldMatrix();
         float4x4 currentOTW = GetObjectToWorldMatrix();
@@ -235,7 +228,6 @@ Varyings BuildVaryings(Attributes input)
 #endif
 
 #if defined(VARYINGS_NEED_SHADOW_COORD) && defined(REQUIRES_VERTEX_SHADOW_COORD_INTERPOLATOR)
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     output.shadowCoord = GetShadowCoord(vertexInput);
 #endif
 

Editor/ShaderGraph/Targets/UniversalLitSubTarget.cs

@@ -139,14 +139,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
             context.AddBlock(BlockFields.SurfaceDescription.NormalWS, normalDropOffSpace == NormalDropOffSpace.World);
             context.AddBlock(BlockFields.SurfaceDescription.Emission);
             context.AddBlock(BlockFields.SurfaceDescription.Occlusion);
-<<<<<<< HEAD
-            context.AddBlock(BlockFields.SurfaceDescription.Specular,           workflowMode == WorkflowMode.Specular);
-            context.AddBlock(BlockFields.SurfaceDescription.Metallic,           workflowMode == WorkflowMode.Metallic);
-            context.AddBlock(BlockFields.SurfaceDescription.Alpha,              target.surfaceType == SurfaceType.Transparent || target.alphaClip);
-            context.AddBlock(BlockFields.SurfaceDescription.AlphaClipThreshold, target.alphaClip);
-            context.AddBlock(BlockFields.SurfaceDescription.CoatMask,           clearCoat);
-            context.AddBlock(BlockFields.SurfaceDescription.CoatSmoothness,     clearCoat);
-=======
 
             // when the surface options are material controlled, we must show all of these blocks
             // when target controlled, we can cull the unnecessary blocks
@@ -186,7 +178,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
             // We initialize queue control to -1 to indicate to UpdateMaterial that it needs to initialize it properly on the material.
             collector.AddFloatProperty(Property.QueueOffset, 0.0f);
             collector.AddFloatProperty(Property.QueueControl, -1.0f);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
 
         public override void GetPropertiesGUI(ref TargetPropertyGUIContext context, Action onChange, Action<String> registerUndo)
@@ -372,83 +363,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
 
                 return result;
             }
-<<<<<<< HEAD
-            #endregion
-
-            // SM 4.5, compute with dots instancing
-            public readonly static SubShaderDescriptor LitComputeDOTS = new SubShaderDescriptor()
-            {
-                pipelineTag = UniversalTarget.kPipelineTag,
-                customTags = UniversalTarget.kLitMaterialTypeTag,
-                generatesPreview = true,
-                passes = new PassCollection
-                {
-                    { PassVariant(LitPasses.Forward,         CorePragmas.DOTSForward) },
-                    { LitPasses.GBuffer },
-                    { PassVariant(CorePasses.ShadowCaster,   CorePragmas.DOTSInstanced) },
-                    { PassVariant(CorePasses.DepthOnly,      CorePragmas.DOTSInstanced) },
-                    { PassVariant(LitPasses.DepthNormalOnly, CorePragmas.DOTSInstanced) },
-                    { PassVariant(LitPasses.Meta,            CorePragmas.DOTSDefault) },
-                    { PassVariant(LitPasses._2D,             CorePragmas.DOTSDefault) },
-                    { CorePasses.MotionVectors },
-                },
-            };
-
-            // Similar to lit, but handles complex material features.
-            // Always ForwardOnly and acts as forward fallback in deferred.
-            // SM 4.5, compute with dots instancing
-            public readonly static SubShaderDescriptor ComplexLitComputeDOTS = new SubShaderDescriptor()
-            {
-                pipelineTag = UniversalTarget.kPipelineTag,
-                customTags = UniversalTarget.kLitMaterialTypeTag,
-                generatesPreview = true,
-                passes = new PassCollection
-                {
-                    { PassVariant(LitPasses.ForwardOnly,     CoreBlockMasks.Vertex, LitBlockMasks.FragmentComplexLit, CorePragmas.DOTSForward, LitDefines.ComplexLit ) },
-                    { PassVariant(CorePasses.ShadowCaster,   CorePragmas.DOTSInstanced) },
-                    { PassVariant(CorePasses.DepthOnly,      CorePragmas.DOTSInstanced) },
-                    { PassVariant(LitPasses.DepthNormalOnly, CorePragmas.DOTSInstanced) },
-                    { PassVariant(LitPasses.Meta,            CorePragmas.DOTSDefault)   },
-                    { PassVariant(LitPasses._2D,             CorePragmas.DOTSDefault)   },
-                },
-            };
-
-            // SM 2.0, GLES
-            public readonly static SubShaderDescriptor LitGLES = new SubShaderDescriptor()
-            {
-                pipelineTag = UniversalTarget.kPipelineTag,
-                customTags = UniversalTarget.kLitMaterialTypeTag,
-                generatesPreview = true,
-                passes = new PassCollection
-                {
-                    { LitPasses.Forward },
-                    { CorePasses.ShadowCaster },
-                    { CorePasses.DepthOnly },
-                    { LitPasses.DepthNormalOnly },
-                    { LitPasses.Meta },
-                    { LitPasses._2D },
-                },
-            };
-
-            // ForwardOnly pass for SM 2.0, GLES
-            // Used as complex Lit SM 2.0 fallback for GLES. Drops advanced features and renders materials as Lit.
-            public readonly static SubShaderDescriptor LitGLESForwardOnly = new SubShaderDescriptor()
-            {
-                pipelineTag = UniversalTarget.kPipelineTag,
-                customTags = UniversalTarget.kLitMaterialTypeTag,
-                generatesPreview = true,
-                passes = new PassCollection
-                {
-                    { LitPasses.ForwardOnly },
-                    { CorePasses.ShadowCaster },
-                    { CorePasses.DepthOnly },
-                    { LitPasses.DepthNormalOnly },
-                    { LitPasses.Meta },
-                    { LitPasses._2D },
-                },
-            };
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
         #endregion
 

Editor/ShaderGraph/Targets/UniversalTarget.cs

@@ -309,12 +309,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
             m_ActiveSubTarget.value.target = this;
         }
 
-        public override void OnAfterMultiDeserialize(string json)
-        {
-            TargetUtils.ProcessSubTargetList(ref m_ActiveSubTarget, ref m_SubTargets);
-            m_ActiveSubTarget.value.target = this;
-        }
-
         public override void GetFields(ref TargetFieldContext context)
         {
             var descs = context.blocks.Select(x => x.descriptor);
@@ -736,38 +730,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
                 lightMode = "DepthOnly",
                 useInPreview = true,
 
-<<<<<<< HEAD
-            // Conditional State
-            renderStates = CoreRenderStates.ShadowCaster,
-            pragmas = CorePragmas.Instanced,
-            includes = CoreIncludes.ShadowCaster,
-        };
-
-        public static readonly PassDescriptor MotionVectors = new PassDescriptor()
-        {
-            // Definition
-            displayName = "MotionVectors",
-            referenceName = "SHADERPASS_MOTIONVECTORS",
-            lightMode = "MotionVectors",
-
-            // Template
-            passTemplatePath = GenerationUtils.GetDefaultTemplatePath("PassMesh.template"),
-            sharedTemplateDirectories = GenerationUtils.GetDefaultSharedTemplateDirectories(),
-
-            // Port Mask
-            validVertexBlocks = CoreBlockMasks.Vertex,
-
-            // Fields
-            structs = CoreStructCollections.Default,
-            requiredFields = CoreRequiredFields.MotionVectors,
-            fieldDependencies = CoreFieldDependencies.Default,
-
-            // Conditional State
-            renderStates = CoreRenderStates.Default,
-            pragmas = CorePragmas.DOTSInstanced,
-            includes = CoreIncludes.MotionVectors,
-        };
-=======
                 // Template
                 passTemplatePath = UniversalTarget.kUberTemplatePath,
                 sharedTemplateDirectories = UniversalTarget.kSharedTemplateDirectories,
@@ -1098,7 +1060,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
 
             return result;
         }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     }
     #endregion
 
@@ -1170,13 +1131,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
             UniversalStructFields.Varyings.curPositionCS,
             UniversalStructFields.Varyings.prevPositionCS,
         };
-
-        public static readonly FieldCollection MotionVectors = new FieldCollection()
-        {
-            StructFields.Attributes.uv4,                   // needed for previousPositionOS
-            UniversalStructFields.Varyings.curPositionCS,
-            UniversalStructFields.Varyings.prevPositionCS,
-        };
     }
     #endregion
 
@@ -1375,11 +1329,7 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
         public static readonly PragmaCollection Default = new PragmaCollection
         {
             { Pragma.Target(ShaderModel.Target20) },
-<<<<<<< HEAD
-            { Pragma.OnlyRenderers(new[]{ Platform.GLES, Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
-=======
             { Pragma.OnlyRenderers(new[] { Platform.GLES, Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             { Pragma.Vertex("vert") },
             { Pragma.Fragment("frag") },
         };
@@ -1387,11 +1337,7 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
         public static readonly PragmaCollection Instanced = new PragmaCollection
         {
             { Pragma.Target(ShaderModel.Target20) },
-<<<<<<< HEAD
-            { Pragma.OnlyRenderers(new[]{ Platform.GLES, Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
-=======
             { Pragma.OnlyRenderers(new[] { Platform.GLES, Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             { Pragma.MultiCompileInstancing },
             { Pragma.Vertex("vert") },
             { Pragma.Fragment("frag") },
@@ -1400,11 +1346,7 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
         public static readonly PragmaCollection Forward = new PragmaCollection
         {
             { Pragma.Target(ShaderModel.Target20) },
-<<<<<<< HEAD
-            { Pragma.OnlyRenderers(new[]{ Platform.GLES, Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
-=======
             { Pragma.OnlyRenderers(new[] { Platform.GLES, Platform.GLES3, Platform.GLCore, Platform.D3D11 }) },
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             { Pragma.MultiCompileInstancing },
             { Pragma.MultiCompileFog },
             { Pragma.InstancingOptions(InstancingOptions.RenderingLayer) },
@@ -1478,11 +1420,8 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
         const string kDepthNormalsOnlyPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/DepthNormalsOnlyPass.hlsl";
         const string kShadowCasterPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/ShadowCasterPass.hlsl";
         const string kTextureStack = "Packages/com.unity.render-pipelines.core/ShaderLibrary/TextureStack.hlsl";
-<<<<<<< HEAD
-=======
         const string kDBuffer = "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DBuffer.hlsl";
         const string kSelectionPickingPass = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/SelectionPickingPass.hlsl";
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         const string kMotionVectors = "Packages/com.unity.render-pipelines.universal/Editor/ShaderGraph/Includes/OculusMotionVectors.hlsl";
 
         public static readonly IncludeCollection CorePregraph = new IncludeCollection
@@ -1537,22 +1476,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
             { CorePostgraph },
             { kShadowCasterPass, IncludeLocation.Postgraph },
         };
-<<<<<<< HEAD
-
-        public static readonly IncludeCollection MotionVectors = new IncludeCollection
-        {
-            // Pre-graph
-            { CoreIncludes.CorePregraph },
-            { CoreIncludes.ShaderGraphPregraph },
-
-            // Post-graph
-            { CoreIncludes.CorePostgraph },
-            { kMotionVectors, IncludeLocation.Postgraph },
-        };
-    }
-#endregion
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
         public static readonly IncludeCollection DBufferPregraph = new IncludeCollection
         {
@@ -1970,10 +1893,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
     {
         public static readonly FieldDescriptor UseLegacySpriteBlocks = new FieldDescriptor("Universal", "UseLegacySpriteBlocks", "UNIVERSAL_USELEGACYSPRITEBLOCKS");
     }
-<<<<<<< HEAD
-#endregion
-}
-=======
     #endregion
 
     #region CustomInterpolators
@@ -1992,4 +1911,3 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
     }
     #endregion
 }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76

Editor/ShaderGraph/Targets/UniversalUnlitSubTarget.cs

@@ -26,14 +26,8 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
             context.AddAssetDependency(kSourceCodeGuid, AssetCollection.Flags.SourceDependency);
             base.Setup(ref context);
 
-<<<<<<< HEAD
-            // Process SubShaders
-            SubShaderDescriptor[] subShaders = { SubShaders.UnlitDOTS, SubShaders.Unlit };
-            for(int i = 0; i < subShaders.Length; i++)
-=======
             var universalRPType = typeof(UnityEngine.Rendering.Universal.UniversalRenderPipelineAsset);
             if (!context.HasCustomEditorForRenderPipeline(universalRPType))
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             {
                 var gui = typeof(ShaderGraphUnlitGUI);
 #if HAS_VFX_GRAPH
@@ -186,22 +180,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
 
                 result.passes.Add(PassVariant(UnlitPasses.Forward(target), CorePragmas.DOTSForward));
 
-<<<<<<< HEAD
-                    return new SubShaderDescriptor()
-                    {
-                        pipelineTag = UniversalTarget.kPipelineTag,
-                        customTags = UniversalTarget.kUnlitMaterialTypeTag,
-                        generatesPreview = true,
-                        passes = new PassCollection
-                        {
-                            { unlit },
-                            { shadowCaster },
-                            { depthOnly },
-                            { CorePasses.MotionVectors },
-                        },
-                    };
-                }
-=======
                 if (target.mayWriteDepth)
                     result.passes.Add(PassVariant(CorePasses.DepthOnly(target), CorePragmas.DOTSInstanced));
 
@@ -218,7 +196,6 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
                 result.passes.Add(PassVariant(UnlitPasses.DepthNormalOnly(target), CorePragmas.DOTSInstanced));
 
                 return result;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             }
         }
         #endregion

Editor/ShaderGraph/UniversalBlockFields.cs

@@ -11,14 +11,11 @@ namespace UnityEditor.Rendering.Universal.ShaderGraph
             public static string name = "SurfaceDescription";
             public static BlockFieldDescriptor SpriteMask = new BlockFieldDescriptor(SurfaceDescription.name, "SpriteMask", "Sprite Mask", "SURFACEDESCRIPTION_SPRITEMASK",
                 new ColorRGBAControl(new Color(1, 1, 1, 1)), ShaderStage.Fragment);
-<<<<<<< HEAD
-=======
 
             public static BlockFieldDescriptor NormalAlpha = new BlockFieldDescriptor(SurfaceDescription.name, "NormalAlpha", "Normal Alpha", "SURFACEDESCRIPTION_NORMALALPHA",
                 new FloatControl(1.0f), ShaderStage.Fragment);
             public static BlockFieldDescriptor MAOSAlpha = new BlockFieldDescriptor(SurfaceDescription.name, "MAOSAlpha", "MAOS Alpha", "SURFACEDESCRIPTION_MAOSALPHA",
                 new FloatControl(1.0f), ShaderStage.Fragment);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
     }
 }

Editor/UniversalRenderPipelineAssetEditor.cs

@@ -6,155 +6,15 @@ using Styles = UnityEditor.Rendering.Universal.UniversalRenderPipelineAssetUI.St
 namespace UnityEditor.Rendering.Universal
 {
     [CustomEditor(typeof(UniversalRenderPipelineAsset)), CanEditMultipleObjects]
-<<<<<<< HEAD
-    [MovedFrom("UnityEditor.Rendering.LWRP")] public class UniversalRenderPipelineAssetEditor : Editor
-    {
-        internal class Styles
-        {
-            // Groups
-            public static GUIContent generalSettingsText = EditorGUIUtility.TrTextContent("General");
-            public static GUIContent qualitySettingsText = EditorGUIUtility.TrTextContent("Quality");
-            public static GUIContent lightingSettingsText = EditorGUIUtility.TrTextContent("Lighting");
-            public static GUIContent shadowSettingsText = EditorGUIUtility.TrTextContent("Shadows");
-            public static GUIContent postProcessingSettingsText = EditorGUIUtility.TrTextContent("Post-processing");
-            public static GUIContent advancedSettingsText = EditorGUIUtility.TrTextContent("Advanced");
-            public static GUIContent adaptivePerformanceText = EditorGUIUtility.TrTextContent("Adaptive Performance");
-
-            // General
-            public static GUIContent rendererHeaderText = EditorGUIUtility.TrTextContent("Renderer List", "Lists all the renderers available to this Render Pipeline Asset.");
-            public static GUIContent rendererDefaultText = EditorGUIUtility.TrTextContent("Default", "This renderer is currently the default for the render pipeline.");
-            public static GUIContent rendererSetDefaultText = EditorGUIUtility.TrTextContent("Set Default", "Makes this renderer the default for the render pipeline.");
-            public static GUIContent rendererSettingsText = EditorGUIUtility.TrIconContent("_Menu", "Opens settings for this renderer.");
-            public static GUIContent rendererMissingText = EditorGUIUtility.TrIconContent("console.warnicon.sml", "Renderer missing. Click this to select a new renderer.");
-            public static GUIContent rendererDefaultMissingText = EditorGUIUtility.TrIconContent("console.erroricon.sml", "Default renderer missing. Click this to select a new renderer.");
-            public static GUIContent requireDepthTextureText = EditorGUIUtility.TrTextContent("Depth Texture", "If enabled the pipeline will generate camera's depth that can be bound in shaders as _CameraDepthTexture.");
-            public static GUIContent requireOpaqueTextureText = EditorGUIUtility.TrTextContent("Opaque Texture", "If enabled the pipeline will copy the screen to texture after opaque objects are drawn. For transparent objects this can be bound in shaders as _CameraOpaqueTexture.");
-            public static GUIContent opaqueDownsamplingText = EditorGUIUtility.TrTextContent("Opaque Downsampling", "The downsampling method that is used for the opaque texture");
-            public static GUIContent supportsTerrainHolesText = EditorGUIUtility.TrTextContent("Terrain Holes", "When disabled, Universal Rendering Pipeline removes all Terrain hole Shader variants when you build for the Unity Player. This decreases build time.");
-
-            // Quality
-            public static GUIContent hdrText = EditorGUIUtility.TrTextContent("HDR", "Controls the global HDR settings.");
-            public static GUIContent msaaText = EditorGUIUtility.TrTextContent("Anti Aliasing (MSAA)", "Controls the global anti aliasing settings.");
-            public static GUIContent renderScaleText = EditorGUIUtility.TrTextContent("Render Scale", "Scales the camera render target allowing the game to render at a resolution different than native resolution. UI is always rendered at native resolution.");
-
-            // Main light
-            public static GUIContent mainLightRenderingModeText = EditorGUIUtility.TrTextContent("Main Light", "Main light is the brightest directional light.");
-            public static GUIContent supportsMainLightShadowsText = EditorGUIUtility.TrTextContent("Cast Shadows", "If enabled the main light can be a shadow casting light.");
-            public static GUIContent mainLightShadowmapResolutionText = EditorGUIUtility.TrTextContent("Shadow Resolution", "Resolution of the main light shadowmap texture. If cascades are enabled, cascades will be packed into an atlas and this setting controls the maximum shadows atlas resolution.");
-
-            // Additional lights
-            public static GUIContent addditionalLightsRenderingModeText = EditorGUIUtility.TrTextContent("Additional Lights", "Additional lights support.");
-            public static GUIContent perObjectLimit = EditorGUIUtility.TrTextContent("Per Object Limit", "Maximum amount of additional lights. These lights are sorted and culled per-object.");
-            public static GUIContent supportsAdditionalShadowsText = EditorGUIUtility.TrTextContent("Cast Shadows", "If enabled shadows will be supported for spot lights.\n");
-            public static GUIContent additionalLightsShadowmapResolution = EditorGUIUtility.TrTextContent("Shadow Resolution", "All additional lights are packed into a single shadowmap atlas. This setting controls the atlas size.");
-
-            // Shadow settings
-            public static GUIContent shadowDistanceText = EditorGUIUtility.TrTextContent("Max Distance", "Maximum shadow rendering distance.");
-            public static GUIContent shadowCascadesText = EditorGUIUtility.TrTextContent("Cascade Count", "Number of cascade splits used for directional shadows.");
-            public static GUIContent shadowDepthBias = EditorGUIUtility.TrTextContent("Depth Bias", "Controls the distance at which the shadows will be pushed away from the light. Useful for avoiding false self-shadowing artifacts.");
-            public static GUIContent shadowNormalBias = EditorGUIUtility.TrTextContent("Normal Bias", "Controls distance at which the shadow casting surfaces will be shrunk along the surface normal. Useful for avoiding false self-shadowing artifacts.");
-            public static GUIContent supportsSoftShadows = EditorGUIUtility.TrTextContent("Soft Shadows", "If enabled pipeline will perform shadow filtering. Otherwise all lights that cast shadows will fallback to perform a single shadow sample.");
-
-            // Post-processing
-            public static GUIContent colorGradingMode = EditorGUIUtility.TrTextContent("Grading Mode", "Defines how color grading will be applied. Operators will react differently depending on the mode.");
-            public static GUIContent colorGradingLutSize = EditorGUIUtility.TrTextContent("LUT size", "Sets the size of the internal and external color grading lookup textures (LUTs).");
-            public static string colorGradingModeWarning = "HDR rendering is required to use the high dynamic range color grading mode. The low dynamic range will be used instead.";
-            public static string colorGradingModeSpecInfo = "The high dynamic range color grading mode works best on platforms that support floating point textures.";
-            public static string colorGradingLutSizeWarning = "The minimal recommended LUT size for the high dynamic range color grading mode is 32. Using lower values will potentially result in color banding and posterization effects.";
-
-            // Advanced settings
-            public static GUIContent srpBatcher = EditorGUIUtility.TrTextContent("SRP Batcher", "If enabled, the render pipeline uses the SRP batcher.");
-            public static GUIContent dynamicBatching = EditorGUIUtility.TrTextContent("Dynamic Batching", "If enabled, the render pipeline will batch drawcalls with few triangles together by copying their vertex buffers into a shared buffer on a per-frame basis.");
-            public static GUIContent mixedLightingSupportLabel = EditorGUIUtility.TrTextContent("Mixed Lighting", "Makes the render pipeline include mixed-lighting Shader Variants in the build.");
-            public static GUIContent debugLevel = EditorGUIUtility.TrTextContent("Debug Level", "Controls the level of debug information generated by the render pipeline. When Profiling is selected, the pipeline provides detailed profiling tags.");
-            public static GUIContent shaderVariantLogLevel = EditorGUIUtility.TrTextContent("Shader Variant Log Level", "Controls the level logging in of shader variants information is outputted when a build is performed. Information will appear in the Unity console when the build finishes.");
-            public static GUIContent volumeFrameworkUpdateMode = EditorGUIUtility.TrTextContent("Volume Update Mode", "Select how Unity updates Volumes: every frame or when triggered via scripting. In the Editor, Unity updates Volumes every frame when not in the Play mode.");
-
-            // Adaptive performance settings
-            public static GUIContent useAdaptivePerformance = EditorGUIUtility.TrTextContent("Use adaptive performance", "Allows Adaptive Performance to adjust rendering quality during runtime");
-
-            // Renderer List Messages
-            public static GUIContent rendererListDefaultMessage =
-                EditorGUIUtility.TrTextContent("Cannot remove Default Renderer",
-                    "Removal of the Default Renderer is not allowed. To remove, set another Renderer to be the new Default and then remove.");
-
-            public static GUIContent rendererMissingDefaultMessage =
-                EditorGUIUtility.TrTextContent("Missing Default Renderer\nThere is no default renderer assigned, so Unity can’t perform any rendering. Set another renderer to be the new Default, or assign a renderer to the Default slot.");
-            public static GUIContent rendererMissingMessage =
-                EditorGUIUtility.TrTextContent("Missing Renderer(s)\nOne or more renderers are either missing or unassigned.  Switching to these renderers at runtime can cause issues.");
-            public static GUIContent rendererUnsupportedAPIMessage =
-                EditorGUIUtility.TrTextContent("Some Renderer(s) in the Renderer List are incompatible with the Player Graphics APIs list.  Switching to these renderers at runtime can cause issues.\n\n");
-
-            // Dropdown menu options
-            public static string[] mainLightOptions = { "Disabled", "Per Pixel" };
-            public static string[] volumeFrameworkUpdateOptions = { "Every Frame", "Via Scripting" };
-            public static string[] opaqueDownsamplingOptions = {"None", "2x (Bilinear)", "4x (Box)", "4x (Bilinear)"};
-        }
-
-        SavedBool m_GeneralSettingsFoldout;
-        SavedBool m_QualitySettingsFoldout;
-        SavedBool m_LightingSettingsFoldout;
-        SavedBool m_ShadowSettingsFoldout;
-        SavedBool m_PostProcessingSettingsFoldout;
-        SavedBool m_AdvancedSettingsFoldout;
-        SavedBool m_AdaptivePerformanceFoldout;
-
-=======
     public class UniversalRenderPipelineAssetEditor : Editor
     {
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         SerializedProperty m_RendererDataProp;
         SerializedProperty m_DefaultRendererProp;
 
         internal ReorderableList rendererList => m_RendererDataList;
         ReorderableList m_RendererDataList;
 
-<<<<<<< HEAD
-        SerializedProperty m_RequireDepthTextureProp;
-        SerializedProperty m_RequireOpaqueTextureProp;
-        SerializedProperty m_OpaqueDownsamplingProp;
-        SerializedProperty m_SupportsTerrainHolesProp;
-
-        SerializedProperty m_HDR;
-        SerializedProperty m_MSAA;
-        SerializedProperty m_RenderScale;
-
-        SerializedProperty m_MainLightRenderingModeProp;
-        SerializedProperty m_MainLightShadowsSupportedProp;
-        SerializedProperty m_MainLightShadowmapResolutionProp;
-
-        SerializedProperty m_AdditionalLightsRenderingModeProp;
-        SerializedProperty m_AdditionalLightsPerObjectLimitProp;
-        SerializedProperty m_AdditionalLightShadowsSupportedProp;
-        SerializedProperty m_AdditionalLightShadowmapResolutionProp;
-
-        SerializedProperty m_ShadowDistanceProp;
-        SerializedProperty m_ShadowCascadeCountProp;
-        SerializedProperty m_ShadowCascade2SplitProp;
-        SerializedProperty m_ShadowCascade3SplitProp;
-        SerializedProperty m_ShadowCascade4SplitProp;
-        SerializedProperty m_ShadowDepthBiasProp;
-        SerializedProperty m_ShadowNormalBiasProp;
-
-        SerializedProperty m_SoftShadowsSupportedProp;
-
-        SerializedProperty m_SRPBatcher;
-        SerializedProperty m_SupportsDynamicBatching;
-        SerializedProperty m_MixedLightingSupportedProp;
-        SerializedProperty m_DebugLevelProp;
-
-        SerializedProperty m_ShaderVariantLogLevel;
-        SerializedProperty m_VolumeFrameworkUpdateModeProp;
-
-        LightRenderingMode selectedLightRenderingMode;
-        SerializedProperty m_ColorGradingMode;
-        SerializedProperty m_ColorGradingLutSize;
-
-        SerializedProperty m_UseAdaptivePerformance;
-        EditorPrefBoolFlags<EditorUtils.Unit> m_State;
-=======
         private SerializedUniversalRenderPipelineAsset m_SerializedURPAsset;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
         public override void OnInspectorGUI()
         {
@@ -173,321 +33,6 @@ namespace UnityEditor.Rendering.Universal
         {
             m_RendererDataProp = serializedObject.FindProperty("m_RendererDataList");
             m_DefaultRendererProp = serializedObject.FindProperty("m_DefaultRendererIndex");
-<<<<<<< HEAD
-            m_RendererDataList = new ReorderableList(serializedObject, m_RendererDataProp, true, true, true, true);
-
-            DrawRendererListLayout(m_RendererDataList, m_RendererDataProp);
-
-            m_RequireDepthTextureProp = serializedObject.FindProperty("m_RequireDepthTexture");
-            m_RequireOpaqueTextureProp = serializedObject.FindProperty("m_RequireOpaqueTexture");
-            m_OpaqueDownsamplingProp = serializedObject.FindProperty("m_OpaqueDownsampling");
-            m_SupportsTerrainHolesProp = serializedObject.FindProperty("m_SupportsTerrainHoles");
-
-            m_HDR = serializedObject.FindProperty("m_SupportsHDR");
-            m_MSAA = serializedObject.FindProperty("m_MSAA");
-            m_RenderScale = serializedObject.FindProperty("m_RenderScale");
-
-            m_MainLightRenderingModeProp = serializedObject.FindProperty("m_MainLightRenderingMode");
-            m_MainLightShadowsSupportedProp = serializedObject.FindProperty("m_MainLightShadowsSupported");
-            m_MainLightShadowmapResolutionProp = serializedObject.FindProperty("m_MainLightShadowmapResolution");
-
-            m_AdditionalLightsRenderingModeProp = serializedObject.FindProperty("m_AdditionalLightsRenderingMode");
-            m_AdditionalLightsPerObjectLimitProp = serializedObject.FindProperty("m_AdditionalLightsPerObjectLimit");
-            m_AdditionalLightShadowsSupportedProp = serializedObject.FindProperty("m_AdditionalLightShadowsSupported");
-            m_AdditionalLightShadowmapResolutionProp = serializedObject.FindProperty("m_AdditionalLightsShadowmapResolution");
-
-            m_ShadowDistanceProp = serializedObject.FindProperty("m_ShadowDistance");
-
-            m_ShadowCascadeCountProp = serializedObject.FindProperty("m_ShadowCascadeCount");
-            m_ShadowCascade2SplitProp = serializedObject.FindProperty("m_Cascade2Split");
-            m_ShadowCascade3SplitProp = serializedObject.FindProperty("m_Cascade3Split");
-            m_ShadowCascade4SplitProp = serializedObject.FindProperty("m_Cascade4Split");
-            m_ShadowDepthBiasProp = serializedObject.FindProperty("m_ShadowDepthBias");
-            m_ShadowNormalBiasProp = serializedObject.FindProperty("m_ShadowNormalBias");
-            m_SoftShadowsSupportedProp = serializedObject.FindProperty("m_SoftShadowsSupported");
-
-            m_SRPBatcher = serializedObject.FindProperty("m_UseSRPBatcher");
-            m_SupportsDynamicBatching = serializedObject.FindProperty("m_SupportsDynamicBatching");
-            m_MixedLightingSupportedProp = serializedObject.FindProperty("m_MixedLightingSupported");
-            m_DebugLevelProp = serializedObject.FindProperty("m_DebugLevel");
-
-            m_ShaderVariantLogLevel = serializedObject.FindProperty("m_ShaderVariantLogLevel");
-            m_VolumeFrameworkUpdateModeProp = serializedObject.FindProperty("m_VolumeFrameworkUpdateMode");
-
-            m_ColorGradingMode = serializedObject.FindProperty("m_ColorGradingMode");
-            m_ColorGradingLutSize = serializedObject.FindProperty("m_ColorGradingLutSize");
-
-            m_UseAdaptivePerformance = serializedObject.FindProperty("m_UseAdaptivePerformance");
-
-            selectedLightRenderingMode = (LightRenderingMode)m_AdditionalLightsRenderingModeProp.intValue;
-
-            string Key = "Universal_Shadow_Setting_Unit:UI_State";
-            m_State = new EditorPrefBoolFlags<EditorUtils.Unit>(Key);
-        }
-
-        void DrawGeneralSettings()
-        {
-            m_GeneralSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_GeneralSettingsFoldout.value, Styles.generalSettingsText);
-            if (m_GeneralSettingsFoldout.value)
-            {
-                EditorGUI.indentLevel++;
-
-                EditorGUILayout.Space();
-                EditorGUI.indentLevel--;
-                m_RendererDataList.DoLayoutList();
-                EditorGUI.indentLevel++;
-
-                UniversalRenderPipelineAsset asset = target as UniversalRenderPipelineAsset;
-                string unsupportedGraphicsApisMessage;
-
-                if (!asset.ValidateRendererData(-1))
-                    EditorGUILayout.HelpBox(Styles.rendererMissingDefaultMessage.text, MessageType.Error, true);
-                else if (!asset.ValidateRendererDataList(true))
-                    EditorGUILayout.HelpBox(Styles.rendererMissingMessage.text, MessageType.Warning, true);
-                else if (!ValidateRendererGraphicsAPIs(asset, out unsupportedGraphicsApisMessage))
-                    EditorGUILayout.HelpBox(Styles.rendererUnsupportedAPIMessage.text + unsupportedGraphicsApisMessage, MessageType.Warning, true);
-
-                EditorGUILayout.PropertyField(m_RequireDepthTextureProp, Styles.requireDepthTextureText);
-                EditorGUILayout.PropertyField(m_RequireOpaqueTextureProp, Styles.requireOpaqueTextureText);
-                EditorGUI.indentLevel++;
-                EditorGUI.BeginDisabledGroup(!m_RequireOpaqueTextureProp.boolValue);
-                EditorGUILayout.PropertyField(m_OpaqueDownsamplingProp, Styles.opaqueDownsamplingText);
-                EditorGUI.EndDisabledGroup();
-                EditorGUI.indentLevel--;
-                EditorGUILayout.PropertyField(m_SupportsTerrainHolesProp, Styles.supportsTerrainHolesText);
-                EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawQualitySettings()
-        {
-            m_QualitySettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_QualitySettingsFoldout.value, Styles.qualitySettingsText);
-            if (m_QualitySettingsFoldout.value)
-            {
-                EditorGUI.indentLevel++;
-                EditorGUILayout.PropertyField(m_HDR, Styles.hdrText);
-                EditorGUILayout.PropertyField(m_MSAA, Styles.msaaText);
-                m_RenderScale.floatValue = EditorGUILayout.Slider(Styles.renderScaleText, m_RenderScale.floatValue, UniversalRenderPipeline.minRenderScale, UniversalRenderPipeline.maxRenderScale);
-                EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawLightingSettings()
-        {
-            m_LightingSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_LightingSettingsFoldout.value, Styles.lightingSettingsText);
-            if (m_LightingSettingsFoldout.value)
-            {
-                EditorGUI.indentLevel++;
-
-                // Main Light
-                bool disableGroup = false;
-                EditorGUI.BeginDisabledGroup(disableGroup);
-                CoreEditorUtils.DrawPopup(Styles.mainLightRenderingModeText, m_MainLightRenderingModeProp, Styles.mainLightOptions);
-                EditorGUI.EndDisabledGroup();
-
-                EditorGUI.indentLevel++;
-                disableGroup |= !m_MainLightRenderingModeProp.boolValue;
-
-                EditorGUI.BeginDisabledGroup(disableGroup);
-                EditorGUILayout.PropertyField(m_MainLightShadowsSupportedProp, Styles.supportsMainLightShadowsText);
-                EditorGUI.EndDisabledGroup();
-
-                disableGroup |= !m_MainLightShadowsSupportedProp.boolValue;
-                EditorGUI.BeginDisabledGroup(disableGroup);
-                EditorGUILayout.PropertyField(m_MainLightShadowmapResolutionProp, Styles.mainLightShadowmapResolutionText);
-                EditorGUI.EndDisabledGroup();
-
-                EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
-
-                // Additional light
-                selectedLightRenderingMode = (LightRenderingMode)EditorGUILayout.EnumPopup(Styles.addditionalLightsRenderingModeText, selectedLightRenderingMode);
-                m_AdditionalLightsRenderingModeProp.intValue = (int)selectedLightRenderingMode;
-                EditorGUI.indentLevel++;
-
-                disableGroup = m_AdditionalLightsRenderingModeProp.intValue == (int)LightRenderingMode.Disabled;
-                EditorGUI.BeginDisabledGroup(disableGroup);
-                m_AdditionalLightsPerObjectLimitProp.intValue = EditorGUILayout.IntSlider(Styles.perObjectLimit, m_AdditionalLightsPerObjectLimitProp.intValue, 0, UniversalRenderPipeline.maxPerObjectLights);
-                EditorGUI.EndDisabledGroup();
-
-                disableGroup |= (m_AdditionalLightsPerObjectLimitProp.intValue == 0 || m_AdditionalLightsRenderingModeProp.intValue != (int)LightRenderingMode.PerPixel);
-                EditorGUI.BeginDisabledGroup(disableGroup);
-                EditorGUILayout.PropertyField(m_AdditionalLightShadowsSupportedProp, Styles.supportsAdditionalShadowsText);
-                EditorGUI.EndDisabledGroup();
-
-                disableGroup |= !m_AdditionalLightShadowsSupportedProp.boolValue;
-                EditorGUI.BeginDisabledGroup(disableGroup);
-                EditorGUILayout.PropertyField(m_AdditionalLightShadowmapResolutionProp, Styles.additionalLightsShadowmapResolution);
-                EditorGUI.EndDisabledGroup();
-
-                EditorGUI.indentLevel--;
-                EditorGUI.indentLevel--;
-
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawShadowSettings()
-        {
-            m_ShadowSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_ShadowSettingsFoldout.value, Styles.shadowSettingsText);
-            if (m_ShadowSettingsFoldout.value)
-            {
-                EditorGUI.indentLevel++;
-                m_ShadowDistanceProp.floatValue = Mathf.Max(0.0f, EditorGUILayout.FloatField(Styles.shadowDistanceText, m_ShadowDistanceProp.floatValue));
-                EditorUtils.Unit unit = EditorUtils.Unit.Metric;
-                if (m_ShadowCascadeCountProp.intValue != 0)
-                {
-                    EditorGUI.BeginChangeCheck();
-                    unit = (EditorUtils.Unit)EditorGUILayout.EnumPopup(EditorGUIUtility.TrTextContent("Working Unit", "Except Max Distance which will be still in meter."), m_State.value);
-                    if (EditorGUI.EndChangeCheck())
-                    {
-                        m_State.value = unit;
-                    }
-                }
-
-                UniversalRenderPipelineAsset asset = target as UniversalRenderPipelineAsset;
-                EditorGUILayout.IntSlider(m_ShadowCascadeCountProp, UniversalRenderPipelineAsset.k_ShadowCascadeMinCount, UniversalRenderPipelineAsset.k_ShadowCascadeMaxCount, Styles.shadowCascadesText);
-
-                int cascadeCount = m_ShadowCascadeCountProp.intValue;
-                EditorGUI.indentLevel++;
-                if (cascadeCount == 4)
-                    EditorUtils.DrawCascadeSplitGUI<Vector3>(ref m_ShadowCascade4SplitProp, m_ShadowDistanceProp.floatValue, cascadeCount, unit);
-                else if (cascadeCount == 3)
-                    EditorUtils.DrawCascadeSplitGUI<Vector2>(ref m_ShadowCascade3SplitProp, m_ShadowDistanceProp.floatValue, cascadeCount, unit);
-                else if (cascadeCount == 2)
-                    EditorUtils.DrawCascadeSplitGUI<float>(ref m_ShadowCascade2SplitProp, m_ShadowDistanceProp.floatValue, cascadeCount, unit);
-                else if (cascadeCount == 1)
-                    EditorUtils.DrawCascadeSplitGUI<float>(ref m_ShadowCascade2SplitProp, m_ShadowDistanceProp.floatValue, cascadeCount, unit);
-
-                m_ShadowDepthBiasProp.floatValue = EditorGUILayout.Slider(Styles.shadowDepthBias, m_ShadowDepthBiasProp.floatValue, 0.0f, UniversalRenderPipeline.maxShadowBias);
-                m_ShadowNormalBiasProp.floatValue = EditorGUILayout.Slider(Styles.shadowNormalBias, m_ShadowNormalBiasProp.floatValue, 0.0f, UniversalRenderPipeline.maxShadowBias);
-                EditorGUILayout.PropertyField(m_SoftShadowsSupportedProp, Styles.supportsSoftShadows);
-                EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawPostProcessingSettings()
-        {
-            m_PostProcessingSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_PostProcessingSettingsFoldout.value, Styles.postProcessingSettingsText);
-            if (m_PostProcessingSettingsFoldout.value)
-            {
-                bool isHdrOn = m_HDR.boolValue;
-
-                EditorGUI.indentLevel++;
-
-                EditorGUILayout.PropertyField(m_ColorGradingMode, Styles.colorGradingMode);
-                if (!isHdrOn && m_ColorGradingMode.intValue == (int)ColorGradingMode.HighDynamicRange)
-                    EditorGUILayout.HelpBox(Styles.colorGradingModeWarning, MessageType.Warning);
-                else if (isHdrOn && m_ColorGradingMode.intValue == (int)ColorGradingMode.HighDynamicRange)
-                    EditorGUILayout.HelpBox(Styles.colorGradingModeSpecInfo, MessageType.Info);
-
-                EditorGUILayout.DelayedIntField(m_ColorGradingLutSize, Styles.colorGradingLutSize);
-                m_ColorGradingLutSize.intValue = Mathf.Clamp(m_ColorGradingLutSize.intValue, UniversalRenderPipelineAsset.k_MinLutSize, UniversalRenderPipelineAsset.k_MaxLutSize);
-                if (isHdrOn && m_ColorGradingMode.intValue == (int)ColorGradingMode.HighDynamicRange && m_ColorGradingLutSize.intValue < 32)
-                    EditorGUILayout.HelpBox(Styles.colorGradingLutSizeWarning, MessageType.Warning);
-
-                EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawAdvancedSettings()
-        {
-            m_AdvancedSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_AdvancedSettingsFoldout.value, Styles.advancedSettingsText);
-            if (m_AdvancedSettingsFoldout.value)
-            {
-                EditorGUI.indentLevel++;
-                EditorGUILayout.PropertyField(m_SRPBatcher, Styles.srpBatcher);
-                EditorGUILayout.PropertyField(m_SupportsDynamicBatching, Styles.dynamicBatching);
-                EditorGUILayout.PropertyField(m_MixedLightingSupportedProp, Styles.mixedLightingSupportLabel);
-                EditorGUILayout.PropertyField(m_DebugLevelProp, Styles.debugLevel);
-                EditorGUILayout.PropertyField(m_ShaderVariantLogLevel, Styles.shaderVariantLogLevel);
-                CoreEditorUtils.DrawPopup(Styles.volumeFrameworkUpdateMode, m_VolumeFrameworkUpdateModeProp, Styles.volumeFrameworkUpdateOptions);
-                EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawAdaptivePerformance()
-        {
-            m_AdaptivePerformanceFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_AdaptivePerformanceFoldout.value, Styles.adaptivePerformanceText);
-            if (m_AdaptivePerformanceFoldout.value)
-            {
-                EditorGUI.indentLevel++;
-                EditorGUILayout.PropertyField(m_UseAdaptivePerformance, Styles.useAdaptivePerformance);
-                EditorGUI.indentLevel--;
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawRendererListLayout(ReorderableList list, SerializedProperty prop)
-        {
-           list.drawElementCallback = (Rect rect, int index, bool isActive, bool isFocused) =>
-            {
-                rect.y += 2;
-                Rect indexRect = new Rect(rect.x, rect.y, 14, EditorGUIUtility.singleLineHeight);
-                EditorGUI.LabelField(indexRect, index.ToString());
-                Rect objRect = new Rect(rect.x + indexRect.width, rect.y, rect.width - 134, EditorGUIUtility.singleLineHeight);
-
-                EditorGUI.BeginChangeCheck();
-                EditorGUI.ObjectField(objRect, prop.GetArrayElementAtIndex(index), GUIContent.none);
-                if (EditorGUI.EndChangeCheck())
-                    EditorUtility.SetDirty(target);
-
-                Rect defaultButton = new Rect(rect.width - 75, rect.y, 86, EditorGUIUtility.singleLineHeight);
-                var defaultRenderer = m_DefaultRendererProp.intValue;
-                GUI.enabled = index != defaultRenderer;
-                if (GUI.Button(defaultButton, !GUI.enabled ? Styles.rendererDefaultText : Styles.rendererSetDefaultText))
-                {
-                    m_DefaultRendererProp.intValue = index;
-                    EditorUtility.SetDirty(target);
-                }
-                GUI.enabled = true;
-
-                Rect selectRect = new Rect(rect.x + rect.width - 24, rect.y, 24, EditorGUIUtility.singleLineHeight);
-
-                UniversalRenderPipelineAsset asset = target as UniversalRenderPipelineAsset;
-
-                if (asset.ValidateRendererData(index))
-                {
-                    if (GUI.Button(selectRect, Styles.rendererSettingsText))
-                    {
-                        Selection.SetActiveObjectWithContext(prop.GetArrayElementAtIndex(index).objectReferenceValue,
-                            null);
-                    }
-                }
-                else // Missing ScriptableRendererData
-                {
-                    if (GUI.Button(selectRect, index == defaultRenderer ? Styles.rendererDefaultMissingText : Styles.rendererMissingText))
-                    {
-                        EditorGUIUtility.ShowObjectPicker<ScriptableRendererData>(null, false, null, index);
-                    }
-                }
-
-                // If object selector chose an object, assign it to the correct ScriptableRendererData slot.
-                if (Event.current.commandName == "ObjectSelectorUpdated" && EditorGUIUtility.GetObjectPickerControlID() == index)
-                {
-                    prop.GetArrayElementAtIndex(index).objectReferenceValue = EditorGUIUtility.GetObjectPickerObject();
-                }
-=======
             m_RendererDataList = new ReorderableList(serializedObject, m_RendererDataProp, true, true, true, true)
             {
                 drawElementCallback = OnDrawElement,
@@ -495,7 +40,6 @@ namespace UnityEditor.Rendering.Universal
                 onCanRemoveCallback = reorderableList => reorderableList.count > 1,
                 onRemoveCallback = OnRemoveElement,
                 onReorderCallbackWithDetails = (reorderableList, index, newIndex) => UpdateDefaultRendererValue(index, newIndex) // Need to update the default renderer index
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             };
         }
 
@@ -505,99 +49,14 @@ namespace UnityEditor.Rendering.Universal
             // Checking so that the user is not deleting  the default renderer
             if (reorderableList.index != m_DefaultRendererProp.intValue)
             {
-<<<<<<< HEAD
-                EditorGUI.LabelField(rect, Styles.rendererHeaderText);
-            };
-=======
                 // Need to add the undo to the removal of our assets here, for it to work properly.
                 Undo.RecordObject(target, $"Deleting renderer at index {reorderableList.index}");
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
                 shouldUpdateIndex = true;
                 m_RendererDataProp.DeleteArrayElementAtIndex(reorderableList.index);
             }
             else
             {
-<<<<<<< HEAD
-                bool shouldUpdateIndex = false;
-                // Checking so that the user is not deleting  the default renderer
-                if (li.index != m_DefaultRendererProp.intValue)
-                {
-                    // Need to add the undo to the removal of our assets here, for it to work properly.
-                    Undo.RecordObject(target, $"Deleting renderer at index {li.index}");
-
-                    if (prop.GetArrayElementAtIndex(li.index).objectReferenceValue == null)
-                    {
-                        shouldUpdateIndex = true;
-                    }
-                    prop.DeleteArrayElementAtIndex(li.index);
-                }
-                else
-                {
-                    EditorUtility.DisplayDialog(Styles.rendererListDefaultMessage.text, Styles.rendererListDefaultMessage.tooltip,
-                        "Close");
-                }
-
-                if (shouldUpdateIndex)
-                {
-                    UpdateDefaultRendererValue(li.index);
-                }
-
-                EditorUtility.SetDirty(target);
-            };
-
-            list.onReorderCallbackWithDetails += (reorderableList, index, newIndex) =>
-            {
-                // Need to update the default renderer index
-                UpdateDefaultRendererValue(index, newIndex);
-            };
-        }
-
-        void UpdateDefaultRendererValue(int index)
-        {
-            // If the index that is being removed is lower than the default renderer value,
-            // the default prop value needs to be one lower.
-            if (index < m_DefaultRendererProp.intValue)
-            {
-                m_DefaultRendererProp.intValue--;
-            }
-        }
-
-        void UpdateDefaultRendererValue(int prevIndex, int newIndex)
-        {
-            // If we are moving the index that is the same as the default renderer we need to update that
-            if (prevIndex == m_DefaultRendererProp.intValue)
-            {
-                m_DefaultRendererProp.intValue = newIndex;
-            }
-            // If newIndex is the same as default
-            // then we need to know if newIndex is above or below the default index
-            else if (newIndex == m_DefaultRendererProp.intValue)
-            {
-                m_DefaultRendererProp.intValue += prevIndex > newIndex ? 1 : -1;
-            }
-            // If the old index is lower than default renderer and
-            // the new index is higher then we need to move the default renderer index one lower
-            else if (prevIndex < m_DefaultRendererProp.intValue && newIndex > m_DefaultRendererProp.intValue)
-            {
-                m_DefaultRendererProp.intValue--;
-            }
-            else if (newIndex < m_DefaultRendererProp.intValue && prevIndex > m_DefaultRendererProp.intValue)
-            {
-                m_DefaultRendererProp.intValue++;
-            }
-        }
-        bool ValidateRendererGraphicsAPIs(UniversalRenderPipelineAsset pipelineAsset, out string unsupportedGraphicsApisMessage)
-        {
-            // Check the list of Renderers against all Graphics APIs the player is built with.
-            unsupportedGraphicsApisMessage = null;
-
-            BuildTarget platform = EditorUserBuildSettings.activeBuildTarget;
-            GraphicsDeviceType[] graphicsAPIs = PlayerSettings.GetGraphicsAPIs(platform);
-            int rendererCount = pipelineAsset.m_RendererDataList.Length;
-
-            for (int i = 0; i < rendererCount; i++)
-=======
                 EditorUtility.DisplayDialog(Styles.rendererListDefaultMessage.text, Styles.rendererListDefaultMessage.tooltip, "Close");
             }
 
@@ -625,7 +84,6 @@ namespace UnityEditor.Rendering.Universal
             var defaultRenderer = m_DefaultRendererProp.intValue;
             GUI.enabled = index != defaultRenderer;
             if (GUI.Button(defaultButton, !GUI.enabled ? Styles.rendererDefaultText : Styles.rendererSetDefaultText))
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             {
                 m_DefaultRendererProp.intValue = index;
                 EditorUtility.SetDirty(target);

Editor/UniversalRenderPipelineCameraEditor.cs

@@ -1,979 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using UnityEditor.AnimatedValues;
-using UnityEditor.SceneManagement;
-using UnityEditorInternal;
-using UnityEngine;
-using UnityEngine.Rendering;
-using UnityEngine.Rendering.Universal;
-using Object = UnityEngine.Object;
-
-namespace UnityEditor.Rendering.Universal
-{
-    [CustomEditorForRenderPipeline(typeof(Camera), typeof(UniversalRenderPipelineAsset))]
-    [CanEditMultipleObjects]
-    class UniversalRenderPipelineCameraEditor : CameraEditor
-    {
-        internal enum BackgroundType
-        {
-            Skybox = 0,
-            SolidColor,
-            DontCare,
-        }
-
-        static class Styles
-        {
-            // Groups
-            public static GUIContent commonCameraSettingsText = EditorGUIUtility.TrTextContent("Projection", "These settings control how the camera views the world.");
-            public static GUIContent environmentSettingsText = EditorGUIUtility.TrTextContent("Environment", "These settings control what the camera background looks like.");
-            public static GUIContent outputSettingsText = EditorGUIUtility.TrTextContent("Output", "These settings control how the camera output is formatted.");
-            public static GUIContent renderingSettingsText = EditorGUIUtility.TrTextContent("Rendering", "These settings control for the specific rendering features for this camera.");
-            public static GUIContent stackSettingsText = EditorGUIUtility.TrTextContent("Stack", "The list of overlay cameras assigned to this camera.");
-
-            public static GUIContent backgroundType = EditorGUIUtility.TrTextContent("Background Type", "Controls how to initialize the Camera's background.\n\nSkybox initializes camera with Skybox, defaulting to a background color if no skybox is found.\n\nSolid Color initializes background with the background color.\n\nUninitialized has undefined values for the camera background. Use this only if you are rendering all pixels in the Camera's view.");
-            public static GUIContent cameraType = EditorGUIUtility.TrTextContent("Render Type", "Controls which type of camera this is.");
-            public static GUIContent renderingShadows = EditorGUIUtility.TrTextContent("Render Shadows", "Makes this camera render shadows.");
-            public static GUIContent requireDepthTexture = EditorGUIUtility.TrTextContent("Depth Texture", "On makes this camera create a _CameraDepthTexture, which is a copy of the rendered depth values.\nOff makes the camera not create a depth texture.\nUse Pipeline Settings applies settings from the Render Pipeline Asset.");
-            public static GUIContent requireOpaqueTexture = EditorGUIUtility.TrTextContent("Opaque Texture", "On makes this camera create a _CameraOpaqueTexture, which is a copy of the rendered view.\nOff makes the camera not create an opaque texture.\nUse Pipeline Settings applies settings from the Render Pipeline Asset.");
-            public static GUIContent allowMSAA = EditorGUIUtility.TrTextContent("MSAA", "Use Multi Sample Anti-Aliasing to reduce aliasing.");
-            public static GUIContent allowHDR = EditorGUIUtility.TrTextContent("HDR", "High Dynamic Range gives you a wider range of light intensities, so your lighting looks more realistic. With it, you can still see details and experience less saturation even with bright light.", (Texture) null);
-            public static GUIContent priority = EditorGUIUtility.TrTextContent("Priority", "A camera with a higher priority is drawn on top of a camera with a lower priority [ -100, 100 ].");
-            public static GUIContent clearDepth = EditorGUIUtility.TrTextContent("Clear Depth", "If enabled, depth from the previous camera will be cleared.");
-            public static GUIContent rendererType = EditorGUIUtility.TrTextContent("Renderer", "Controls which renderer this camera uses.");
-
-            public static GUIContent volumesSettingsText = EditorGUIUtility.TrTextContent("Volumes", "These settings define how Volumes affect this Camera.");
-            public static GUIContent volumeLayerMask = EditorGUIUtility.TrTextContent("Mask", "This Camera is only affected by Volumes in the Layers that are assigned to the Camera.");
-            public static GUIContent volumeTrigger = EditorGUIUtility.TrTextContent("Trigger", "A Transform component that acts as a trigger for Volume blending. If none is set, the Camera itself acts as a trigger.");
-            public static GUIContent volumeUpdates = EditorGUIUtility.TrTextContent("Update Mode", "Select how Unity updates Volumes: every frame or when triggered via scripting. In the Editor, Unity updates Volumes every frame when not in the Play mode.");
-
-            public static GUIContent renderPostProcessing = EditorGUIUtility.TrTextContent("Post Processing", "Enable this to make this camera render post-processing effects.");
-            public static GUIContent antialiasing = EditorGUIUtility.TrTextContent("Anti-aliasing", "The anti-aliasing method to use.");
-            public static GUIContent antialiasingQuality = EditorGUIUtility.TrTextContent("Quality", "The quality level to use for the selected anti-aliasing method.");
-            public static GUIContent stopNaN = EditorGUIUtility.TrTextContent("Stop NaN", "Automatically replaces NaN/Inf in shaders by a black pixel to avoid breaking some effects. This will affect performances and should only be used if you experience NaN issues that you can't fix. Has no effect on GLES2 platforms.");
-            public static GUIContent dithering = EditorGUIUtility.TrTextContent("Dithering", "Applies 8-bit dithering to the final render to reduce color banding.");
-
-#if ENABLE_VR && ENABLE_XR_MODULE
-            public static GUIContent[] xrTargetEyeOptions =
-            {
-                new GUIContent("None"),
-                new GUIContent("Both"),
-            };
-            public static int[] xrTargetEyeValues = { 0, 1 };
-            public static readonly GUIContent xrTargetEye = EditorGUIUtility.TrTextContent("Target Eye", "Allows XR rendering if target eye sets to both eye. Disable XR for this camera otherwise.");
-#endif
-            public static readonly GUIContent targetTextureLabel = EditorGUIUtility.TrTextContent("Output Texture", "The texture to render this camera into, if none then this camera renders to screen.");
-
-            public static readonly string hdrDisabledWarning = "HDR rendering is disabled in the Universal Render Pipeline asset.";
-            public static readonly string mssaDisabledWarning = "Anti-aliasing is disabled in the Universal Render Pipeline asset.";
-
-            public static readonly string missingRendererWarning = "The currently selected Renderer is missing from the Universal Render Pipeline asset.";
-            public static readonly string noRendererError = "There are no valid Renderers available on the Universal Render Pipeline asset.";
-
-            public static GUIContent[] cameraBackgroundType =
-            {
-                new GUIContent("Skybox"),
-                new GUIContent("Solid Color"),
-                new GUIContent("Uninitialized"),
-            };
-
-            public static int[] cameraBackgroundValues = { 0, 1, 2};
-
-            // Using the pipeline Settings
-            public static GUIContent[] displayedCameraOptions =
-            {
-                new GUIContent("Off"),
-                new GUIContent("Use Pipeline Settings"),
-            };
-
-            public static int[] cameraOptions = { 0, 1 };
-
-            // Camera Types
-            public static List<GUIContent> m_CameraTypeNames = null;
-            public static readonly string[] cameraTypeNames = Enum.GetNames(typeof(CameraRenderType));
-
-            // Beautified anti-aliasing options
-            public static GUIContent[] antialiasingOptions =
-            {
-                new GUIContent("None"),
-                new GUIContent("Fast Approximate Anti-aliasing (FXAA)"),
-                new GUIContent("Subpixel Morphological Anti-aliasing (SMAA)"),
-            };
-            public static int[] antialiasingValues = { 0, 1, 2};
-        }
-
-        ReorderableList m_LayerList;
-
-        public Camera camera { get { return target as Camera; } }
-        static List<Camera> k_Cameras;
-
-        List<Camera> validCameras = new List<Camera>();
-        // This is the valid list of types, so if we need to add more types we just add it here.
-        List<CameraRenderType> validCameraTypes = new List<CameraRenderType>{CameraRenderType.Overlay};
-        List<Camera> errorCameras = new List<Camera>();
-        Texture2D m_ErrorIcon;
-
-        // Temporary saved bools for foldout header
-        SavedBool m_CommonCameraSettingsFoldout;
-        SavedBool m_EnvironmentSettingsFoldout;
-        SavedBool m_OutputSettingsFoldout;
-        SavedBool m_RenderingSettingsFoldout;
-        SavedBool m_StackSettingsFoldout;
-
-        // Animation Properties
-        public bool isSameClearFlags { get { return !settings.clearFlags.hasMultipleDifferentValues; } }
-        public bool isSameOrthographic { get { return !settings.orthographic.hasMultipleDifferentValues; } }
-
-        Dictionary<Object, UniversalAdditionalCameraData> m_AdditionalCameraDatas = new Dictionary<Object, UniversalAdditionalCameraData>();
-        SerializedObject m_AdditionalCameraDataSO;
-
-        readonly AnimBool m_ShowBGColorAnim = new AnimBool();
-        readonly AnimBool m_ShowOrthoAnim = new AnimBool();
-        readonly AnimBool m_ShowTargetEyeAnim = new AnimBool();
-
-        SerializedProperty m_AdditionalCameraDataRenderShadowsProp;
-        SerializedProperty m_AdditionalCameraDataRenderDepthProp;
-        SerializedProperty m_AdditionalCameraDataRenderOpaqueProp;
-        SerializedProperty m_AdditionalCameraDataRendererProp;
-        SerializedProperty m_AdditionalCameraDataCameraTypeProp;
-		SerializedProperty m_AdditionalCameraDataCameras;
-        SerializedProperty m_AdditionalCameraDataVolumeLayerMask;
-        SerializedProperty m_AdditionalCameraDataVolumeTrigger;
-        SerializedProperty m_AdditionalCameraDataVolumeFrameworkUpdateMode;
-        SerializedProperty m_AdditionalCameraDataRenderPostProcessing;
-        SerializedProperty m_AdditionalCameraDataAntialiasing;
-        SerializedProperty m_AdditionalCameraDataAntialiasingQuality;
-        SerializedProperty m_AdditionalCameraDataStopNaN;
-        SerializedProperty m_AdditionalCameraDataDithering;
-        SerializedProperty m_AdditionalCameraClearDepth;
-#if ENABLE_VR && ENABLE_XR_MODULE
-        SerializedProperty m_AdditionalCameraDataAllowXRRendering;
-#endif
-        void SetAnimationTarget(AnimBool anim, bool initialize, bool targetValue)
-        {
-            if (initialize)
-            {
-                anim.value = targetValue;
-                anim.valueChanged.AddListener(Repaint);
-            }
-            else
-            {
-                anim.target = targetValue;
-            }
-        }
-
-        void UpdateAnimationValues(bool initialize)
-        {
-            SetAnimationTarget(m_ShowBGColorAnim, initialize, isSameClearFlags && (camera.clearFlags == CameraClearFlags.SolidColor || camera.clearFlags == CameraClearFlags.Skybox));
-            SetAnimationTarget(m_ShowOrthoAnim, initialize, isSameOrthographic && camera.orthographic);
-            SetAnimationTarget(m_ShowTargetEyeAnim, initialize, settings.targetEye.intValue != (int)StereoTargetEyeMask.Both);
-        }
-
-        void UpdateCameraTypeIntPopupData()
-        {
-            if (Styles.m_CameraTypeNames == null)
-            {
-                Styles.m_CameraTypeNames = new List<GUIContent>();
-                foreach (string typeName in Styles.cameraTypeNames)
-                {
-                    Styles.m_CameraTypeNames.Add(new GUIContent(typeName));
-                }
-            }
-        }
-
-        public new void OnEnable()
-        {
-            base.OnEnable();
-
-            m_CommonCameraSettingsFoldout = new SavedBool($"{target.GetType()}.CommonCameraSettingsFoldout", false);
-            m_EnvironmentSettingsFoldout = new SavedBool($"{target.GetType()}.EnvironmentSettingsFoldout", false);
-            m_OutputSettingsFoldout = new SavedBool($"{target.GetType()}.OutputSettingsFoldout", false);
-            m_RenderingSettingsFoldout = new SavedBool($"{target.GetType()}.RenderingSettingsFoldout", false);
-            m_StackSettingsFoldout = new SavedBool($"{target.GetType()}.StackSettingsFoldout", false);
-
-            var additionalCameraList = new List<Object>();
-            foreach (var cameraTarget in targets)
-            {
-                var additionData = (cameraTarget as Component).gameObject.GetComponent<UniversalAdditionalCameraData>();
-                if(additionData == null)
-                    additionData = (cameraTarget as Component).gameObject.AddComponent<UniversalAdditionalCameraData>();
-                m_AdditionalCameraDatas[cameraTarget] = additionData;
-                additionalCameraList.Add(additionData);
-            }
-            m_ErrorIcon = EditorGUIUtility.Load("icons/console.erroricon.sml.png") as Texture2D;
-            validCameras.Clear();
-            errorCameras.Clear();
-            settings.OnEnable();
-
-            init(additionalCameraList);
-
-            UpdateAnimationValues(true);
-            UpdateCameraTypeIntPopupData();
-
-            UpdateCameras();
-        }
-        void UpdateCameras()
-        {
-            var o = new PropertyFetcher<UniversalAdditionalCameraData>(m_AdditionalCameraDataSO);
-            m_AdditionalCameraDataCameras = o.Find("m_Cameras");
-
-            var camType = (CameraRenderType)m_AdditionalCameraDataCameraTypeProp.intValue;
-            if (camType == CameraRenderType.Base)
-            {
-                m_LayerList = new ReorderableList(m_AdditionalCameraDataSO, m_AdditionalCameraDataCameras, true, false, true, true);
-
-                m_LayerList.drawElementCallback += DrawElementCallback;
-                m_LayerList.onSelectCallback += SelectElement;
-                m_LayerList.onRemoveCallback = list =>
-                {
-                    m_AdditionalCameraDataCameras.DeleteArrayElementAtIndex(list.index);
-                    ReorderableList.defaultBehaviours.DoRemoveButton(list);
-                    m_AdditionalCameraDataSO.ApplyModifiedProperties();
-                };
-
-                m_LayerList.onAddDropdownCallback = (rect, list) => AddCameraToCameraList(rect, list);
-            }
-        }
-
-        void SelectElement(ReorderableList list)
-        {
-            var element = m_AdditionalCameraDataCameras.GetArrayElementAtIndex(list.index);
-            var cam = element.objectReferenceValue as Camera;
-            if (Event.current.clickCount == 2)
-            {
-                Selection.activeObject = cam;
-            }
-
-            EditorGUIUtility.PingObject(cam);
-        }
-
-        static GUIContent s_TextImage = new GUIContent();
-        static GUIContent TempContent(string text, string tooltip, Texture i)
-        {
-            s_TextImage.image = i;
-            s_TextImage.text = text;
-            s_TextImage.tooltip = tooltip;
-            return s_TextImage;
-        }
-
-        GUIContent m_NameContent = new GUIContent();
-
-        void DrawElementCallback(Rect rect, int index, bool isActive, bool isFocused)
-        {
-            rect.height = EditorGUIUtility.singleLineHeight;
-            rect.y += 1;
-
-            var element = m_AdditionalCameraDataCameras.GetArrayElementAtIndex(index);
-
-            var cam = element.objectReferenceValue as Camera;
-            if (cam != null)
-            {
-                bool warning = false;
-                string warningInfo = "";
-                var type = cam.gameObject.GetComponent<UniversalAdditionalCameraData>().renderType;
-                if (!validCameraTypes.Contains(type))
-                {
-                    warning = true;
-                    warningInfo += "Not a supported type";
-                    if (!errorCameras.Contains(cam))
-                    {
-                        errorCameras.Add(cam);
-                    }
-                }
-                else if (errorCameras.Contains(cam))
-                {
-                    errorCameras.Remove(cam);
-                }
-
-                var labelWidth = EditorGUIUtility.labelWidth;
-                EditorGUIUtility.labelWidth -= 20f;
-                if (warning)
-                {
-                    GUIStyle errorStyle = new GUIStyle(EditorStyles.label) { padding = new RectOffset { left = -16 } };
-                    m_NameContent.text = cam.name;
-                    EditorGUI.LabelField(rect, m_NameContent, TempContent(type.GetName(), warningInfo, m_ErrorIcon), errorStyle);
-                }
-                else
-                {
-                    EditorGUI.LabelField(rect, cam.name, type.ToString());
-
-                    // Printing if Post Processing is on or not.
-                    var isPostActive = cam.gameObject.GetComponent<UniversalAdditionalCameraData>().renderPostProcessing;
-                    if (isPostActive)
-                    {
-                        Rect selectRect = new Rect(rect.width - 20, rect.y, 50, EditorGUIUtility.singleLineHeight);
-
-                        EditorGUI.LabelField(selectRect, "PP");
-                    }
-                }
-
-                EditorGUIUtility.labelWidth = labelWidth;
-            }
-            else
-            {
-                camera.GetComponent<UniversalAdditionalCameraData>().UpdateCameraStack();
-
-                // Need to clean out the errorCamera list here.
-                errorCameras.Clear();
-            }
-        }
-
-        // Modified version of StageHandle.FindComponentsOfType<T>()
-        // This version more closely represents unity object referencing restrictions.
-        // I added these restrictions:
-        // - Can not reference scene object outside scene
-        // - Can not reference cross scenes
-        // - Can reference child objects if it is prefab
-        Camera[] FindCamerasToReference(GameObject gameObject)
-        {
-            var scene = gameObject.scene;
-
-            var inScene = !EditorUtility.IsPersistent(camera) || scene.IsValid();
-            var inPreviewScene = EditorSceneManager.IsPreviewScene(scene) && scene.IsValid();
-            var inCurrentScene = !EditorUtility.IsPersistent(camera) && scene.IsValid();
-
-            Camera[] cameras = Resources.FindObjectsOfTypeAll<Camera>();
-            List<Camera> result = new List<Camera>();
-            if (!inScene)
-            {
-                foreach (var camera in cameras)
-                {
-                    if (camera.transform.IsChildOf(gameObject.transform))
-                        result.Add(camera);
-                }
-            }
-            else if (inPreviewScene)
-            {
-                foreach (var camera in cameras)
-                {
-                    if (camera.gameObject.scene == scene)
-                        result.Add(camera);
-                }
-            }
-            else if (inCurrentScene)
-            {
-                foreach (var camera in cameras)
-                {
-                    if (!EditorUtility.IsPersistent(camera) && !EditorSceneManager.IsPreviewScene(camera.gameObject.scene) && camera.gameObject.scene == scene)
-                        result.Add(camera);
-                }
-            }
-
-            return result.ToArray();
-        }
-
-        void AddCameraToCameraList(Rect rect, ReorderableList list)
-        {
-            // Need to do clear the list here otherwise the meu just fills up with more and more entries
-            validCameras.Clear();
-            var allCameras = FindCamerasToReference(camera.gameObject);
-            foreach (var camera in allCameras)
-            {
-                var component = camera.gameObject.GetComponent<UniversalAdditionalCameraData>();
-                if (component != null)
-                {
-                    if (validCameraTypes.Contains(component.renderType))
-                    {
-                        validCameras.Add(camera);
-                    }
-                }
-            }
-
-            var names = new GUIContent[validCameras.Count];
-            for (int i = 0; i < validCameras.Count; ++i)
-            {
-                names[i] = new GUIContent((i+1) + " " + validCameras[i].name);
-            }
-
-            if (!validCameras.Any())
-            {
-                names = new GUIContent[1];
-                names[0] = new GUIContent("No Overlay Cameras exist.");
-            }
-            EditorUtility.DisplayCustomMenu(rect, names, -1, AddCameraToCameraListMenuSelected, null);
-        }
-
-        void AddCameraToCameraListMenuSelected(object userData, string[] options, int selected)
-        {
-            if(!validCameras.Any())
-                return;
-
-            var length = m_AdditionalCameraDataCameras.arraySize;
-            ++m_AdditionalCameraDataCameras.arraySize;
-            m_AdditionalCameraDataCameras.serializedObject.ApplyModifiedProperties();
-            m_AdditionalCameraDataCameras.GetArrayElementAtIndex(length).objectReferenceValue = validCameras[selected];
-            m_AdditionalCameraDataCameras.serializedObject.ApplyModifiedProperties();
-        }
-
-        void init(List<Object> additionalCameraData)
-        {
-            if(additionalCameraData == null)
-                return;
-
-            m_AdditionalCameraDataSO = new SerializedObject(additionalCameraData.ToArray());
-            m_AdditionalCameraDataRenderShadowsProp = m_AdditionalCameraDataSO.FindProperty("m_RenderShadows");
-            m_AdditionalCameraDataRenderDepthProp = m_AdditionalCameraDataSO.FindProperty("m_RequiresDepthTextureOption");
-            m_AdditionalCameraDataRenderOpaqueProp = m_AdditionalCameraDataSO.FindProperty("m_RequiresOpaqueTextureOption");
-            m_AdditionalCameraDataRendererProp = m_AdditionalCameraDataSO.FindProperty("m_RendererIndex");
-            m_AdditionalCameraDataVolumeLayerMask = m_AdditionalCameraDataSO.FindProperty("m_VolumeLayerMask");
-            m_AdditionalCameraDataVolumeTrigger = m_AdditionalCameraDataSO.FindProperty("m_VolumeTrigger");
-            m_AdditionalCameraDataVolumeFrameworkUpdateMode = m_AdditionalCameraDataSO.FindProperty("m_VolumeFrameworkUpdateModeOption");
-            m_AdditionalCameraDataRenderPostProcessing = m_AdditionalCameraDataSO.FindProperty("m_RenderPostProcessing");
-            m_AdditionalCameraDataAntialiasing = m_AdditionalCameraDataSO.FindProperty("m_Antialiasing");
-            m_AdditionalCameraDataAntialiasingQuality = m_AdditionalCameraDataSO.FindProperty("m_AntialiasingQuality");
-            m_AdditionalCameraDataStopNaN = m_AdditionalCameraDataSO.FindProperty("m_StopNaN");
-            m_AdditionalCameraDataDithering = m_AdditionalCameraDataSO.FindProperty("m_Dithering");
-            m_AdditionalCameraClearDepth = m_AdditionalCameraDataSO.FindProperty("m_ClearDepth");
-            m_AdditionalCameraDataCameraTypeProp = m_AdditionalCameraDataSO.FindProperty("m_CameraType");
-            m_AdditionalCameraDataCameras = m_AdditionalCameraDataSO.FindProperty("m_Cameras");
-#if ENABLE_VR && ENABLE_XR_MODULE
-            m_AdditionalCameraDataAllowXRRendering = m_AdditionalCameraDataSO.FindProperty("m_AllowXRRendering");
-#endif
-        }
-
-        public new void OnDisable()
-        {
-            base.OnDisable();
-            m_ShowBGColorAnim.valueChanged.RemoveListener(Repaint);
-            m_ShowOrthoAnim.valueChanged.RemoveListener(Repaint);
-            m_ShowTargetEyeAnim.valueChanged.RemoveListener(Repaint);
-        }
-
-        BackgroundType GetBackgroundType(CameraClearFlags clearFlags)
-        {
-            switch (clearFlags)
-            {
-                case CameraClearFlags.Skybox:
-                    return BackgroundType.Skybox;
-                case CameraClearFlags.Nothing:
-                    return BackgroundType.DontCare;
-
-                // DepthOnly is not supported by design in UniversalRP. We upgrade it to SolidColor
-                default:
-                    return BackgroundType.SolidColor;
-            }
-        }
-
-        public override void OnInspectorGUI()
-        {
-            var rpAsset = UniversalRenderPipeline.asset;
-            if(rpAsset == null)
-			{
-                base.OnInspectorGUI();
-                return;
-			}
-
-            settings.Update();
-            m_AdditionalCameraDataSO.Update();
-            UpdateAnimationValues(false);
-
-            // Get the type of Camera we are using
-            CameraRenderType camType = (CameraRenderType)m_AdditionalCameraDataCameraTypeProp.intValue;
-
-            DrawCameraType();
-
-            EditorGUILayout.Space();
-            // If we have different cameras selected that are of different types we do not allow multi editing and we do not draw any more UI.
-            if (m_AdditionalCameraDataCameraTypeProp.hasMultipleDifferentValues)
-            {
-                EditorGUILayout.HelpBox("Cannot multi edit cameras of different types.", MessageType.Info);
-                return;
-            }
-
-            EditorGUI.indentLevel++;
-
-            DrawCommonSettings();
-            DrawRenderingSettings(camType, rpAsset);
-            DrawEnvironmentSettings(camType);
-
-            // Settings only relevant to base cameras
-            if (camType == CameraRenderType.Base)
-            {
-                DrawOutputSettings(rpAsset);
-                DrawStackSettings();
-            }
-
-            EditorGUI.indentLevel--;
-	        settings.ApplyModifiedProperties();
-            m_AdditionalCameraDataSO.ApplyModifiedProperties();
-        }
-
-        void DrawCommonSettings()
-        {
-            m_CommonCameraSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_CommonCameraSettingsFoldout.value, Styles.commonCameraSettingsText);
-            if (m_CommonCameraSettingsFoldout.value)
-            {
-                settings.DrawProjection();
-                settings.DrawClippingPlanes();
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawStackSettings()
-        {
-            m_StackSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_StackSettingsFoldout.value, Styles.stackSettingsText);
-            if (m_AdditionalCameraDataCameras.hasMultipleDifferentValues)
-            {
-                EditorGUILayout.HelpBox("Cannot multi edit stack of multiple cameras.", MessageType.Info);
-                EditorGUILayout.EndFoldoutHeaderGroup();
-                return;
-            }
-
-            ScriptableRenderer.RenderingFeatures supportedRenderingFeatures = m_AdditionalCameraDatas[target]?.scriptableRenderer?.supportedRenderingFeatures;
-
-            if (supportedRenderingFeatures != null && supportedRenderingFeatures.cameraStacking == false)
-            {
-                EditorGUILayout.HelpBox("The renderer used by this camera doesn't support camera stacking. Only Base camera will render.", MessageType.Warning);
-                return;
-            }
-
-            if (m_StackSettingsFoldout.value)
-            {
-                m_LayerList.DoLayoutList();
-                m_AdditionalCameraDataSO.ApplyModifiedProperties();
-
-                if (errorCameras.Any())
-                {
-                    string errorString = "These cameras are not of a valid type:\n";
-                    string validCameras = "";
-                    foreach (var errorCamera in errorCameras)
-                    {
-                        errorString += errorCamera.name + "\n";
-                    }
-
-                    foreach (var validCameraType in validCameraTypes)
-                    {
-                        validCameras += validCameraType + "  ";
-                    }
-                    errorString += "Valid types are " + validCameras;
-                    EditorGUILayout.HelpBox(errorString, MessageType.Warning);
-                }
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawEnvironmentSettings(CameraRenderType camType)
-        {
-            m_EnvironmentSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_EnvironmentSettingsFoldout.value, Styles.environmentSettingsText);
-            if (m_EnvironmentSettingsFoldout.value)
-            {
-                if (camType == CameraRenderType.Base)
-                {
-                    DrawClearFlags();
-                    if (!settings.clearFlags.hasMultipleDifferentValues)
-                    {
-                        if (GetBackgroundType((CameraClearFlags)settings.clearFlags.intValue) == BackgroundType.SolidColor)
-                        {
-                            using (var group = new EditorGUILayout.FadeGroupScope(m_ShowBGColorAnim.faded))
-                            {
-                                if (group.visible)
-                                {
-                                    settings.DrawBackgroundColor();
-                                }
-                            }
-                        }
-                    }
-                }
-                DrawVolumes();
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawRenderingSettings(CameraRenderType camType, UniversalRenderPipelineAsset rpAsset)
-        {
-            m_RenderingSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_RenderingSettingsFoldout.value, Styles.renderingSettingsText);
-            if (m_RenderingSettingsFoldout.value)
-            {
-                DrawRenderer(rpAsset);
-
-                if (camType == CameraRenderType.Base)
-                {
-                    DrawPostProcessing();
-                }
-                else if (camType == CameraRenderType.Overlay)
-                {
-                    DrawPostProcessingOverlay();
-                    EditorGUILayout.PropertyField(m_AdditionalCameraClearDepth, Styles.clearDepth);
-                    m_AdditionalCameraDataSO.ApplyModifiedProperties();
-                }
-
-                DrawRenderShadows();
-
-                if (camType == CameraRenderType.Base)
-                {
-                    DrawPriority();
-                    DrawOpaqueTexture();
-                    DrawDepthTexture();
-                }
-
-                settings.DrawCullingMask();
-                settings.DrawOcclusionCulling();
-
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawPostProcessingOverlay()
-        {
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataRenderPostProcessing, Styles.renderPostProcessing);
-        }
-
-        void DrawOutputSettings(UniversalRenderPipelineAsset rpAsset)
-        {
-            m_OutputSettingsFoldout.value = EditorGUILayout.BeginFoldoutHeaderGroup(m_OutputSettingsFoldout.value, Styles.outputSettingsText);
-            if (m_OutputSettingsFoldout.value)
-            {
-                DrawTargetTexture(rpAsset);
-
-                if (camera.targetTexture == null)
-                {
-                    DrawHDR();
-                    DrawMSAA();
-                    settings.DrawNormalizedViewPort();
-                    settings.DrawDynamicResolution();
-                    settings.DrawMultiDisplay();
-                }
-                else
-                {
-                    settings.DrawNormalizedViewPort();
-                }
-#if ENABLE_VR && ENABLE_XR_MODULE
-                DrawXRRendering();
-#endif
-                EditorGUILayout.Space();
-                EditorGUILayout.Space();
-            }
-            EditorGUILayout.EndFoldoutHeaderGroup();
-        }
-
-        void DrawCameraType()
-        {
-            EditorGUI.BeginChangeCheck();
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataCameraTypeProp, Styles.cameraType);
-            if (EditorGUI.EndChangeCheck())
-            {
-                UpdateCameras();
-
-                // ScriptableRenderContext.SetupCameraProperties still depends on camera target texture
-                // In order for overlay camera not to override base camera target texture we null it here
-                CameraRenderType camType = (CameraRenderType)m_AdditionalCameraDataCameraTypeProp.intValue;
-                if (camType == CameraRenderType.Overlay && settings.targetTexture.objectReferenceValue != null)
-                    settings.targetTexture.objectReferenceValue = null;
-            }
-        }
-
-        void DrawClearFlags()
-        {
-            // Converts between ClearFlags and Background Type.
-            BackgroundType backgroundType = GetBackgroundType((CameraClearFlags) settings.clearFlags.intValue);
-            EditorGUI.showMixedValue = settings.clearFlags.hasMultipleDifferentValues;
-
-            EditorGUI.BeginChangeCheck();
-            Rect controlRect = EditorGUILayout.GetControlRect(true);
-            EditorGUI.BeginProperty(controlRect, Styles.backgroundType, settings.clearFlags);
-
-            BackgroundType selectedType = (BackgroundType)EditorGUI.IntPopup(controlRect, Styles.backgroundType, (int)backgroundType,
-                Styles.cameraBackgroundType, Styles.cameraBackgroundValues);
-            EditorGUI.EndProperty();
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                CameraClearFlags selectedClearFlags;
-                switch (selectedType)
-                {
-                    case BackgroundType.Skybox:
-                        selectedClearFlags = CameraClearFlags.Skybox;
-                        break;
-
-                    case BackgroundType.DontCare:
-                        selectedClearFlags = CameraClearFlags.Nothing;
-                        break;
-
-                    default:
-                        selectedClearFlags = CameraClearFlags.SolidColor;
-                        break;
-                }
-
-                settings.clearFlags.intValue = (int) selectedClearFlags;
-            }
-        }
-
-        void DrawPriority()
-        {
-            EditorGUILayout.PropertyField(settings.depth, Styles.priority);
-        }
-
-        void DrawHDR()
-        {
-            Rect controlRect = EditorGUILayout.GetControlRect(true);
-            EditorGUI.BeginProperty(controlRect, Styles.allowHDR, settings.HDR);
-            int selectedValue = !settings.HDR.boolValue ? 0 : 1;
-            settings.HDR.boolValue = EditorGUI.IntPopup(controlRect, Styles.allowHDR, selectedValue, Styles.displayedCameraOptions, Styles.cameraOptions) == 1;
-            EditorGUI.EndProperty();
-        }
-
-        void DrawMSAA()
-        {
-            Rect controlRect = EditorGUILayout.GetControlRect(true);
-            EditorGUI.BeginProperty(controlRect, Styles.allowMSAA, settings.allowMSAA);
-            int selectedValue = !settings.allowMSAA.boolValue ? 0 : 1;
-            settings.allowMSAA.boolValue = EditorGUI.IntPopup(controlRect, Styles.allowMSAA, selectedValue, Styles.displayedCameraOptions, Styles.cameraOptions) == 1;
-            EditorGUI.EndProperty();
-        }
-
-#if ENABLE_VR && ENABLE_XR_MODULE
-        void DrawXRRendering()
-        {
-            Rect controlRect = EditorGUILayout.GetControlRect(true);
-            EditorGUI.BeginProperty(controlRect, Styles.xrTargetEye, m_AdditionalCameraDataAllowXRRendering);
-            int selectedValue = !m_AdditionalCameraDataAllowXRRendering.boolValue ? 0 : 1;
-            m_AdditionalCameraDataAllowXRRendering.boolValue = EditorGUI.IntPopup(controlRect, Styles.xrTargetEye, selectedValue, Styles.xrTargetEyeOptions, Styles.xrTargetEyeValues) == 1;
-            EditorGUI.EndProperty();
-        }
-#endif
-
-        void DrawTargetTexture(UniversalRenderPipelineAsset rpAsset)
-        {
-            EditorGUILayout.PropertyField(settings.targetTexture, Styles.targetTextureLabel);
-
-            if (!settings.targetTexture.hasMultipleDifferentValues && rpAsset != null)
-            {
-                var texture = settings.targetTexture.objectReferenceValue as RenderTexture;
-                int pipelineSamplesCount = rpAsset.msaaSampleCount;
-
-                if (texture && texture.antiAliasing > pipelineSamplesCount)
-                {
-                    string pipelineMSAACaps = (pipelineSamplesCount > 1)
-                        ? String.Format("is set to support {0}x", pipelineSamplesCount)
-                        : "has MSAA disabled";
-                    EditorGUILayout.HelpBox(String.Format("Camera target texture requires {0}x MSAA. Universal pipeline {1}.", texture.antiAliasing, pipelineMSAACaps),
-                        MessageType.Warning, true);
-                }
-            }
-        }
-
-        void DrawVolumes()
-        {
-            // Display the Volume Update mode, LayerMask and Trigger
-            LayerMask selectedVolumeLayerMask = m_AdditionalCameraDataVolumeLayerMask.intValue;
-            Transform selectedVolumeTrigger = (Transform)m_AdditionalCameraDataVolumeTrigger.objectReferenceValue;
-
-            EditorGUILayout.LabelField(Styles.volumesSettingsText, EditorStyles.boldLabel);
-
-            EditorGUI.indentLevel++;
-
-            EditorGUI.BeginChangeCheck();
-            DrawLayerMask(m_AdditionalCameraDataVolumeLayerMask, ref selectedVolumeLayerMask, Styles.volumeLayerMask);
-            DrawObjectField(m_AdditionalCameraDataVolumeTrigger, ref selectedVolumeTrigger, Styles.volumeTrigger);
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataVolumeFrameworkUpdateMode, Styles.volumeUpdates);
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_AdditionalCameraDataVolumeLayerMask.intValue = selectedVolumeLayerMask;
-                m_AdditionalCameraDataVolumeTrigger.objectReferenceValue = selectedVolumeTrigger;
-
-                VolumeFrameworkUpdateMode curVolumeUpdateMode = (VolumeFrameworkUpdateMode)m_AdditionalCameraDataVolumeFrameworkUpdateMode.intValue;
-                camera.SetVolumeFrameworkUpdateMode(curVolumeUpdateMode);
-
-                m_AdditionalCameraDataSO.ApplyModifiedProperties();
-            }
-            EditorGUI.indentLevel--;
-        }
-
-        void DrawRenderer(UniversalRenderPipelineAsset rpAsset)
-        {
-            int selectedRendererOption = m_AdditionalCameraDataRendererProp.intValue;
-            EditorGUI.BeginChangeCheck();
-
-            Rect controlRect = EditorGUILayout.GetControlRect(true);
-            EditorGUI.BeginProperty(controlRect, Styles.rendererType, m_AdditionalCameraDataRendererProp);
-
-            EditorGUI.showMixedValue = m_AdditionalCameraDataRendererProp.hasMultipleDifferentValues;
-            int selectedRenderer = EditorGUI.IntPopup(controlRect, Styles.rendererType, selectedRendererOption, rpAsset.rendererDisplayList, UniversalRenderPipeline.asset.rendererIndexList);
-            EditorGUI.EndProperty();
-            if (!rpAsset.ValidateRendererDataList())
-            {
-                EditorGUILayout.HelpBox(Styles.noRendererError, MessageType.Error);
-            }
-            else if (!rpAsset.ValidateRendererData(selectedRendererOption))
-            {
-                EditorGUILayout.HelpBox(Styles.missingRendererWarning, MessageType.Warning);
-                var rect = EditorGUI.IndentedRect(EditorGUILayout.GetControlRect());
-                if (GUI.Button(rect, "Select Render Pipeline Asset"))
-                {
-                    Selection.activeObject = AssetDatabase.LoadAssetAtPath<UniversalRenderPipelineAsset>(AssetDatabase.GetAssetPath(UniversalRenderPipeline.asset));
-                }
-                GUILayout.Space(5);
-            }
-
-            if (EditorGUI.EndChangeCheck())
-            {
-                m_AdditionalCameraDataRendererProp.intValue = selectedRenderer;
-                m_AdditionalCameraDataSO.ApplyModifiedProperties();
-            }
-        }
-
-        void DrawPostProcessing()
-        {
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataRenderPostProcessing, Styles.renderPostProcessing);
-
-            // Draw Final Post-processing
-            DrawIntPopup(m_AdditionalCameraDataAntialiasing, Styles.antialiasing, Styles.antialiasingOptions, Styles.antialiasingValues);
-
-            // If AntiAliasing has mixed value we do not draw the sub menu
-            if (m_AdditionalCameraDataAntialiasing.hasMultipleDifferentValues)
-            {
-                return;
-            }
-
-            var selectedAntialiasing = (AntialiasingMode)m_AdditionalCameraDataAntialiasing.intValue;
-
-            if (selectedAntialiasing == AntialiasingMode.SubpixelMorphologicalAntiAliasing)
-            {
-                EditorGUI.indentLevel++;
-                EditorGUILayout.PropertyField(m_AdditionalCameraDataAntialiasingQuality, Styles.antialiasingQuality);
-                if (CoreEditorUtils.buildTargets.Contains(GraphicsDeviceType.OpenGLES2))
-                    EditorGUILayout.HelpBox("Sub-pixel Morphological Anti-Aliasing isn't supported on GLES2 platforms.", MessageType.Warning);
-                EditorGUI.indentLevel--;
-            }
-
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataStopNaN, Styles.stopNaN);
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataDithering, Styles.dithering);
-        }
-
-        bool DrawLayerMask(SerializedProperty prop, ref LayerMask mask, GUIContent style)
-        {
-            var layers = InternalEditorUtility.layers;
-            bool hasChanged = false;
-            var controlRect = BeginProperty(prop, style);
-
-            EditorGUI.BeginChangeCheck();
-
-            // LayerMask needs to be converted to be used in a MaskField...
-            int field = 0;
-            for (int c = 0; c < layers.Length; c++)
-                if ((mask & (1 << LayerMask.NameToLayer(layers[c]))) != 0)
-                    field |= 1 << c;
-
-            field = EditorGUI.MaskField(controlRect, style, field, InternalEditorUtility.layers);
-            if (EditorGUI.EndChangeCheck())
-                hasChanged = true;
-
-            // ...and converted back.
-            mask = 0;
-            for (int c = 0; c < layers.Length; c++)
-                if ((field & (1 << c)) != 0)
-                    mask |= 1 << LayerMask.NameToLayer(layers[c]);
-
-            EndProperty();
-            return hasChanged;
-        }
-
-        bool DrawObjectField<T>(SerializedProperty prop, ref T value, GUIContent style)
-            where T : Object
-        {
-            var defaultVal = value;
-            bool hasChanged = false;
-            var controlRect = BeginProperty(prop, style);
-
-            EditorGUI.BeginChangeCheck();
-            value = (T)EditorGUI.ObjectField(controlRect, style, value, typeof(T), true);
-            if (EditorGUI.EndChangeCheck() && !Equals(defaultVal, value))
-            {
-                hasChanged = true;
-            }
-
-            EndProperty();
-            return hasChanged;
-		}
-
-        void DrawDepthTexture()
-        {
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataRenderDepthProp, Styles.requireDepthTexture);
-        }
-
-        void DrawOpaqueTexture()
-        {
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataRenderOpaqueProp, Styles.requireOpaqueTexture);
-        }
-
-        void DrawIntPopup(SerializedProperty prop, GUIContent style, GUIContent[] optionNames, int[] optionValues)
-        {
-            var controlRect = BeginProperty(prop, style);
-
-            EditorGUI.BeginChangeCheck();
-            var value = EditorGUI.IntPopup(controlRect, style, prop.intValue, optionNames, optionValues);
-            if (EditorGUI.EndChangeCheck())
-            {
-                prop.intValue = value;
-            }
-
-            EndProperty();
-        }
-
-        Rect BeginProperty(SerializedProperty prop, GUIContent style)
-        {
-            var controlRect = EditorGUILayout.GetControlRect(true);
-            EditorGUI.BeginProperty(controlRect, style, prop);
-            return controlRect;
-		}
-
-        void DrawRenderShadows()
-        {
-            EditorGUILayout.PropertyField(m_AdditionalCameraDataRenderShadowsProp, Styles.renderingShadows);
-        }
-
-        void EndProperty()
-        {
-            if (m_AdditionalCameraDataSO != null)
-                EditorGUI.EndProperty();
-        }
-    }
-
-    [ScriptableRenderPipelineExtension(typeof(UniversalRenderPipelineAsset))]
-    class UniversalRenderPipelineCameraContextualMenu : IRemoveAdditionalDataContextualMenu<Camera>
-    {
-        //The call is delayed to the dispatcher to solve conflict with other SRP
-        public void RemoveComponent(Camera camera, IEnumerable<Component> dependencies)
-        {
-            // do not use keyword is to remove the additional data. It will not work
-            dependencies = dependencies.Where(c => c.GetType() != typeof(UniversalAdditionalCameraData));
-            if (dependencies.Any())
-            {
-                EditorUtility.DisplayDialog("Can't remove component", $"Can't remove Camera because {dependencies.First().GetType().Name} depends on it.", "Ok");
-                return;
-            }
-
-            var isAssetEditing = EditorUtility.IsPersistent(camera);
-            try
-            {
-                if (isAssetEditing)
-                {
-                    AssetDatabase.StartAssetEditing();
-                }
-                Undo.SetCurrentGroupName("Remove Universal Camera");
-                var additionalCameraData = camera.GetComponent<UniversalAdditionalCameraData>();
-                if (additionalCameraData != null)
-                {
-                    Undo.DestroyObjectImmediate(additionalCameraData);
-                }
-                Undo.DestroyObjectImmediate(camera);
-            }
-            finally
-            {
-                if (isAssetEditing)
-                {
-                    AssetDatabase.StopAssetEditing();
-                }
-            }
-        }
-    }
-}

Editor/UniversalRenderPipelineLightEditor.cs

@@ -8,82 +8,7 @@ namespace UnityEditor.Rendering.Universal
     [CustomEditorForRenderPipeline(typeof(Light), typeof(UniversalRenderPipelineAsset))]
     class UniversalRenderPipelineLightEditor : LightEditor
     {
-<<<<<<< HEAD
-        AnimBool m_AnimSpotOptions = new AnimBool();
-        AnimBool m_AnimPointOptions = new AnimBool();
-        AnimBool m_AnimDirOptions = new AnimBool();
-        AnimBool m_AnimAreaOptions = new AnimBool();
-        AnimBool m_AnimRuntimeOptions = new AnimBool();
-        AnimBool m_AnimShadowOptions = new AnimBool();
-        AnimBool m_AnimShadowAngleOptions = new AnimBool();
-        AnimBool m_AnimShadowRadiusOptions = new AnimBool();
-        AnimBool m_AnimLightBounceIntensity = new AnimBool();
-
-        class Styles
-        {
-            public readonly GUIContent SpotAngle = EditorGUIUtility.TrTextContent("Spot Angle", "Controls the angle in degrees at the base of a Spot light's cone.");
-
-            public readonly GUIContent BakingWarning = EditorGUIUtility.TrTextContent("Light mode is currently overridden to Realtime mode. Enable Baked Global Illumination to use Mixed or Baked light modes.");
-            public readonly GUIContent DisabledLightWarning = EditorGUIUtility.TrTextContent("Lighting has been disabled in at least one Scene view. Any changes applied to lights in the Scene will not be updated in these views until Lighting has been enabled again.");
-            public readonly GUIContent SunSourceWarning = EditorGUIUtility.TrTextContent("This light is set as the current Sun Source, which requires a directional light. Go to the Lighting Window's Environment settings to edit the Sun Source.");
-
-            public readonly GUIContent ShadowsNotSupportedWarning = EditorGUIUtility.TrTextContent("Realtime shadows for point lights are not supported. Either disable shadows or set the light mode to Baked.");
-            public static readonly GUIContent ShadowRealtimeSettings = EditorGUIUtility.TrTextContent("Realtime Shadows", "Settings for realtime direct shadows.");
-            public static readonly GUIContent ShadowStrength = EditorGUIUtility.TrTextContent("Strength", "Controls how dark the shadows cast by the light will be.");
-            public static readonly GUIContent ShadowNearPlane = EditorGUIUtility.TrTextContent("Near Plane", "Controls the value for the near clip plane when rendering shadows. Currently clamped to 0.1 units or 1% of the lights range property, whichever is lower.");
-
-            public static GUIContent shadowBias = EditorGUIUtility.TrTextContent("Bias", "Select if the Bias should use the settings from the Pipeline Asset or Custom settings.");
-            public static int[] optionDefaultValues = { 0, 1 };
-
-            public static GUIContent[] displayedDefaultOptions =
-            {
-                new GUIContent("Custom"),
-                new GUIContent("Use Pipeline Settings")
-            };
-        }
-
-        static Styles s_Styles;
-
-        public bool typeIsSame { get { return !settings.lightType.hasMultipleDifferentValues; } }
-        public bool shadowTypeIsSame { get { return !settings.shadowsType.hasMultipleDifferentValues; } }
-        public bool lightmappingTypeIsSame { get { return !settings.lightmapping.hasMultipleDifferentValues; } }
-        public Light lightProperty { get { return target as Light; } }
-
-        public bool spotOptionsValue { get { return typeIsSame && lightProperty.type == LightType.Spot; } }
-        public bool pointOptionsValue { get { return typeIsSame && lightProperty.type == LightType.Point; } }
-        public bool dirOptionsValue { get { return typeIsSame && lightProperty.type == LightType.Directional; } }
-        public bool areaOptionsValue { get { return typeIsSame && (lightProperty.type == LightType.Rectangle || lightProperty.type == LightType.Disc); } }
-
-        // Point light realtime shadows not supported
-        public bool runtimeOptionsValue { get { return typeIsSame && (lightProperty.type != LightType.Rectangle && lightProperty.type != LightType.Point && !settings.isCompletelyBaked); } }
-        public bool bakedShadowRadius { get { return typeIsSame && (lightProperty.type == LightType.Point || lightProperty.type == LightType.Spot) && settings.isBakedOrMixed; } }
-        public bool bakedShadowAngle { get { return typeIsSame && lightProperty.type == LightType.Directional && settings.isBakedOrMixed; } }
-        public bool shadowOptionsValue { get { return shadowTypeIsSame && lightProperty.shadows != LightShadows.None; } }
-#pragma warning disable 618
-        public bool bakingWarningValue { get { return !UnityEditor.Lightmapping.bakedGI && lightmappingTypeIsSame && settings.isBakedOrMixed; } }
-#pragma warning restore 618
-        public bool showLightBounceIntensity { get { return true; } }
-
-        public bool isShadowEnabled { get { return settings.shadowsType.intValue != 0; } }
-
-        public bool realtimeShadowsWarningValue
-        {
-            get
-            {
-                return typeIsSame && lightProperty.type == LightType.Point &&
-                    shadowTypeIsSame && isShadowEnabled &&
-                    lightmappingTypeIsSame && !settings.isCompletelyBaked;
-            }
-        }
-
-        UniversalAdditionalLightData m_AdditionalLightData;
-        SerializedObject m_AdditionalLightDataSO;
-
-        SerializedProperty m_UseAdditionalDataProp;
-
-=======
         UniversalRenderPipelineSerializedLight serializedLight { get; set; }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
         protected override void OnEnable()
         {
@@ -101,73 +26,7 @@ namespace UnityEditor.Rendering.Universal
         {
             serializedLight.Update();
 
-<<<<<<< HEAD
-            settings.Update();
-
-            // Update AnimBool options. For properties changed they will be smoothly interpolated.
-            UpdateShowOptions(false);
-
-            settings.DrawLightType();
-
-            Light light = target as Light;
-            if (LightType.Directional != light.type && light == RenderSettings.sun)
-            {
-                EditorGUILayout.HelpBox(s_Styles.SunSourceWarning.text, MessageType.Warning);
-            }
-
-            EditorGUILayout.Space();
-
-            // When we are switching between two light types that don't show the range (directional and area lights)
-            // we want the fade group to stay hidden.
-            using (var group = new EditorGUILayout.FadeGroupScope(1.0f - m_AnimDirOptions.faded))
-                if (group.visible)
-                #if UNITY_2020_1_OR_NEWER
-                    settings.DrawRange();
-                #else
-                    settings.DrawRange(m_AnimAreaOptions.target);
-                #endif
-
-            // Spot angle
-            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimSpotOptions.faded))
-                if (group.visible)
-                    DrawSpotAngle();
-
-            // Area width & height
-            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimAreaOptions.faded))
-                if (group.visible)
-                    settings.DrawArea();
-
-            settings.DrawColor();
-
-            EditorGUILayout.Space();
-
-            CheckLightmappingConsistency();
-            using (var group = new EditorGUILayout.FadeGroupScope(1.0f - m_AnimAreaOptions.faded))
-                if (group.visible)
-                {
-                    if (light.type != LightType.Disc)
-                    {
-                        settings.DrawLightmapping();
-                    }
-                }
-
-            settings.DrawIntensity();
-
-            using (var group = new EditorGUILayout.FadeGroupScope(m_AnimLightBounceIntensity.faded))
-                if (group.visible)
-                    settings.DrawBounceIntensity();
-
-            ShadowsGUI();
-
-            settings.DrawRenderMode();
-            settings.DrawCullingMask();
-
-            EditorGUILayout.Space();
-
-            if (SceneView.lastActiveSceneView != null )
-=======
             if (IsPresetEditor(this))
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             {
                 UniversalRenderPipelineLightUI.PresetInspector.Draw(serializedLight, this);
             }
@@ -176,99 +35,7 @@ namespace UnityEditor.Rendering.Universal
                 UniversalRenderPipelineLightUI.Inspector.Draw(serializedLight, this);
             }
 
-<<<<<<< HEAD
-            Rect controlRectAdditionalData = EditorGUILayout.GetControlRect(true);
-            if(m_AdditionalLightDataSO != null)
-                EditorGUI.BeginProperty(controlRectAdditionalData, Styles.shadowBias, m_UseAdditionalDataProp);
-            EditorGUI.BeginChangeCheck();
-
-            selectedUseAdditionalData = EditorGUI.IntPopup(controlRectAdditionalData, Styles.shadowBias, selectedUseAdditionalData, Styles.displayedDefaultOptions, Styles.optionDefaultValues);
-            if (EditorGUI.EndChangeCheck())
-            {
-                hasChanged = true;
-            }
-            if(m_AdditionalLightDataSO != null)
-                EditorGUI.EndProperty();
-
-            if (selectedUseAdditionalData != 1 && m_AdditionalLightDataSO != null)
-            {
-                EditorGUI.indentLevel++;
-                EditorGUILayout.Slider(settings.shadowsBias, 0f, 10f, "Depth");
-                EditorGUILayout.Slider(settings.shadowsNormalBias, 0f, 10f, "Normal");
-                EditorGUI.indentLevel--;
-
-                m_AdditionalLightDataSO.ApplyModifiedProperties();
-            }
-
-            if (hasChanged)
-            {
-                if (m_AdditionalLightDataSO == null)
-                {
-                    lightProperty.gameObject.AddComponent<UniversalAdditionalLightData>();
-                    m_AdditionalLightData = lightProperty.gameObject.GetComponent<UniversalAdditionalLightData>();
-
-                    var asset = UniversalRenderPipeline.asset;
-                    settings.shadowsBias.floatValue = asset.shadowDepthBias;
-                    settings.shadowsNormalBias.floatValue = asset.shadowNormalBias;
-
-                    init(m_AdditionalLightData);
-                }
-
-                m_UseAdditionalDataProp.intValue = selectedUseAdditionalData;
-                m_AdditionalLightDataSO.ApplyModifiedProperties();
-            }
-        }
-
-        void ShadowsGUI()
-        {
-            // Shadows drop-down. Area lights can only be baked and always have shadows.
-            float show = 1.0f - m_AnimAreaOptions.faded;
-
-			settings.DrawShadowsType();
-
-            EditorGUI.indentLevel += 1;
-            show *= m_AnimShadowOptions.faded;
-            // Baked Shadow radius
-            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimShadowRadiusOptions.faded))
-                if (group.visible)
-                    settings.DrawBakedShadowRadius();
-
-            // Baked Shadow angle
-            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimShadowAngleOptions.faded))
-                if (group.visible)
-                    settings.DrawBakedShadowAngle();
-
-            // Runtime shadows - shadow strength, resolution and near plane offset
-            // Bias is handled differently in UniversalRP
-            using (var group = new EditorGUILayout.FadeGroupScope(show * m_AnimRuntimeOptions.faded))
-            {
-                if (group.visible)
-                {
-                    EditorGUILayout.LabelField(Styles.ShadowRealtimeSettings);
-                    EditorGUI.indentLevel += 1;
-                    EditorGUILayout.Slider(settings.shadowsStrength, 0f, 1f, Styles.ShadowStrength);
-
-                    DrawAdditionalShadowData();
-
-                    // this min bound should match the calculation in SharedLightData::GetNearPlaneMinBound()
-                    float nearPlaneMinBound = Mathf.Min(0.01f * settings.range.floatValue, 0.1f);
-                    EditorGUILayout.Slider(settings.shadowsNearPlane, nearPlaneMinBound, 10.0f, Styles.ShadowNearPlane);
-                    EditorGUI.indentLevel -= 1;
-                }
-            }
-
-            EditorGUI.indentLevel -= 1;
-
-            if (bakingWarningValue)
-                EditorGUILayout.HelpBox(s_Styles.BakingWarning.text, MessageType.Warning);
-
-            if (realtimeShadowsWarningValue)
-                EditorGUILayout.HelpBox(s_Styles.ShadowsNotSupportedWarning.text, MessageType.Warning);
-
-            EditorGUILayout.Space();
-=======
             serializedLight.Apply();
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
 
         protected override void OnSceneGUI()

Runtime/2D/Passes/PixelPerfectBackgroundPass.cs

@@ -1,11 +1,4 @@
-<<<<<<< HEAD
-using UnityEngine.Rendering;
-using UnityEngine.Rendering.Universal;
-
-namespace UnityEngine.Experimental.Rendering.Universal
-=======
 namespace UnityEngine.Rendering.Universal
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 {
     // Only to be used when Pixel Perfect Camera is present and it has Crop Frame X or Y enabled.
     // This pass simply clears BuiltinRenderTextureType.CameraTarget to black, so that the letterbox or pillarbox is black instead of garbage.
@@ -13,26 +6,20 @@ namespace UnityEngine.Rendering.Universal
     internal class PixelPerfectBackgroundPass : ScriptableRenderPass
     {
         private static readonly ProfilingSampler m_ProfilingScope = new ProfilingSampler("Pixel Perfect Background Pass");
-<<<<<<< HEAD
-=======
         private bool m_SavedIsOrthographic;
         private float m_SavedOrthographicSize;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
         public PixelPerfectBackgroundPass(RenderPassEvent evt)
         {
             renderPassEvent = evt;
         }
 
-<<<<<<< HEAD
-=======
         public void Setup(bool savedIsOrthographic, float savedOrthographicSize)
         {
             m_SavedIsOrthographic = savedIsOrthographic;
             m_SavedOrthographicSize = savedOrthographicSize;
         }
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
         {
             var cmd = CommandBufferPool.Get();
@@ -48,17 +35,12 @@ namespace UnityEngine.Rendering.Universal
                     Color.black);
             }
 
-<<<<<<< HEAD
-            context.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
-=======
 
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
 
             renderingData.cameraData.camera.orthographic = m_SavedIsOrthographic;
             renderingData.cameraData.camera.orthographicSize = m_SavedOrthographicSize;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
     }
 }

Runtime/2D/Passes/Render2DLightingPass.cs

@@ -72,8 +72,6 @@ namespace UnityEngine.Rendering.Universal
                     sortingSettings.distanceMetric = DistanceMetric.CustomAxis;
                     sortingSettings.customAxis = m_Renderer2DData.transparencySortAxis;
                     break;
-<<<<<<< HEAD
-=======
             }
         }
 
@@ -150,7 +148,6 @@ namespace UnityEngine.Rendering.Universal
             {
                 resolveDuringBatch = lastVolumetricLightBatch;
                 resolveIsAfterCopy = false;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             }
         }
 
@@ -390,12 +387,9 @@ namespace UnityEngine.Rendering.Universal
             else
             {
                 var unlitDrawSettings = CreateDrawingSettings(k_ShaderTags, ref renderingData, SortingCriteria.CommonTransparent);
-<<<<<<< HEAD
-=======
                 var msaaEnabled = renderingData.cameraData.cameraTargetDescriptor.msaaSamples > 1;
                 var storeAction = msaaEnabled ? RenderBufferStoreAction.Resolve : RenderBufferStoreAction.Store;
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                 var sortSettings = unlitDrawSettings.sortingSettings;
                 GetTransparencySortingMode(camera, ref sortSettings);
                 unlitDrawSettings.sortingSettings = sortSettings;

Runtime/2D/PixelPerfectCamera.cs

@@ -279,15 +279,6 @@ namespace UnityEngine.Experimental.Rendering.Universal
             }
         }
 
-        Vector2Int cameraRTSize
-        {
-            get
-            {
-                var targetTexture = m_Camera.targetTexture;
-                return targetTexture == null ? new Vector2Int(Screen.width, Screen.height) : new Vector2Int(targetTexture.width, targetTexture.height);
-            }
-        }
-
         // Snap camera position to pixels using Camera.worldToCameraMatrix.
         void PixelSnap()
         {
@@ -305,24 +296,12 @@ namespace UnityEngine.Experimental.Rendering.Universal
             m_Camera = GetComponent<Camera>();
             m_Internal = new PixelPerfectCameraInternal(this);
 
-<<<<<<< HEAD
-            m_Internal.originalOrthoSize = m_Camera.orthographicSize;
-
-            // Case 1249076: Initialize internals immediately after the scene is loaded,
-            // as the Cinemachine extension may need them before OnBeginContextRendering is called.
-            var rtSize = cameraRTSize;
-            m_Internal.CalculateCameraProperties(rtSize.x, rtSize.y);
-        }
-
-        void OnBeginFrameRendering(ScriptableRenderContext context, Camera[] cameras)
-=======
             // Case 1249076: Initialize internals immediately after the scene is loaded,
             // as the Cinemachine extension may need them before OnBeginContextRendering is called.
             UpdateCameraProperties();
         }
 
         void UpdateCameraProperties()
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         {
             var rtSize = cameraRTSize;
             m_Internal.CalculateCameraProperties(rtSize.x, rtSize.y);
@@ -337,16 +316,6 @@ namespace UnityEngine.Experimental.Rendering.Universal
         {
             if (camera == m_Camera)
             {
-<<<<<<< HEAD
-                m_Camera.orthographicSize = m_Internal.orthoSize;
-            }
-        }
-
-        void OnBeginCameraRendering(ScriptableRenderContext context, Camera camera)
-        {
-            if (camera == m_Camera)
-                UnityEngine.U2D.PixelPerfectRendering.pixelSnapSpacing = m_Internal.unitsPerPixel;
-=======
                 UpdateCameraProperties();
                 PixelSnap();
 
@@ -357,7 +326,6 @@ namespace UnityEngine.Experimental.Rendering.Universal
 
                 UnityEngine.U2D.PixelPerfectRendering.pixelSnapSpacing = m_Internal.unitsPerPixel;
             }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
 
         void OnEndCameraRendering(ScriptableRenderContext context, Camera camera)
@@ -370,14 +338,12 @@ namespace UnityEngine.Experimental.Rendering.Universal
         {
             m_CinemachineCompatibilityMode = false;
 
-            RenderPipelineManager.beginFrameRendering += OnBeginFrameRendering;
             RenderPipelineManager.beginCameraRendering += OnBeginCameraRendering;
             RenderPipelineManager.endCameraRendering += OnEndCameraRendering;
         }
 
         internal void OnDisable()
         {
-            RenderPipelineManager.beginFrameRendering -= OnBeginFrameRendering;
             RenderPipelineManager.beginCameraRendering -= OnBeginCameraRendering;
             RenderPipelineManager.endCameraRendering -= OnEndCameraRendering;
 

Runtime/2D/Renderer2D.cs

@@ -6,10 +6,6 @@ namespace UnityEngine.Rendering.Universal
     internal class Renderer2D : ScriptableRenderer
     {
         Render2DLightingPass m_Render2DLightingPass;
-<<<<<<< HEAD
-        PostProcessPass m_PostProcessPass;
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         PixelPerfectBackgroundPass m_PixelPerfectBackgroundPass;
         FinalBlitPass m_FinalBlitPass;
         Light2DCullResult m_LightCullResult;
@@ -43,14 +39,7 @@ namespace UnityEngine.Rendering.Universal
             m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.blitShader);
             m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.samplingShader);
 
-<<<<<<< HEAD
-            m_ColorGradingLutPass = new ColorGradingLutPass(RenderPassEvent.BeforeRenderingOpaques, data.postProcessData);
-            m_Render2DLightingPass = new Render2DLightingPass(data);
-            m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing, data.postProcessData, m_BlitMaterial);
-            m_FinalPostProcessPass = new PostProcessPass(RenderPassEvent.AfterRenderingPostProcessing, data.postProcessData, m_BlitMaterial);
-=======
             m_Render2DLightingPass = new Render2DLightingPass(data, m_BlitMaterial, m_SamplingMaterial);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             // we should determine why clearing the camera target is set so late in the events... sounds like it could be earlier
             m_PixelPerfectBackgroundPass = new PixelPerfectBackgroundPass(RenderPassEvent.AfterRenderingTransparents);
             m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering + 1, m_BlitMaterial);
@@ -153,8 +142,6 @@ namespace UnityEngine.Rendering.Universal
             bool ppcUsesOffscreenRT = false;
             bool ppcUpscaleRT = false;
 
-<<<<<<< HEAD
-=======
             bool savedIsOrthographic = renderingData.cameraData.camera.orthographic;
             float savedOrthographicSize = renderingData.cameraData.camera.orthographicSize;
 
@@ -170,7 +157,6 @@ namespace UnityEngine.Rendering.Universal
                 DebugHandler.Setup(context, ref cameraData);
             }
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #if UNITY_EDITOR
             // The scene view camera cannot be uninitialized or skybox when using the 2D renderer.
             if (cameraData.cameraType == CameraType.SceneView)
@@ -261,14 +247,7 @@ namespace UnityEngine.Rendering.Universal
                 colorTargetHandle = postProcessDestHandle;
             }
 
-<<<<<<< HEAD
-            if (ppc != null && ppc.isRunning && (ppc.cropFrameX || ppc.cropFrameY))
-                EnqueuePass(m_PixelPerfectBackgroundPass);
-
-            if (requireFinalPostProcessPass)
-=======
             if (ppc != null && ppc.enabled && (ppc.cropFrame == PixelPerfectCamera.CropFrame.Pillarbox || ppc.cropFrame == PixelPerfectCamera.CropFrame.Letterbox || ppc.cropFrame == PixelPerfectCamera.CropFrame.Windowbox || ppc.cropFrame == PixelPerfectCamera.CropFrame.StretchFill))
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             {
                 m_PixelPerfectBackgroundPass.Setup(savedIsOrthographic, savedOrthographicSize);
                 EnqueuePass(m_PixelPerfectBackgroundPass);

Runtime/Data/UniversalRenderPipelineAsset.cs

@@ -112,8 +112,6 @@ namespace UnityEngine.Rendering.Universal
     }
 
     /// <summary>
-<<<<<<< HEAD
-=======
     /// Defines if Unity discards or stores the render targets of the DrawObjects Passes. Selecting the Store option significantly increases the memory bandwidth on mobile and tile-based GPUs.
     /// </summary>
     public enum StoreActionsOptimization
@@ -127,7 +125,6 @@ namespace UnityEngine.Rendering.Universal
     }
 
     /// <summary>
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     /// Defines the update frequency for the Volume Framework.
     /// </summary>
     public enum VolumeFrameworkUpdateMode
@@ -140,8 +137,6 @@ namespace UnityEngine.Rendering.Universal
         UsePipelineSettings = 2,
     }
 
-<<<<<<< HEAD
-=======
     /// <summary>
     /// Defines the upscaling filter selected by the user the universal render pipeline asset.
     /// </summary>
@@ -157,7 +152,6 @@ namespace UnityEngine.Rendering.Universal
         FSR
     }
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     [ExcludeFromPreset]
     public partial class UniversalRenderPipelineAsset : RenderPipelineAsset, ISerializationCallbackReceiver
     {

Runtime/DeferredLights.cs

@@ -462,47 +462,12 @@ namespace UnityEngine.Rendering.Universal.Internal
             // Cachre result for DX10 platform too. Same reasons as above.
             DeferredConfig.IsDX10 = SystemInfo.graphicsDeviceType == GraphicsDeviceType.Direct3D11 && SystemInfo.graphicsShaderLevel <= 40;
 
-<<<<<<< HEAD
-            if (m_TileDeferredMaterial != null)
-            {
-                m_TileDeferredMaterial.SetInt(ShaderConstants._LitStencilRef, (int)StencilUsage.MaterialLit);
-                m_TileDeferredMaterial.SetInt(ShaderConstants._LitStencilReadMask, (int)StencilUsage.MaterialMask);
-                m_TileDeferredMaterial.SetInt(ShaderConstants._LitStencilWriteMask, 0);
-                m_TileDeferredMaterial.SetInt(ShaderConstants._SimpleLitStencilRef, (int)StencilUsage.MaterialSimpleLit);
-                m_TileDeferredMaterial.SetInt(ShaderConstants._SimpleLitStencilReadMask, (int)StencilUsage.MaterialMask);
-                m_TileDeferredMaterial.SetInt(ShaderConstants._SimpleLitStencilWriteMask, 0);
-            }
-
-
-            if (m_StencilDeferredMaterial != null)
-            {
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._StencilRef, (int)StencilUsage.MaterialUnlit);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._StencilReadMask, (int)StencilUsage.MaterialMask);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._StencilWriteMask, (int)StencilUsage.StencilLight);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._LitPunctualStencilRef, (int)StencilUsage.StencilLight | (int)StencilUsage.MaterialLit);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._LitPunctualStencilReadMask, (int)StencilUsage.StencilLight | (int)StencilUsage.MaterialMask);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._LitPunctualStencilWriteMask, (int)StencilUsage.StencilLight);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._SimpleLitPunctualStencilRef, (int)StencilUsage.StencilLight | (int)StencilUsage.MaterialSimpleLit);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._SimpleLitPunctualStencilReadMask, (int)StencilUsage.StencilLight | (int)StencilUsage.MaterialMask);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._SimpleLitPunctualStencilWriteMask, (int)StencilUsage.StencilLight);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._LitDirStencilRef, (int)StencilUsage.MaterialLit);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._LitDirStencilReadMask, (int)StencilUsage.MaterialMask);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._LitDirStencilWriteMask, 0);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._SimpleLitDirStencilRef, (int)StencilUsage.MaterialSimpleLit);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._SimpleLitDirStencilReadMask, (int)StencilUsage.MaterialMask);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._SimpleLitDirStencilWriteMask, 0);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._ClearStencilRef, 0);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._ClearStencilReadMask, (int)StencilUsage.MaterialMask);
-                m_StencilDeferredMaterial.SetInt(ShaderConstants._ClearStencilWriteMask, (int)StencilUsage.MaterialMask);
-            }
-=======
             m_TileDepthInfoMaterial = initParams.tileDepthInfoMaterial;
             m_TileDeferredMaterial = initParams.tileDeferredMaterial;
             m_StencilDeferredMaterial = initParams.stencilDeferredMaterial;
 
             m_TileDeferredPasses = new int[k_TileDeferredPassNames.Length];
             InitTileDeferredMaterial();
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
             m_StencilDeferredPasses = new int[k_StencilDeferredPassNames.Length];
             InitStencilDeferredMaterial();
@@ -1396,8 +1361,6 @@ namespace UnityEngine.Rendering.Universal.Internal
                 return;
             }
 
-<<<<<<< HEAD
-=======
             // Workaround for bug.
             // When changing the URP asset settings (ex: shadow cascade resolution), all ScriptableRenderers are recreated but
             // materials passed in have not finished initializing at that point if they have fallback shader defined. In particular deferred shaders only have 1 pass available,
@@ -1405,7 +1368,6 @@ namespace UnityEngine.Rendering.Universal.Internal
             if (m_TileDeferredPasses[0] < 0)
                 InitTileDeferredMaterial();
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             Profiler.BeginSample(k_DeferredTiledPass);
 
             // Allow max 256 draw calls for rendering all the batches of tiles

Runtime/ForwardRenderer.cs

@@ -1,818 +0,0 @@
-using UnityEngine.Rendering.Universal.Internal;
-using System.Reflection;
-
-namespace UnityEngine.Rendering.Universal
-{
-    /// <summary>
-    /// Rendering modes for Universal renderer.
-    /// </summary>
-    public enum RenderingMode
-    {
-        /// <summary>Render all objects and lighting in one pass, with a hard limit on the number of lights that can be applied on an object.</summary>
-        Forward,
-        /// <summary>Render all objects first in a g-buffer pass, then apply all lighting in a separate pass using deferred shading.</summary>
-        Deferred
-    };
-
-    /// <summary>
-    /// Default renderer for Universal RP.
-    /// This renderer is supported on all Universal RP supported platforms.
-    /// It uses a classic forward rendering strategy with per-object light culling.
-    /// </summary>
-    public sealed class ForwardRenderer : ScriptableRenderer
-    {
-        const int k_DepthStencilBufferBits = 32;
-
-        private static class Profiling
-        {
-            private const string k_Name = nameof(ForwardRenderer);
-            public static readonly ProfilingSampler createCameraRenderTarget = new ProfilingSampler($"{k_Name}.{nameof(CreateCameraRenderTarget)}");
-        }
-
-        // Rendering mode setup from UI.
-        internal RenderingMode renderingMode { get { return RenderingMode.Forward;  } }
-        // Actual rendering mode, which may be different (ex: wireframe rendering, harware not capable of deferred rendering).
-        internal RenderingMode actualRenderingMode { get { return GL.wireframe || m_DeferredLights == null || !m_DeferredLights.IsRuntimeSupportedThisFrame()  ? RenderingMode.Forward : this.renderingMode; } }
-        internal bool accurateGbufferNormals { get { return m_DeferredLights != null ? m_DeferredLights.AccurateGbufferNormals : false; } }
-        ColorGradingLutPass m_ColorGradingLutPass;
-        DepthOnlyPass m_DepthPrepass;
-        DepthNormalOnlyPass m_DepthNormalPrepass;
-        MainLightShadowCasterPass m_MainLightShadowCasterPass;
-        AdditionalLightsShadowCasterPass m_AdditionalLightsShadowCasterPass;
-        GBufferPass m_GBufferPass;
-        CopyDepthPass m_GBufferCopyDepthPass;
-        TileDepthRangePass m_TileDepthRangePass;
-        TileDepthRangePass m_TileDepthRangeExtraPass; // TODO use subpass API to hide this pass
-        DeferredPass m_DeferredPass;
-        OculusMotionVectorPass m_OculusMotionVecPass;
-        DrawObjectsPass m_RenderOpaqueForwardOnlyPass;
-        DrawObjectsPass m_RenderOpaqueForwardPass;
-        DrawSkyboxPass m_DrawSkyboxPass;
-        CopyDepthPass m_CopyDepthPass;
-        CopyColorPass m_CopyColorPass;
-        TransparentSettingsPass m_TransparentSettingsPass;
-        DrawObjectsPass m_RenderTransparentForwardPass;
-        InvokeOnRenderObjectCallbackPass m_OnRenderObjectCallbackPass;
-        PostProcessPass m_PostProcessPass;
-        PostProcessPass m_FinalPostProcessPass;
-        FinalBlitPass m_FinalBlitPass;
-        CapturePass m_CapturePass;
-#if ENABLE_VR && ENABLE_XR_MODULE
-        XROcclusionMeshPass m_XROcclusionMeshPass;
-        CopyDepthPass m_XRCopyDepthPass;
-#endif
-#if UNITY_EDITOR
-        SceneViewDepthCopyPass m_SceneViewDepthCopyPass;
-#endif
-
-        RenderTargetHandle m_ActiveCameraColorAttachment;
-        RenderTargetHandle m_ActiveCameraDepthAttachment;
-        RenderTargetHandle m_CameraColorAttachment;
-        RenderTargetHandle m_CameraDepthAttachment;
-        RenderTargetHandle m_DepthTexture;
-        RenderTargetHandle m_NormalsTexture;
-        RenderTargetHandle[] m_GBufferHandles;
-        RenderTargetHandle m_OpaqueColor;
-        RenderTargetHandle m_AfterPostProcessColor;
-        RenderTargetHandle m_ColorGradingLut;
-        // For tiled-deferred shading.
-        RenderTargetHandle m_DepthInfoTexture;
-        RenderTargetHandle m_TileDepthInfoTexture;
-
-        ForwardLights m_ForwardLights;
-        DeferredLights m_DeferredLights;
-#pragma warning disable 414
-        RenderingMode m_RenderingMode;
-#pragma warning restore 414
-        StencilState m_DefaultStencilState;
-
-        Material m_BlitMaterial;
-        Material m_CopyDepthMaterial;
-        Material m_SamplingMaterial;
-        Material m_ScreenspaceShadowsMaterial;
-        Material m_TileDepthInfoMaterial;
-        Material m_TileDeferredMaterial;
-        Material m_StencilDeferredMaterial;
-
-        public ForwardRenderer(ForwardRendererData data) : base(data)
-        {
-#if ENABLE_VR && ENABLE_XR_MODULE
-            UniversalRenderPipeline.m_XRSystem.InitializeXRSystemData(data.xrSystemData);
-#endif
-
-            m_BlitMaterial = CoreUtils.CreateEngineMaterial(data.shaders.blitPS);
-            m_CopyDepthMaterial = CoreUtils.CreateEngineMaterial(data.shaders.copyDepthPS);
-            m_SamplingMaterial = CoreUtils.CreateEngineMaterial(data.shaders.samplingPS);
-            m_ScreenspaceShadowsMaterial = CoreUtils.CreateEngineMaterial(data.shaders.screenSpaceShadowPS);
-            //m_TileDepthInfoMaterial = CoreUtils.CreateEngineMaterial(data.shaders.tileDepthInfoPS);
-            //m_TileDeferredMaterial = CoreUtils.CreateEngineMaterial(data.shaders.tileDeferredPS);
-            m_StencilDeferredMaterial = CoreUtils.CreateEngineMaterial(data.shaders.stencilDeferredPS);
-
-            StencilStateData stencilData = data.defaultStencilState;
-            m_DefaultStencilState = StencilState.defaultValue;
-            m_DefaultStencilState.enabled = stencilData.overrideStencilState;
-            m_DefaultStencilState.SetCompareFunction(stencilData.stencilCompareFunction);
-            m_DefaultStencilState.SetPassOperation(stencilData.passOperation);
-            m_DefaultStencilState.SetFailOperation(stencilData.failOperation);
-            m_DefaultStencilState.SetZFailOperation(stencilData.zFailOperation);
-
-            m_ForwardLights = new ForwardLights();
-            //m_DeferredLights.LightCulling = data.lightCulling;
-            this.m_RenderingMode = RenderingMode.Forward;
-
-            // Note: Since all custom render passes inject first and we have stable sort,
-            // we inject the builtin passes in the before events.
-            m_MainLightShadowCasterPass = new MainLightShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
-            m_AdditionalLightsShadowCasterPass = new AdditionalLightsShadowCasterPass(RenderPassEvent.BeforeRenderingShadows);
-#if ENABLE_VR && ENABLE_XR_MODULE
-            m_XROcclusionMeshPass = new XROcclusionMeshPass(RenderPassEvent.BeforeRenderingOpaques);
-            // Schedule XR copydepth right after m_FinalBlitPass(AfterRendering + 1)
-            m_XRCopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRendering + 2, m_CopyDepthMaterial);
-#endif
-            m_DepthPrepass = new DepthOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
-            m_DepthNormalPrepass = new DepthNormalOnlyPass(RenderPassEvent.BeforeRenderingPrepasses, RenderQueueRange.opaque, data.opaqueLayerMask);
-            m_ColorGradingLutPass = new ColorGradingLutPass(RenderPassEvent.BeforeRenderingPrepasses, data.postProcessData);
-
-            if (this.renderingMode == RenderingMode.Deferred)
-            {
-                m_DeferredLights = new DeferredLights(m_TileDepthInfoMaterial, m_TileDeferredMaterial, m_StencilDeferredMaterial);
-                m_DeferredLights.AccurateGbufferNormals = data.accurateGbufferNormals;
-                //m_DeferredLights.TiledDeferredShading = data.tiledDeferredShading;
-                m_DeferredLights.TiledDeferredShading = false;
-                UniversalRenderPipelineAsset urpAsset = GraphicsSettings.renderPipelineAsset as UniversalRenderPipelineAsset;
-
-                m_GBufferPass = new GBufferPass(RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference, m_DeferredLights);
-                // Forward-only pass only runs if deferred renderer is enabled.
-                // It allows specific materials to be rendered in a forward-like pass.
-                // We render both gbuffer pass and forward-only pass before the deferred lighting pass so we can minimize copies of depth buffer and
-                // benefits from some depth rejection.
-                // - If a material can be rendered either forward or deferred, then it should declare a UniversalForward and a UniversalGBuffer pass.
-                // - If a material cannot be lit in deferred (unlit, bakedLit, special material such as hair, skin shader), then it should declare UniversalForwardOnly pass
-                // - Legacy materials have unamed pass, which is implicitely renamed as SRPDefaultUnlit. In that case, they are considered forward-only too.
-                // TO declare a material with unnamed pass and UniversalForward/UniversalForwardOnly pass is an ERROR, as the material will be rendered twice.
-                StencilState forwardOnlyStencilState = DeferredLights.OverwriteStencil(m_DefaultStencilState, (int)StencilUsage.MaterialMask);
-                ShaderTagId[] forwardOnlyShaderTagIds = new ShaderTagId[] {
-                    new ShaderTagId("UniversalForwardOnly"),
-                    new ShaderTagId("SRPDefaultUnlit"), // Legacy shaders (do not have a gbuffer pass) are considered forward-only for backward compatibility
-                    new ShaderTagId("LightweightForward") // Legacy shaders (do not have a gbuffer pass) are considered forward-only for backward compatibility
-                };
-                int forwardOnlyStencilRef = stencilData.stencilReference | (int)StencilUsage.MaterialUnlit;
-                m_RenderOpaqueForwardOnlyPass = new DrawObjectsPass("Render Opaques Forward Only", forwardOnlyShaderTagIds, true, RenderPassEvent.BeforeRenderingOpaques + 1, RenderQueueRange.opaque, data.opaqueLayerMask, forwardOnlyStencilState, forwardOnlyStencilRef);
-                m_GBufferCopyDepthPass = new CopyDepthPass(RenderPassEvent.BeforeRenderingOpaques + 2, m_CopyDepthMaterial);
-                m_TileDepthRangePass = new TileDepthRangePass(RenderPassEvent.BeforeRenderingOpaques + 3, m_DeferredLights, 0);
-                m_TileDepthRangeExtraPass = new TileDepthRangePass(RenderPassEvent.BeforeRenderingOpaques + 4, m_DeferredLights, 1);
-                m_DeferredPass = new DeferredPass(RenderPassEvent.BeforeRenderingOpaques + 5, m_DeferredLights);
-            }
-
-            m_OculusMotionVecPass = new OculusMotionVectorPass(URPProfileId.DrawMVOpaqueObjects, true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
-
-            // Always create this pass even in deferred because we use it for wireframe rendering in the Editor or offscreen depth texture rendering.
-            m_RenderOpaqueForwardPass = new DrawObjectsPass(URPProfileId.DrawOpaqueObjects, true, RenderPassEvent.BeforeRenderingOpaques, RenderQueueRange.opaque, data.opaqueLayerMask, m_DefaultStencilState, stencilData.stencilReference);
-
-            m_CopyDepthPass = new CopyDepthPass(RenderPassEvent.AfterRenderingSkybox, m_CopyDepthMaterial);
-            m_DrawSkyboxPass = new DrawSkyboxPass(RenderPassEvent.BeforeRenderingSkybox);
-            m_CopyColorPass = new CopyColorPass(RenderPassEvent.AfterRenderingSkybox, m_SamplingMaterial, m_BlitMaterial);
-#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
-            if (!UniversalRenderPipeline.asset.useAdaptivePerformance || AdaptivePerformance.AdaptivePerformanceRenderSettings.SkipTransparentObjects == false)
-#endif
-            {
-                m_TransparentSettingsPass = new TransparentSettingsPass(RenderPassEvent.BeforeRenderingTransparents, data.shadowTransparentReceive);
-                m_RenderTransparentForwardPass = new DrawObjectsPass(URPProfileId.DrawTransparentObjects, false, RenderPassEvent.BeforeRenderingTransparents, RenderQueueRange.transparent, data.transparentLayerMask, m_DefaultStencilState, stencilData.stencilReference);
-            }
-            m_OnRenderObjectCallbackPass = new InvokeOnRenderObjectCallbackPass(RenderPassEvent.BeforeRenderingPostProcessing);
-            m_PostProcessPass = new PostProcessPass(RenderPassEvent.BeforeRenderingPostProcessing, data.postProcessData, m_BlitMaterial);
-            m_FinalPostProcessPass = new PostProcessPass(RenderPassEvent.AfterRendering + 1, data.postProcessData, m_BlitMaterial);
-            m_CapturePass = new CapturePass(RenderPassEvent.AfterRendering);
-            m_FinalBlitPass = new FinalBlitPass(RenderPassEvent.AfterRendering + 1, m_BlitMaterial);
-
-#if UNITY_EDITOR
-            m_SceneViewDepthCopyPass = new SceneViewDepthCopyPass(RenderPassEvent.AfterRendering + 9, m_CopyDepthMaterial);
-#endif
-
-            // RenderTexture format depends on camera and pipeline (HDR, non HDR, etc)
-            // Samples (MSAA) depend on camera and pipeline
-            m_CameraColorAttachment.Init("_CameraColorTexture");
-            m_CameraDepthAttachment.Init("_CameraDepthAttachment");
-            m_DepthTexture.Init("_CameraDepthTexture");
-            m_NormalsTexture.Init("_CameraNormalsTexture");
-            if (this.renderingMode == RenderingMode.Deferred)
-            {
-                m_GBufferHandles = new RenderTargetHandle[(int)DeferredLights.GBufferHandles.Count];
-                m_GBufferHandles[(int)DeferredLights.GBufferHandles.DepthAsColor].Init("_GBufferDepthAsColor");
-                m_GBufferHandles[(int)DeferredLights.GBufferHandles.Albedo].Init("_GBuffer0");
-                m_GBufferHandles[(int)DeferredLights.GBufferHandles.SpecularMetallic].Init("_GBuffer1");
-                m_GBufferHandles[(int)DeferredLights.GBufferHandles.NormalSmoothness].Init("_GBuffer2");
-                m_GBufferHandles[(int)DeferredLights.GBufferHandles.Lighting] = new RenderTargetHandle();
-                m_GBufferHandles[(int)DeferredLights.GBufferHandles.ShadowMask].Init("_GBuffer4");
-            }
-            m_OpaqueColor.Init("_CameraOpaqueTexture");
-            m_AfterPostProcessColor.Init("_AfterPostProcessTexture");
-            m_ColorGradingLut.Init("_InternalGradingLut");
-            m_DepthInfoTexture.Init("_DepthInfoTexture");
-            m_TileDepthInfoTexture.Init("_TileDepthInfoTexture");
-
-            supportedRenderingFeatures = new RenderingFeatures()
-            {
-                cameraStacking = true,
-            };
-
-            if (this.renderingMode == RenderingMode.Deferred)
-            {
-                unsupportedGraphicsDeviceTypes = new GraphicsDeviceType[] {
-                    GraphicsDeviceType.OpenGLCore,
-                    GraphicsDeviceType.OpenGLES2,
-                    GraphicsDeviceType.OpenGLES3
-                };
-            }
-        }
-
-        /// <inheritdoc />
-        protected override void Dispose(bool disposing)
-        {
-            // always dispose unmanaged resources
-            m_PostProcessPass.Cleanup();
-            m_FinalPostProcessPass.Cleanup();
-            m_ColorGradingLutPass.Cleanup();
-
-            CoreUtils.Destroy(m_BlitMaterial);
-            CoreUtils.Destroy(m_CopyDepthMaterial);
-            CoreUtils.Destroy(m_SamplingMaterial);
-            CoreUtils.Destroy(m_ScreenspaceShadowsMaterial);
-            CoreUtils.Destroy(m_TileDepthInfoMaterial);
-            CoreUtils.Destroy(m_TileDeferredMaterial);
-            CoreUtils.Destroy(m_StencilDeferredMaterial);
-        }
-
-        /// <inheritdoc />
-        public override void Setup(ScriptableRenderContext context, ref RenderingData renderingData)
-        {
-#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
-            bool needTransparencyPass = !UniversalRenderPipeline.asset.useAdaptivePerformance || !AdaptivePerformance.AdaptivePerformanceRenderSettings.SkipTransparentObjects;
-#endif
-            Camera camera = renderingData.cameraData.camera;
-            ref CameraData cameraData = ref renderingData.cameraData;
-            RenderTextureDescriptor cameraTargetDescriptor = renderingData.cameraData.cameraTargetDescriptor;
-
-            // Special path for depth only offscreen cameras. Only write opaques + transparents.
-            bool isOffscreenDepthTexture = cameraData.targetTexture != null && cameraData.targetTexture.format == RenderTextureFormat.Depth;
-            if (isOffscreenDepthTexture)
-            {
-                ConfigureCameraTarget(BuiltinRenderTextureType.CameraTarget, BuiltinRenderTextureType.CameraTarget);
-                AddRenderPasses(ref renderingData);
-                EnqueuePass(m_RenderOpaqueForwardPass);
-
-                // TODO: Do we need to inject transparents and skybox when rendering depth only camera? They don't write to depth.
-                EnqueuePass(m_DrawSkyboxPass);
-#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
-                if (!needTransparencyPass)
-                    return;
-#endif
-                EnqueuePass(m_RenderTransparentForwardPass);
-                return;
-            }
-
-            if (m_DeferredLights != null)
-                m_DeferredLights.ResolveMixedLightingMode(ref renderingData);
-
-            // Assign the camera color target early in case it is needed during AddRenderPasses.
-            bool isPreviewCamera = cameraData.isPreviewCamera;
-            bool isRunningHololens = false;
-#if ENABLE_VR && ENABLE_VR_MODULE
-            isRunningHololens = UniversalRenderPipeline.IsRunningHololens(cameraData);
-#endif
-            var createColorTexture = (rendererFeatures.Count != 0 && !isRunningHololens) && !isPreviewCamera;
-            if (createColorTexture)
-            {
-                m_ActiveCameraColorAttachment = m_CameraColorAttachment;
-                var activeColorRenderTargetId = m_ActiveCameraColorAttachment.Identifier();
-#if ENABLE_VR && ENABLE_XR_MODULE
-                if (cameraData.xr.enabled) activeColorRenderTargetId = new RenderTargetIdentifier(activeColorRenderTargetId, 0, CubemapFace.Unknown, -1);
-#endif
-                ConfigureCameraColorTarget(activeColorRenderTargetId);
-            }
-
-            // Add render passes and gather the input requirements
-            isCameraColorTargetValid = true;
-            AddRenderPasses(ref renderingData);
-            isCameraColorTargetValid = false;
-            RenderPassInputSummary renderPassInputs = GetRenderPassInputs(ref renderingData);
-
-            // Should apply post-processing after rendering this camera?
-            bool applyPostProcessing = cameraData.postProcessEnabled;
-
-            // There's at least a camera in the camera stack that applies post-processing
-            bool anyPostProcessing = renderingData.postProcessingEnabled;
-
-            // TODO: We could cache and generate the LUT before rendering the stack
-            bool generateColorGradingLUT = cameraData.postProcessEnabled;
-            bool isSceneViewCamera = cameraData.isSceneViewCamera;
-            bool requiresDepthTexture = cameraData.requiresDepthTexture || renderPassInputs.requiresDepthTexture || this.actualRenderingMode == RenderingMode.Deferred;
-
-            bool mainLightShadows = m_MainLightShadowCasterPass.Setup(ref renderingData);
-            bool additionalLightShadows = m_AdditionalLightsShadowCasterPass.Setup(ref renderingData);
-            bool transparentsNeedSettingsPass = m_TransparentSettingsPass.Setup(ref renderingData);
-
-            // Depth prepass is generated in the following cases:
-            // - If game or offscreen camera requires it we check if we can copy the depth from the rendering opaques pass and use that instead.
-            // - Scene or preview cameras always require a depth texture. We do a depth pre-pass to simplify it and it shouldn't matter much for editor.
-            // - Render passes require it
-            bool requiresDepthPrepass = requiresDepthTexture && !CanCopyDepth(ref renderingData.cameraData);
-            requiresDepthPrepass |= isSceneViewCamera;
-            requiresDepthPrepass |= isPreviewCamera;
-            requiresDepthPrepass |= renderPassInputs.requiresDepthPrepass;
-            requiresDepthPrepass |= renderPassInputs.requiresNormalsTexture;
-
-            // The copying of depth should normally happen after rendering opaques.
-            // But if we only require it for post processing or the scene camera then we do it after rendering transparent objects
-            m_CopyDepthPass.renderPassEvent = (!requiresDepthTexture && (applyPostProcessing || isSceneViewCamera)) ? RenderPassEvent.AfterRenderingTransparents : RenderPassEvent.AfterRenderingOpaques;
-            createColorTexture |= RequiresIntermediateColorTexture(ref cameraData);
-            createColorTexture |= renderPassInputs.requiresColorTexture;
-            createColorTexture &= !isPreviewCamera;
-
-            // TODO: There's an issue in multiview and depth copy pass. Atm forcing a depth prepass on XR until we have a proper fix.
-            if (cameraData.xr.enabled && requiresDepthTexture)
-                requiresDepthPrepass = true;
-
-            // If camera requires depth and there's no depth pre-pass we create a depth texture that can be read later by effect requiring it.
-            // When deferred renderer is enabled, we must always create a depth texture and CANNOT use BuiltinRenderTextureType.CameraTarget. This is to get
-            // around a bug where during gbuffer pass (MRT pass), the camera depth attachment is correctly bound, but during
-            // deferred pass ("camera color" + "camera depth"), the implicit depth surface of "camera color" is used instead of "camera depth",
-            // because BuiltinRenderTextureType.CameraTarget for depth means there is no explicit depth attachment...
-            bool createDepthTexture = cameraData.requiresDepthTexture && !requiresDepthPrepass;
-            createDepthTexture |= (cameraData.renderType == CameraRenderType.Base && !cameraData.resolveFinalTarget);
-            // Deferred renderer always need to access depth buffer.
-            createDepthTexture |= this.actualRenderingMode == RenderingMode.Deferred;
-#if ENABLE_VR && ENABLE_XR_MODULE
-            if (cameraData.xr.enabled)
-            {
-                // URP can't handle msaa/size mismatch between depth RT and color RT(for now we create intermediate textures to ensure they match)
-                createDepthTexture |= createColorTexture;
-                createColorTexture = createDepthTexture;
-            }
-#endif
-
-#if UNITY_ANDROID || UNITY_WEBGL
-            if (SystemInfo.graphicsDeviceType != GraphicsDeviceType.Vulkan)
-            {
-                // GLES can not use render texture's depth buffer with the color buffer of the backbuffer
-                // in such case we create a color texture for it too.
-                createColorTexture |= createDepthTexture;
-            }
-#endif
-
-            // Configure all settings require to start a new camera stack (base camera only)
-            if (cameraData.renderType == CameraRenderType.Base)
-            {
-                RenderTargetHandle cameraTargetHandle = RenderTargetHandle.GetCameraTarget(cameraData.xr);
-
-                m_ActiveCameraColorAttachment = (createColorTexture) ? m_CameraColorAttachment : cameraTargetHandle;
-                m_ActiveCameraDepthAttachment = (createDepthTexture) ? m_CameraDepthAttachment : cameraTargetHandle;
-
-                bool intermediateRenderTexture = createColorTexture || createDepthTexture;
-
-                // Doesn't create texture for Overlay cameras as they are already overlaying on top of created textures.
-                if (intermediateRenderTexture)
-                    CreateCameraRenderTarget(context, ref cameraTargetDescriptor, createColorTexture, createDepthTexture);
-            }
-            else
-            {
-                m_ActiveCameraColorAttachment = m_CameraColorAttachment;
-                m_ActiveCameraDepthAttachment = m_CameraDepthAttachment;
-            }
-
-            // Assign camera targets (color and depth)
-            {
-                var activeColorRenderTargetId = m_ActiveCameraColorAttachment.Identifier();
-                var activeDepthRenderTargetId = m_ActiveCameraDepthAttachment.Identifier();
-
-#if ENABLE_VR && ENABLE_XR_MODULE
-                if (cameraData.xr.enabled)
-                {
-                    activeColorRenderTargetId = new RenderTargetIdentifier(activeColorRenderTargetId, 0, CubemapFace.Unknown, -1);
-                    activeDepthRenderTargetId = new RenderTargetIdentifier(activeDepthRenderTargetId, 0, CubemapFace.Unknown, -1);
-                }
-#endif
-
-                ConfigureCameraTarget(activeColorRenderTargetId, activeDepthRenderTargetId);
-            }
-
-            bool hasPassesAfterPostProcessing = activeRenderPassQueue.Find(x => x.renderPassEvent == RenderPassEvent.AfterRendering) != null;
-
-            if (mainLightShadows)
-                EnqueuePass(m_MainLightShadowCasterPass);
-
-            if (additionalLightShadows)
-                EnqueuePass(m_AdditionalLightsShadowCasterPass);
-
-            if (requiresDepthPrepass)
-            {
-                if (renderPassInputs.requiresNormalsTexture)
-                {
-                    m_DepthNormalPrepass.Setup(cameraTargetDescriptor, m_DepthTexture, m_NormalsTexture);
-                    EnqueuePass(m_DepthNormalPrepass);
-                }
-                else
-                {
-                    m_DepthPrepass.Setup(cameraTargetDescriptor, m_DepthTexture);
-                    EnqueuePass(m_DepthPrepass);
-                }
-            }
-
-            if (generateColorGradingLUT)
-            {
-                m_ColorGradingLutPass.Setup(m_ColorGradingLut);
-                EnqueuePass(m_ColorGradingLutPass);
-            }
-
-#if ENABLE_VR && ENABLE_XR_MODULE
-            if (cameraData.xr.hasValidOcclusionMesh)
-                EnqueuePass(m_XROcclusionMeshPass);
-#endif
-
-#if !UNITY_EDITOR
-            if (cameraData.xr.motionVectorRenderTargetValid)
-            {
-                RenderTargetHandle motionVecHandle = new RenderTargetHandle(cameraData.xr.motionVectorRenderTarget);
-                var rtMotionId = motionVecHandle.Identifier();
-                rtMotionId = new RenderTargetIdentifier(rtMotionId, 0, CubemapFace.Unknown, -1);
-
-                // ID is the same since a RenderTexture encapsulates all the attachments, including both color+depth.
-                m_OculusMotionVecPass.Setup(rtMotionId, rtMotionId);
-                EnqueuePass(m_OculusMotionVecPass);
-            }
-#endif
-
-            if (this.actualRenderingMode == RenderingMode.Deferred)
-                EnqueueDeferred(ref renderingData, requiresDepthPrepass, mainLightShadows, additionalLightShadows);
-            else
-                EnqueuePass(m_RenderOpaqueForwardPass);
-
-            Skybox cameraSkybox;
-            cameraData.camera.TryGetComponent<Skybox>(out cameraSkybox);
-            bool isOverlayCamera = cameraData.renderType == CameraRenderType.Overlay;
-            if (camera.clearFlags == CameraClearFlags.Skybox && (RenderSettings.skybox != null || cameraSkybox?.material != null) && !isOverlayCamera)
-                EnqueuePass(m_DrawSkyboxPass);
-
-            // If a depth texture was created we necessarily need to copy it, otherwise we could have render it to a renderbuffer.
-            // If deferred rendering path was selected, it has already made a copy.
-            bool requiresDepthCopyPass = !requiresDepthPrepass
-                                         && renderingData.cameraData.requiresDepthTexture
-                                         && createDepthTexture
-                                         && this.actualRenderingMode != RenderingMode.Deferred;
-            if (requiresDepthCopyPass)
-            {
-                m_CopyDepthPass.Setup(m_ActiveCameraDepthAttachment, m_DepthTexture);
-                EnqueuePass(m_CopyDepthPass);
-            }
-
-            // For Base Cameras: Set the depth texture to the far Z if we do not have a depth prepass or copy depth
-            if (cameraData.renderType == CameraRenderType.Base && !requiresDepthPrepass && !requiresDepthCopyPass)
-            {
-                Shader.SetGlobalTexture(m_DepthTexture.id, SystemInfo.usesReversedZBuffer ? Texture2D.blackTexture : Texture2D.whiteTexture);
-            }
-
-            if (renderingData.cameraData.requiresOpaqueTexture || renderPassInputs.requiresColorTexture)
-            {
-                // TODO: Downsampling method should be store in the renderer instead of in the asset.
-                // We need to migrate this data to renderer. For now, we query the method in the active asset.
-                Downsampling downsamplingMethod = UniversalRenderPipeline.asset.opaqueDownsampling;
-                m_CopyColorPass.Setup(m_ActiveCameraColorAttachment.Identifier(), m_OpaqueColor, downsamplingMethod);
-                EnqueuePass(m_CopyColorPass);
-            }
-#if ADAPTIVE_PERFORMANCE_2_1_0_OR_NEWER
-            if (needTransparencyPass)
-#endif
-            {
-                if (transparentsNeedSettingsPass)
-                {
-                    EnqueuePass(m_TransparentSettingsPass);
-                }
-
-                EnqueuePass(m_RenderTransparentForwardPass);
-            }
-            EnqueuePass(m_OnRenderObjectCallbackPass);
-
-            bool lastCameraInTheStack = cameraData.resolveFinalTarget;
-            bool hasCaptureActions = renderingData.cameraData.captureActions != null && lastCameraInTheStack;
-            bool applyFinalPostProcessing = anyPostProcessing && lastCameraInTheStack &&
-                                     renderingData.cameraData.antialiasing == AntialiasingMode.FastApproximateAntialiasing;
-
-            // When post-processing is enabled we can use the stack to resolve rendering to camera target (screen or RT).
-            // However when there are render passes executing after post we avoid resolving to screen so rendering continues (before sRGBConvertion etc)
-            bool resolvePostProcessingToCameraTarget = !hasCaptureActions && !hasPassesAfterPostProcessing && !applyFinalPostProcessing;
-
-            if (lastCameraInTheStack)
-            {
-                // Post-processing will resolve to final target. No need for final blit pass.
-                if (applyPostProcessing)
-                {
-                    var destination = resolvePostProcessingToCameraTarget ? RenderTargetHandle.CameraTarget : m_AfterPostProcessColor;
-
-                    // if resolving to screen we need to be able to perform sRGBConvertion in post-processing if necessary
-                    bool doSRGBConvertion = resolvePostProcessingToCameraTarget;
-                    m_PostProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, destination, m_ActiveCameraDepthAttachment, m_ColorGradingLut, applyFinalPostProcessing, doSRGBConvertion);
-                    EnqueuePass(m_PostProcessPass);
-                }
-
-
-                // if we applied post-processing for this camera it means current active texture is m_AfterPostProcessColor
-                var sourceForFinalPass = (applyPostProcessing) ? m_AfterPostProcessColor : m_ActiveCameraColorAttachment;
-
-                // Do FXAA or any other final post-processing effect that might need to run after AA.
-                if (applyFinalPostProcessing)
-                {
-                    m_FinalPostProcessPass.SetupFinalPass(sourceForFinalPass);
-                    EnqueuePass(m_FinalPostProcessPass);
-                }
-
-                if (renderingData.cameraData.captureActions != null)
-                {
-                    m_CapturePass.Setup(sourceForFinalPass);
-                    EnqueuePass(m_CapturePass);
-                }
-
-                // if post-processing then we already resolved to camera target while doing post.
-                // Also only do final blit if camera is not rendering to RT.
-                bool cameraTargetResolved =
-                    // final PP always blit to camera target
-                    applyFinalPostProcessing ||
-                    // no final PP but we have PP stack. In that case it blit unless there are render pass after PP
-                    (applyPostProcessing && !hasPassesAfterPostProcessing) ||
-                    // offscreen camera rendering to a texture, we don't need a blit pass to resolve to screen
-                    m_ActiveCameraColorAttachment == RenderTargetHandle.GetCameraTarget(cameraData.xr);
-
-                // We need final blit to resolve to screen
-                if (!cameraTargetResolved)
-                {
-                    m_FinalBlitPass.Setup(cameraTargetDescriptor, sourceForFinalPass);
-                    EnqueuePass(m_FinalBlitPass);
-                }
-
-#if ENABLE_VR && ENABLE_XR_MODULE
-                bool depthTargetResolved =
-                    // active depth is depth target, we don't need a blit pass to resolve
-                    m_ActiveCameraDepthAttachment == RenderTargetHandle.GetCameraTarget(cameraData.xr);
-
-                if (!depthTargetResolved && cameraData.xr.copyDepth)
-                {
-                    m_XRCopyDepthPass.Setup(m_ActiveCameraDepthAttachment, RenderTargetHandle.GetCameraTarget(cameraData.xr));
-                    EnqueuePass(m_XRCopyDepthPass);
-                }
-#endif
-            }
-
-            // stay in RT so we resume rendering on stack after post-processing
-            else if (applyPostProcessing)
-            {
-                m_PostProcessPass.Setup(cameraTargetDescriptor, m_ActiveCameraColorAttachment, m_AfterPostProcessColor, m_ActiveCameraDepthAttachment, m_ColorGradingLut, false, false);
-                EnqueuePass(m_PostProcessPass);
-            }
-
-#if UNITY_EDITOR
-            if (isSceneViewCamera)
-            {
-                // Scene view camera should always resolve target (not stacked)
-                Assertions.Assert.IsTrue(lastCameraInTheStack, "Editor camera must resolve target upon finish rendering.");
-                m_SceneViewDepthCopyPass.Setup(m_DepthTexture);
-                EnqueuePass(m_SceneViewDepthCopyPass);
-            }
-#endif
-        }
-
-        /// <inheritdoc />
-        public override void SetupLights(ScriptableRenderContext context, ref RenderingData renderingData)
-        {
-            m_ForwardLights.Setup(context, ref renderingData);
-
-            // Perform per-tile light culling on CPU
-            if (this.actualRenderingMode == RenderingMode.Deferred)
-                m_DeferredLights.SetupLights(context, ref renderingData);
-        }
-
-        /// <inheritdoc />
-        public override void SetupCullingParameters(ref ScriptableCullingParameters cullingParameters,
-            ref CameraData cameraData)
-        {
-            // TODO: PerObjectCulling also affect reflection probes. Enabling it for now.
-            // if (asset.additionalLightsRenderingMode == LightRenderingMode.Disabled ||
-            //     asset.maxAdditionalLightsCount == 0)
-            // {
-            //     cullingParameters.cullingOptions |= CullingOptions.DisablePerObjectCulling;
-            // }
-
-            // We disable shadow casters if both shadow casting modes are turned off
-            // or the shadow distance has been turned down to zero
-            bool isShadowCastingDisabled = !UniversalRenderPipeline.asset.supportsMainLightShadows && !UniversalRenderPipeline.asset.supportsAdditionalLightShadows;
-            bool isShadowDistanceZero = Mathf.Approximately(cameraData.maxShadowDistance, 0.0f);
-            if (isShadowCastingDisabled || isShadowDistanceZero)
-            {
-                cullingParameters.cullingOptions &= ~CullingOptions.ShadowCasters;
-            }
-
-            if (this.actualRenderingMode == RenderingMode.Deferred)
-                cullingParameters.maximumVisibleLights = 0xFFFF;
-            else
-            {
-                // We set the number of maximum visible lights allowed and we add one for the mainlight...
-                cullingParameters.maximumVisibleLights = UniversalRenderPipeline.maxVisibleAdditionalLights + 1;
-            }
-            cullingParameters.shadowDistance = cameraData.maxShadowDistance;
-        }
-
-        /// <inheritdoc />
-        public override void FinishRendering(CommandBuffer cmd)
-        {
-            if (m_ActiveCameraColorAttachment != RenderTargetHandle.CameraTarget)
-            {
-                cmd.ReleaseTemporaryRT(m_ActiveCameraColorAttachment.id);
-                m_ActiveCameraColorAttachment = RenderTargetHandle.CameraTarget;
-            }
-
-            if (m_ActiveCameraDepthAttachment != RenderTargetHandle.CameraTarget)
-            {
-                cmd.ReleaseTemporaryRT(m_ActiveCameraDepthAttachment.id);
-                m_ActiveCameraDepthAttachment = RenderTargetHandle.CameraTarget;
-            }
-        }
-
-        void EnqueueDeferred(ref RenderingData renderingData, bool hasDepthPrepass, bool applyMainShadow, bool applyAdditionalShadow)
-        {
-            // the last slice is the lighting buffer created in DeferredRenderer.cs
-            m_GBufferHandles[(int)DeferredLights.GBufferHandles.Lighting] = m_ActiveCameraColorAttachment;
-
-            m_DeferredLights.Setup(
-                ref renderingData,
-                applyAdditionalShadow ? m_AdditionalLightsShadowCasterPass : null,
-                hasDepthPrepass,
-                renderingData.cameraData.renderType == CameraRenderType.Overlay,
-                m_DepthTexture,
-                m_DepthInfoTexture,
-                m_TileDepthInfoTexture,
-                m_ActiveCameraDepthAttachment, m_GBufferHandles
-            );
-
-            EnqueuePass(m_GBufferPass);
-
-            EnqueuePass(m_RenderOpaqueForwardOnlyPass);
-
-            //Must copy depth for deferred shading: TODO wait for API fix to bind depth texture as read-only resource.
-            if (!hasDepthPrepass)
-            {
-                m_GBufferCopyDepthPass.Setup(m_CameraDepthAttachment, m_DepthTexture);
-                EnqueuePass(m_GBufferCopyDepthPass);
-            }
-
-            // Note: DeferredRender.Setup is called by UniversalRenderPipeline.RenderSingleCamera (overrides ScriptableRenderer.Setup).
-            // At this point, we do not know if m_DeferredLights.m_Tilers[x].m_Tiles actually contain any indices of lights intersecting tiles (If there are no lights intersecting tiles, we could skip several following passes) : this information is computed in DeferredRender.SetupLights, which is called later by UniversalRenderPipeline.RenderSingleCamera (via ScriptableRenderer.Execute).
-            // However HasTileLights uses m_HasTileVisLights which is calculated by CheckHasTileLights from all visibleLights. visibleLights is the list of lights that have passed camera culling, so we know they are in front of the camera. So we can assume m_DeferredLights.m_Tilers[x].m_Tiles will not be empty in that case.
-            // m_DeferredLights.m_Tilers[x].m_Tiles could be empty if we implemented an algorithm accessing scene depth information on the CPU side, but this (access depth from CPU) will probably not happen.
-            if (m_DeferredLights.HasTileLights())
-            {
-                // Compute for each tile a 32bits bitmask in which a raised bit means "this 1/32th depth slice contains geometry that could intersect with lights".
-                // Per-tile bitmasks are obtained by merging together the per-pixel bitmasks computed for each individual pixel of the tile.
-                EnqueuePass(m_TileDepthRangePass);
-
-                // On some platform, splitting the bitmasks computation into two passes:
-                //   1/ Compute bitmasks for individual or small blocks of pixels
-                //   2/ merge those individual bitmasks into per-tile bitmasks
-                // provides better performance that doing it in a single above pass.
-                if (m_DeferredLights.HasTileDepthRangeExtraPass())
-                    EnqueuePass(m_TileDepthRangeExtraPass);
-            }
-
-            EnqueuePass(m_DeferredPass);
-        }
-
-        private struct RenderPassInputSummary
-        {
-            internal bool requiresDepthTexture;
-            internal bool requiresDepthPrepass;
-            internal bool requiresNormalsTexture;
-            internal bool requiresColorTexture;
-        }
-
-        private RenderPassInputSummary GetRenderPassInputs(ref RenderingData renderingData)
-        {
-            RenderPassInputSummary inputSummary = new RenderPassInputSummary();
-            for (int i = 0; i < activeRenderPassQueue.Count; ++i)
-            {
-                ScriptableRenderPass pass = activeRenderPassQueue[i];
-                bool needsDepth   = (pass.input & ScriptableRenderPassInput.Depth) != ScriptableRenderPassInput.None;
-                bool needsNormals = (pass.input & ScriptableRenderPassInput.Normal) != ScriptableRenderPassInput.None;
-                bool needsColor   = (pass.input & ScriptableRenderPassInput.Color) != ScriptableRenderPassInput.None;
-                bool eventBeforeOpaque = pass.renderPassEvent <= RenderPassEvent.BeforeRenderingOpaques;
-
-                inputSummary.requiresDepthTexture   |= needsDepth;
-                inputSummary.requiresDepthPrepass   |= needsNormals || needsDepth && eventBeforeOpaque;
-                inputSummary.requiresNormalsTexture |= needsNormals;
-                inputSummary.requiresColorTexture   |= needsColor;
-            }
-
-            return inputSummary;
-        }
-
-        void CreateCameraRenderTarget(ScriptableRenderContext context, ref RenderTextureDescriptor descriptor, bool createColor, bool createDepth)
-        {
-            CommandBuffer cmd = CommandBufferPool.Get();
-            using (new ProfilingScope(cmd, Profiling.createCameraRenderTarget))
-            {
-                if (createColor)
-                {
-                    bool useDepthRenderBuffer = m_ActiveCameraDepthAttachment == RenderTargetHandle.CameraTarget;
-                    var colorDescriptor = descriptor;
-                    colorDescriptor.useMipMap = false;
-                    colorDescriptor.autoGenerateMips = false;
-                    colorDescriptor.depthBufferBits = (useDepthRenderBuffer) ? k_DepthStencilBufferBits : 0;
-                    cmd.GetTemporaryRT(m_ActiveCameraColorAttachment.id, colorDescriptor, FilterMode.Bilinear);
-                }
-
-                if (createDepth)
-                {
-                    var depthDescriptor = descriptor;
-                    depthDescriptor.useMipMap = false;
-                    depthDescriptor.autoGenerateMips = false;
-#if ENABLE_VR && ENABLE_XR_MODULE
-                    // XRTODO: Enabled this line for non-XR pass? URP copy depth pass is already capable of handling MSAA.
-                    depthDescriptor.bindMS = depthDescriptor.msaaSamples > 1 && !SystemInfo.supportsMultisampleAutoResolve && (SystemInfo.supportsMultisampledTextures != 0);
-#endif
-                    depthDescriptor.colorFormat = RenderTextureFormat.Depth;
-                    depthDescriptor.depthBufferBits = k_DepthStencilBufferBits;
-                    cmd.GetTemporaryRT(m_ActiveCameraDepthAttachment.id, depthDescriptor, FilterMode.Point);
-                }
-            }
-
-            context.ExecuteCommandBuffer(cmd);
-            CommandBufferPool.Release(cmd);
-        }
-
-        bool PlatformRequiresExplicitMsaaResolve()
-        {
-            // On Metal/iOS the MSAA resolve is done implicitly as part of the renderpass, so we do not need an extra intermediate pass for the explicit autoresolve.
-            // TODO: should also be valid on Metal MacOS/Editor, but currently not working as expected. Remove the "mobile only" requirement once trunk has a fix.
-
-            return !SystemInfo.supportsMultisampleAutoResolve &&
-                   !(SystemInfo.graphicsDeviceType == GraphicsDeviceType.Metal && Application.isMobilePlatform);
-        }
-
-        /// <summary>
-        /// Checks if the pipeline needs to create a intermediate render texture.
-        /// </summary>
-        /// <param name="cameraData">CameraData contains all relevant render target information for the camera.</param>
-        /// <seealso cref="CameraData"/>
-        /// <returns>Return true if pipeline needs to render to a intermediate render texture.</returns>
-        bool RequiresIntermediateColorTexture(ref CameraData cameraData)
-        {
-            // When rendering a camera stack we always create an intermediate render texture to composite camera results.
-            // We create it upon rendering the Base camera.
-            if (cameraData.renderType == CameraRenderType.Base && !cameraData.resolveFinalTarget)
-                return true;
-
-            // Always force rendering into intermediate color texture if deferred rendering mode is selected.
-            // Reason: without intermediate color texture, the target camera texture is y-flipped.
-            // However, the target camera texture is bound during gbuffer pass and deferred pass.
-            // Gbuffer pass will not be y-flipped because it is MRT (see ScriptableRenderContext implementation),
-            // while deferred pass will be y-flipped, which breaks rendering.
-            // This incurs an extra blit into at the end of rendering.
-            if (this.actualRenderingMode == RenderingMode.Deferred)
-                return true;
-
-            bool isSceneViewCamera = cameraData.isSceneViewCamera;
-            var cameraTargetDescriptor = cameraData.cameraTargetDescriptor;
-            int msaaSamples = cameraTargetDescriptor.msaaSamples;
-            bool isScaledRender = !Mathf.Approximately(cameraData.renderScale, 1.0f);
-            bool isCompatibleBackbufferTextureDimension = cameraTargetDescriptor.dimension == TextureDimension.Tex2D;
-            bool requiresExplicitMsaaResolve = msaaSamples > 1 && PlatformRequiresExplicitMsaaResolve();
-            bool isOffscreenRender = cameraData.targetTexture != null && !isSceneViewCamera;
-            bool isCapturing = cameraData.captureActions != null;
-
-#if ENABLE_VR && ENABLE_XR_MODULE
-            if (cameraData.xr.enabled)
-            {
-                isScaledRender = false;
-                isCompatibleBackbufferTextureDimension = cameraData.xr.renderTargetDesc.dimension == cameraTargetDescriptor.dimension;
-            }
-#endif
-
-            bool requiresBlitForOffscreenCamera = cameraData.postProcessEnabled || cameraData.requiresOpaqueTexture || requiresExplicitMsaaResolve || !cameraData.isDefaultViewport;
-            if (isOffscreenRender)
-                return requiresBlitForOffscreenCamera;
-
-            return requiresBlitForOffscreenCamera || isSceneViewCamera || isScaledRender || cameraData.isHdrEnabled ||
-                   !isCompatibleBackbufferTextureDimension || isCapturing || cameraData.requireSrgbConversion;
-        }
-
-        bool CanCopyDepth(ref CameraData cameraData)
-        {
-            bool msaaEnabledForCamera = cameraData.cameraTargetDescriptor.msaaSamples > 1;
-            bool supportsTextureCopy = SystemInfo.copyTextureSupport != CopyTextureSupport.None;
-            bool supportsDepthTarget = RenderingUtils.SupportsRenderTextureFormat(RenderTextureFormat.Depth);
-            bool supportsDepthCopy = !msaaEnabledForCamera && (supportsDepthTarget || supportsTextureCopy);
-
-            // TODO:  We don't have support to highp Texture2DMS currently and this breaks depth precision.
-            // currently disabling it until shader changes kick in.
-            //bool msaaDepthResolve = msaaEnabledForCamera && SystemInfo.supportsMultisampledTextures != 0;
-            bool msaaDepthResolve = false;
-            return supportsDepthCopy || msaaDepthResolve;
-        }
-    }
-}

Runtime/ForwardRendererData.cs

@@ -4,11 +4,6 @@ using UnityEditor.ProjectWindowCallback;
 using UnityEditor.Rendering.Universal;
 #endif
 using System;
-<<<<<<< HEAD
-using UnityEngine.Scripting.APIUpdating;
-using System.ComponentModel;
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 namespace UnityEngine.Rendering.Universal
 {
@@ -37,17 +32,6 @@ namespace UnityEngine.Rendering.Universal
             [Reload("Shaders/Utils/Sampling.shader")]
             public Shader samplingPS;
 
-<<<<<<< HEAD
-            [EditorBrowsable(EditorBrowsableState.Never)]
-            //[Reload("Shaders/Utils/TileDepthInfo.shader")]
-            public Shader tileDepthInfoPS;
-
-            [EditorBrowsable(EditorBrowsableState.Never)]
-            //[Reload("Shaders/Utils/TileDeferred.shader")]
-            public Shader tileDeferredPS;
-            
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             [Reload("Shaders/Utils/StencilDeferred.shader")]
             public Shader stencilDeferredPS;
 
@@ -121,12 +105,6 @@ namespace UnityEngine.Rendering.Universal
             set { throw new NotSupportedException(k_ErrorMessage); }
         }
 
-<<<<<<< HEAD
-        /// <summary>
-        /// Rendering mode. Only Forward rendering is supported in this version.
-        /// </summary>
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         public RenderingMode renderingMode
         {
             get { throw new NotSupportedException(k_ErrorMessage); }

Runtime/Materials/Lit.mat

@@ -12,11 +12,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-<<<<<<< HEAD
-  version: 4
-=======
   version: 5
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 --- !u!21 &2100000
 Material:
   serializedVersion: 6
@@ -93,8 +89,6 @@ Material:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
-<<<<<<< HEAD
-=======
     - unity_Lightmaps:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
@@ -107,7 +101,6 @@ Material:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     m_Ints: []
     m_Floats:
     - _AlphaClip: 0

Runtime/Materials/ParticlesUnlit.mat

@@ -12,11 +12,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-<<<<<<< HEAD
-  version: 4
-=======
   version: 5
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 --- !u!21 &2100000
 Material:
   serializedVersion: 6

Runtime/Materials/SimpleLit.mat

@@ -60,8 +60,6 @@ Material:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
-<<<<<<< HEAD
-=======
     - unity_Lightmaps:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
@@ -74,7 +72,6 @@ Material:
         m_Texture: {fileID: 0}
         m_Scale: {x: 1, y: 1}
         m_Offset: {x: 0, y: 0}
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     m_Ints: []
     m_Floats:
     - _AlphaClip: 0
@@ -121,8 +118,4 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-<<<<<<< HEAD
-  version: 4
-=======
   version: 5
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76

Runtime/Materials/TerrainLit.mat

@@ -12,11 +12,7 @@ MonoBehaviour:
   m_Script: {fileID: 11500000, guid: d0353a89b1f911e48b9e16bdc9f2e058, type: 3}
   m_Name: 
   m_EditorClassIdentifier: 
-<<<<<<< HEAD
-  version: 4
-=======
   version: 5
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 --- !u!21 &2100000
 Material:
   serializedVersion: 6

Runtime/Passes/CopyDepthPass.cs

@@ -78,10 +78,6 @@ namespace UnityEngine.Rendering.Universal.Internal
                 if (SystemInfo.supportsMultisampleAutoResolve || SystemInfo.supportsMultisampledTextures == 0)
                     cameraSamples = 1;
 
-                // When auto resolve is supported or multisampled texture is not supported, set camera samples to 1
-                if (SystemInfo.supportsMultisampleAutoResolve || SystemInfo.supportsMultisampledTextures == 0)
-                    cameraSamples = 1;
-
                 CameraData cameraData = renderingData.cameraData;
 
                 switch (cameraSamples)

Runtime/Passes/DrawSkyboxPass.cs

@@ -57,44 +57,26 @@ namespace UnityEngine.Rendering.Universal
                     // Disable Legacy XR path
                     cmd.SetSinglePassStereo(SinglePassStereoMode.None);
                     context.ExecuteCommandBuffer(cmd);
-<<<<<<< HEAD
-                    // We do not need to submit here due to special handling of stereo matricies in core.
-                    // context.Submit();
-                    CommandBufferPool.Release(cmd);
-
-                    renderingData.cameraData.camera.ResetStereoProjectionMatrices();
-                    renderingData.cameraData.camera.ResetStereoViewMatrices();
-=======
                     // We do not need to submit here due to special handling of stereo matrices in core.
                     // context.Submit();
                     CommandBufferPool.Release(cmd);
 
                     camera.ResetStereoProjectionMatrices();
                     camera.ResetStereoViewMatrices();
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                 }
                 else
                 {
                     camera.projectionMatrix = cameraData.GetProjectionMatrix(0);
                     camera.worldToCameraMatrix = cameraData.GetViewMatrix(0);
 
-<<<<<<< HEAD
-                    context.DrawSkybox(renderingData.cameraData.camera);
-=======
                     context.DrawSkybox(camera);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
                     // XRTODO: remove this call because it creates issues with nested profiling scopes
                     // See examples in UniversalRenderPipeline.RenderSingleCamera() and in ScriptableRenderer.Execute()
                     context.Submit(); // Submit and execute the skybox pass before resetting the matrices
 
-<<<<<<< HEAD
-                    renderingData.cameraData.camera.ResetProjectionMatrix();
-                    renderingData.cameraData.camera.ResetWorldToCameraMatrix();
-=======
                     camera.ResetProjectionMatrix();
                     camera.ResetWorldToCameraMatrix();
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                 }
             }
             else

Runtime/Passes/OculusMotionVectorPass.cs.meta

@@ -1,9 +1,5 @@
 fileFormatVersion: 2
-<<<<<<< HEAD
-guid: 7067363c5383b1040853fc79e54b29a0
-=======
 guid: b0d755984f255494bbf1c7d807fd24f9
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 MonoImporter:
   externalObjects: {}
   serializedVersion: 2

Runtime/Passes/PostProcessPass.cs

@@ -149,9 +149,6 @@ namespace UnityEngine.Rendering.Universal.Internal
             m_Descriptor = baseDescriptor;
             m_Descriptor.useMipMap = false;
             m_Descriptor.autoGenerateMips = false;
-<<<<<<< HEAD
-            m_Source = source;
-=======
             m_Source = source.id;
             m_Depth = depth;
             m_InternalLut = internalLut;
@@ -170,7 +167,6 @@ namespace UnityEngine.Rendering.Universal.Internal
             m_Descriptor.useMipMap = false;
             m_Descriptor.autoGenerateMips = false;
             m_Source = source.id;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             m_Destination = destination;
             m_Depth = depth;
             m_InternalLut = internalLut;

Runtime/Passes/RenderObjectsPass.cs

@@ -65,10 +65,6 @@ namespace UnityEngine.Experimental.Rendering.Universal
                 m_ShaderTagIdList.Add(new ShaderTagId("SRPDefaultUnlit"));
                 m_ShaderTagIdList.Add(new ShaderTagId("UniversalForward"));
                 m_ShaderTagIdList.Add(new ShaderTagId("UniversalForwardOnly"));
-<<<<<<< HEAD
-                m_ShaderTagIdList.Add(new ShaderTagId("LightweightForward"));
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             }
 
             m_RenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);

Runtime/ScriptableRenderer.cs

@@ -523,14 +523,11 @@ namespace UnityEngine.Rendering.Universal
             useRenderPassEnabled = data.useNativeRenderPass && SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
             Clear(CameraRenderType.Base);
             m_ActiveRenderPassQueue.Clear();
-<<<<<<< HEAD
-=======
 
             if (UniversalRenderPipeline.asset)
                 m_StoreActionsOptimizationSetting = UniversalRenderPipeline.asset.storeActionsOptimization;
 
             m_UseOptimizedStoreActions = m_StoreActionsOptimizationSetting != StoreActionsOptimization.Store;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
 
         public void Dispose()
@@ -563,8 +560,6 @@ namespace UnityEngine.Rendering.Universal
             m_CameraDepthTarget = depthTarget;
         }
 
-<<<<<<< HEAD
-=======
         internal void ConfigureCameraTarget(RenderTargetIdentifier colorTarget, RenderTargetIdentifier depthTarget, RenderTargetIdentifier resolveTarget)
         {
             m_CameraColorTarget = colorTarget;
@@ -572,7 +567,6 @@ namespace UnityEngine.Rendering.Universal
             m_CameraResolveTarget = resolveTarget;
         }
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         // This should be removed when early camera color target assignment is removed.
         internal void ConfigureCameraColorTarget(RenderTargetIdentifier colorTarget)
         {
@@ -981,15 +975,11 @@ namespace UnityEngine.Rendering.Universal
             context.ExecuteCommandBuffer(cmd);
             CommandBufferPool.Release(cmd);
 
-<<<<<<< HEAD
-            renderPass.Execute(context, ref renderingData);
-=======
             if (IsRenderPassEnabled(renderPass) && cameraData.isRenderPassSupportedCamera)
                 ExecuteNativeRenderPass(context, renderPass, cameraData, ref renderingData);
             else
                 renderPass.Execute(context, ref renderingData);
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #if ENABLE_VR && ENABLE_XR_MODULE
             if (cameraData.xr.enabled && cameraData.xr.hasMarkedLateLatch)
                 cameraData.xr.UnmarkLateLatchShaderProperties(cmd, ref cameraData);
@@ -1212,18 +1202,6 @@ namespace UnityEngine.Rendering.Universal
                         SetRenderTarget(cmd, passColorAttachment, passDepthAttachment, finalClearFlag, finalClearColor, renderPass.colorStoreActions[0], renderPass.depthStoreAction);
 
 #if ENABLE_VR && ENABLE_XR_MODULE
-<<<<<<< HEAD
-                    if (cameraData.xr.enabled)
-                    {
-                        bool isOculusMotionVec = renderPass is Internal.OculusMotionVectorPass;
-
-                        // SetRenderTarget might alter the internal device state(winding order).
-                        // Non-stereo buffer is already updated internally when switching render target. We update stereo buffers here to keep the consistency.
-                        bool isRenderToBackBufferTarget = ((passColorAttachment == cameraData.xr.renderTarget) && !cameraData.xr.renderTargetIsRenderTexture) ||
-                                ((passColorAttachment == cameraData.xr.motionVectorRenderTarget) && !cameraData.xr.motionVectorRenderTargetIsRenderTexture);
-                        cameraData.xr.UpdateGPUViewAndProjectionMatrices(cmd, ref cameraData, !isRenderToBackBufferTarget, isOculusMotionVec);
-                    }
-=======
                         if (cameraData.xr.enabled)
                         {
                             bool isOculusMotionVec = renderPass is Internal.OculusMotionVectorPass;
@@ -1233,7 +1211,6 @@ namespace UnityEngine.Rendering.Universal
                                 ((passColorAttachment == cameraData.xr.motionVectorRenderTarget) && !cameraData.xr.motionVectorRenderTargetIsRenderTexture);
                             cameraData.xr.UpdateGPUViewAndProjectionMatrices(cmd, ref cameraData, !isRenderToBackBufferTarget, isOculusMotionVec);
                         }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #endif
                     }
                 }

Runtime/UniversalAdditionalCameraData.cs

@@ -3,22 +3,8 @@ using System.Collections.Generic;
 using System.Linq;
 using UnityEditor;
 using UnityEngine.Serialization;
-<<<<<<< HEAD
-using UnityEngine.Rendering;
-using System.ComponentModel;
 using UnityEngine.Assertions;
 
-namespace UnityEngine.Rendering.LWRP
-{
-    [Obsolete("LWRP -> Universal (UnityUpgradable) -> UnityEngine.Rendering.Universal.UniversalAdditionalCameraData", true)]
-    public class LWRPAdditionalCameraData
-    {
-    }
-}
-=======
-using UnityEngine.Assertions;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
-
 namespace UnityEngine.Rendering.Universal
 {
     /// <summary>
@@ -283,10 +269,6 @@ namespace UnityEngine.Rendering.Universal
         [SerializeField] bool m_AllowXRRendering = true;
 
         [NonSerialized] Camera m_Camera;
-<<<<<<< HEAD
-
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         // Deprecated:
         [FormerlySerializedAs("requiresDepthTexture"), SerializeField]
         bool m_RequiresDepthTexture = false;
@@ -325,11 +307,8 @@ namespace UnityEngine.Rendering.Universal
                 return m_Camera;
             }
         }
-<<<<<<< HEAD
-=======
 
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         /// <summary>
         /// Controls if this camera should render shadows.
         /// </summary>

Runtime/UniversalRenderPipeline.cs

@@ -332,11 +332,7 @@ namespace UnityEngine.Rendering.Universal
                 cullingParams = cameraData.xr.cullingParams;
 
                 // Sync the FOV on the camera to match the projection from the XR device
-<<<<<<< HEAD
-                if (!cameraData.camera.usePhysicalProperties)
-=======
                 if (!cameraData.camera.usePhysicalProperties && !XRGraphicsAutomatedTests.enabled)
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                     cameraData.camera.fieldOfView = Mathf.Rad2Deg * Mathf.Atan(1.0f / cullingParams.stereoProjectionMatrix.m11) * 2.0f;
 
                 return true;
@@ -514,18 +510,7 @@ namespace UnityEngine.Rendering.Universal
             anyPostProcessingEnabled &= SystemInfo.graphicsDeviceType != GraphicsDeviceType.OpenGLES2;
 
             bool isStackedRendering = lastActiveOverlayCameraIndex != -1;
-            using (new ProfilingScope(null, Profiling.Pipeline.beginCameraRendering))
-            {
-                BeginCameraRendering(context, baseCamera);
-            }
-
-<<<<<<< HEAD
-            // Update volumeframework before initializing additional camera data
-            UpdateVolumeFramework(baseCamera, baseCameraAdditionalData);
-            InitializeCameraData(baseCamera, baseCameraAdditionalData, !isStackedRendering, out var baseCameraData);
 
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #if ENABLE_VR && ENABLE_XR_MODULE
             var xrActive = false;
             var xrRendering = true;
@@ -559,28 +544,12 @@ namespace UnityEngine.Rendering.Universal
                 baseCameraData.isStereoEnabled = xrPass.enabled;
 #pragma warning restore 0618
 
-<<<<<<< HEAD
-                if (baseCameraData.xr.enabled)
-                {
-                    xrActive = true;
-                    // Helper function for updating cameraData with xrPass Data
-                    m_XRSystem.UpdateCameraData(ref baseCameraData, baseCameraData.xr);
-
-                    // Update volume manager to use baseCamera's settings for XR multipass rendering.
-                    if (baseCameraData.xr.multipassId > 0)
-                    {
-                        UpdateVolumeFramework(baseCamera, baseCameraAdditionalData);
-                    }
-					m_XRSystem.BeginLateLatching(baseCamera, xrPass);
-                }
-=======
                 // Helper function for updating cameraData with xrPass Data
                 m_XRSystem.UpdateCameraData(ref baseCameraData, baseCameraData.xr);
                 // Need to update XRSystem using baseCameraData to handle the case where camera position is modified in BeginCameraRendering
                 m_XRSystem.UpdateFromCamera(ref baseCameraData.xr, baseCameraData);
                 m_XRSystem.BeginLateLatching(baseCamera, xrPass);
             }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #endif
 
 #if VISUAL_EFFECT_GRAPH_0_0_1_OR_NEWER
@@ -591,49 +560,12 @@ namespace UnityEngine.Rendering.Universal
             if (asset.useAdaptivePerformance)
                 ApplyAdaptivePerformance(ref baseCameraData);
 #endif
-<<<<<<< HEAD
-                RenderSingleCamera(context, baseCameraData, anyPostProcessingEnabled);
-                using (new ProfilingScope(null, Profiling.Pipeline.endCameraRendering))
-                {
-                    EndCameraRendering(context, baseCamera);
-                }
-#if ENABLE_VR && ENABLE_XR_MODULE
-                m_XRSystem.EndLateLatching(baseCamera, xrPass);
-#endif
-                if (isStackedRendering)
-                {
-                    for (int i = 0; i < cameraStack.Count; ++i)
-                    {
-                        var currCamera = cameraStack[i];
-                        if (!currCamera.isActiveAndEnabled)
-                            continue;
-
-                        currCamera.TryGetComponent<UniversalAdditionalCameraData>(out var currCameraData);
-                        // Camera is overlay and enabled
-                        if (currCameraData != null)
-                        {
-                            // Copy base settings from base camera data and initialize initialize remaining specific settings for this camera type.
-                            CameraData overlayCameraData = baseCameraData;
-                            bool lastCamera = i == lastActiveOverlayCameraIndex;
-
-                            using (new ProfilingScope(null, Profiling.Pipeline.beginCameraRendering))
-                            {
-                                BeginCameraRendering(context, currCamera);
-                            }
-#if VISUAL_EFFECT_GRAPH_0_0_1_OR_NEWER
-                            //It should be called before culling to prepare material. When there isn't any VisualEffect component, this method has no effect.
-                            VFX.VFXManager.PrepareCamera(currCamera);
-#endif
-                            UpdateVolumeFramework(currCamera, currCameraData);
-                            InitializeAdditionalCameraData(currCamera, currCameraData, lastCamera, ref overlayCameraData);
-=======
             RenderSingleCamera(context, baseCameraData, anyPostProcessingEnabled);
             using (new ProfilingScope(null, Profiling.Pipeline.endCameraRendering))
             {
                 EndCameraRendering(context, baseCamera);
             }
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #if ENABLE_VR && ENABLE_XR_MODULE
             m_XRSystem.EndLateLatching(baseCamera, xrPass);
 #endif
@@ -716,15 +648,9 @@ namespace UnityEngine.Rendering.Universal
             bool shouldUpdate = camera.cameraType == CameraType.SceneView;
             shouldUpdate |= additionalCameraData != null && additionalCameraData.requiresVolumeFrameworkUpdate;
 
-<<<<<<< HEAD
-            #if UNITY_EDITOR
-            shouldUpdate |= Application.isPlaying == false;
-            #endif
-=======
 #if UNITY_EDITOR
             shouldUpdate |= Application.isPlaying == false;
 #endif
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
             // When we have volume updates per-frame disabled...
             if (!shouldUpdate && additionalCameraData)
@@ -815,11 +741,7 @@ namespace UnityEngine.Rendering.Universal
 #if ENABLE_VR && ENABLE_XR_MODULE
             // Use XR's MSAA if camera is XR camera. XR MSAA needs special handle here because it is not per Camera.
             // Multiple cameras could render into the same XR display and they should share the same MSAA level.
-<<<<<<< HEAD
-            if (cameraData.xrRendering)
-=======
             if (cameraData.xrRendering && rendererSupportsMSAA)
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                 msaaSamples = XRSystem.GetMSAALevel();
 #endif
 
@@ -1320,8 +1242,6 @@ namespace UnityEngine.Rendering.Universal
 
             // Required for 2D Unlit Shadergraph master node as it doesn't currently support hidden properties.
             Shader.SetGlobalColor(ShaderPropertyId.rendererColor, Color.white);
-<<<<<<< HEAD
-=======
         }
 
         static void CheckAndApplyDebugSettings(ref RenderingData renderingData)
@@ -1416,7 +1336,6 @@ namespace UnityEngine.Rendering.Universal
             }
 
             return filter;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         }
 
 #if ADAPTIVE_PERFORMANCE_2_0_0_OR_NEWER

Runtime/UniversalRenderPipelineCore.cs

@@ -535,45 +535,6 @@ namespace UnityEngine.Rendering.Universal
             return false;
         }
 
-<<<<<<< HEAD
-#if ENABLE_VR && ENABLE_VR_MODULE
-        static List<XR.XRDisplaySubsystem> displaySubsystemList = new List<XR.XRDisplaySubsystem>();
-        static XR.XRDisplaySubsystem GetFirstXRDisplaySubsystem()
-        {
-            XR.XRDisplaySubsystem display = null;
-            SubsystemManager.GetInstances(displaySubsystemList);
-
-            if (displaySubsystemList.Count > 0)
-                display = displaySubsystemList[0];
-
-            return display;
-        }
-
-        // NB: This method is required for a hotfix in Hololens to prevent creating a render texture when using a renderer
-        // with custom render pass.
-        // TODO: Remove this method and usages when we have proper dependency tracking in the pipeline to know
-        // when a render pass requires camera color as input.
-        internal static bool IsRunningHololens(CameraData cameraData)
-        {
-#if PLATFORM_WINRT
-            if (cameraData.xr.enabled)
-            {
-                var platform = Application.platform;
-                if (platform == RuntimePlatform.WSAPlayerX86 || platform == RuntimePlatform.WSAPlayerARM || platform == RuntimePlatform.WSAPlayerX64)
-                {
-                    var displaySubsystem = GetFirstXRDisplaySubsystem();
-                    
-                    if (displaySubsystem != null && !displaySubsystem.displayOpaque)
-                        return true;
-                }
-            }
-#endif
-            return false;
-        }
-#endif
-
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         Comparison<Camera> cameraComparison = (camera1, camera2) => { return (int)camera1.depth - (int)camera2.depth; };
 #if UNITY_2021_1_OR_NEWER
         void SortCameras(List<Camera> cameras)
@@ -625,15 +586,9 @@ namespace UnityEngine.Rendering.Universal
                 desc = camera.targetTexture.descriptor;
                 desc.width = camera.pixelWidth;
                 desc.height = camera.pixelHeight;
-<<<<<<< HEAD
-                if (camera.cameraType == CameraType.SceneView  && !isHdrEnabled)
-                {
-                    desc.graphicsFormat = renderTextureFormatDefault;
-=======
                 if (camera.cameraType == CameraType.SceneView && !isHdrEnabled)
                 {
                     desc.graphicsFormat = SystemInfo.GetGraphicsFormat(DefaultFormat.LDR);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
                 }
                 // SystemInfo.SupportsRenderTextureFormat(camera.targetTexture.descriptor.colorFormat)
                 // will assert on R8_SINT since it isn't a valid value of RenderTextureFormat.
@@ -650,8 +605,6 @@ namespace UnityEngine.Rendering.Universal
             desc.bindMS = false;
             desc.useDynamicScale = camera.allowDynamicResolution;
 
-<<<<<<< HEAD
-=======
             // The way RenderTextures handle MSAA fallback when an unsupported sample count of 2 is requested (falling back to numSamples = 1), differs fom the way
             // the fallback is handled when setting up the Vulkan swapchain (rounding up numSamples to 4, if supported). This caused an issue on Mali GPUs which don't support
             // 2x MSAA.
@@ -665,7 +618,6 @@ namespace UnityEngine.Rendering.Universal
                     desc.msaaSamples = 4;
             }
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             // check that the requested MSAA samples count is supported by the current platform. If it's not supported,
             // replace the requested desc.msaaSamples value with the actual value the engine falls back to
             desc.msaaSamples = SystemInfo.GetRenderTextureSupportedMSAASampleCount(desc);

Runtime/XR/XRPass.cs

@@ -6,10 +6,6 @@
 
 #if ENABLE_VR && ENABLE_XR_MODULE
 
-#if UNITY_2020_3_OR_NEWER && !UNITY_2021_1_OR_NEWER && !UNITY_2020_3_1 && !UNITY_2020_3_2 && !UNITY_2020_3_3 && !UNITY_2020_3_4 && !UNITY_2020_3_5 && !UNITY_2020_3_6 && !UNITY_2020_3_7 && !UNITY_2020_3_8 && !UNITY_2020_3_9 && !UNITY_2020_3_10 && !UNITY_2020_3_11 && !UNITY_2020_3_12 && !UNITY_2020_3_13 && !UNITY_2020_3_14 && !UNITY_2020_3_15 && !UNITY_2020_3_16 && !UNITY_2020_3_17 && !UNITY_2020_3_18 && !UNITY_2020_3_19 && !UNITY_2020_3_20 && !UNITY_2020_3_21
-#define UNITY_2020_3_22_OR_NEWER
-#endif
-
 using System;
 using System.Collections.Generic;
 using UnityEngine.XR;
@@ -60,18 +56,8 @@ namespace UnityEngine.Rendering.Universal
         {
             projMatrix = renderParameter.projection;
             viewMatrix = renderParameter.view;
-<<<<<<< HEAD
-#if UNITY_2020_3_22_OR_NEWER
-            prevViewValid = renderParameter.isPreviousViewValid;
-            prevViewMatrix = (prevViewValid) ? renderParameter.previousView : Matrix4x4.identity;
-#else
-            prevViewValid = false;
-            prevViewMatrix = Matrix4x4.identity;
-#endif
-=======
             prevViewValid = renderParameter.isPreviousViewValid;
             prevViewMatrix = (prevViewValid) ? renderParameter.previousView : Matrix4x4.identity;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             viewport = renderParameter.viewport;
             occlusionMesh = renderParameter.occlusionMesh;
             textureArraySlice = renderParameter.textureArraySlice;
@@ -117,11 +103,7 @@ namespace UnityEngine.Rendering.Universal
         internal Matrix4x4 GetProjMatrix(int viewIndex = 0)  { return views[viewIndex].projMatrix; }
         internal Matrix4x4 GetViewMatrix(int viewIndex = 0)  { return views[viewIndex].viewMatrix; }
         internal bool GetPrevViewValid(int viewIndex = 0) { return views[viewIndex].prevViewValid; }
-<<<<<<< HEAD
-        internal Matrix4x4 GetPrevViewMatrix(int viewIndex = 0)  { return views[viewIndex].prevViewMatrix; }
-=======
         internal Matrix4x4 GetPrevViewMatrix(int viewIndex = 0) { return views[viewIndex].prevViewMatrix; }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         internal int GetTextureArraySlice(int viewIndex = 0) { return views[viewIndex].textureArraySlice; }
         internal Rect GetViewport(int viewIndex = 0)         { return views[viewIndex].viewport; }
 
@@ -270,10 +252,7 @@ namespace UnityEngine.Rendering.Universal
                 Debug.Assert(passInfo.motionVectorRenderTargetValid, "Invalid motion vector render target from XRDisplaySubsystem!");
             }
 
-<<<<<<< HEAD
-=======
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             return passInfo;
         }
 

Runtime/XR/XRSystem.cs

@@ -153,11 +153,7 @@ namespace UnityEngine.Rendering.Universal
             }
         }
 
-<<<<<<< HEAD
-        internal List<XRPass> SetupFrame(CameraData cameraData)
-=======
         internal List<XRPass> SetupFrame(Camera camera, bool enableXRRendering)
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         {
             bool xrEnabled = RefreshXrSdk();
 
@@ -280,30 +276,7 @@ namespace UnityEngine.Rendering.Universal
         // Used for camera stacking where we need to update the parameters per camera
         internal void UpdateFromCamera(ref XRPass xrPass, CameraData cameraData)
         {
-<<<<<<< HEAD
-            bool isGameCamera = (cameraData.camera.cameraType == CameraType.Game || cameraData.camera.cameraType == CameraType.VR);
-            if (XRGraphicsAutomatedTests.enabled && XRGraphicsAutomatedTests.running && isGameCamera)
-            {
-                // XR test framework code path. Update 2nd view with camera's view projection data
-                Matrix4x4 projMatrix = cameraData.camera.projectionMatrix;
-                Matrix4x4 viewMatrix = cameraData.camera.worldToCameraMatrix;
-                Rect      viewport = new Rect(0, 0, testRenderTexture.width, testRenderTexture.height);
-                int       textureArraySlice = -1;
-                xrPass.UpdateView(1, projMatrix, viewMatrix, viewport, textureArraySlice);
-
-                // Update culling params for this xr pass using camera's culling params
-                cameraData.camera.TryGetCullingParameters(false, out var cullingParams);
-                cullingParams.stereoProjectionMatrix = cameraData.camera.projectionMatrix;
-                cullingParams.stereoViewMatrix = cameraData.camera.worldToCameraMatrix;
-
-                //// Disable legacy stereo culling path
-                cullingParams.cullingOptions &= ~CullingOptions.Stereo;
-                xrPass.UpdateCullingParams(0, cullingParams);
-            }
-            else if (xrPass.enabled && display != null)
-=======
             if (xrPass.enabled && display != null)
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             {
                 display.GetRenderPass(xrPass.multipassId, out var renderPass);
                 display.GetCullingParameters(cameraData.camera, renderPass.cullingPassIndex, out var cullingParams);

ShaderLibrary/Input.hlsl

@@ -151,12 +151,8 @@ CBUFFER_END
 #define UNITY_MATRIX_T_MV  transpose(UNITY_MATRIX_MV)
 #define UNITY_MATRIX_IT_MV transpose(mul(UNITY_MATRIX_I_M, UNITY_MATRIX_I_V))
 #define UNITY_MATRIX_MVP   mul(UNITY_MATRIX_VP, UNITY_MATRIX_M)
-<<<<<<< HEAD
-#define UNITY_MATRIX_PREV_M unity_MatrixPreviousM
-=======
 #define UNITY_PREV_MATRIX_M   unity_MatrixPreviousM
 #define UNITY_PREV_MATRIX_I_M unity_MatrixPreviousMI
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 // Note: #include order is important here.
 // UnityInput.hlsl must be included before UnityInstancing.hlsl, so constant buffer

ShaderLibrary/Lighting.hlsl

@@ -18,654 +18,6 @@
     #define OUTPUT_SH(normalWS, OUT) OUT.xyz = SampleSHVertex(normalWS)
 #endif
 
-<<<<<<< HEAD
-// Renamed -> LIGHTMAP_SHADOW_MIXING
-#if !defined(_MIXED_LIGHTING_SUBTRACTIVE) && defined(LIGHTMAP_SHADOW_MIXING) && !defined(SHADOWS_SHADOWMASK)
-    #define _MIXED_LIGHTING_SUBTRACTIVE
-#endif
-
-
-///////////////////////////////////////////////////////////////////////////////
-//                          Light Helpers                                    //
-///////////////////////////////////////////////////////////////////////////////
-
-// Abstraction over Light shading data.
-struct Light
-{
-    half3   direction;
-    half3   color;
-    half    distanceAttenuation;
-    half    shadowAttenuation;
-};
-
-///////////////////////////////////////////////////////////////////////////////
-//                        Attenuation Functions                               /
-///////////////////////////////////////////////////////////////////////////////
-
-// Matches Unity Vanila attenuation
-// Attenuation smoothly decreases to light range.
-float DistanceAttenuation(float distanceSqr, half2 distanceAttenuation)
-{
-    // We use a shared distance attenuation for additional directional and puctual lights
-    // for directional lights attenuation will be 1
-    float lightAtten = rcp(distanceSqr);
-
-#if SHADER_HINT_NICE_QUALITY
-    // Use the smoothing factor also used in the Unity lightmapper.
-    half factor = distanceSqr * distanceAttenuation.x;
-    half smoothFactor = saturate(1.0h - factor * factor);
-    smoothFactor = smoothFactor * smoothFactor;
-#else
-    // We need to smoothly fade attenuation to light range. We start fading linearly at 80% of light range
-    // Therefore:
-    // fadeDistance = (0.8 * 0.8 * lightRangeSq)
-    // smoothFactor = (lightRangeSqr - distanceSqr) / (lightRangeSqr - fadeDistance)
-    // We can rewrite that to fit a MAD by doing
-    // distanceSqr * (1.0 / (fadeDistanceSqr - lightRangeSqr)) + (-lightRangeSqr / (fadeDistanceSqr - lightRangeSqr)
-    // distanceSqr *        distanceAttenuation.y            +             distanceAttenuation.z
-    half smoothFactor = saturate(distanceSqr * distanceAttenuation.x + distanceAttenuation.y);
-#endif
-
-    return lightAtten * smoothFactor;
-}
-
-half AngleAttenuation(half3 spotDirection, half3 lightDirection, half2 spotAttenuation)
-{
-    // Spot Attenuation with a linear falloff can be defined as
-    // (SdotL - cosOuterAngle) / (cosInnerAngle - cosOuterAngle)
-    // This can be rewritten as
-    // invAngleRange = 1.0 / (cosInnerAngle - cosOuterAngle)
-    // SdotL * invAngleRange + (-cosOuterAngle * invAngleRange)
-    // SdotL * spotAttenuation.x + spotAttenuation.y
-
-    // If we precompute the terms in a MAD instruction
-    half SdotL = dot(spotDirection, lightDirection);
-    half atten = saturate(SdotL * spotAttenuation.x + spotAttenuation.y);
-    return atten * atten;
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                      Light Abstraction                                    //
-///////////////////////////////////////////////////////////////////////////////
-
-Light GetMainLight()
-{
-    Light light;
-    light.direction = _MainLightPosition.xyz;
-    light.distanceAttenuation = unity_LightData.z; // unity_LightData.z is 1 when not culled by the culling mask, otherwise 0.
-    light.shadowAttenuation = 1.0;
-    light.color = _MainLightColor.rgb;
-
-    return light;
-}
-
-Light GetMainLight(float4 shadowCoord)
-{
-    Light light = GetMainLight();
-    light.shadowAttenuation = MainLightRealtimeShadow(shadowCoord);
-    return light;
-}
-
-Light GetMainLight(float4 shadowCoord, float3 positionWS, half4 shadowMask)
-{
-    Light light = GetMainLight();
-    light.shadowAttenuation = MainLightShadow(shadowCoord, positionWS, shadowMask, _MainLightOcclusionProbes);
-    return light;
-}
-
-// Fills a light struct given a perObjectLightIndex
-Light GetAdditionalPerObjectLight(int perObjectLightIndex, float3 positionWS)
-{
-    // Abstraction over Light input constants
-#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
-    float4 lightPositionWS = _AdditionalLightsBuffer[perObjectLightIndex].position;
-    half3 color = _AdditionalLightsBuffer[perObjectLightIndex].color.rgb;
-    half4 distanceAndSpotAttenuation = _AdditionalLightsBuffer[perObjectLightIndex].attenuation;
-    half4 spotDirection = _AdditionalLightsBuffer[perObjectLightIndex].spotDirection;
-#else
-    float4 lightPositionWS = _AdditionalLightsPosition[perObjectLightIndex];
-    half3 color = _AdditionalLightsColor[perObjectLightIndex].rgb;
-    half4 distanceAndSpotAttenuation = _AdditionalLightsAttenuation[perObjectLightIndex];
-    half4 spotDirection = _AdditionalLightsSpotDir[perObjectLightIndex];
-#endif
-
-    // Directional lights store direction in lightPosition.xyz and have .w set to 0.0.
-    // This way the following code will work for both directional and punctual lights.
-    float3 lightVector = lightPositionWS.xyz - positionWS * lightPositionWS.w;
-    float distanceSqr = max(dot(lightVector, lightVector), HALF_MIN);
-
-    half3 lightDirection = half3(lightVector * rsqrt(distanceSqr));
-    half attenuation = DistanceAttenuation(distanceSqr, distanceAndSpotAttenuation.xy) * AngleAttenuation(spotDirection.xyz, lightDirection, distanceAndSpotAttenuation.zw);
-
-    Light light;
-    light.direction = lightDirection;
-    light.distanceAttenuation = attenuation;
-    light.shadowAttenuation = 1.0;
-    light.color = color;
-
-    return light;
-}
-
-uint GetPerObjectLightIndexOffset()
-{
-#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
-    return unity_LightData.x;
-#else
-    return 0;
-#endif
-}
-
-// Returns a per-object index given a loop index.
-// This abstract the underlying data implementation for storing lights/light indices
-int GetPerObjectLightIndex(uint index)
-{
-/////////////////////////////////////////////////////////////////////////////////////////////
-// Structured Buffer Path                                                                   /
-//                                                                                          /
-// Lights and light indices are stored in StructuredBuffer. We can just index them.         /
-// Currently all non-mobile platforms take this path :(                                     /
-// There are limitation in mobile GPUs to use SSBO (performance / no vertex shader support) /
-/////////////////////////////////////////////////////////////////////////////////////////////
-#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
-    uint offset = unity_LightData.x;
-    return _AdditionalLightsIndices[offset + index];
-
-/////////////////////////////////////////////////////////////////////////////////////////////
-// UBO path                                                                                 /
-//                                                                                          /
-// We store 8 light indices in float4 unity_LightIndices[2];                                /
-// Due to memory alignment unity doesn't support int[] or float[]                           /
-// Even trying to reinterpret cast the unity_LightIndices to float[] won't work             /
-// it will cast to float4[] and create extra register pressure. :(                          /
-/////////////////////////////////////////////////////////////////////////////////////////////
-#elif !defined(SHADER_API_GLES)
-    // since index is uint shader compiler will implement
-    // div & mod as bitfield ops (shift and mask).
-
-    // TODO: Can we index a float4? Currently compiler is
-    // replacing unity_LightIndicesX[i] with a dp4 with identity matrix.
-    // u_xlat16_40 = dot(unity_LightIndices[int(u_xlatu13)], ImmCB_0_0_0[u_xlati1]);
-    // This increases both arithmetic and register pressure.
-    return unity_LightIndices[index / 4][index % 4];
-#else
-    // Fallback to GLES2. No bitfield magic here :(.
-    // We limit to 4 indices per object and only sample unity_4LightIndices0.
-    // Conditional moves are branch free even on mali-400
-    // small arithmetic cost but no extra register pressure from ImmCB_0_0_0 matrix.
-    half2 lightIndex2 = (index < 2.0h) ? unity_LightIndices[0].xy : unity_LightIndices[0].zw;
-    half i_rem = (index < 2.0h) ? index : index - 2.0h;
-    return (i_rem < 1.0h) ? lightIndex2.x : lightIndex2.y;
-#endif
-}
-
-// Fills a light struct given a loop i index. This will convert the i
-// index to a perObjectLightIndex
-Light GetAdditionalLight(uint i, float3 positionWS)
-{
-    int perObjectLightIndex = GetPerObjectLightIndex(i);
-    return GetAdditionalPerObjectLight(perObjectLightIndex, positionWS);
-}
-
-Light GetAdditionalLight(uint i, float3 positionWS, half4 shadowMask)
-{
-    int perObjectLightIndex = GetPerObjectLightIndex(i);
-    Light light = GetAdditionalPerObjectLight(perObjectLightIndex, positionWS);
-
-#if USE_STRUCTURED_BUFFER_FOR_LIGHT_DATA
-    half4 occlusionProbeChannels = _AdditionalLightsBuffer[perObjectLightIndex].occlusionProbeChannels;
-#else
-    half4 occlusionProbeChannels = _AdditionalLightsOcclusionProbes[perObjectLightIndex];
-#endif
-    light.shadowAttenuation = AdditionalLightShadow(perObjectLightIndex, positionWS, shadowMask, occlusionProbeChannels);
-
-    return light;
-}
-
-int GetAdditionalLightsCount()
-{
-    // TODO: we need to expose in SRP api an ability for the pipeline cap the amount of lights
-    // in the culling. This way we could do the loop branch with an uniform
-    // This would be helpful to support baking exceeding lights in SH as well
-    return min(_AdditionalLightsCount.x, unity_LightData.y);
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                         BRDF Functions                                    //
-///////////////////////////////////////////////////////////////////////////////
-
-#define kDielectricSpec half4(0.04, 0.04, 0.04, 1.0 - 0.04) // standard dielectric reflectivity coef at incident angle (= 4%)
-
-struct BRDFData
-{
-    half3 diffuse;
-    half3 specular;
-    half reflectivity;
-    half perceptualRoughness;
-    half roughness;
-    half roughness2;
-    half grazingTerm;
-
-    // We save some light invariant BRDF terms so we don't have to recompute
-    // them in the light loop. Take a look at DirectBRDF function for detailed explaination.
-    half normalizationTerm;     // roughness * 4.0 + 2.0
-    half roughness2MinusOne;    // roughness^2 - 1.0
-};
-
-half ReflectivitySpecular(half3 specular)
-{
-#if defined(SHADER_API_GLES)
-    return specular.r; // Red channel - because most metals are either monocrhome or with redish/yellowish tint
-#else
-    return max(max(specular.r, specular.g), specular.b);
-#endif
-}
-
-half OneMinusReflectivityMetallic(half metallic)
-{
-    // We'll need oneMinusReflectivity, so
-    //   1-reflectivity = 1-lerp(dielectricSpec, 1, metallic) = lerp(1-dielectricSpec, 0, metallic)
-    // store (1-dielectricSpec) in kDielectricSpec.a, then
-    //   1-reflectivity = lerp(alpha, 0, metallic) = alpha + metallic*(0 - alpha) =
-    //                  = alpha - metallic * alpha
-    half oneMinusDielectricSpec = kDielectricSpec.a;
-    return oneMinusDielectricSpec - metallic * oneMinusDielectricSpec;
-}
-
-inline void InitializeBRDFDataDirect(half3 diffuse, half3 specular, half reflectivity, half oneMinusReflectivity, half smoothness, inout half alpha, out BRDFData outBRDFData)
-{
-    outBRDFData.diffuse = diffuse;
-    outBRDFData.specular = specular;
-    outBRDFData.reflectivity = reflectivity;
-
-    outBRDFData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(smoothness);
-    outBRDFData.roughness           = max(PerceptualRoughnessToRoughness(outBRDFData.perceptualRoughness), HALF_MIN_SQRT);
-    outBRDFData.roughness2          = max(outBRDFData.roughness * outBRDFData.roughness, HALF_MIN);
-    outBRDFData.grazingTerm         = saturate(smoothness + reflectivity);
-    outBRDFData.normalizationTerm   = outBRDFData.roughness * 4.0h + 2.0h;
-    outBRDFData.roughness2MinusOne  = outBRDFData.roughness2 - 1.0h;
-
-#ifdef _ALPHAPREMULTIPLY_ON
-    outBRDFData.diffuse *= alpha;
-    alpha = alpha * oneMinusReflectivity + reflectivity; // NOTE: alpha modified and propagated up.
-#endif
-}
-
-inline void InitializeBRDFData(half3 albedo, half metallic, half3 specular, half smoothness, inout half alpha, out BRDFData outBRDFData)
-{
-#ifdef _SPECULAR_SETUP
-    half reflectivity = ReflectivitySpecular(specular);
-    half oneMinusReflectivity = 1.0 - reflectivity;
-    half3 brdfDiffuse = albedo * (half3(1.0h, 1.0h, 1.0h) - specular);
-    half3 brdfSpecular = specular;
-#else
-    half oneMinusReflectivity = OneMinusReflectivityMetallic(metallic);
-    half reflectivity = 1.0 - oneMinusReflectivity;
-    half3 brdfDiffuse = albedo * oneMinusReflectivity;
-    half3 brdfSpecular = lerp(kDieletricSpec.rgb, albedo, metallic);
-#endif
-
-    InitializeBRDFDataDirect(brdfDiffuse, brdfSpecular, reflectivity, oneMinusReflectivity, smoothness, alpha, outBRDFData);
-}
-
-half3 ConvertF0ForClearCoat15(half3 f0)
-{
-#if defined(SHADER_API_MOBILE)
-    return ConvertF0ForAirInterfaceToF0ForClearCoat15Fast(f0);
-#else
-    return ConvertF0ForAirInterfaceToF0ForClearCoat15(f0);
-#endif
-}
-
-inline void InitializeBRDFDataClearCoat(half clearCoatMask, half clearCoatSmoothness, inout BRDFData baseBRDFData, out BRDFData outBRDFData)
-{
-    // Calculate Roughness of Clear Coat layer
-    outBRDFData.diffuse             = kDielectricSpec.aaa; // 1 - kDielectricSpec
-    outBRDFData.specular            = kDielectricSpec.rgb;
-    outBRDFData.reflectivity        = kDielectricSpec.r;
-
-    outBRDFData.perceptualRoughness = PerceptualSmoothnessToPerceptualRoughness(clearCoatSmoothness);
-    outBRDFData.roughness           = max(PerceptualRoughnessToRoughness(outBRDFData.perceptualRoughness), HALF_MIN_SQRT);
-    outBRDFData.roughness2          = max(outBRDFData.roughness * outBRDFData.roughness, HALF_MIN);
-    outBRDFData.normalizationTerm   = outBRDFData.roughness * 4.0h + 2.0h;
-    outBRDFData.roughness2MinusOne  = outBRDFData.roughness2 - 1.0h;
-    outBRDFData.grazingTerm         = saturate(clearCoatSmoothness + kDielectricSpec.x);
-
-// Relatively small effect, cut it for lower quality
-#if !defined(SHADER_API_MOBILE)
-    // Modify Roughness of base layer using coat IOR
-    half ieta                        = lerp(1.0h, CLEAR_COAT_IETA, clearCoatMask);
-    half coatRoughnessScale          = Sq(ieta);
-    half sigma                       = RoughnessToVariance(PerceptualRoughnessToRoughness(baseBRDFData.perceptualRoughness));
-
-    baseBRDFData.perceptualRoughness = RoughnessToPerceptualRoughness(VarianceToRoughness(sigma * coatRoughnessScale));
-
-    // Recompute base material for new roughness, previous computation should be eliminated by the compiler (as it's unused)
-    baseBRDFData.roughness          = max(PerceptualRoughnessToRoughness(baseBRDFData.perceptualRoughness), HALF_MIN_SQRT);
-    baseBRDFData.roughness2         = max(baseBRDFData.roughness * baseBRDFData.roughness, HALF_MIN);
-    baseBRDFData.normalizationTerm  = baseBRDFData.roughness * 4.0h + 2.0h;
-    baseBRDFData.roughness2MinusOne = baseBRDFData.roughness2 - 1.0h;
-#endif
-
-    // Darken/saturate base layer using coat to surface reflectance (vs. air to surface)
-    baseBRDFData.specular = lerp(baseBRDFData.specular, ConvertF0ForClearCoat15(baseBRDFData.specular), clearCoatMask);
-    // TODO: what about diffuse? at least in specular workflow diffuse should be recalculated as it directly depends on it.
-}
-
-// Computes the specular term for EnvironmentBRDF
-half3 EnvironmentBRDFSpecular(BRDFData brdfData, half fresnelTerm)
-{
-    float surfaceReduction = 1.0 / (brdfData.roughness2 + 1.0);
-    return surfaceReduction * lerp(brdfData.specular, brdfData.grazingTerm, fresnelTerm);
-}
-
-half3 EnvironmentBRDF(BRDFData brdfData, half3 indirectDiffuse, half3 indirectSpecular, half fresnelTerm)
-{
-    half3 c = indirectDiffuse * brdfData.diffuse;
-    c += indirectSpecular * EnvironmentBRDFSpecular(brdfData, fresnelTerm);
-    return c;
-}
-
-// Environment BRDF without diffuse for clear coat
-half3 EnvironmentBRDFClearCoat(BRDFData brdfData, half clearCoatMask, half3 indirectSpecular, half fresnelTerm)
-{
-    float surfaceReduction = 1.0 / (brdfData.roughness2 + 1.0);
-    return indirectSpecular * EnvironmentBRDFSpecular(brdfData, fresnelTerm) * clearCoatMask;
-}
-
-// Computes the scalar specular term for Minimalist CookTorrance BRDF
-// NOTE: needs to be multiplied with reflectance f0, i.e. specular color to complete
-half DirectBRDFSpecular(BRDFData brdfData, half3 normalWS, half3 lightDirectionWS, half3 viewDirectionWS)
-{
-    float3 halfDir = SafeNormalize(float3(lightDirectionWS) + float3(viewDirectionWS));
-
-    float NoH = saturate(dot(normalWS, halfDir));
-    half LoH = saturate(dot(lightDirectionWS, halfDir));
-
-    // GGX Distribution multiplied by combined approximation of Visibility and Fresnel
-    // BRDFspec = (D * V * F) / 4.0
-    // D = roughness^2 / ( NoH^2 * (roughness^2 - 1) + 1 )^2
-    // V * F = 1.0 / ( LoH^2 * (roughness + 0.5) )
-    // See "Optimizing PBR for Mobile" from Siggraph 2015 moving mobile graphics course
-    // https://community.arm.com/events/1155
-
-    // Final BRDFspec = roughness^2 / ( NoH^2 * (roughness^2 - 1) + 1 )^2 * (LoH^2 * (roughness + 0.5) * 4.0)
-    // We further optimize a few light invariant terms
-    // brdfData.normalizationTerm = (roughness + 0.5) * 4.0 rewritten as roughness * 4.0 + 2.0 to a fit a MAD.
-    float d = NoH * NoH * brdfData.roughness2MinusOne + 1.00001f;
-
-    half LoH2 = LoH * LoH;
-    half specularTerm = brdfData.roughness2 / ((d * d) * max(0.1h, LoH2) * brdfData.normalizationTerm);
-
-    // On platforms where half actually means something, the denominator has a risk of overflow
-    // clamp below was added specifically to "fix" that, but dx compiler (we convert bytecode to metal/gles)
-    // sees that specularTerm have only non-negative terms, so it skips max(0,..) in clamp (leaving only min(100,...))
-#if defined (SHADER_API_MOBILE) || defined (SHADER_API_SWITCH)
-    specularTerm = specularTerm - HALF_MIN;
-    specularTerm = clamp(specularTerm, 0.0, 100.0); // Prevent FP16 overflow on mobiles
-#endif
-
-return specularTerm;
-}
-
-// Based on Minimalist CookTorrance BRDF
-// Implementation is slightly different from original derivation: http://www.thetenthplanet.de/archives/255
-//
-// * NDF [Modified] GGX
-// * Modified Kelemen and Szirmay-Kalos for Visibility term
-// * Fresnel approximated with 1/LdotH
-half3 DirectBDRF(BRDFData brdfData, half3 normalWS, half3 lightDirectionWS, half3 viewDirectionWS, bool specularHighlightsOff)
-{
-    // Can still do compile-time optimisation.
-    // If no compile-time optimized, extra overhead if branch taken is around +2.5% on Switch, -10% if not taken.
-    [branch] if (!specularHighlightsOff)
-    {
-        half specularTerm = DirectBRDFSpecular(brdfData, normalWS, lightDirectionWS, viewDirectionWS);
-        half3 color = brdfData.diffuse + specularTerm * brdfData.specular;
-        return color;
-    }
-    else
-        return brdfData.diffuse;
-}
-
-// Based on Minimalist CookTorrance BRDF
-// Implementation is slightly different from original derivation: http://www.thetenthplanet.de/archives/255
-//
-// * NDF [Modified] GGX
-// * Modified Kelemen and Szirmay-Kalos for Visibility term
-// * Fresnel approximated with 1/LdotH
-half3 DirectBRDF(BRDFData brdfData, half3 normalWS, half3 lightDirectionWS, half3 viewDirectionWS)
-{
-#ifndef _SPECULARHIGHLIGHTS_OFF
-    return brdfData.diffuse + DirectBRDFSpecular(brdfData, normalWS, lightDirectionWS, viewDirectionWS) * brdfData.specular;
-#else
-    return brdfData.diffuse;
-#endif
-}
-
-///////////////////////////////////////////////////////////////////////////////
-//                      Global Illumination                                  //
-///////////////////////////////////////////////////////////////////////////////
-
-// Ambient occlusion
-TEXTURE2D_X(_ScreenSpaceOcclusionTexture);
-SAMPLER(sampler_ScreenSpaceOcclusionTexture);
-
-struct AmbientOcclusionFactor
-{
-    half indirectAmbientOcclusion;
-    half directAmbientOcclusion;
-};
-
-half SampleAmbientOcclusion(float2 normalizedScreenSpaceUV)
-{
-    float2 uv = UnityStereoTransformScreenSpaceTex(normalizedScreenSpaceUV);
-    return SAMPLE_TEXTURE2D_X(_ScreenSpaceOcclusionTexture, sampler_ScreenSpaceOcclusionTexture, uv).x;
-}
-
-AmbientOcclusionFactor GetScreenSpaceAmbientOcclusion(float2 normalizedScreenSpaceUV)
-{
-    AmbientOcclusionFactor aoFactor;
-    aoFactor.indirectAmbientOcclusion = SampleAmbientOcclusion(normalizedScreenSpaceUV);
-    aoFactor.directAmbientOcclusion = lerp(1.0, aoFactor.indirectAmbientOcclusion, _AmbientOcclusionParam.w);
-    return aoFactor;
-}
-
-// Samples SH L0, L1 and L2 terms
-half3 SampleSH(half3 normalWS)
-{
-    // LPPV is not supported in Ligthweight Pipeline
-    real4 SHCoefficients[7];
-    SHCoefficients[0] = unity_SHAr;
-    SHCoefficients[1] = unity_SHAg;
-    SHCoefficients[2] = unity_SHAb;
-    SHCoefficients[3] = unity_SHBr;
-    SHCoefficients[4] = unity_SHBg;
-    SHCoefficients[5] = unity_SHBb;
-    SHCoefficients[6] = unity_SHC;
-
-    return max(half3(0, 0, 0), SampleSH9(SHCoefficients, normalWS));
-}
-
-// SH Vertex Evaluation. Depending on target SH sampling might be
-// done completely per vertex or mixed with L2 term per vertex and L0, L1
-// per pixel. See SampleSHPixel
-half3 SampleSHVertex(half3 normalWS)
-{
-#if defined(EVALUATE_SH_VERTEX)
-    return SampleSH(normalWS);
-#elif defined(EVALUATE_SH_MIXED)
-    // no max since this is only L2 contribution
-    return SHEvalLinearL2(normalWS, unity_SHBr, unity_SHBg, unity_SHBb, unity_SHC);
-#endif
-
-    // Fully per-pixel. Nothing to compute.
-    return half3(0.0, 0.0, 0.0);
-}
-
-// SH Pixel Evaluation. Depending on target SH sampling might be done
-// mixed or fully in pixel. See SampleSHVertex
-half3 SampleSHPixel(half3 L2Term, half3 normalWS)
-{
-#if defined(EVALUATE_SH_VERTEX)
-    return L2Term;
-#elif defined(EVALUATE_SH_MIXED)
-    half3 L0L1Term = SHEvalLinearL0L1(normalWS, unity_SHAr, unity_SHAg, unity_SHAb);
-    half3 res = L2Term + L0L1Term;
-#ifdef UNITY_COLORSPACE_GAMMA
-    res = LinearToSRGB(res);
-#endif
-    return max(half3(0, 0, 0), res);
-#endif
-
-    // Default: Evaluate SH fully per-pixel
-    return SampleSH(normalWS);
-}
-
-#if defined(UNITY_DOTS_INSTANCING_ENABLED)
-#define LIGHTMAP_NAME unity_Lightmaps
-#define LIGHTMAP_INDIRECTION_NAME unity_LightmapsInd
-#define LIGHTMAP_SAMPLER_NAME samplerunity_Lightmaps
-#define LIGHTMAP_SAMPLE_EXTRA_ARGS lightmapUV, unity_LightmapIndex.x
-#else
-#define LIGHTMAP_NAME unity_Lightmap
-#define LIGHTMAP_INDIRECTION_NAME unity_LightmapInd
-#define LIGHTMAP_SAMPLER_NAME samplerunity_Lightmap
-#define LIGHTMAP_SAMPLE_EXTRA_ARGS lightmapUV
-#endif
-
-// Sample baked lightmap. Non-Direction and Directional if available.
-// Realtime GI is not supported.
-half3 SampleLightmap(float2 lightmapUV, half3 normalWS)
-{
-#ifdef UNITY_LIGHTMAP_FULL_HDR
-    bool encodedLightmap = false;
-#else
-    bool encodedLightmap = true;
-#endif
-
-    half4 decodeInstructions = half4(LIGHTMAP_HDR_MULTIPLIER, LIGHTMAP_HDR_EXPONENT, 0.0h, 0.0h);
-
-    // The shader library sample lightmap functions transform the lightmap uv coords to apply bias and scale.
-    // However, universal pipeline already transformed those coords in vertex. We pass half4(1, 1, 0, 0) and
-    // the compiler will optimize the transform away.
-    half4 transformCoords = half4(1, 1, 0, 0);
-
-#if defined(LIGHTMAP_ON) && defined(DIRLIGHTMAP_COMBINED)
-    return SampleDirectionalLightmap(TEXTURE2D_LIGHTMAP_ARGS(LIGHTMAP_NAME, LIGHTMAP_SAMPLER_NAME),
-        TEXTURE2D_LIGHTMAP_ARGS(LIGHTMAP_INDIRECTION_NAME, LIGHTMAP_SAMPLER_NAME),
-        LIGHTMAP_SAMPLE_EXTRA_ARGS, transformCoords, normalWS, encodedLightmap, decodeInstructions);
-#elif defined(LIGHTMAP_ON)
-    return SampleSingleLightmap(TEXTURE2D_LIGHTMAP_ARGS(LIGHTMAP_NAME, LIGHTMAP_SAMPLER_NAME), LIGHTMAP_SAMPLE_EXTRA_ARGS, transformCoords, encodedLightmap, decodeInstructions);
-#else
-    return half3(0.0, 0.0, 0.0);
-#endif
-}
-
-// We either sample GI from baked lightmap or from probes.
-// If lightmap: sampleData.xy = lightmapUV
-// If probe: sampleData.xyz = L2 SH terms
-#if defined(LIGHTMAP_ON)
-#define SAMPLE_GI(lmName, shName, normalWSName) SampleLightmap(lmName, normalWSName)
-#else
-#define SAMPLE_GI(lmName, shName, normalWSName) SampleSHPixel(shName, normalWSName)
-#endif
-
-half3 GlossyEnvironmentReflection(half3 reflectVector, half perceptualRoughness, half occlusion)
-{
-#if !defined(_ENVIRONMENTREFLECTIONS_OFF)
-    half mip = PerceptualRoughnessToMipmapLevel(perceptualRoughness);
-    half4 encodedIrradiance = SAMPLE_TEXTURECUBE_LOD(unity_SpecCube0, samplerunity_SpecCube0, reflectVector, mip);
-
-#if defined(UNITY_USE_NATIVE_HDR)
-    half3 irradiance = encodedIrradiance.rgb;
-#else
-    half3 irradiance = DecodeHDREnvironment(encodedIrradiance, unity_SpecCube0_HDR);
-#endif
-
-    return irradiance * occlusion;
-#endif // GLOSSY_REFLECTIONS
-
-    return _GlossyEnvironmentColor.rgb * occlusion;
-}
-
-half3 SubtractDirectMainLightFromLightmap(Light mainLight, half3 normalWS, half3 bakedGI)
-{
-    // Let's try to make realtime shadows work on a surface, which already contains
-    // baked lighting and shadowing from the main sun light.
-    // Summary:
-    // 1) Calculate possible value in the shadow by subtracting estimated light contribution from the places occluded by realtime shadow:
-    //      a) preserves other baked lights and light bounces
-    //      b) eliminates shadows on the geometry facing away from the light
-    // 2) Clamp against user defined ShadowColor.
-    // 3) Pick original lightmap value, if it is the darkest one.
-
-
-    // 1) Gives good estimate of illumination as if light would've been shadowed during the bake.
-    // We only subtract the main direction light. This is accounted in the contribution term below.
-    half shadowStrength = GetMainLightShadowStrength();
-    half contributionTerm = saturate(dot(mainLight.direction, normalWS));
-    half3 lambert = mainLight.color * contributionTerm;
-    half3 estimatedLightContributionMaskedByInverseOfShadow = lambert * (1.0 - mainLight.shadowAttenuation);
-    half3 subtractedLightmap = bakedGI - estimatedLightContributionMaskedByInverseOfShadow;
-
-    // 2) Allows user to define overall ambient of the scene and control situation when realtime shadow becomes too dark.
-    half3 realtimeShadow = max(subtractedLightmap, _SubtractiveShadowColor.xyz);
-    realtimeShadow = lerp(bakedGI, realtimeShadow, shadowStrength);
-
-    // 3) Pick darkest color
-    return min(bakedGI, realtimeShadow);
-}
-
-half3 GlobalIllumination(BRDFData brdfData, BRDFData brdfDataClearCoat, float clearCoatMask,
-    half3 bakedGI, half occlusion,
-    half3 normalWS, half3 viewDirectionWS)
-{
-    half3 reflectVector = reflect(-viewDirectionWS, normalWS);
-    half NoV = saturate(dot(normalWS, viewDirectionWS));
-    half fresnelTerm = Pow4(1.0 - NoV);
-
-    half3 indirectDiffuse = bakedGI * occlusion;
-    half3 indirectSpecular = GlossyEnvironmentReflection(reflectVector, brdfData.perceptualRoughness, occlusion);
-
-    half3 color = EnvironmentBRDF(brdfData, indirectDiffuse, indirectSpecular, fresnelTerm);
-
-#if defined(_CLEARCOAT) || defined(_CLEARCOATMAP)
-    half3 coatIndirectSpecular = GlossyEnvironmentReflection(reflectVector, brdfDataClearCoat.perceptualRoughness, occlusion);
-    // TODO: "grazing term" causes problems on full roughness
-    half3 coatColor = EnvironmentBRDFClearCoat(brdfDataClearCoat, clearCoatMask, coatIndirectSpecular, fresnelTerm);
-
-    // Blend with base layer using khronos glTF recommended way using NoV
-    // Smooth surface & "ambiguous" lighting
-    // NOTE: fresnelTerm (above) is pow4 instead of pow5, but should be ok as blend weight.
-    half coatFresnel = kDielectricSpec.x + kDielectricSpec.a * fresnelTerm;
-    return color * (1.0 - coatFresnel * clearCoatMask) + coatColor;
-#else
-    return color;
-#endif
-}
-
-// Backwards compatiblity
-half3 GlobalIllumination(BRDFData brdfData, half3 bakedGI, half occlusion, half3 normalWS, half3 viewDirectionWS)
-{
-    const BRDFData noClearCoat = (BRDFData)0;
-    return GlobalIllumination(brdfData, noClearCoat, 0.0, bakedGI, occlusion, normalWS, viewDirectionWS);
-}
-
-void MixRealtimeAndBakedGI(inout Light light, half3 normalWS, inout half3 bakedGI)
-{
-#if defined(LIGHTMAP_ON) && defined(_MIXED_LIGHTING_SUBTRACTIVE)
-    bakedGI = SubtractDirectMainLightFromLightmap(light, normalWS, bakedGI);
-#endif
-}
-
-// Backwards compatiblity
-void MixRealtimeAndBakedGI(inout Light light, half3 normalWS, inout half3 bakedGI, half4 shadowMask)
-{
-    MixRealtimeAndBakedGI(light, normalWS, bakedGI);
-}
-
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 ///////////////////////////////////////////////////////////////////////////////
 //                      Lighting Functions                                   //
 ///////////////////////////////////////////////////////////////////////////////

ShaderLibrary/OculusMotionVectorCore.hlsl

@@ -15,8 +15,6 @@ struct Varyings
     UNITY_VERTEX_OUTPUT_STEREO
 };
 
-<<<<<<< HEAD
-=======
 bool IsSmoothRotation(float3 prevAxis1, float3 prevAxis2, float3 currAxis1, float3 currAxis2)
 {
     float angleThreshold = 0.984f; // cos(10 degrees)
@@ -41,7 +39,6 @@ Varyings vertParticles(Attributes input)
     return output;
 }
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 Varyings vert(Attributes input)
 {
     Varyings output = (Varyings)0;
@@ -62,9 +59,6 @@ Varyings vert(Attributes input)
         bool hasDeformation = unity_MotionVectorsParams.x > 0.0;
         float3 effectivePositionOS = (hasDeformation ? input.previousPositionOS : input.positionOS.xyz);
         float3 previousWS = TransformPreviousObjectToWorld(effectivePositionOS);
-<<<<<<< HEAD
-        output.prevPositionCS = TransformWorldToPrevHClip(previousWS);
-=======
 
         float4x4 previousOTW = GetPrevObjectToWorldMatrix();
         float4x4 currentOTW = GetObjectToWorldMatrix();
@@ -76,7 +70,6 @@ Varyings vert(Attributes input)
         {
             output.prevPositionCS = TransformWorldToPrevHClip(previousWS);
         }
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     }
 
     return output;

ShaderLibrary/OculusMotionVectorCore.hlsl.meta

@@ -1,16 +1,7 @@
 fileFormatVersion: 2
-<<<<<<< HEAD
-guid: 3b70aa8fbb58fcf44abf17fae4d75d4c
-ShaderImporter:
-  externalObjects: {}
-  defaultTextures: []
-  nonModifiableTextures: []
-  preprocessorOverride: 0
-=======
 guid: 99ad40ad175bccc4ca8fda2e17d92f0a
 ShaderIncludeImporter:
   externalObjects: {}
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
   userData: 
   assetBundleName: 
   assetBundleVariant: 

ShaderLibrary/Particles.hlsl

@@ -102,11 +102,7 @@ float SoftParticles(float near, float far, ParticleParams params)
     if (near > 0.0 || far > 0.0)
     {
         float rawDepth = SampleSceneDepth(params.projectedPosition.xy / params.projectedPosition.w);
-<<<<<<< HEAD
-        float sceneZ = LinearEyeDepth(rawDepth, _ZBufferParams);
-=======
         float sceneZ = (unity_OrthoParams.w == 0) ? LinearEyeDepth(rawDepth, _ZBufferParams) : LinearDepthToEyeDepth(rawDepth);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         float thisZ = LinearEyeDepth(params.positionWS.xyz, GetWorldToViewMatrix());
         fade = saturate(far * ((sceneZ - near) - thisZ));
     }

ShaderLibrary/ShaderTypes.cs.hlsl

@@ -1,9 +1,5 @@
 //
-<<<<<<< HEAD
-// This file was automatically generated. Please don't edit by hand. Execute Editor command [ Edit / Render Pipeline / Generate Shader Includes ] instead
-=======
 // This file was automatically generated. Please don't edit by hand. Execute Editor command [ Edit > Rendering > Generate Shader Includes ] instead
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 //
 
 #ifndef SHADERTYPES_CS_HLSL

ShaderLibrary/UnityInput.hlsl

@@ -146,17 +146,11 @@ real4 unity_SHBr;
 real4 unity_SHBg;
 real4 unity_SHBb;
 real4 unity_SHC;
-<<<<<<< HEAD
-float4x4 unity_MatrixPreviousM;
-float4x4 unity_MatrixPreviousMI;
-//X : Use last frame positions (right now skinned meshes are the only objects that use this)
-=======
 
 // Velocity
 float4x4 unity_MatrixPreviousM;
 float4x4 unity_MatrixPreviousMI;
 //X : Use last frame positions (right now skinned meshes are the only objects that use this
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 //Y : Force No Motion
 //Z : Z bias value
 //W : Camera only

Shaders/BakedLit.shader

@@ -73,99 +73,7 @@ Shader "Universal Render Pipeline/Baked Lit"
 
             // Lighting include is needed because of GI
             #include "Packages/com.unity.render-pipelines.universal/Shaders/BakedLitInput.hlsl"
-<<<<<<< HEAD
-            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
-
-            struct Attributes
-            {
-                float4 positionOS       : POSITION;
-                float2 uv               : TEXCOORD0;
-                float2 lightmapUV       : TEXCOORD1;
-                float3 normalOS         : NORMAL;
-                float4 tangentOS        : TANGENT;
-
-                UNITY_VERTEX_INPUT_INSTANCE_ID
-            };
-
-            struct Varyings
-            {
-                float3 uv0AndFogCoord           : TEXCOORD0; // xy: uv0, z: fogCoord
-                DECLARE_LIGHTMAP_OR_SH(lightmapUV, vertexSH, 1);
-                half3 normalWS                  : TEXCOORD2;
-    #if defined(_NORMALMAP)
-                half4 tangentWS                 : TEXCOORD3;
-    #endif
-                float4 vertex : SV_POSITION;
-
-                UNITY_VERTEX_INPUT_INSTANCE_ID
-                UNITY_VERTEX_OUTPUT_STEREO
-            };
-
-            Varyings vert(Attributes input)
-            {
-                Varyings output = (Varyings)0;
-
-                UNITY_SETUP_INSTANCE_ID(input);
-                UNITY_TRANSFER_INSTANCE_ID(input, output);
-                UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(output);
-
-                VertexPositionInputs vertexInput = GetVertexPositionInputs(input.positionOS.xyz);
-                output.vertex = vertexInput.positionCS;
-                output.uv0AndFogCoord.xy = TRANSFORM_TEX(input.uv, _BaseMap);
-                output.uv0AndFogCoord.z = ComputeFogFactor(vertexInput.positionCS.z);
-
-                // normalWS and tangentWS already normalize.
-                // this is required to avoid skewing the direction during interpolation
-                // also required for per-vertex SH evaluation
-                VertexNormalInputs normalInput = GetVertexNormalInputs(input.normalOS, input.tangentOS);
-                output.normalWS = normalInput.normalWS;
-    #if defined(_NORMALMAP)
-                real sign = input.tangentOS.w * GetOddNegativeScale();
-                output.tangentWS = half4(normalInput.tangentWS.xyz, sign);
-    #endif
-                OUTPUT_LIGHTMAP_UV(input.lightmapUV, unity_LightmapST, output.lightmapUV);
-                OUTPUT_SH(output.normalWS, output.vertexSH);
-
-                return output;
-            }
-
-            half4 frag(Varyings input) : SV_Target
-            {
-                UNITY_SETUP_INSTANCE_ID(input);
-                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
-
-                half2 uv = input.uv0AndFogCoord.xy;
-                half4 texColor = SAMPLE_TEXTURE2D(_BaseMap, sampler_BaseMap, uv);
-                half3 color = texColor.rgb * _BaseColor.rgb;
-                half alpha = texColor.a * _BaseColor.a;
-                AlphaDiscard(alpha, _Cutoff);
-
-#ifdef _ALPHAPREMULTIPLY_ON
-                color *= alpha;
-#endif
-
-    #if defined(_NORMALMAP)
-                half3 normalTS = SampleNormal(uv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap)).xyz;
-                float sgn = input.tangentWS.w;      // should be either +1 or -1
-                float3 bitangent = sgn * cross(input.normalWS.xyz, input.tangentWS.xyz);
-                half3 normalWS = TransformTangentToWorld(normalTS, half3x3(input.tangentWS.xyz, bitangent, input.normalWS));
-    #else
-                half3 normalWS = input.normalWS;
-    #endif
-                normalWS = NormalizeNormalPerPixel(normalWS);
-                color *= SAMPLE_GI(input.lightmapUV, input.vertexSH, normalWS);
-                #if defined(_SCREEN_SPACE_OCCLUSION)
-                    float2 normalizedScreenSpaceUV = GetNormalizedScreenSpaceUV(input.vertex);
-                    color *= SampleAmbientOcclusion(normalizedScreenSpaceUV);
-                #endif
-                color = MixFog(color, input.uv0AndFogCoord.z);
-                alpha = OutputAlpha(alpha, _Surface);
-
-                return half4(color, alpha);
-            }
-=======
             #include "Packages/com.unity.render-pipelines.universal/Shaders/BakedLitForwardPass.hlsl"
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             ENDHLSL
         }
 

Shaders/BakedLitDepthNormalsPass.hlsl.meta

@@ -1,9 +1,5 @@
 fileFormatVersion: 2
-<<<<<<<< HEAD:com.unity.shadergraph/ShaderGraphLibrary/LODDitheringTransition.hlsl.meta
-guid: 5248225944112fb418a213fa587fe10d
-========
 guid: 9604e389528d04ae39fe05a7b4212172
->>>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76:com.unity.render-pipelines.universal/Shaders/BakedLitDepthNormalsPass.hlsl.meta
 ShaderImporter:
   externalObjects: {}
   defaultTextures: []

Shaders/Nature/SpeedTree7CommonPasses.hlsl

@@ -271,10 +271,6 @@ half4 SpeedTree7FragDepthNormal(SpeedTreeVertexDepthNormalOutput input) : SV_Tar
         AlphaDiscard(diffuse.a, _Cutoff);
     #endif
 
-<<<<<<< HEAD
-    float3 normalWS = input.normalWS.xyz;
-    return float4(PackNormalOctRectEncode(TransformWorldToViewDir(normalWS, true)), 0.0, 0.0);
-=======
     #if defined(EFFECT_BUMP)
         half3 normalTS = SampleNormal(uv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap));
         #ifdef GEOM_TYPE_BRANCH_DETAIL
@@ -289,7 +285,6 @@ half4 SpeedTree7FragDepthNormal(SpeedTreeVertexDepthNormalOutput input) : SV_Tar
     #endif
 
     return half4(NormalizeNormalPerPixel(normalWS), 0.0);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 }
 
 #endif

Shaders/Nature/SpeedTree8Passes.hlsl

@@ -365,16 +365,12 @@ half4 SpeedTree8Frag(SpeedTreeFragmentInput input) : SV_Target
 
 #if !defined(SHADER_QUALITY_LOW)
     #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
-<<<<<<< HEAD
-        LODDitheringTransition(input.interpolated.clipPos.xy, unity_LODFade.x);
-=======
         #ifdef EFFECT_BUMP
             half3 viewDirectionWS = half3(input.interpolated.normalWS.w, input.interpolated.tangentWS.w, input.interpolated.bitangentWS.w);
         #else
             half3 viewDirectionWS = input.interpolated.viewDirWS;
         #endif
         LODDitheringTransition(ComputeFadeMaskSeed(viewDirectionWS, input.interpolated.clipPos.xy), unity_LODFade.x);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     #endif
 #endif
 
@@ -456,21 +452,6 @@ half4 SpeedTree8Frag(SpeedTreeFragmentInput input) : SV_Target
     emission = directSubsurface + indirectSubsurface;
     #endif
 
-    // subsurface (hijack emissive)
-    #ifdef EFFECT_SUBSURFACE
-    	Light mainLight = GetMainLight();
-	half fSubsurfaceRough = 0.7 - smoothness * 0.5;
-	half fSubsurface = D_GGX(clamp(-dot(mainLight.direction.xyz, inputData.viewDirectionWS.xyz), 0, 1), fSubsurfaceRough); 
-
-    float4 shadowCoord = TransformWorldToShadowCoord(inputData.positionWS);
-    half realtimeShadow = MainLightRealtimeShadow(shadowCoord);
-	float3 tintedSubsurface = tex2D(_SubsurfaceTex, uv).rgb * _SubsurfaceColor.rgb;
-        float3 directSubsurface = tintedSubsurface.rgb * mainLight.color.rgb * fSubsurface * realtimeShadow; 
-	float3 indirectSubsurface = tintedSubsurface.rgb * inputData.bakedGI.rgb * _SubsurfaceIndirect;
-	emission = directSubsurface + indirectSubsurface;
-    #endif
-
-
 #ifdef GBUFFER
     // in LitForwardPass GlobalIllumination (and temporarily LightingPhysicallyBased) are called inside UniversalFragmentPBR
     // in Deferred rendering we store the sum of these values (and of emission as well) in the GBuffer
@@ -517,11 +498,7 @@ half4 SpeedTree8FragDepth(SpeedTreeVertexDepthOutput input) : SV_Target
 
 #if !defined(SHADER_QUALITY_LOW)
     #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
-<<<<<<< HEAD
-        LODDitheringTransition(input.clipPos.xy, unity_LODFade.x);
-=======
         LODDitheringTransition(ComputeFadeMaskSeed(input.viewDirWS, input.clipPos.xy), unity_LODFade.x);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     #endif
 #endif
 
@@ -580,16 +557,12 @@ half4 SpeedTree8FragDepthNormal(SpeedTreeDepthNormalFragmentInput input) : SV_Ta
 
     #if !defined(SHADER_QUALITY_LOW)
         #ifdef LOD_FADE_CROSSFADE // enable dithering LOD transition if user select CrossFade transition in LOD group
-<<<<<<< HEAD
-            LODDitheringTransition(input.interpolated.clipPos.xy, unity_LODFade.x);
-=======
             #ifdef EFFECT_BUMP
                 half3 viewDirectionWS = half3(input.interpolated.normalWS.w, input.interpolated.tangentWS.w, input.interpolated.bitangentWS.w);
             #else
                 half3 viewDirectionWS = input.interpolated.viewDirWS;
             #endif
             LODDitheringTransition(ComputeFadeMaskSeed(viewDirectionWS, input.interpolated.clipPos.xy), unity_LODFade.x);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         #endif
     #endif
 
@@ -599,10 +572,6 @@ half4 SpeedTree8FragDepthNormal(SpeedTreeDepthNormalFragmentInput input) : SV_Ta
     half alpha = diffuse.a * input.interpolated.color.a;
     AlphaDiscard(alpha, 0.3333);
 
-<<<<<<< HEAD
-    float3 normalWS = NormalizeNormalPerPixel(input.interpolated.normalWS.xyz);
-    return float4(PackNormalOctRectEncode(TransformWorldToViewDir(normalWS, true)), 0.0, 0.0);
-=======
     // normal
     #if defined(EFFECT_BUMP)
         half3 normalTs = SampleNormal(uv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap));
@@ -630,7 +599,6 @@ half4 SpeedTree8FragDepthNormal(SpeedTreeDepthNormalFragmentInput input) : SV_Ta
     #else
         return half4(NormalizeNormalPerPixel(input.interpolated.normalWS), 0.0h);
     #endif
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 }
 
 #endif

Shaders/Particles/ParticlesDepthNormalsPass.hlsl.meta

@@ -1,9 +1,5 @@
 fileFormatVersion: 2
-<<<<<<<< HEAD:com.unity.shadergraph/ShaderGraphLibrary/Nature/SpeedTree8Wind.hlsl.meta
-guid: 8b4aa8c48881d4142b1c30e408b503d8
-========
 guid: 637c27b6fe6224a06b2b066769d0a6e6
->>>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76:com.unity.render-pipelines.universal/Shaders/Particles/ParticlesDepthNormalsPass.hlsl.meta
 ShaderImporter:
   externalObjects: {}
   defaultTextures: []

Shaders/Particles/ParticlesInput.hlsl

@@ -5,21 +5,6 @@
 
 struct AttributesParticle
 {
-<<<<<<< HEAD
-    float4 vertex : POSITION;
-    half4 color : COLOR;
-
-    #if defined(_FLIPBOOKBLENDING_ON) && !defined(UNITY_PARTICLE_INSTANCING_ENABLED)
-        float4 texcoords : TEXCOORD0;
-        float texcoordBlend : TEXCOORD1;
-    #else
-        float2 texcoords : TEXCOORD0;
-    #endif
-
-    #if !defined(PARTICLES_EDITOR_META_PASS)
-        float3 normal : NORMAL;
-        float4 tangent : TANGENT;
-=======
     float4 positionOS               : POSITION;
     half4 color                     : COLOR;
 
@@ -33,7 +18,6 @@ struct AttributesParticle
     #if !defined(PARTICLES_EDITOR_META_PASS)
         float3 normalOS             : NORMAL;
         float4 tangentOS            : TANGENT;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     #endif
     UNITY_VERTEX_INPUT_INSTANCE_ID
 };
@@ -52,21 +36,12 @@ struct VaryingsParticle
         float4 positionWS           : TEXCOORD1;
 
         #ifdef _NORMALMAP
-<<<<<<< HEAD
-            float4 normalWS         : TEXCOORD2;    // xyz: normal, w: viewDir.x
-            float4 tangentWS        : TEXCOORD3;    // xyz: tangent, w: viewDir.y
-            float4 bitangentWS      : TEXCOORD4;    // xyz: bitangent, w: viewDir.z
-        #else
-            float3 normalWS         : TEXCOORD2;
-            float3 viewDirWS        : TEXCOORD3;
-=======
             half4 normalWS         : TEXCOORD2;    // xyz: normal, w: viewDir.x
             half4 tangentWS        : TEXCOORD3;    // xyz: tangent, w: viewDir.y
             half4 bitangentWS      : TEXCOORD4;    // xyz: bitangent, w: viewDir.z
         #else
             half3 normalWS         : TEXCOORD2;
             half3 viewDirWS        : TEXCOORD3;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         #endif
 
         #if defined(_SOFTPARTICLES_ON) || defined(_FADING_ON) || defined(_DISTORTION_ON)
@@ -77,9 +52,6 @@ struct VaryingsParticle
             float4 shadowCoord      : TEXCOORD7;
         #endif
 
-<<<<<<< HEAD
-        float3 vertexSH             : TEXCOORD8; // SH
-=======
         half3 vertexSH             : TEXCOORD8; // SH
     #endif
 
@@ -168,7 +140,6 @@ struct VaryingsDepthNormalsParticle
     #else
         float3 normalWS                 : TEXCOORD2;
         float3 viewDirWS                : TEXCOORD3;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     #endif
 
     UNITY_VERTEX_INPUT_INSTANCE_ID

Shaders/Particles/ParticlesLitForwardPass.hlsl

@@ -4,19 +4,11 @@
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Particles.hlsl"
 
-<<<<<<< HEAD
-void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData output)
-{
-    output = (InputData)0;
-
-    output.positionWS = input.positionWS.xyz;
-=======
 void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData inputData)
 {
     inputData = (InputData)0;
 
     inputData.positionWS = input.positionWS.xyz;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 #ifdef _NORMALMAP
     half3 viewDirWS = half3(input.normalWS.w, input.tangentWS.w, input.bitangentWS.w);

Shaders/Particles/ParticlesLitGbufferPass.hlsl

@@ -4,20 +4,12 @@
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UnityGBuffer.hlsl"
 
-<<<<<<< HEAD
-void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData output)
-{
-    output = (InputData)0;
-
-    output.positionWS = input.positionWS.xyz;
-=======
 void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData inputData)
 {
     inputData = (InputData)0;
 
     inputData.positionWS = input.positionWS.xyz;
     inputData.positionCS = input.clipPos;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 #ifdef _NORMALMAP
     half3 viewDirWS = half3(input.normalWS.w, input.tangentWS.w, input.bitangentWS.w);

Shaders/Particles/ParticlesLitInput.hlsl

@@ -71,11 +71,7 @@ half4 SampleAlbedo(TEXTURE2D_PARAM(albedoMap, sampler_albedoMap), ParticleParams
     colorAddSubDiff = _BaseColorAddSubDiff;
 #endif
     // No distortion Support
-<<<<<<< HEAD
-    albedo = MixParticleColor(albedo, params.vertexColor, colorAddSubDiff);
-=======
     albedo = MixParticleColor(albedo, half4(params.vertexColor), colorAddSubDiff);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
     AlphaDiscard(albedo.a, _Cutoff);
 
@@ -166,42 +162,4 @@ inline void InitializeParticleLitSurfaceData(ParticleParams params, out SurfaceD
     outSurfaceData.clearCoatSmoothness = half(1.0);
 }
 
-inline void InitializeParticleLitSurfaceData(ParticleParams params, out SurfaceData outSurfaceData)
-{
-    half4 albedo = SampleAlbedo(TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), params);
-
-    #if defined(_METALLICSPECGLOSSMAP)
-        half2 metallicGloss = BlendTexture(TEXTURE2D_ARGS(_MetallicGlossMap, sampler_MetallicGlossMap), params.uv, params.blendUv).ra * half2(1.0, _Smoothness);
-    #else
-        half2 metallicGloss = half2(_Metallic, _Smoothness);
-    #endif
-
-    half3 normalTS = SampleNormalTS(params.uv, params.blendUv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap), _BumpScale);
-
-    #if defined(_EMISSION)
-        half3 emission = BlendTexture(TEXTURE2D_ARGS(_EmissionMap, sampler_EmissionMap), params.uv, params.blendUv).rgb * _EmissionColor.rgb;
-    #else
-        half3 emission = half3(0, 0, 0);
-    #endif
-
-    #if defined(_DISTORTION_ON)
-        albedo.rgb = Distortion(albedo, normalTS, _DistortionStrengthScaled, _DistortionBlend, params.projectedPosition);
-    #endif
-
-    outSurfaceData = (SurfaceData)0;
-    outSurfaceData.albedo = albedo.rgb;
-    outSurfaceData.specular = half3(0.0h, 0.0h, 0.0h);
-    outSurfaceData.normalTS = normalTS;
-    outSurfaceData.emission = emission;
-    outSurfaceData.metallic = metallicGloss.r;
-    outSurfaceData.smoothness = metallicGloss.g;
-    outSurfaceData.occlusion = 1.0;
-
-    outSurfaceData.albedo = AlphaModulate(outSurfaceData.albedo, albedo.a);
-    outSurfaceData.alpha = albedo.a;
-
-    outSurfaceData.clearCoatMask       = 0.0h;
-    outSurfaceData.clearCoatSmoothness = 1.0h;
-}
-
 #endif // UNIVERSAL_PARTICLES_LIT_INPUT_INCLUDED

Shaders/Particles/ParticlesSimpleLitForwardPass.hlsl

@@ -4,19 +4,11 @@
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Particles.hlsl"
 
-<<<<<<< HEAD
-void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData output)
-{
-    output = (InputData)0;
-
-    output.positionWS = input.positionWS.xyz;
-=======
 void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData inputData)
 {
     inputData = (InputData)0;
 
     inputData.positionWS = input.positionWS.xyz;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 #ifdef _NORMALMAP
     half3 viewDirWS = half3(input.normalWS.w, input.tangentWS.w, input.bitangentWS.w);
@@ -130,10 +122,6 @@ half4 ParticlesLitFragment(VaryingsParticle input) : SV_Target
     half3 emission = half3(0, 0, 0);
 #endif
     half4 specularGloss = SampleSpecularSmoothness(particleParams.uv, particleParams.blendUv, albedo.a, _SpecColor, TEXTURE2D_ARGS(_SpecGlossMap, sampler_SpecGlossMap));
-<<<<<<< HEAD
-    half shininess = specularGloss.a;
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 #if defined(_DISTORTION_ON)
     diffuse = Distortion(half4(diffuse, alpha), normalTS, _DistortionStrengthScaled, _DistortionBlend, particleParams.projectedPosition);
@@ -142,12 +130,8 @@ half4 ParticlesLitFragment(VaryingsParticle input) : SV_Target
     InputData inputData;
     InitializeInputData(input, normalTS, inputData);
 
-<<<<<<< HEAD
-    half4 color = UniversalFragmentBlinnPhong(inputData, diffuse, specularGloss, shininess, emission, alpha);
-=======
     half4 color = UniversalFragmentBlinnPhong(inputData, diffuse, specularGloss, specularGloss.a, emission, alpha, normalTS);
 
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     color.rgb = MixFog(color.rgb, inputData.fogCoord);
     color.a = OutputAlpha(color.a, _Surface);
 

Shaders/Particles/ParticlesSimpleLitGBufferPass.hlsl

@@ -5,20 +5,12 @@
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/UnityGBuffer.hlsl"
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Particles.hlsl"
 
-<<<<<<< HEAD
-void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData output)
-{
-    output = (InputData)0;
-
-    output.positionWS = input.positionWS.xyz;
-=======
 void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData inputData)
 {
     inputData = (InputData)0;
 
     inputData.positionWS = input.positionWS.xyz;
     inputData.positionCS = input.clipPos;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 #ifdef _NORMALMAP
     half3 viewDirWS = half3(input.normalWS.w, input.tangentWS.w, input.bitangentWS.w);

Shaders/Particles/ParticlesSimpleLitInput.hlsl

@@ -63,11 +63,7 @@ half4 SampleAlbedo(TEXTURE2D_PARAM(albedoMap, sampler_albedoMap), ParticleParams
     #if defined (_COLORADDSUBDIFF_ON)
         colorAddSubDiff = _BaseColorAddSubDiff;
     #endif
-<<<<<<< HEAD
-    albedo = MixParticleColor(albedo, params.vertexColor, colorAddSubDiff);
-=======
     albedo = MixParticleColor(albedo, half4(params.vertexColor), colorAddSubDiff);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
     AlphaDiscard(albedo.a, _Cutoff);
 

Shaders/Particles/ParticlesUnlitForwardPass.hlsl

@@ -1,16 +1,6 @@
 #ifndef UNIVERSAL_PARTICLES_UNLIT_FORWARD_PASS_INCLUDED
 #define UNIVERSAL_PARTICLES_UNLIT_FORWARD_PASS_INCLUDED
 
-<<<<<<< HEAD
-#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Lighting.hlsl"
-#include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Particles.hlsl"
-
-void InitializeInputData(VaryingsParticle input, half3 normalTS, out InputData output)
-{
-    output = (InputData)0;
-
-    output.positionWS = input.positionWS.xyz;
-=======
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Unlit.hlsl"
 #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Particles.hlsl"
 
@@ -19,7 +9,6 @@ void InitializeInputData(VaryingsParticle input, SurfaceData surfaceData, out In
     inputData = (InputData)0;
 
     inputData.positionWS = input.positionWS.xyz;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
 #ifdef _NORMALMAP
     half3 viewDirWS = half3(input.normalWS.w, input.tangentWS.w, input.bitangentWS.w);
@@ -141,20 +130,6 @@ half4 fragParticleUnlit(VaryingsParticle input) : SV_Target
     ParticleParams particleParams;
     InitParticleParams(input, particleParams);
 
-<<<<<<< HEAD
-    half4 albedo = SampleAlbedo(TEXTURE2D_ARGS(_BaseMap, sampler_BaseMap), particleParams);
-    half3 normalTS = SampleNormalTS(particleParams.uv, particleParams.blendUv, TEXTURE2D_ARGS(_BumpMap, sampler_BumpMap));
-
-#if defined (_DISTORTION_ON)
-    albedo.rgb = Distortion(albedo, normalTS, _DistortionStrengthScaled, _DistortionBlend, particleParams.projectedPosition);
-#endif
-
-#if defined(_EMISSION)
-    half3 emission = BlendTexture(TEXTURE2D_ARGS(_EmissionMap, sampler_EmissionMap), particleParams.uv, particleParams.blendUv).rgb * _EmissionColor.rgb;
-#else
-    half3 emission = half3(0, 0, 0);
-#endif
-=======
     SurfaceData surfaceData;
     InitializeSurfaceData(particleParams, surfaceData);
     InputData inputData;
@@ -171,7 +146,6 @@ half4 fragParticleUnlit(VaryingsParticle input) : SV_Target
 
     finalColor.rgb = MixFog(finalColor.rgb, inputData.fogCoord);
     finalColor.a = OutputAlpha(finalColor.a, _Surface);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
     return finalColor;
 }

Shaders/Particles/ParticlesUnlitInput.hlsl

@@ -65,21 +65,13 @@ half4 SampleAlbedo(TEXTURE2D_PARAM(albedoMap, sampler_albedoMap), ParticleParams
     #else
         half4 colorAddSubDiff = half4(0, 0, 0, 0);
     #endif
-<<<<<<< HEAD
-    albedo = MixParticleColor(albedo, params.vertexColor, colorAddSubDiff);
-=======
     albedo = MixParticleColor(albedo, half4(params.vertexColor), colorAddSubDiff);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 
     AlphaDiscard(albedo.a, _Cutoff);
     albedo.rgb = AlphaModulate(albedo.rgb, albedo.a);
 
     #if defined(_SOFTPARTICLES_ON)
-<<<<<<< HEAD
-        albedo = SOFT_PARTICLE_MUL_ALBEDO(albedo, SoftParticles(SOFT_PARTICLE_NEAR_FADE, SOFT_PARTICLE_INV_FADE_DISTANCE, params));
-=======
         albedo = SOFT_PARTICLE_MUL_ALBEDO(albedo, half(SoftParticles(SOFT_PARTICLE_NEAR_FADE, SOFT_PARTICLE_INV_FADE_DISTANCE, params)));
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     #endif
 
     #if defined(_FADING_ON)

Shaders/PostProcessing/UberPost.shader

@@ -223,8 +223,6 @@ Shader "Hidden/Universal Render Pipeline/UberPost"
                 // Assume color > 0 and prevent 0 - ditherNoise.
                 // Negative colors can cause problems if fed back to the postprocess via render to FP16 texture.
                 color = max(color, 0);
-<<<<<<< HEAD
-=======
             }
             #endif
 
@@ -234,7 +232,6 @@ Shader "Hidden/Universal Render Pipeline/UberPost"
             if(CanDebugOverrideOutputColor(half4(color, 1), uv, debugColor))
             {
                 return debugColor;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
             }
             #endif
 

Shaders/Terrain/TerrainLitPasses.hlsl

@@ -153,19 +153,11 @@ void SplatmapMix(float4 uvMainAndLM, float4 uvSplat01, float4 uvSplat23, inout h
     defaultSmoothness = half4(diffAlbedo[0].a, diffAlbedo[1].a, diffAlbedo[2].a, diffAlbedo[3].a);
     defaultSmoothness *= half4(_Smoothness0, _Smoothness1, _Smoothness2, _Smoothness3);
 
-<<<<<<< HEAD
-#ifndef _TERRAIN_BLEND_HEIGHT
-    if(_NumLayersCount <= 4)
-    {
-        // 20.0 is the number of steps in inputAlphaMask (Density mask. We decided 20 empirically)
-        half4 opacityAsDensity = saturate((half4(diffAlbedo[0].a, diffAlbedo[1].a, diffAlbedo[2].a, diffAlbedo[3].a) - (half4(1.0, 1.0, 1.0, 1.0) - splatControl)) * 20.0);
-=======
 #ifndef _TERRAIN_BLEND_HEIGHT // density blending
     if(_NumLayersCount <= 4)
     {
         // 20.0 is the number of steps in inputAlphaMask (Density mask. We decided 20 empirically)
         half4 opacityAsDensity = saturate((half4(diffAlbedo[0].a, diffAlbedo[1].a, diffAlbedo[2].a, diffAlbedo[3].a) - (1 - splatControl)) * 20.0);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
         opacityAsDensity += 0.001h * splatControl;      // if all weights are zero, default to what the blend mask says
         half4 useOpacityAsDensityParam = { _DiffuseRemapScale0.w, _DiffuseRemapScale1.w, _DiffuseRemapScale2.w, _DiffuseRemapScale3.w }; // 1 is off
         splatControl = lerp(opacityAsDensity, splatControl, useOpacityAsDensityParam);
@@ -352,11 +344,7 @@ half4 SplatmapFragment(Varyings IN) : SV_TARGET
     float2 splatUV = (IN.uvMainAndLM.xy * (_Control_TexelSize.zw - 1.0f) + 0.5f) * _Control_TexelSize.xy;
     half4 splatControl = SAMPLE_TEXTURE2D(_Control, sampler_Control, splatUV);
 
-<<<<<<< HEAD
-    half alpha = dot(splatControl, half4(1.0h, 1.0h, 1.0h, 1.0h));
-=======
     half alpha = dot(splatControl, 1.0h);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #ifdef _TERRAIN_BLEND_HEIGHT
     // disable Height Based blend when there are more than 4 layers (multi-pass breaks the normalization)
     if (_NumLayersCount <= 4)
@@ -507,11 +495,7 @@ VaryingsLean DepthOnlyVertex(AttributesLean v)
     TerrainInstancing(v.position, v.normalOS);
     o.clipPos = TransformObjectToHClip(v.position.xyz);
     o.texcoord = v.texcoord;
-<<<<<<< HEAD
-	return o;
-=======
     return o;
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 }
 
 half4 DepthOnlyFragment(VaryingsLean IN) : SV_TARGET
@@ -526,85 +510,4 @@ half4 DepthOnlyFragment(VaryingsLean IN) : SV_TARGET
     return 0;
 }
 
-<<<<<<< HEAD
-
-// DepthNormal pass
-struct AttributesDepthNormal
-{
-    float4 positionOS : POSITION;
-    float3 normalOS : NORMAL;
-    float2 texcoord : TEXCOORD0;
-    UNITY_VERTEX_INPUT_INSTANCE_ID
-};
-
-struct VaryingsDepthNormal
-{
-    float4 uvMainAndLM              : TEXCOORD0; // xy: control, zw: lightmap
-    #ifndef TERRAIN_SPLAT_BASEPASS
-        float4 uvSplat01                : TEXCOORD1; // xy: splat0, zw: splat1
-        float4 uvSplat23                : TEXCOORD2; // xy: splat2, zw: splat3
-    #endif
-
-    #if defined(_NORMALMAP) && !defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)
-        float4 normal                   : TEXCOORD3;    // xyz: normal, w: viewDir.x
-        float4 tangent                  : TEXCOORD4;    // xyz: tangent, w: viewDir.y
-        float4 bitangent                : TEXCOORD5;    // xyz: bitangent, w: viewDir.z
-    #else
-        float3 normal                   : TEXCOORD3;
-    #endif
-
-    float4 clipPos                  : SV_POSITION;
-    UNITY_VERTEX_OUTPUT_STEREO
-};
-
-VaryingsDepthNormal DepthNormalOnlyVertex(AttributesDepthNormal v)
-{
-    VaryingsDepthNormal o = (VaryingsDepthNormal)0;
-
-    UNITY_SETUP_INSTANCE_ID(v);
-    UNITY_INITIALIZE_VERTEX_OUTPUT_STEREO(o);
-    TerrainInstancing(v.positionOS, v.normalOS, v.texcoord);
-
-    VertexPositionInputs Attributes = GetVertexPositionInputs(v.positionOS.xyz);
-
-    o.uvMainAndLM.xy = v.texcoord;
-    o.uvMainAndLM.zw = v.texcoord * unity_LightmapST.xy + unity_LightmapST.zw;
-    #ifndef TERRAIN_SPLAT_BASEPASS
-        o.uvSplat01.xy = TRANSFORM_TEX(v.texcoord, _Splat0);
-        o.uvSplat01.zw = TRANSFORM_TEX(v.texcoord, _Splat1);
-        o.uvSplat23.xy = TRANSFORM_TEX(v.texcoord, _Splat2);
-        o.uvSplat23.zw = TRANSFORM_TEX(v.texcoord, _Splat3);
-    #endif
-
-    #if defined(_NORMALMAP) && !defined(ENABLE_TERRAIN_PERPIXEL_NORMAL)
-        half3 viewDirWS = GetWorldSpaceViewDir(Attributes.positionWS);
-        #if !SHADER_HINT_NICE_QUALITY
-            viewDirWS = SafeNormalize(viewDirWS);
-        #endif
-        float4 vertexTangent = float4(cross(float3(0, 0, 1), v.normalOS), 1.0);
-        VertexNormalInputs normalInput = GetVertexNormalInputs(v.normalOS, vertexTangent);
-
-        o.normal = half4(normalInput.normalWS, viewDirWS.x);
-        o.tangent = half4(normalInput.tangentWS, viewDirWS.y);
-        o.bitangent = half4(normalInput.bitangentWS, viewDirWS.z);
-    #else
-        o.normal = TransformObjectToWorldNormal(v.normalOS);
-    #endif
-
-    o.clipPos = Attributes.positionCS;
-    return o;
-}
-
-half4 DepthNormalOnlyFragment(VaryingsDepthNormal IN) : SV_TARGET
-{
-    #ifdef _ALPHATEST_ON
-        ClipHoles(IN.uvMainAndLM.xy);
-    #endif
-
-    half3 normalWS = IN.normal.xyz;
-    return float4(PackNormalOctRectEncode(TransformWorldToViewDir(normalWS, true)), 0.0, 0.0);
-}
-
-=======
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
 #endif

Shaders/Unlit.shader

@@ -162,24 +162,6 @@ Shader "Universal Render Pipeline/Unlit"
 
             ENDHLSL
         }
-
-        Pass
-        {
-            Name "MotionVectors"
-            Tags{ "LightMode" = "MotionVectors"}
-            Tags { "RenderType" = "Opaque" }
-
-            ZWrite[_ZWrite]
-            Cull[_Cull]
-
-            HLSLPROGRAM
-            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/OculusMotionVectorCore.hlsl"
-
-            #pragma vertex vert
-            #pragma fragment frag
-
-            ENDHLSL
-        }
     }
 
     SubShader

Shaders/XR/XRMirrorView.hlsl

@@ -29,13 +29,6 @@ Varyings VertQuad(Attributes input)
     output.positionCS = GetQuadVertexPosition(input.vertexID) * float4(_ScaleBiasRt.x, _ScaleBiasRt.y, 1, 1) + float4(_ScaleBiasRt.z, _ScaleBiasRt.w, 0, 0);
     output.positionCS.xy = output.positionCS.xy * float2(2.0f, -2.0f) + float2(-1.0f, 1.0f); //convert to -1..1
 
-<<<<<<< HEAD
-#if UNITY_UV_STARTS_AT_TOP
-    // Unity viewport convention is bottom left as origin. Adjust Scalebias to read the correct region.
-    _ScaleBias.w = 1 - _ScaleBias.w - _ScaleBias.y;
-#endif
-    output.texcoord = GetQuadTexCoord(input.vertexID) * _ScaleBias.xy + _ScaleBias.zw;
-=======
     //Using temporary as writing to global _ScaleBias.w is prohibited when compiling with DXC
     float scaleBiasW = _ScaleBias.w;
 #if UNITY_UV_STARTS_AT_TOP
@@ -43,7 +36,6 @@ Varyings VertQuad(Attributes input)
     scaleBiasW = 1 - _ScaleBias.w - _ScaleBias.y;
 #endif
     output.texcoord = GetQuadTexCoord(input.vertexID) * _ScaleBias.xy + float2(_ScaleBias.z, scaleBiasW);
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     return output;
 }
 

Textures/SMAA/SearchTex.tga.meta

@@ -33,13 +33,8 @@ TextureImporter:
   textureSettings:
     serializedVersion: 2
     filterMode: 1
-<<<<<<< HEAD
-    aniso: -1
-    mipBias: -100
-=======
     aniso: 1
     mipBias: 0
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
     wrapU: 1
     wrapV: 1
     wrapW: 1

package.json

@@ -1,16 +1,6 @@
 {
   "name": "com.unity.render-pipelines.universal",
   "description": "The Universal Render Pipeline (URP) is a prebuilt Scriptable Render Pipeline, made by Unity. URP provides artist-friendly workflows that let you quickly and easily create optimized graphics across a range of platforms, from mobile to high-end consoles and PCs.",
-<<<<<<< HEAD
-  "version": "10.8.0",
-  "unity": "2020.3",
-  "unityRelease": "18f1",
-  "displayName": "Universal RP",
-  "dependencies": {
-    "com.unity.mathematics": "1.1.0",
-    "com.unity.render-pipelines.core": "10.8.0",
-    "com.unity.shadergraph": "10.8.0"
-=======
   "version": "12.1.6",
   "unity": "2021.2",
   "displayName": "Universal RP",
@@ -19,7 +9,6 @@
     "com.unity.burst": "1.5.0",
     "com.unity.render-pipelines.core": "12.1.6",
     "com.unity.shadergraph": "12.1.6"
->>>>>>> 30e14a2ca18f7c4c9903767895c1ca15d1af6c76
   },
   "keywords": [
     "graphics",