[content automatically redacted] touching PlatformDependent folder

Author: timcannellunity3d

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/Compiler/NativePassCompiler.cs

@@ -1420,7 +1420,7 @@ public void ExecuteGraph(InternalRenderGraphContext rgContext, RenderGraphResour
                 if (pass.waitOnGraphicsFencePassId != -1)
                 {
                     var fence = contextData.fences[pass.waitOnGraphicsFencePassId];
-                    rgContext.cmd.WaitOnAsyncGraphicsFence(fence);
+                    rgContext.cmd.WaitOnAsyncGraphicsFence(fence, SynchronisationStageFlags.PixelProcessing);
                 }
 
                 var nrpBegan = false;

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraph.cs

@@ -2263,14 +2263,14 @@ void PreRenderPassExecute(in CompiledPassInfo passInfo, RenderGraphPass pass, In
 
                 if (executedWorkDuringResourceCreation)
                 {
-                    rgContext.cmd.WaitOnAsyncGraphicsFence(previousFence);
+                    rgContext.cmd.WaitOnAsyncGraphicsFence(previousFence, SynchronisationStageFlags.PixelProcessing);
                 }
             }
 
             // Synchronize with graphics or compute pipe if needed.
             if (passInfo.syncToPassIndex != -1)
             {
-                rgContext.cmd.WaitOnAsyncGraphicsFence(m_CurrentCompiledGraph.compiledPassInfos[passInfo.syncToPassIndex].fence);
+                rgContext.cmd.WaitOnAsyncGraphicsFence(m_CurrentCompiledGraph.compiledPassInfos[passInfo.syncToPassIndex].fence, SynchronisationStageFlags.PixelProcessing);
             }
         }
 

Packages/com.unity.render-pipelines.core/Runtime/RenderGraph/RenderGraphDefaultResources.cs

@@ -48,7 +48,7 @@ private void InitDefaultResourcesIfNeeded()
                 m_WhiteTexture2D = RTHandles.Alloc(Texture2D.whiteTexture);
 
             if (m_ShadowTexture2D == null)
-                m_ShadowTexture2D = RTHandles.Alloc(1, 1, Experimental.Rendering.GraphicsFormat.D32_SFloat, isShadowMap: true, name: "DefaultShadowTexture");
+                m_ShadowTexture2D = RTHandles.Alloc(1, 1, CoreUtils.GetDefaultDepthOnlyFormat(), isShadowMap: true, name: "DefaultShadowTexture");
         }
 
         internal void Cleanup()

Packages/com.unity.render-pipelines.high-definition/Editor/RenderPipeline/HDRenderPipelineUI.Skin.cs

@@ -350,8 +350,8 @@ public class Styles
             public static readonly GUIContent volumeProfileLabel = EditorGUIUtility.TrTextContent("Volume Profile", "Settings that will override the values defined in the Default Volume Profile set in the Render Pipeline Global settings. Local Volumes inside scenes may override these settings further.");
             public static System.Lazy<GUIStyle> volumeProfileContextMenuStyle = new(() => new GUIStyle(CoreEditorStyles.contextMenuStyle) { margin = new RectOffset(0, 1, 3, 0) });
 
-            public static readonly GUIContent[] shadowBitDepthNames = { new GUIContent("32 bit"), new GUIContent("16 bit") };
-            public static readonly int[] shadowBitDepthValues = { (int)DepthBits.Depth32, (int)DepthBits.Depth16 };
+            public static readonly GUIContent[] shadowBitDepthNames = { new GUIContent("32 bit"), new GUIContent("16 bit"), new GUIContent("24 bit") };
+            public static readonly int[] shadowBitDepthValues = { (int)DepthBits.Depth32, (int)DepthBits.Depth16, (int)DepthBits.Depth24 };
 
             public static readonly GUIContent gpuResidentDrawerMode = EditorGUIUtility.TrTextContent("GPU Resident Drawer", "Enables draw submission through the GPU Resident Drawer, which can improve CPU performance");
             public static readonly GUIContent smallMeshScreenPercentage = EditorGUIUtility.TrTextContent("Small-Mesh Screen-Percentage", "Default minimum screen percentage (0-20%) gpu-driven Renderers can cover before getting culled. If a Renderer is part of a LODGroup, this will be ignored.");

Packages/com.unity.render-pipelines.universal/Runtime/Passes/PostProcessPassRenderGraph.cs

@@ -1429,22 +1429,27 @@ public void RenderFinalSetup(RenderGraph renderGraph, UniversalCameraData camera
             // Scaled FXAA
             using (var builder = renderGraph.AddRasterRenderPass<PostProcessingFinalSetupPassData>("Postprocessing Final Setup Pass", out var passData, ProfilingSampler.Get(URPProfileId.RG_FinalSetup)))
             {
+
+                builder.AllowGlobalStateModification(true);
+                builder.AllowPassCulling(false);
+
                 Material material = m_Materials.scalingSetup;
                 material.shaderKeywords = null;
 
+                material.shaderKeywords = null;
+
                 if (settings.isFxaaEnabled)
-                    material.EnableKeyword(ShaderKeywordStrings.Fxaa);
+                    CoreUtils.SetKeyword(material, ShaderKeywordStrings.Fxaa, settings.isFxaaEnabled);
 
                 if (settings.isFsrEnabled)
-                    material.EnableKeyword(settings.hdrOperations.HasFlag(HDROutputUtils.Operation.ColorEncoding) ? ShaderKeywordStrings.Gamma20AndHDRInput : ShaderKeywordStrings.Gamma20);
+                    CoreUtils.SetKeyword(material, (settings.hdrOperations.HasFlag(HDROutputUtils.Operation.ColorEncoding) ? ShaderKeywordStrings.Gamma20AndHDRInput : ShaderKeywordStrings.Gamma20), true);
 
                 if (settings.hdrOperations.HasFlag(HDROutputUtils.Operation.ColorEncoding))
                     SetupHDROutput(cameraData.hdrDisplayInformation, cameraData.hdrDisplayColorGamut, material, settings.hdrOperations, cameraData.rendersOverlayUI);
 
                 if (settings.isAlphaOutputEnabled)
                     CoreUtils.SetKeyword(material, ShaderKeywordStrings._ENABLE_ALPHA_OUTPUT, settings.isAlphaOutputEnabled);
 
-                builder.AllowGlobalStateModification(true);
                 passData.destinationTexture = destination;
                 builder.SetRenderAttachment(destination, 0, AccessFlags.Write);
                 passData.sourceTexture = source;
@@ -1567,6 +1572,7 @@ public void RenderFinalBlit(RenderGraph renderGraph, UniversalCameraData cameraD
             using (var builder = renderGraph.AddRasterRenderPass<PostProcessingFinalBlitPassData>("Postprocessing Final Blit Pass", out var passData, ProfilingSampler.Get(URPProfileId.RG_FinalBlit)))
             {
                 builder.AllowGlobalStateModification(true);
+                builder.AllowPassCulling(false);
                 passData.destinationTexture = postProcessingTarget;
                 builder.SetRenderAttachment(postProcessingTarget, 0, AccessFlags.Write);
                 passData.sourceTexture = source;
@@ -1602,8 +1608,7 @@ public void RenderFinalBlit(RenderGraph renderGraph, UniversalCameraData cameraD
 
                     PostProcessUtils.SetSourceSize(cmd, data.sourceTexture);
 
-                    if (isFxaaEnabled)
-                        material.EnableKeyword(ShaderKeywordStrings.Fxaa);
+                    CoreUtils.SetKeyword(material, ShaderKeywordStrings.Fxaa, isFxaaEnabled);
 
                     if (isFsrEnabled)
                     {
@@ -1615,15 +1620,15 @@ public void RenderFinalBlit(RenderGraph renderGraph, UniversalCameraData cameraD
                         if (data.cameraData.fsrSharpness > 0.0f)
                         {
                             // RCAS is performed during the final post blit, but we set up the parameters here for better logical grouping.
-                            material.EnableKeyword(requireHDROutput ? ShaderKeywordStrings.EasuRcasAndHDRInput : ShaderKeywordStrings.Rcas);
+                            CoreUtils.SetKeyword(material, (requireHDROutput ? ShaderKeywordStrings.EasuRcasAndHDRInput : ShaderKeywordStrings.Rcas), true);
                             FSRUtils.SetRcasConstantsLinear(cmd, sharpness);
                         }
                     }
                     else if (isRcasEnabled)   // RCAS only
                     {
                         // Reuse RCAS as a standalone sharpening filter for TAA.
                         // If FSR is enabled then it overrides the sharpening/TAA setting and we skip it.
-                        material.EnableKeyword(ShaderKeywordStrings.Rcas);
+                        CoreUtils.SetKeyword(material, ShaderKeywordStrings.Rcas, true);
                         FSRUtils.SetRcasConstantsLinear(cmd, data.cameraData.taaSettings.contrastAdaptiveSharpening);
                     }
 
@@ -1656,6 +1661,7 @@ public void RenderFinalBlit(RenderGraph renderGraph, UniversalCameraData cameraD
 
         public void RenderFinalPassRenderGraph(RenderGraph renderGraph, ContextContainer frameData, in TextureHandle source, in TextureHandle overlayUITexture, in TextureHandle postProcessingTarget, bool enableColorEncodingIfNeeded)
         {
+
             var stack = VolumeManager.instance.stack;
             m_Tonemapping = stack.GetComponent<Tonemapping>();
             m_FilmGrain = stack.GetComponent<FilmGrain>();
@@ -1699,7 +1705,7 @@ public void RenderFinalPassRenderGraph(RenderGraph renderGraph, ContextContainer
             }
 
             if (RequireSRGBConversionBlitToBackBuffer(cameraData.requireSrgbConversion))
-                material.EnableKeyword(ShaderKeywordStrings.LinearToSRGBConversion);
+                CoreUtils.SetKeyword(material, ShaderKeywordStrings.LinearToSRGBConversion, true);
 
             settings.hdrOperations = HDROutputUtils.Operation.None;
             settings.requireHDROutput = RequireHDROutput(cameraData);
@@ -1927,14 +1933,14 @@ public void RenderUberPost(RenderGraph renderGraph, ContextContainer frameData,
 
                     if (data.isHdrGrading)
                     {
-                        material.EnableKeyword(ShaderKeywordStrings.HDRGrading);
+                        CoreUtils.SetKeyword(material, ShaderKeywordStrings.HDRGrading, true);
                     }
                     else
                     {
                         switch (data.toneMappingMode)
                         {
-                            case TonemappingMode.Neutral: material.EnableKeyword(ShaderKeywordStrings.TonemapNeutral); break;
-                            case TonemappingMode.ACES: material.EnableKeyword(ShaderKeywordStrings.TonemapACES); break;
+                            case TonemappingMode.Neutral: CoreUtils.SetKeyword(material, ShaderKeywordStrings.TonemapNeutral, true); break;
+                            case TonemappingMode.ACES: CoreUtils.SetKeyword(material, ShaderKeywordStrings.TonemapACES, true); break;
                             default: break; // None
                         }
                     }
@@ -2139,11 +2145,11 @@ public void RenderPostProcessingRenderGraph(RenderGraph renderGraph, ContextCont
                 SetupDithering(cameraData, m_Materials.uber);
 
                 if (RequireSRGBConversionBlitToBackBuffer(cameraData.requireSrgbConversion))
-                    m_Materials.uber.EnableKeyword(ShaderKeywordStrings.LinearToSRGBConversion);
+                    CoreUtils.SetKeyword(m_Materials.uber, ShaderKeywordStrings.LinearToSRGBConversion, true);
 
                 if (m_UseFastSRGBLinearConversion)
                 {
-                    m_Materials.uber.EnableKeyword(ShaderKeywordStrings.UseFastSRGBLinearConversion);
+                    CoreUtils.SetKeyword(m_Materials.uber, ShaderKeywordStrings.UseFastSRGBLinearConversion, true);
                 }
 
                 bool requireHDROutput = RequireHDROutput(cameraData);