Adaug proiectul Unity

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/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@ffe395a3a1d1/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@ffe395a3a1d1/Runtime/Decal/DBuffer/DBufferDepthCopyPass.cs

@@ -0,0 +1,55 @@
+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)
+            : base(evt, copyDepthShader, shouldClear)
+        {
+        }
+
+        public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
+        {
+            UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            var universalRenderer = cameraData.renderer as UniversalRenderer;
+
+            Debug.Assert(renderPassEvent < RenderPassEvent.BeforeRenderingGbuffer, "DBufferCopyDepthPass assumes the pipeline does a prepass and it is injected before opaque/gbuffer rendering.");
+
+            var currentCameraDepthInfo = renderGraph.GetRenderTargetInfo(resourceData.activeDepthTexture);
+
+            //Check if the active depth texture is already written to so we can use it
+            bool useDepthPriming = universalRenderer.useDepthPriming;
+
+            //Check if the active depth texture is compabible with the other render targets that we'll use for the dbuffer pass
+            bool isMsaa = currentCameraDepthInfo.msaaSamples > 1;
+
+            // We must create a temporary depth buffer for dbuffer rendering if the cameraDepth isn't compatible or was written to.
+            bool hasCompatibleDepth = useDepthPriming && !isMsaa;
+            if (!hasCompatibleDepth)
+            {
+                //Here we assume that when using depth priming, there is no prepass to the cameraDepthTexture but a copy, so that the texture is a color format. 
+                var source = (useDepthPriming || universalRenderer.usesDeferredLighting) ? resourceData.cameraDepth : resourceData.cameraDepthTexture;
+
+                Debug.Assert(source.IsValid(), "DBufferCopyDepthPass needs a valid cameraDepth or cameraDepth texture to copy from. You might be using depth priming, with MSAA and direct to backbuffer rendering, which is not supported.");
+                Debug.Assert(GraphicsFormatUtility.IsDepthFormat(source.GetDescriptor(renderGraph).format), "DBufferCopyDepthPass assumes source has a depth format.");
+
+                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 depth texture (filled by a prepass) into the new attachment so it can be used for depth testing
+                Render(renderGraph, resourceData.dBufferDepth, source, resourceData, cameraData, false, "Copy DBuffer Depth");
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/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@ffe395a3a1d1/Runtime/Decal/DBuffer/DBufferRenderPass.cs

@@ -0,0 +1,190 @@
+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 readonly string[] s_DBufferNames = { "_DBufferTexture0", "_DBufferTexture1", "_DBufferTexture2", "_DBufferTexture3" };
+        internal static readonly string s_DBufferDepthName = "DBufferDepth";
+        static readonly int s_SSAOTextureID = Shader.PropertyToID("_ScreenSpaceOcclusionTexture");
+
+        private DecalDrawDBufferSystem m_DrawSystem;
+        private DBufferSettings m_Settings;
+
+        private FilteringSettings m_FilteringSettings;
+        private List<ShaderTagId> m_ShaderTagIdList;
+
+        private bool m_DecalLayers;
+
+        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);
+
+            // DBuffer requires color texture created as it does not handle y flip correctly
+            requiresIntermediateTexture = true;
+
+            m_DrawSystem = drawSystem;
+            m_Settings = settings;
+            profilingSampler = new ProfilingSampler("Draw DBuffer");
+            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));
+        }
+
+        private static void ExecutePass(RasterCommandBuffer cmd, PassData passData, RendererList rendererList, bool renderGraph)
+        {
+            passData.drawSystem.Execute(cmd);
+            cmd.DrawRendererList(rendererList);
+        }
+
+        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 class PassData
+        {
+            internal DecalDrawDBufferSystem drawSystem;
+            internal DBufferSettings settings;
+            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.decalLayers = m_DecalLayers;
+        }
+
+        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;
+
+            TextureHandle renderingLayersTexture = resourceData.renderingLayersTexture;
+
+            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 && renderingLayersTexture.IsValid())
+                    builder.UseTexture(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.AllowGlobalStateModification(true);
+
+                builder.SetRenderFunc(static (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@ffe395a3a1d1/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@ffe395a3a1d1/Runtime/Decal/DBuffer/DecalForwardEmissivePass.cs

@@ -0,0 +1,84 @@
+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;
+
+        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));
+        }
+
+        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(static (PassData data, RasterGraphContext rgContext) =>
+                {
+                    ExecutePass(rgContext.cmd, data, data.rendererList);
+                });
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/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: