Adaug proiectul Unity

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/CameraRenderingLayerMask.cs

@@ -0,0 +1,82 @@
+using System;
+using UnityEngine.Rendering.RenderGraphModule;
+using CommonResourceData = UnityEngine.Rendering.Universal.UniversalResourceData;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class CameraRenderingLayerMaskPass : ScriptableRenderPass
+    {
+        static readonly string k_RenderingLayerMaskPass = "RenderingLayerMask Pass";
+        internal static readonly string k_RenderingLayersTextureName = "_CameraRenderingLayersTexture";
+
+        private static readonly ProfilingSampler m_ProfilingSampler = new ProfilingSampler(k_RenderingLayerMaskPass);
+        private static readonly int k_RenderingLayerMaskID = Shader.PropertyToID(k_RenderingLayersTextureName);
+
+        Material m_Material = null;
+
+        internal CameraRenderingLayerMaskPass()
+        {
+            if (GraphicsSettings.TryGetRenderPipelineSettings<Renderer2DResources>(out var resources))
+            {
+                m_Material = CoreUtils.CreateEngineMaterial(resources.renderingLayerMaskShader);
+            }
+        }
+
+        internal void Dispose()
+        {
+            CoreUtils.Destroy(m_Material);
+        }
+
+        private class PassData
+        {
+            internal RendererListHandle rendererList;
+        }
+
+        private static void Execute(RasterCommandBuffer cmd, PassData passData)
+        {
+            cmd.DrawRendererList(passData.rendererList);
+        }
+
+        internal void Render(RenderGraph graph, ContextContainer frameData)
+        {
+            Renderer2DData rendererData = frameData.Get<Universal2DRenderingData>().renderingData;
+
+            if (!rendererData.useRenderingLayers || m_Material == null)
+                return;
+
+            Universal2DResourceData universal2DResourceData = frameData.Get<Universal2DResourceData>();
+            CommonResourceData commonResourceData = frameData.Get<CommonResourceData>();
+            UniversalRenderingData renderingData = frameData.Get<UniversalRenderingData>();
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            UniversalLightData lightData = frameData.Get<UniversalLightData>();
+
+            using (var builder = graph.AddRasterRenderPass<PassData>(k_RenderingLayerMaskPass, out var passData, LayerDebug.GetProfilingSampler(passName, m_ProfilingSampler)))
+            {
+                // Render all
+                var filterSettings = new FilteringSettings(RenderQueueRange.all);
+                filterSettings.layerMask = rendererData.layerMask;
+
+                var drawSettings = CreateDrawingSettings(DrawRenderer2DPass.k_ShaderTags, renderingData, cameraData, lightData, SortingCriteria.CommonTransparent);
+                drawSettings.overrideMaterial = m_Material; // render with override RenderingLayerMask.shader
+                var sortSettings = drawSettings.sortingSettings;
+                RendererLighting.GetTransparencySortingMode(rendererData, cameraData.camera, ref sortSettings);
+                drawSettings.sortingSettings = sortSettings;
+
+                builder.AllowPassCulling(false);
+
+                builder.SetRenderAttachment(universal2DResourceData.renderingLayersTexture, 0);
+
+                var param = new RendererListParams(renderingData.cullResults, drawSettings, filterSettings);
+                passData.rendererList = graph.CreateRendererList(param);
+                builder.UseRendererList(passData.rendererList);
+
+                builder.SetGlobalTextureAfterPass(universal2DResourceData.renderingLayersTexture, k_RenderingLayerMaskID);
+
+                builder.SetRenderFunc(static (PassData data, RasterGraphContext context) =>
+                {
+                    Execute(context.cmd, data);
+                });
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/CameraRenderingLayerMask.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 6687e5bb66c445b4ab45af224ef4a18c

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/CopyCameraSortingLayerPass.cs

@@ -0,0 +1,72 @@
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.U2D.Profiler;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class CopyCameraSortingLayerPass : ScriptableRenderPass
+    {
+        internal static readonly string k_CameraSortingLayerTexture = "_CameraSortingLayerTexture";
+        internal static readonly int k_CameraSortingLayerTextureId = Shader.PropertyToID(k_CameraSortingLayerTexture);
+        Material m_BlitMaterial;
+
+        public CopyCameraSortingLayerPass(Material blitMaterial)
+        {
+            m_BlitMaterial = blitMaterial;
+        }
+
+        public static void ConfigureDescriptor(Downsampling downsamplingMethod, ref RenderTextureDescriptor descriptor, out FilterMode filterMode)
+        {
+            descriptor.msaaSamples = 1;
+            descriptor.depthStencilFormat = GraphicsFormat.None;
+            if (downsamplingMethod == Downsampling._2xBilinear)
+            {
+                descriptor.width /= 2;
+                descriptor.height /= 2;
+            }
+            else if (downsamplingMethod == Downsampling._4xBox || downsamplingMethod == Downsampling._4xBilinear)
+            {
+                descriptor.width /= 4;
+                descriptor.height /= 4;
+            }
+
+            filterMode = downsamplingMethod == Downsampling.None || downsamplingMethod == Downsampling._4xBox ? FilterMode.Point : FilterMode.Bilinear;
+        }
+
+        private static void Execute(RasterCommandBuffer cmd, RTHandle source, Material blitMaterial)
+        {
+            using (new ProfilingScope(cmd, ProfilerMarkers.s_ProfilingSamplerCopy))
+            {
+                Vector2 viewportScale = source.useScaling ? new Vector2(source.rtHandleProperties.rtHandleScale.x, source.rtHandleProperties.rtHandleScale.y) : Vector2.one;
+                Blitter.BlitTexture(cmd, source, viewportScale, blitMaterial, source.rt.filterMode == FilterMode.Bilinear ? 1 : 0);
+            }
+        }
+
+        class PassData
+        {
+            internal TextureHandle source;
+            internal Material blitMaterial;
+        }
+
+        public void Render(RenderGraph graph, ContextContainer frameData)
+        {
+            UniversalResourceData commonResourceData = frameData.Get<UniversalResourceData>();
+            Universal2DResourceData universal2DResourceData = frameData.Get<Universal2DResourceData>();
+
+            using (var builder = graph.AddRasterRenderPass<PassData>(ProfilerMarkers.s_CopyCameraSortingLayerPass, out var passData, ProfilerMarkers.s_ProfilingSamplerCopyCameraSortingLayerPass))
+            {
+                passData.source = commonResourceData.activeColorTexture;
+                passData.blitMaterial = m_BlitMaterial;
+
+                builder.SetRenderAttachment(universal2DResourceData.cameraSortingLayerTexture, 0);
+                builder.UseTexture(passData.source);
+                builder.AllowPassCulling(false);
+
+                builder.SetRenderFunc(static (PassData data, RasterGraphContext context) =>
+                {
+                    Execute(context.cmd, data.source, data.blitMaterial);
+                });
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/CopyCameraSortingLayerPass.cs.meta

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

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/DrawLight2DPass.cs

@@ -0,0 +1,270 @@
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.U2D.Profiler;
+using CommonResourceData = UnityEngine.Rendering.Universal.UniversalResourceData;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class DrawLight2DPass : ScriptableRenderPass
+    {
+        internal static readonly int k_InverseHDREmulationScaleID = Shader.PropertyToID("_InverseHDREmulationScale");
+        internal static readonly string k_NormalMapID = "_NormalMap";
+        internal static readonly string k_ShadowMapID = "_ShadowTex";
+        TextureHandle[] intermediateTexture = new TextureHandle[1];
+
+        internal static MaterialPropertyBlock s_PropertyBlock = new MaterialPropertyBlock();
+
+#if UNITY_EDITOR
+        [RuntimeInitializeOnLoadMethod]
+        static void ResetStaticsOnLoad()
+        {
+            s_PropertyBlock = new MaterialPropertyBlock();
+        }
+#endif
+
+        internal void Setup(RenderGraph renderGraph, ContextContainer frameData)
+        {
+            var renderingData = frameData.Get<Universal2DRenderingData>().renderingData;
+
+            foreach (var light in renderingData.lightCullResult.visibleLights)
+            {
+                if (light.useCookieSprite && light.m_CookieSpriteTexture != null)
+                    light.m_CookieSpriteTextureHandle = renderGraph.ImportTexture(light.m_CookieSpriteTexture);
+
+#if ENABLE_PROFILER && PROFILER_INSTALLED
+                if (Renderer2D.canProfilerCapture)
+                    ProfilerMarkers.s_LightMeshFrameData.Capture(light.gameObject, light.lightMesh);
+#endif
+            }
+        }
+
+        static bool TryGetShadowIndex(ref LayerBatch layerBatch, int lightIndex, out int shadowIndex)
+        {
+            shadowIndex = 0;
+
+            for (int i = 0; i < layerBatch.shadowIndices.Count; ++i)
+            {
+                if (layerBatch.shadowIndices[i] == lightIndex)
+                {
+                    shadowIndex = i;
+                    return true;
+                }
+            }
+
+            return false;
+        }
+
+        private static void Execute(RasterCommandBuffer cmd, PassData passData, LayerBatch layerBatch, int lightTextureIndex)
+        {
+            cmd.SetGlobalFloat(k_InverseHDREmulationScaleID, 1.0f / passData.rendererData.hdrEmulationScale);
+
+            var blendStyleIndex = layerBatch.activeBlendStylesIndices[lightTextureIndex];
+            var blendOpName = passData.rendererData.lightBlendStyles[blendStyleIndex].name;
+            cmd.BeginSample(blendOpName);
+
+            var indicesIndex = Renderer2D.supportsMRT ? lightTextureIndex : 0;
+            if (!passData.isVolumetric)
+                RendererLighting.EnableBlendStyle(cmd, indicesIndex, true);
+
+            // Enable Rendering Layers
+            if (passData.useRenderingLayers)
+                cmd.EnableKeyword(ShaderGlobalKeywords.LightLayers);
+
+            var lights = passData.layerBatch.lights;
+
+            for (int j = 0; j < lights.Count; ++j)
+            {
+                var light = lights[j];
+
+                // Check if light is valid
+                if (light == null ||
+                    light.lightType == Light2D.LightType.Global ||
+                    light.blendStyleIndex != blendStyleIndex)
+                    continue;
+
+                // Check if light is volumetric
+                if (passData.isVolumetric &&
+                    (light.volumeIntensity <= 0.0f ||
+                    !light.volumetricEnabled ||
+                    layerBatch.endLayerValue != light.GetTopMostLitLayer()))
+                    continue;
+
+                var useShadows = (!passData.isVolumetric && passData.layerBatch.lightStats.useShadows) || (passData.isVolumetric && passData.layerBatch.lightStats.useVolumetricShadowLights);
+                useShadows &= layerBatch.shadowIndices.Contains(j);
+                var lightMaterial = passData.rendererData.GetLightMaterial(light, passData.isVolumetric, useShadows);
+                var lightMesh = light.lightMesh;
+
+                // For Batching.
+                var index = light.batchSlotIndex;
+                var slotIndex = RendererLighting.lightBatch.SlotIndex(index);
+                bool canBatch = RendererLighting.lightBatch.CanBatch(light, lightMaterial, index, out int lightHash);
+
+                bool breakBatch = !canBatch;
+                if (breakBatch && LightBatch.isBatchingSupported)
+                    RendererLighting.lightBatch.Flush(cmd);
+
+                if (passData.layerBatch.lightStats.useNormalMap)
+                    s_PropertyBlock.SetTexture(k_NormalMapID, passData.normalMap);
+
+                if (useShadows && TryGetShadowIndex(ref layerBatch, j, out var shadowIndex))
+                    s_PropertyBlock.SetTexture(k_ShadowMapID, passData.shadowTextures[shadowIndex]);
+
+                if (!passData.isVolumetric || (passData.isVolumetric && light.volumetricEnabled))
+                    RendererLighting.SetCookieShaderProperties(light, s_PropertyBlock);
+
+                // Set shader global properties
+                RendererLighting.SetPerLightShaderGlobals(cmd, light, slotIndex, passData.isVolumetric, useShadows, LightBatch.isBatchingSupported);
+
+                if (light.normalMapQuality != Light2D.NormalMapQuality.Disabled || light.lightType == Light2D.LightType.Point)
+                    RendererLighting.SetPerPointLightShaderGlobals(cmd, light, slotIndex, LightBatch.isBatchingSupported);
+
+                if (LightBatch.isBatchingSupported)
+                {
+                    RendererLighting.lightBatch.AddBatch(light, lightMaterial, light.GetMatrix(), lightMesh, 0, lightHash, index);
+                    RendererLighting.lightBatch.Flush(cmd);
+                }
+                else
+                {
+#if ENABLE_PROFILER && PROFILER_INSTALLED
+                    if (Renderer2D.canProfilerCapture)
+                        ProfilerMarkers.s_U2DLightBatchCounterValue.Value++;
+#endif
+                    cmd.DrawMesh(lightMesh, light.GetMatrix(), lightMaterial, 0, 0, s_PropertyBlock);
+                }
+#if ENABLE_PROFILER && PROFILER_INSTALLED
+                if (Renderer2D.canProfilerCapture)
+                    ProfilerMarkers.s_LightRenderFrameData.Capture(light.gameObject.GetEntityId());
+#endif
+            }
+            RendererLighting.EnableBlendStyle(cmd, indicesIndex, false);
+
+            // Disable Rendering Layers
+            if (passData.useRenderingLayers)
+                cmd.DisableKeyword(ShaderGlobalKeywords.LightLayers);
+
+            cmd.EndSample(blendOpName);
+        }
+
+        internal class PassData
+        {
+            internal LayerBatch layerBatch;
+            internal Renderer2DData rendererData;
+            internal bool isVolumetric;
+
+            internal TextureHandle normalMap;
+            internal TextureHandle[] shadowTextures;
+
+            internal int lightTextureIndex;
+            internal bool useRenderingLayers;
+            internal RenderingLayerUtils.MaskSize maskSize;
+        }
+
+        void InitializeRenderPass(IRasterRenderGraphBuilder builder, ContextContainer frameData, PassData passData, int batchIndex, bool isVolumetric = false)
+        {
+            Universal2DResourceData universal2DResourceData = frameData.Get<Universal2DResourceData>();
+            CommonResourceData commonResourceData = frameData.Get<CommonResourceData>();
+            Renderer2DData rendererData = frameData.Get<Universal2DRenderingData>().renderingData;
+            var layerBatch = frameData.Get<Universal2DRenderingData>().layerBatches[batchIndex];
+
+            intermediateTexture[0] = commonResourceData.activeColorTexture;
+
+            if (layerBatch.lightStats.useNormalMap)
+                builder.UseTexture(universal2DResourceData.normalsTexture[batchIndex]);
+
+            if (layerBatch.lightStats.useShadows)
+            {
+                passData.shadowTextures = universal2DResourceData.shadowTextures[batchIndex];
+                for (var i = 0; i < passData.shadowTextures.Length; i++)
+                    builder.UseTexture(passData.shadowTextures[i]);
+            }
+
+            foreach (var light in layerBatch.lights)
+            {
+                if (light == null || !light.m_CookieSpriteTextureHandle.IsValid())
+                    continue;
+
+                if (!isVolumetric || (isVolumetric && light.volumetricEnabled))
+                    builder.UseTexture(light.m_CookieSpriteTextureHandle);
+            }
+
+            if (rendererData.useRenderingLayers)
+                builder.UseTexture(universal2DResourceData.renderingLayersTexture);
+
+            passData.useRenderingLayers = rendererData.useRenderingLayers;
+            passData.maskSize = rendererData.renderingLayersMaskSize;
+            passData.layerBatch = layerBatch;
+            passData.rendererData = rendererData;
+            passData.isVolumetric = isVolumetric;
+            passData.normalMap = layerBatch.lightStats.useNormalMap ? universal2DResourceData.normalsTexture[batchIndex] : TextureHandle.nullHandle;
+
+            builder.AllowGlobalStateModification(true);
+        }
+
+        internal void Render(RenderGraph graph, ContextContainer frameData, int batchIndex, bool isVolumetric = false)
+        {
+            Universal2DResourceData universal2DResourceData = frameData.Get<Universal2DResourceData>();
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            var layerBatch = frameData.Get<Universal2DRenderingData>().layerBatches[batchIndex];
+
+            // Check for lighting in scene/prefab/preview camera 
+            var isLightingActive = Renderer2D.IsSceneViewOrPreviewLightingActive(cameraData);
+
+            if (!layerBatch.lightStats.useLights ||
+                isVolumetric && !layerBatch.lightStats.useVolumetricLights ||
+                !isLightingActive)
+                return;
+
+            // Render single RTs by for apis that don't support MRTs
+            if (!isVolumetric && !Renderer2D.supportsMRT)
+            {
+                var passName = ProfilerMarkers.s_LightSRTPass;
+                LayerDebug.FormatPassName(layerBatch, ref passName);
+
+                for (var i = 0; i < layerBatch.activeBlendStylesIndices.Length; ++i)
+                {
+                    using (var builder = graph.AddRasterRenderPass<PassData>(passName, out var passData, LayerDebug.GetProfilingSampler(passName, ProfilerMarkers.s_ProfilingSampleSRT)))
+                    {
+                        InitializeRenderPass(builder, frameData, passData, batchIndex, isVolumetric);
+
+                        var lightTextures = universal2DResourceData.lightTextures[batchIndex];
+
+                        builder.SetRenderAttachment(lightTextures[i], 0);
+
+                        passData.lightTextureIndex = i;
+
+                        builder.SetRenderFunc(static (PassData data, RasterGraphContext context) =>
+                        {
+                            RenderingLayerUtils.SetupProperties(context.cmd, data.maskSize);
+
+                            Execute(context.cmd, data, data.layerBatch, data.lightTextureIndex);
+                        });
+                    }
+                }
+            }
+            else
+            {
+                var passName = !isVolumetric ? ProfilerMarkers.s_LightPass : ProfilerMarkers.s_LightVolumetricPass;
+                var profilingSampler = !isVolumetric ? ProfilerMarkers.s_ProfilingSampler : ProfilerMarkers.s_ProfilingSamplerVolume;
+                LayerDebug.FormatPassName(layerBatch, ref passName);
+
+                // Default Raster Pass with MRTs
+                using (var builder = graph.AddRasterRenderPass<PassData>(passName, out var passData, LayerDebug.GetProfilingSampler(passName, profilingSampler)))
+                {
+                    InitializeRenderPass(builder, frameData, passData, batchIndex, isVolumetric);
+
+                    var lightTextures = !isVolumetric ? universal2DResourceData.lightTextures[batchIndex] : intermediateTexture;
+
+                    for (var i = 0; i < lightTextures.Length; i++)
+                        builder.SetRenderAttachment(lightTextures[i], i);
+
+                    builder.SetRenderFunc(static (PassData data, RasterGraphContext context) =>
+                    {
+                        RenderingLayerUtils.SetupProperties(context.cmd, data.maskSize);
+
+                        for (var i = 0; i < data.layerBatch.activeBlendStylesIndices.Length; ++i)
+                            Execute(context.cmd, data, data.layerBatch, i);
+                    });
+                }
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/DrawLight2DPass.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: 718db304c67a4e7692ab540c060259b2
+timeCreated: 1652943248

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/DrawNormal2DPass.cs

@@ -0,0 +1,70 @@
+using System;
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.U2D.Profiler;
+using CommonResourceData = UnityEngine.Rendering.Universal.UniversalResourceData;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class DrawNormal2DPass : ScriptableRenderPass
+    {
+        private static readonly ShaderTagId k_NormalsRenderingPassName = new ShaderTagId("NormalsRendering");
+
+        private class PassData
+        {
+            internal RendererListHandle rendererList;
+        }
+
+        private static void Execute(RasterCommandBuffer cmd, PassData passData)
+        {
+            cmd.DrawRendererList(passData.rendererList);
+        }
+
+        public void Render(RenderGraph graph, ContextContainer frameData, int batchIndex)
+        {
+            Universal2DResourceData universal2DResourceData = frameData.Get<Universal2DResourceData>();
+            CommonResourceData commonResourceData = frameData.Get<CommonResourceData>();
+            Renderer2DData rendererData = frameData.Get<Universal2DRenderingData>().renderingData;
+            var layerBatch = frameData.Get<Universal2DRenderingData>().layerBatches[batchIndex];
+
+            if (!layerBatch.useNormals)
+                return;
+
+            UniversalRenderingData renderingData = frameData.Get<UniversalRenderingData>();
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            UniversalLightData lightData = frameData.Get<UniversalLightData>();
+
+            var passName = ProfilerMarkers.s_MormalPass;
+            LayerDebug.FormatPassName(layerBatch, ref passName);
+
+            using (var builder = graph.AddRasterRenderPass<PassData>(passName, out var passData, LayerDebug.GetProfilingSampler(passName, ProfilerMarkers.s_ProfilingSamplerNormalPass)))
+            {
+                LayerUtility.GetFilterSettings(rendererData, layerBatch, out var filterSettings);
+
+                var drawSettings = CreateDrawingSettings(k_NormalsRenderingPassName, renderingData, cameraData, lightData, SortingCriteria.CommonTransparent);
+                var sortSettings = drawSettings.sortingSettings;
+                RendererLighting.GetTransparencySortingMode(rendererData, cameraData.camera, ref sortSettings);
+                drawSettings.sortingSettings = sortSettings;
+
+                builder.AllowPassCulling(false);
+
+                builder.SetRenderAttachment(universal2DResourceData.normalsTexture[batchIndex], 0);
+
+                // Depth needed for sprite mask stencil or z test for 3d meshes
+                if (commonResourceData.activeDepthTexture.IsValid())
+                {
+                    var depth = universal2DResourceData.normalsDepth.IsValid() ? universal2DResourceData.normalsDepth : commonResourceData.activeDepthTexture;
+                    builder.SetRenderAttachmentDepth(depth);
+                }
+
+                var param = new RendererListParams(renderingData.cullResults, drawSettings, filterSettings);
+                passData.rendererList = graph.CreateRendererList(param);
+                builder.UseRendererList(passData.rendererList);
+
+                builder.SetRenderFunc(static (PassData data, RasterGraphContext context) =>
+                {
+                    Execute(context.cmd, data);
+                });
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/DrawNormal2DPass.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: b256dac03c4645f593e9cb8ecbc51419
+timeCreated: 1652930589

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/DrawRenderer2DPass.cs

@@ -0,0 +1,209 @@
+using System.Collections.Generic;
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.U2D.Profiler;
+using CommonResourceData = UnityEngine.Rendering.Universal.UniversalResourceData;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class DrawRenderer2DPass : ScriptableRenderPass
+    {
+        private static readonly ShaderTagId k_CombinedRenderingPassName = new ShaderTagId("Universal2D");
+        private static readonly ShaderTagId k_LegacyPassName = new ShaderTagId("SRPDefaultUnlit");
+
+        internal static readonly List<ShaderTagId> k_ShaderTags =
+            new List<ShaderTagId>() {k_LegacyPassName, k_CombinedRenderingPassName};
+
+        private static readonly int k_HDREmulationScaleID = Shader.PropertyToID("_HDREmulationScale");
+        private static readonly int k_RendererColorID = Shader.PropertyToID("_RendererColor");
+
+        private static void Execute(RasterGraphContext context, PassData passData)
+        {
+            var cmd = context.cmd;
+            var blendStylesCount = passData.blendStyleIndices.Length;
+
+            cmd.SetGlobalFloat(k_HDREmulationScaleID, passData.hdrEmulationScale);
+            cmd.SetGlobalColor(k_RendererColorID, Color.white);
+            RendererLighting.SetLightShaderGlobals(cmd, passData.lightBlendStyles, passData.blendStyleIndices);
+
+#if UNITY_EDITOR
+            if (passData.isLightingActive)
+#endif
+            {
+                if (passData.layerUseLights)
+                {
+                    for (var i = 0; i < blendStylesCount; i++)
+                    {
+                        var blendStyleIndex = passData.blendStyleIndices[i];
+                        RendererLighting.EnableBlendStyle(cmd, blendStyleIndex, true);
+                    }
+                }
+                else if (passData.isSceneLit)
+                {
+                    RendererLighting.EnableBlendStyle(cmd, 0, true);
+                }
+            }
+
+            if (passData.activeDebugHandler)
+            {
+                passData.debugRendererLists.DrawWithRendererList(cmd);
+            }
+            else
+            {
+                // Draw all renderers in layer batch
+                cmd.DrawRendererList(passData.rendererList);
+            }
+
+            RendererLighting.DisableAllKeywords(cmd);
+        }
+
+        class SetGlobalPassData
+        {
+            internal TextureHandle[] lightTextures;
+        }
+
+        class PassData
+        {
+            internal Light2DBlendStyle[] lightBlendStyles;
+            internal int[] blendStyleIndices;
+            internal float hdrEmulationScale;
+            internal bool isSceneLit;
+            internal bool layerUseLights;
+            internal TextureHandle[] lightTextures;
+            internal RendererListHandle rendererList;
+            internal DebugRendererLists debugRendererLists;
+            internal bool activeDebugHandler;
+
+#if UNITY_EDITOR
+            internal bool isLightingActive; // Required for prefab view and preview camera
+#endif
+        }
+
+        public void Render(RenderGraph graph, ContextContainer frameData, int batchIndex, ref FilteringSettings filterSettings)
+        {
+            UniversalRenderingData renderingData = frameData.Get<UniversalRenderingData>();
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            UniversalLightData lightData = frameData.Get<UniversalLightData>();
+            Universal2DResourceData universal2DResourceData = frameData.Get<Universal2DResourceData>();
+            CommonResourceData commonResourceData = frameData.Get<CommonResourceData>();
+            Universal2DRenderingData rendering2DData = frameData.Get<Universal2DRenderingData>();
+            Renderer2DData rendererData = rendering2DData.renderingData;
+            var layerBatch = rendering2DData.layerBatches[batchIndex];
+
+            // Check for lighting in scene/prefab/preview camera 
+            var isLightingActive = Renderer2D.IsSceneViewOrPreviewLightingActive(cameraData);
+
+            // Preset global light textures for first batch
+            if (batchIndex == 0)
+            {
+                using (var builder = graph.AddRasterRenderPass<SetGlobalPassData>(ProfilerMarkers.s_SetLightBlendTexture, out var passData, ProfilerMarkers.s_ProfilingSamplerSetLightBlendTexture))
+                {
+                    if (layerBatch.lightStats.useLights && isLightingActive)
+                    {
+                        passData.lightTextures = universal2DResourceData.lightTextures[batchIndex];
+                        for (var i = 0; i < passData.lightTextures.Length; i++)
+                            builder.UseTexture(passData.lightTextures[i]);
+                    }
+
+                    SetGlobalLightTextures(graph, builder, frameData, batchIndex, isLightingActive);
+
+                    builder.AllowGlobalStateModification(true);
+
+                    builder.SetRenderFunc(static (SetGlobalPassData data, RasterGraphContext context) =>
+                    {
+                    });
+                }
+            }
+
+            // Renderer Pass
+            var passName = ProfilerMarkers.s_RenderPass;
+            LayerDebug.FormatPassName(layerBatch, ref passName);
+
+            using (var builder = graph.AddRasterRenderPass<PassData>(passName, out var passData, LayerDebug.GetProfilingSampler(passName, ProfilerMarkers.s_ProfilingSamplerRenderPass)))
+            {
+                passData.lightBlendStyles = rendererData.lightBlendStyles;
+                passData.blendStyleIndices = layerBatch.activeBlendStylesIndices;
+                passData.hdrEmulationScale = rendererData.hdrEmulationScale;
+                passData.isSceneLit = rendererData.lightCullResult.IsSceneLit();
+                passData.layerUseLights = layerBatch.lightStats.useLights;
+#if UNITY_EDITOR
+                passData.isLightingActive = isLightingActive;
+#endif
+
+                var drawSettings = CreateDrawingSettings(k_ShaderTags, renderingData, cameraData, lightData, SortingCriteria.CommonTransparent);
+                var sortSettings = drawSettings.sortingSettings;
+                RendererLighting.GetTransparencySortingMode(rendererData, cameraData.camera, ref sortSettings);
+                drawSettings.sortingSettings = sortSettings;
+
+                var activeDebugHandler = GetActiveDebugHandler(cameraData);
+                passData.activeDebugHandler = activeDebugHandler != null;
+
+                if (activeDebugHandler != null)
+                {
+                    var renderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
+                    passData.debugRendererLists = activeDebugHandler.CreateRendererListsWithDebugRenderState(graph,
+                        ref renderingData.cullResults, ref drawSettings, ref filterSettings, ref renderStateBlock);
+                    passData.debugRendererLists.PrepareRendererListForRasterPass(builder);
+                }
+                else
+                {
+                    var param = new RendererListParams(renderingData.cullResults, drawSettings, filterSettings);
+                    passData.rendererList = graph.CreateRendererList(param);
+                    builder.UseRendererList(passData.rendererList);
+                }
+
+                if (passData.layerUseLights && isLightingActive)
+                {
+                    passData.lightTextures = universal2DResourceData.lightTextures[batchIndex];
+                    for (var i = 0; i < passData.lightTextures.Length; i++)
+                        builder.UseTexture(passData.lightTextures[i]);
+                }
+
+                if (rendererData.useCameraSortingLayerTexture)
+                    builder.UseTexture(universal2DResourceData.cameraSortingLayerTexture);
+
+                // Set color and depth attachments
+                builder.SetRenderAttachment(commonResourceData.activeColorTexture, 0);
+
+                if (commonResourceData.activeDepthTexture.IsValid())
+                    builder.SetRenderAttachmentDepth(commonResourceData.activeDepthTexture);
+
+                builder.AllowGlobalStateModification(true);
+
+                // Post set global light textures for next renderer pass
+                var nextBatch = batchIndex + 1;
+                if (nextBatch < universal2DResourceData.lightTextures.Length)
+                    SetGlobalLightTextures(graph, builder, frameData, nextBatch, isLightingActive);
+
+                builder.SetRenderFunc(static (PassData data, RasterGraphContext context) =>
+                {
+                    Execute(context, data);
+                });
+            }
+        }
+
+        void SetGlobalLightTextures(RenderGraph graph, IRasterRenderGraphBuilder builder, ContextContainer frameData, int batchIndex, bool isLightingActive)
+        {
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            Renderer2DData rendererData = frameData.Get<Universal2DRenderingData>().renderingData;
+            var layerBatch = frameData.Get<Universal2DRenderingData>().layerBatches[batchIndex];
+            var lightTextures = frameData.Get<Universal2DResourceData>().lightTextures[batchIndex];
+
+            if (isLightingActive)
+            {
+                if (layerBatch.lightStats.useLights)
+                {
+                    for (var i = 0; i < lightTextures.Length; i++)
+                    {
+                        var blendStyleIndex = layerBatch.activeBlendStylesIndices[i];
+                        builder.SetGlobalTextureAfterPass(lightTextures[i], Shader.PropertyToID(RendererLighting.k_ShapeLightTextureIDs[blendStyleIndex]));
+                    }
+                }
+                else if (rendererData.lightCullResult.IsSceneLit())
+                {
+                    for (var i = 0; i < RendererLighting.k_ShapeLightTextureIDs.Length; i++)
+                        builder.SetGlobalTextureAfterPass(graph.defaultResources.blackTexture, Shader.PropertyToID(RendererLighting.k_ShapeLightTextureIDs[i]));
+                }
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/DrawRenderer2DPass.cs.meta

@@ -0,0 +1,3 @@
+fileFormatVersion: 2
+guid: e0f10937bae94291b66fd98a6d300c08
+timeCreated: 1653032228

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/DrawShadow2DPass.cs

@@ -0,0 +1,83 @@
+using System;
+using System.Collections.Generic;
+using UnityEngine.Experimental.Rendering;
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.U2D.Profiler;
+using CommonResourceData = UnityEngine.Rendering.Universal.UniversalResourceData;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class DrawShadow2DPass : ScriptableRenderPass
+    {
+
+        private static void ExecuteShadowPass(UnsafeCommandBuffer cmd, PassData passData, Light2D light, int batchIndex)
+        {
+            cmd.SetRenderTarget(passData.shadowTextures[batchIndex], passData.shadowDepth);
+
+            // Reusing the depth/stencil so we have to clear it
+            cmd.ClearRenderTarget(RTClearFlags.All, Color.clear, 1, 0);
+
+            var projectedShadowMaterial = passData.rendererData.GetProjectedShadowMaterial();
+            var projectedUnshadowMaterial = passData.rendererData.GetProjectedUnshadowMaterial();
+
+            ShadowRendering.PrerenderShadows(cmd, passData.rendererData, ref passData.layerBatch, light, 0, light.shadowIntensity);
+        }
+
+        internal class PassData
+        {
+            internal LayerBatch layerBatch;
+            internal Renderer2DData rendererData;
+            internal TextureHandle[] shadowTextures;
+            internal TextureHandle shadowDepth;
+            internal bool isVolumetric;
+        }
+
+        public void Render(RenderGraph graph, ContextContainer frameData, int batchIndex, bool isVolumetric = false)
+        {
+            Universal2DResourceData universal2DResourceData = frameData.Get<Universal2DResourceData>();
+            CommonResourceData commonResourceData = frameData.Get<CommonResourceData>();
+            Renderer2DData rendererData = frameData.Get<Universal2DRenderingData>().renderingData;
+            var layerBatch = frameData.Get<Universal2DRenderingData>().layerBatches[batchIndex];
+
+            if (!layerBatch.lightStats.useShadows ||
+                isVolumetric && !layerBatch.lightStats.useVolumetricShadowLights)
+                return;
+
+            var passName = !isVolumetric ? ProfilerMarkers.s_ShadowPass : ProfilerMarkers.s_ShadowVolumetricPass;
+            var profilingSampler = !isVolumetric ? ProfilerMarkers.s_ProfilingSamplerShadowPass : ProfilerMarkers.s_ProfilingSamplerShadowVolumetricPass;
+            LayerDebug.FormatPassName(layerBatch, ref passName);
+
+            using (var builder = graph.AddUnsafePass<PassData>(passName, out var passData, LayerDebug.GetProfilingSampler(passName, profilingSampler)))
+            {
+                passData.isVolumetric = isVolumetric;
+                passData.layerBatch = layerBatch;
+                passData.rendererData = rendererData;
+                passData.shadowTextures = universal2DResourceData.shadowTextures[batchIndex];
+                passData.shadowDepth = universal2DResourceData.shadowDepth;
+
+                for (var i = 0; i < passData.shadowTextures.Length; i++)
+                    builder.UseTexture(passData.shadowTextures[i], AccessFlags.Write);
+
+                builder.UseTexture(passData.shadowDepth, AccessFlags.Write);
+
+                builder.AllowGlobalStateModification(true);
+
+                builder.SetRenderFunc(static (PassData data, UnsafeGraphContext context) =>
+                {
+                    for (int i = 0; i < data.layerBatch.shadowIndices.Count; ++i)
+                    {
+                        var cmd = context.cmd;
+                        var index = data.layerBatch.shadowIndices[i];
+                        var light = data.layerBatch.lights[index];
+
+                        if (data.isVolumetric && !RendererLighting.CanCastVolumetricShadows(light, data.layerBatch.endLayerValue))
+                            continue;
+
+                        // Shadow Pass
+                        ExecuteShadowPass(cmd, data, light, i);
+                    }
+                });
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/DrawShadow2DPass.cs.meta

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

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/GlobalPropertiesPass.cs

@@ -0,0 +1,55 @@
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.U2D.Profiler;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class GlobalPropertiesPass : ScriptableRenderPass
+    {
+
+        class PassData
+        {
+            internal Vector2Int screenParams;
+        }
+
+        internal static void Setup(RenderGraph graph, ContextContainer frameData, bool useLights)
+        {
+            Universal2DResourceData universal2DResourceData = frameData.Get<Universal2DResourceData>();
+            UniversalCameraData cameraData = frameData.Get<UniversalCameraData>();
+            Renderer2DData rendererData = frameData.Get<Universal2DRenderingData>().renderingData;
+
+            using (var builder = graph.AddRasterRenderPass<PassData>(ProfilerMarkers.s_SetGlobalProperties, out var passData, ProfilerMarkers.s_ProfilingSamplerSetGlobalProperties))
+            {
+                // Set screenParams when pixel perfect camera is used with the reference resolution
+                passData.screenParams = Vector2Int.zero;
+                cameraData.camera.TryGetComponent(out PixelPerfectCamera pixelPerfectCamera);
+                if (pixelPerfectCamera != null && pixelPerfectCamera.enabled && pixelPerfectCamera.offscreenRTSize != Vector2Int.zero)
+                    passData.screenParams = pixelPerfectCamera.offscreenRTSize;
+
+                if (useLights)
+                {
+                    // Set light lookup and fall off textures as global
+                    var lightLookupTexture = graph.ImportTexture(Light2DLookupTexture.GetLightLookupTexture_Rendergraph());
+                    var fallOffTexture = graph.ImportTexture(Light2DLookupTexture.GetFallOffLookupTexture_Rendergraph());
+
+                    builder.SetGlobalTextureAfterPass(lightLookupTexture, Light2DLookupTexture.k_LightLookupID);
+                    builder.SetGlobalTextureAfterPass(fallOffTexture, Light2DLookupTexture.k_FalloffLookupID);
+                }
+
+                if (rendererData.useCameraSortingLayerTexture)
+                    builder.SetGlobalTextureAfterPass(universal2DResourceData.cameraSortingLayerTexture, CopyCameraSortingLayerPass.k_CameraSortingLayerTextureId);
+
+                builder.AllowGlobalStateModification(true);
+
+                builder.SetRenderFunc(static (PassData data, RasterGraphContext context) =>
+                {
+                    if (data.screenParams != Vector2Int.zero)
+                    {
+                        var cameraWidth = data.screenParams.x;
+                        var cameraHeight = data.screenParams.y;
+                        context.cmd.SetGlobalVector(ShaderPropertyId.screenParams, new Vector4(cameraWidth, cameraHeight, 1.0f + 1.0f / cameraWidth, 1.0f + 1.0f / cameraHeight));
+                    }
+                });
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/GlobalPropertiesPass.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 3c49b0c9c0fdfac469942832f71ce5b1

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/Renderer2DRendergraph.cs.meta

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

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/UpscalePass.cs

@@ -0,0 +1,54 @@
+using UnityEngine.Rendering.RenderGraphModule;
+using UnityEngine.Rendering.Universal.U2D.Profiler;
+
+namespace UnityEngine.Rendering.Universal
+{
+    internal class UpscalePass : ScriptableRenderPass
+    {
+        Material m_BlitMaterial;
+
+        private class PassData
+        {
+            internal TextureHandle source;
+            internal Material blitMaterial;
+        }
+
+        public UpscalePass(RenderPassEvent evt, Material blitMaterial)
+        {
+            renderPassEvent = evt;
+            m_BlitMaterial = blitMaterial;
+        }
+
+        private static void ExecutePass(RasterCommandBuffer cmd, RTHandle source, Material blitMaterial)
+        {
+            using (new ProfilingScope(cmd, ProfilerMarkers.s_ProfilingSamplerDrawUpscale))
+            {
+                Vector2 viewportScale = source.useScaling ? new Vector2(source.rtHandleProperties.rtHandleScale.x, source.rtHandleProperties.rtHandleScale.y) : Vector2.one;
+                Blitter.BlitTexture(cmd, source, viewportScale, blitMaterial, source.rt.filterMode == FilterMode.Bilinear ? 1 : 0);
+            }
+        }
+
+        public void Render(RenderGraph graph, Camera camera, in TextureHandle cameraColorAttachment, in TextureHandle upscaleHandle)
+        {
+            camera.TryGetComponent<PixelPerfectCamera>(out var ppc);
+            if (ppc == null || !ppc.enabled || !ppc.requiresUpscalePass)
+                return;
+
+            using (var builder = graph.AddRasterRenderPass<PassData>(ProfilerMarkers.s_UpscalePass, out var passData, ProfilerMarkers.s_ProfilingSamplerUpscalePass))
+            {
+                passData.source = cameraColorAttachment;
+                passData.blitMaterial = m_BlitMaterial;
+
+                builder.SetRenderAttachment(upscaleHandle, 0);
+                builder.UseTexture(cameraColorAttachment);
+
+                builder.AllowPassCulling(false);
+
+                builder.SetRenderFunc(static (PassData data, RasterGraphContext context) =>
+                {
+                    ExecutePass(context.cmd, data.source, data.blitMaterial);
+                });
+            }
+        }
+    }
+}

Library/PackageCache/com.unity.render-pipelines.universal@ffe395a3a1d1/Runtime/2D/Rendergraph/UpscalePass.cs.meta

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