intial commit

Library/PackageCache/com.unity.render-pipelines.universal@087c6d6dbb7d/Runtime/Decal/DBuffer/DBufferClear.shader

@@ -0,0 +1,42 @@
+Shader "Hidden/Universal Render Pipeline/DBufferClear"
+{
+    SubShader
+    {
+        Tags { "RenderType" = "Opaque" "RenderPipeline" = "UniversalPipeline"}
+        LOD 100
+
+        Pass
+        {
+            Name "DBufferClear"
+            ZTest Always
+            ZWrite Off
+            Cull Off
+
+            HLSLPROGRAM
+            #pragma vertex Vert
+            #pragma fragment Fragment
+            #pragma multi_compile_fragment _DBUFFER_MRT1 _DBUFFER_MRT2 _DBUFFER_MRT3
+
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/Core.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/Runtime/Utilities/Blit.hlsl"
+            #include "Packages/com.unity.render-pipelines.core/ShaderLibrary/Color.hlsl"
+            #include "Packages/com.unity.render-pipelines.universal/ShaderLibrary/DBuffer.hlsl"
+
+            void Fragment(
+                Varyings input,
+                OUTPUT_DBUFFER(outDBuffer))
+            {
+                UNITY_SETUP_STEREO_EYE_INDEX_POST_VERTEX(input);
+
+                outDBuffer0 = half4(0, 0, 0, 1);
+#if defined(_DBUFFER_MRT3) || defined(_DBUFFER_MRT2)
+                outDBuffer1 = half4(0.5f, 0.5f, 0.5f, 1);
+#endif
+#if defined(_DBUFFER_MRT3)
+                outDBuffer2 = half4(0, 0, 0, 1);
+#endif
+            }
+            ENDHLSL
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@087c6d6dbb7d/Runtime/Decal/DBuffer/DBufferClear.shader.meta

@@ -0,0 +1,10 @@
+fileFormatVersion: 2
+guid: f056d8bd2a1c7e44e9729144b4c70395
+ShaderImporter:
+  externalObjects: {}
+  defaultTextures: []
+  nonModifiableTextures: []
+  preprocessorOverride: 0
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.universal@087c6d6dbb7d/Runtime/Decal/DBuffer/DBufferDepthCopyPass.cs

@@ -0,0 +1,45 @@
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.Internal;
+
+namespace UnityEngine.Rendering.Universal
+{
+    /// <summary>
+    /// Used by DBuffer to copy depth into different texture.
+    /// In future this should be replaced by proper depth copy logic, as current CopyDepthPass do not implement RecordRenderGraph.
+    /// </summary>
+    internal class DBufferCopyDepthPass : CopyDepthPass
+    {
+        public DBufferCopyDepthPass(RenderPassEvent evt, Shader copyDepthShader, bool shouldClear = false, bool copyToDepth = false, bool copyResolvedDepth = false)
+            : base(evt, copyDepthShader, shouldClear, copyToDepth, copyResolvedDepth)
+        {
+        }
+
+        public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
+        {
+            UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            var universalRenderer = cameraData.renderer as UniversalRenderer;
+
+            bool isDeferred = universalRenderer.renderingModeActual == RenderingMode.Deferred;
+            bool useDepthPriming = universalRenderer.useDepthPriming;
+            bool isMsaa = cameraData.cameraTargetDescriptor.msaaSamples > 1;
+
+            // We must create a temporary depth buffer for dbuffer rendering if the existing one isn't compatible.
+            // The deferred path always has compatible depth
+            // The forward path only has compatible depth when depth priming is enabled without MSAA
+            bool hasCompatibleDepth = isDeferred || (useDepthPriming && !isMsaa);
+            if (!hasCompatibleDepth)
+            {
+                var depthDesc = cameraData.cameraTargetDescriptor;
+                depthDesc.graphicsFormat = GraphicsFormat.None; //Depth only rendering
+                depthDesc.depthStencilFormat = cameraData.cameraTargetDescriptor.depthStencilFormat;
+                depthDesc.msaaSamples = 1;
+                resourceData.dBufferDepth = UniversalRenderer.CreateRenderGraphTexture(renderGraph, depthDesc, DBufferRenderPass.s_DBufferDepthName, true);
+
+                // Copy the current depth data into the new attachment
+                Render(renderGraph, resourceData.dBufferDepth, resourceData.cameraDepthTexture, resourceData, cameraData, false, "Copy DBuffer Depth");
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@087c6d6dbb7d/Runtime/Decal/DBuffer/DBufferDepthCopyPass.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: bc72453fe7004b54a9b676b403c0ba54
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.universal@087c6d6dbb7d/Runtime/Decal/DBuffer/DBufferRenderPass.cs

@@ -0,0 +1,323 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.Internal;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class DecalDrawDBufferSystem : DecalDrawSystem
+    {
+        public DecalDrawDBufferSystem(DecalEntityManager entityManager) : base("DecalDrawIntoDBufferSystem.Execute", entityManager) { }
+        protected override int GetPassIndex(DecalCachedChunk decalCachedChunk) => decalCachedChunk.passIndexDBuffer;
+    }
+
+    internal class DBufferRenderPass : ScriptableRenderPass
+    {
+        internal static string[] s_DBufferNames = { "_DBufferTexture0", "_DBufferTexture1", "_DBufferTexture2", "_DBufferTexture3" };
+        internal static string s_DBufferDepthName = "DBufferDepth";
+
+        static readonly int s_SSAOTextureID = Shader.PropertyToID("_ScreenSpaceOcclusionTexture");
+
+        private DecalDrawDBufferSystem m_DrawSystem;
+        private DBufferSettings m_Settings;
+        private Material m_DBufferClear;
+
+        private FilteringSettings m_FilteringSettings;
+        private List<ShaderTagId> m_ShaderTagIdList;
+        private ProfilingSampler m_DBufferClearSampler;
+
+        private bool m_DecalLayers;
+
+        private RTHandle m_DBufferDepth;
+
+        private PassData m_PassData;
+
+        internal RTHandle[] dBufferColorHandles { get; private set; }
+        internal RTHandle depthHandle { get; private set; }
+        internal RTHandle dBufferDepth { get => m_DBufferDepth; }
+
+        private TextureHandle[] dbufferHandles;
+
+        public DBufferRenderPass(Material dBufferClear, DBufferSettings settings, DecalDrawDBufferSystem drawSystem, bool decalLayers)
+        {
+            renderPassEvent = RenderPassEvent.AfterRenderingPrePasses + 1;
+
+            var scriptableRenderPassInput = ScriptableRenderPassInput.Depth | ScriptableRenderPassInput.Normal;
+            ConfigureInput(scriptableRenderPassInput);
+
+            m_DrawSystem = drawSystem;
+            m_Settings = settings;
+            m_DBufferClear = dBufferClear;
+            profilingSampler = new ProfilingSampler("Draw DBuffer");
+            m_DBufferClearSampler = new ProfilingSampler("Clear");
+            m_FilteringSettings = new FilteringSettings(RenderQueueRange.opaque, -1);
+            m_DecalLayers = decalLayers;
+
+            m_ShaderTagIdList = new List<ShaderTagId>();
+            m_ShaderTagIdList.Add(new ShaderTagId(DecalShaderPassNames.DBufferMesh));
+            m_ShaderTagIdList.Add(new ShaderTagId(DecalShaderPassNames.DBufferProjectorVFX));
+
+            int dBufferCount = (int)settings.surfaceData + 1;
+            dBufferColorHandles = new RTHandle[dBufferCount];
+
+            m_PassData = new PassData();
+        }
+
+        public void Dispose()
+        {
+            m_DBufferDepth?.Release();
+            foreach (var handle in dBufferColorHandles)
+                handle?.Release();
+        }
+
+        public void Setup(in CameraData cameraData)
+        {
+            var depthDesc = cameraData.cameraTargetDescriptor;
+            depthDesc.graphicsFormat = GraphicsFormat.None; //Depth only rendering
+            depthDesc.depthStencilFormat = cameraData.cameraTargetDescriptor.depthStencilFormat;
+            depthDesc.msaaSamples = 1;
+
+            RenderingUtils.ReAllocateHandleIfNeeded(ref m_DBufferDepth, depthDesc, name: s_DBufferDepthName);
+
+            Setup(cameraData, m_DBufferDepth);
+        }
+
+        public void Setup(in CameraData cameraData, RTHandle depthTextureHandle)
+        {
+            // base
+            {
+                var desc = cameraData.cameraTargetDescriptor;
+                desc.graphicsFormat = QualitySettings.activeColorSpace == ColorSpace.Linear ? GraphicsFormat.R8G8B8A8_SRGB : GraphicsFormat.R8G8B8A8_UNorm;
+                desc.depthStencilFormat = GraphicsFormat.None;
+                desc.msaaSamples = 1;
+
+                RenderingUtils.ReAllocateHandleIfNeeded(ref dBufferColorHandles[0], desc, name: s_DBufferNames[0]);
+            }
+
+            if (m_Settings.surfaceData == DecalSurfaceData.AlbedoNormal || m_Settings.surfaceData == DecalSurfaceData.AlbedoNormalMAOS)
+            {
+                var desc = cameraData.cameraTargetDescriptor;
+                desc.graphicsFormat = GraphicsFormat.R8G8B8A8_UNorm;
+                desc.depthStencilFormat = GraphicsFormat.None;
+                desc.msaaSamples = 1;
+
+                RenderingUtils.ReAllocateHandleIfNeeded(ref dBufferColorHandles[1], desc, name: s_DBufferNames[1]);
+            }
+
+            if (m_Settings.surfaceData == DecalSurfaceData.AlbedoNormalMAOS)
+            {
+                var desc = cameraData.cameraTargetDescriptor;
+                desc.graphicsFormat = GraphicsFormat.R8G8B8A8_UNorm;
+                desc.depthStencilFormat = GraphicsFormat.None;
+                desc.msaaSamples = 1;
+
+                RenderingUtils.ReAllocateHandleIfNeeded(ref dBufferColorHandles[2], desc, name: s_DBufferNames[2]);
+            }
+
+            // depth
+            depthHandle = depthTextureHandle;
+        }
+
+        [Obsolete(DeprecationMessage.CompatibilityScriptingAPIObsolete, false)]
+        public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
+        {
+            // Disable obsolete warning for internal usage
+            #pragma warning disable CS0618
+            ConfigureTarget(dBufferColorHandles, depthHandle);
+            #pragma warning restore CS0618
+        }
+
+        [Obsolete(DeprecationMessage.CompatibilityScriptingAPIObsolete, false)]
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+            InitPassData(ref m_PassData);
+            var cmd = renderingData.commandBuffer;
+            var passData = m_PassData;
+            using (new ProfilingScope(cmd, profilingSampler))
+            {
+                context.ExecuteCommandBuffer(cmd);
+                cmd.Clear();
+
+                SetGlobalTextures(renderingData.commandBuffer, m_PassData);
+                SetKeywords(CommandBufferHelpers.GetRasterCommandBuffer(renderingData.commandBuffer), m_PassData);
+                Clear(renderingData.commandBuffer, m_PassData);
+
+                UniversalRenderingData universalRenderingData = renderingData.frameData.Get<UniversalRenderingData>();
+                UniversalCameraData cameraData = renderingData.frameData.Get<UniversalCameraData>();
+                UniversalLightData lightData = renderingData.frameData.Get<UniversalLightData>();
+
+                var param = InitRendererListParams(universalRenderingData, cameraData, lightData);
+                var rendererList = context.CreateRendererList(ref param);
+                ExecutePass(CommandBufferHelpers.GetRasterCommandBuffer(renderingData.commandBuffer), m_PassData, rendererList, false);
+            }
+        }
+
+        private static void ExecutePass(RasterCommandBuffer cmd, PassData passData, RendererList rendererList, bool renderGraph)
+        {
+            passData.drawSystem.Execute(cmd);
+            cmd.DrawRendererList(rendererList);
+        }
+
+        private static void SetGlobalTextures(CommandBuffer cmd, PassData passData)
+        {
+            var dBufferColorHandles = passData.dBufferColorHandles;
+            cmd.SetGlobalTexture(dBufferColorHandles[0].name, dBufferColorHandles[0].nameID);
+            if (passData.settings.surfaceData == DecalSurfaceData.AlbedoNormal || passData.settings.surfaceData == DecalSurfaceData.AlbedoNormalMAOS)
+                cmd.SetGlobalTexture(dBufferColorHandles[1].name, dBufferColorHandles[1].nameID);
+            if (passData.settings.surfaceData == DecalSurfaceData.AlbedoNormalMAOS)
+                cmd.SetGlobalTexture(dBufferColorHandles[2].name, dBufferColorHandles[2].nameID);
+        }
+
+        private static void SetKeywords(RasterCommandBuffer cmd, PassData passData)
+        {
+            cmd.SetKeyword(ShaderGlobalKeywords.DBufferMRT1, passData.settings.surfaceData == DecalSurfaceData.Albedo);
+            cmd.SetKeyword(ShaderGlobalKeywords.DBufferMRT2, passData.settings.surfaceData == DecalSurfaceData.AlbedoNormal);
+            cmd.SetKeyword(ShaderGlobalKeywords.DBufferMRT3, passData.settings.surfaceData == DecalSurfaceData.AlbedoNormalMAOS);
+
+            cmd.SetKeyword(ShaderGlobalKeywords.DecalLayers, passData.decalLayers);
+        }
+
+        private static void Clear(CommandBuffer cmd, PassData passData)
+        {
+            // TODO: This should be replace with mrt clear once we support it
+            // Clear render targets
+            using (new ProfilingScope(cmd, passData.dBufferClearSampler))
+            {
+                // for alpha compositing, color is cleared to 0, alpha to 1
+                // https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch23.html
+                Blitter.BlitTexture(cmd, passData.dBufferColorHandles[0], new Vector4(1, 1, 0, 0), passData.dBufferClear, 0);
+            }
+        }
+
+        private class PassData
+        {
+            internal DecalDrawDBufferSystem drawSystem;
+            internal DBufferSettings settings;
+            internal Material dBufferClear;
+
+            internal ProfilingSampler dBufferClearSampler;
+
+            internal bool decalLayers;
+            internal RTHandle dBufferDepth;
+            internal RTHandle[] dBufferColorHandles;
+
+            internal RendererListHandle rendererList;
+        }
+
+        private void InitPassData(ref PassData passData)
+        {
+            passData.drawSystem = m_DrawSystem;
+            passData.settings = m_Settings;
+            passData.dBufferClear = m_DBufferClear;
+            passData.dBufferClearSampler = m_DBufferClearSampler;
+            passData.decalLayers = m_DecalLayers;
+            passData.dBufferDepth = m_DBufferDepth;
+            passData.dBufferColorHandles = dBufferColorHandles;
+        }
+
+        private RendererListParams InitRendererListParams(UniversalRenderingData renderingData, UniversalCameraData cameraData, UniversalLightData lightData)
+        {
+            SortingCriteria sortingCriteria = cameraData.defaultOpaqueSortFlags;
+            DrawingSettings drawingSettings = RenderingUtils.CreateDrawingSettings(m_ShaderTagIdList, renderingData, cameraData, lightData, sortingCriteria);
+            return new RendererListParams(renderingData.cullResults, drawingSettings, m_FilteringSettings);
+        }
+
+        public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
+        {
+            UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
+            UniversalRenderingData renderingData = frameData.Get<UniversalRenderingData>();
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            UniversalLightData lightData = frameData.Get<UniversalLightData>();
+
+            TextureHandle cameraDepthTexture = resourceData.cameraDepthTexture;
+            TextureHandle cameraNormalsTexture = resourceData.cameraNormalsTexture;
+
+            TextureHandle depthTarget = resourceData.dBufferDepth.IsValid() ? resourceData.dBufferDepth : resourceData.activeDepthTexture;
+
+            using (var builder = renderGraph.AddRasterRenderPass<PassData>(passName, out var passData, profilingSampler))
+            {
+                InitPassData(ref passData);
+
+                if (dbufferHandles == null)
+                    dbufferHandles = new TextureHandle[RenderGraphUtils.DBufferSize];
+
+                // base
+                {
+                    var desc = cameraData.cameraTargetDescriptor;
+                    desc.graphicsFormat = QualitySettings.activeColorSpace == ColorSpace.Linear ? GraphicsFormat.R8G8B8A8_SRGB : GraphicsFormat.R8G8B8A8_UNorm;
+                    desc.depthStencilFormat = GraphicsFormat.None;
+                    desc.msaaSamples = 1;
+                    dbufferHandles[0] = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, s_DBufferNames[0], true, new Color(0, 0, 0, 1));
+                    builder.SetRenderAttachment(dbufferHandles[0], 0, AccessFlags.Write);
+                }
+
+                if (m_Settings.surfaceData == DecalSurfaceData.AlbedoNormal || m_Settings.surfaceData == DecalSurfaceData.AlbedoNormalMAOS)
+                {
+                    var desc = cameraData.cameraTargetDescriptor;
+                    desc.graphicsFormat = GraphicsFormat.R8G8B8A8_UNorm;
+                    desc.depthStencilFormat = GraphicsFormat.None;
+                    desc.msaaSamples = 1;
+                    dbufferHandles[1] = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, s_DBufferNames[1], true, new Color(0.5f, 0.5f, 0.5f, 1));
+                    builder.SetRenderAttachment(dbufferHandles[1], 1, AccessFlags.Write);
+                }
+
+                if (m_Settings.surfaceData == DecalSurfaceData.AlbedoNormalMAOS)
+                {
+                    var desc = cameraData.cameraTargetDescriptor;
+                    desc.graphicsFormat = GraphicsFormat.R8G8B8A8_UNorm;
+                    desc.depthStencilFormat = GraphicsFormat.None;
+                    desc.msaaSamples = 1;
+                    dbufferHandles[2] = UniversalRenderer.CreateRenderGraphTexture(renderGraph, desc, s_DBufferNames[2], true, new Color(0, 0, 0, 1));
+                    builder.SetRenderAttachment(dbufferHandles[2], 2, AccessFlags.Write);
+                }
+
+                builder.SetRenderAttachmentDepth(depthTarget, AccessFlags.Read);
+
+                if (cameraDepthTexture.IsValid())
+                    builder.UseTexture(cameraDepthTexture, AccessFlags.Read);
+                if (cameraNormalsTexture.IsValid())
+                    builder.UseTexture(cameraNormalsTexture, AccessFlags.Read);
+                if (passData.decalLayers)
+                    builder.UseTexture(resourceData.renderingLayersTexture, AccessFlags.Read);
+
+                if (resourceData.ssaoTexture.IsValid())
+                    builder.UseGlobalTexture(s_SSAOTextureID);
+
+                var param = InitRendererListParams(renderingData, cameraData, lightData);
+                passData.rendererList = renderGraph.CreateRendererList(param);
+                builder.UseRendererList(passData.rendererList);
+
+                for (int i = 0; i < RenderGraphUtils.DBufferSize; ++i)
+                {
+                    if (dbufferHandles[i].IsValid())
+                        builder.SetGlobalTextureAfterPass(dbufferHandles[i], Shader.PropertyToID(s_DBufferNames[i]));
+                }
+
+                builder.AllowPassCulling(false);
+                builder.AllowGlobalStateModification(true);
+
+                builder.SetRenderFunc((PassData data, RasterGraphContext rgContext) =>
+                {
+                    SetKeywords(rgContext.cmd, data);
+                    ExecutePass(rgContext.cmd, data, data.rendererList, true);
+                });
+            }
+
+            resourceData.dBuffer = dbufferHandles;
+        }
+
+        public override void OnCameraCleanup(CommandBuffer cmd)
+        {
+            if (cmd == null)
+            {
+                throw new System.ArgumentNullException("cmd");
+            }
+
+            cmd.SetKeyword(ShaderGlobalKeywords.DBufferMRT1, false);
+            cmd.SetKeyword(ShaderGlobalKeywords.DBufferMRT2, false);
+            cmd.SetKeyword(ShaderGlobalKeywords.DBufferMRT3, false);
+            cmd.SetKeyword(ShaderGlobalKeywords.DecalLayers, false);
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@087c6d6dbb7d/Runtime/Decal/DBuffer/DBufferRenderPass.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d2bfdb1a6a725194f86f62742dda59d2
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

Library/PackageCache/com.unity.render-pipelines.universal@087c6d6dbb7d/Runtime/Decal/DBuffer/DecalForwardEmissivePass.cs

@@ -0,0 +1,105 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering.RenderGraphModule;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class DecalDrawFowardEmissiveSystem : DecalDrawSystem
+    {
+        public DecalDrawFowardEmissiveSystem(DecalEntityManager entityManager) : base("DecalDrawFowardEmissiveSystem.Execute", entityManager) { }
+        protected override int GetPassIndex(DecalCachedChunk decalCachedChunk) => decalCachedChunk.passIndexEmissive;
+    }
+
+    internal class DecalForwardEmissivePass : ScriptableRenderPass
+    {
+        private FilteringSettings m_FilteringSettings;
+        private List<ShaderTagId> m_ShaderTagIdList;
+        private DecalDrawFowardEmissiveSystem m_DrawSystem;
+        private PassData m_PassData;
+
+        public DecalForwardEmissivePass(DecalDrawFowardEmissiveSystem drawSystem)
+        {
+            renderPassEvent = RenderPassEvent.AfterRenderingOpaques;
+            ConfigureInput(ScriptableRenderPassInput.Depth); // Require depth
+
+            m_DrawSystem = drawSystem;
+            profilingSampler = new ProfilingSampler("Draw Decal Forward Emissive");
+            m_FilteringSettings = new FilteringSettings(RenderQueueRange.opaque, -1);
+
+            m_ShaderTagIdList = new List<ShaderTagId>();
+            m_ShaderTagIdList.Add(new ShaderTagId(DecalShaderPassNames.DecalMeshForwardEmissive));
+            m_ShaderTagIdList.Add(new ShaderTagId(DecalShaderPassNames.DecalProjectorForwardEmissive));
+
+            m_PassData = new PassData();
+        }
+
+        [Obsolete(DeprecationMessage.CompatibilityScriptingAPIObsolete, false)]
+        public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
+        {
+            InitPassData(ref m_PassData);
+
+            UniversalRenderingData universalRenderingData = renderingData.frameData.Get<UniversalRenderingData>();
+            UniversalCameraData cameraData = renderingData.frameData.Get<UniversalCameraData>();
+            UniversalLightData lightData = renderingData.frameData.Get<UniversalLightData>();
+
+            var param = InitRendererListParams(universalRenderingData, cameraData, lightData);
+
+            var rendererList = context.CreateRendererList(ref param);
+            using (new ProfilingScope(universalRenderingData.commandBuffer, profilingSampler))
+            {
+                ExecutePass(CommandBufferHelpers.GetRasterCommandBuffer(universalRenderingData.commandBuffer), m_PassData, rendererList);
+            }
+        }
+
+        private class PassData
+        {
+            internal DecalDrawFowardEmissiveSystem drawSystem;
+
+            internal RendererListHandle rendererList;
+        }
+
+        private void InitPassData(ref PassData passData)
+        {
+            passData.drawSystem = m_DrawSystem;
+        }
+
+        private RendererListParams InitRendererListParams(UniversalRenderingData renderingData, UniversalCameraData cameraData, UniversalLightData lightData)
+        {
+            SortingCriteria sortingCriteria = cameraData.defaultOpaqueSortFlags;
+            DrawingSettings drawingSettings = RenderingUtils.CreateDrawingSettings(m_ShaderTagIdList, renderingData, cameraData, lightData, sortingCriteria);
+            return new RendererListParams(renderingData.cullResults, drawingSettings, m_FilteringSettings);
+        }
+
+        private static void ExecutePass(RasterCommandBuffer cmd, PassData passData, RendererList rendererList)
+        {
+            passData.drawSystem.Execute(cmd);
+            cmd.DrawRendererList(rendererList);
+        }
+
+        public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
+        {
+            using (var builder = renderGraph.AddRasterRenderPass<PassData>(passName, out var passData, profilingSampler))
+            {
+                UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
+                UniversalRenderingData renderingData = frameData.Get<UniversalRenderingData>();
+                UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+                UniversalLightData lightData = frameData.Get<UniversalLightData>();
+
+                InitPassData(ref passData);
+                var param = InitRendererListParams(renderingData, cameraData, lightData);
+                passData.rendererList = renderGraph.CreateRendererList(param);
+                builder.UseRendererList(passData.rendererList);
+
+                UniversalRenderer renderer = (UniversalRenderer)cameraData.renderer;
+                builder.SetRenderAttachment(resourceData.activeColorTexture, 0, AccessFlags.Write);
+                builder.SetRenderAttachmentDepth(resourceData.activeDepthTexture, AccessFlags.Read);
+
+                builder.SetRenderFunc((PassData data, RasterGraphContext rgContext) =>
+                {
+                    ExecutePass(rgContext.cmd, data, data.rendererList);
+                });
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@087c6d6dbb7d/Runtime/Decal/DBuffer/DecalForwardEmissivePass.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 93c9bd87382837c4aab136fa4c0c7bf8
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: