499 lines
26 KiB
C#
499 lines
26 KiB
C#
//pipelinedefine
|
|
#define H_URP
|
|
|
|
using HTraceSSGI.Scripts.Data.Private;
|
|
using HTraceSSGI.Scripts.Data.Public;
|
|
using HTraceSSGI.Scripts.Extensions;
|
|
using HTraceSSGI.Scripts.Globals;
|
|
using HTraceSSGI.Scripts.Infrastructure.URP;
|
|
using HTraceSSGI.Scripts.Wrappers;
|
|
using UnityEngine;
|
|
using UnityEngine.Experimental.Rendering;
|
|
using UnityEngine.Rendering;
|
|
using UnityEngine.Rendering.RendererUtils;
|
|
using UnityEngine.Rendering.Universal;
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
using UnityEngine.Rendering.RenderGraphModule;
|
|
#endif
|
|
|
|
namespace HTraceSSGI.Scripts.Passes.URP
|
|
{
|
|
internal class GBufferPassURP : ScriptableRenderPass
|
|
{
|
|
// Texture Names
|
|
private const string _Dummy = "_Dummy";
|
|
private const string _DepthPyramid = "_DepthPyramid";
|
|
private const string _ForwardGBuffer0 = "_ForwardGBuffer0";
|
|
private const string _ForwardGBuffer1 = "_ForwardGBuffer1";
|
|
private const string _ForwardGBuffer2 = "_ForwardGBuffer2";
|
|
private const string _ForwardGBuffer3 = "_ForwardGBuffer3";
|
|
private const string _ForwardRenderLayerMask = "_ForwardRenderLayerMask";
|
|
private const string _ForwardGBufferDepth = "_ForwardGBufferDepth";
|
|
|
|
// Materials & Computes
|
|
internal static ComputeShader HDepthPyramid = null;
|
|
|
|
// Samplers
|
|
internal static readonly ProfilingSampler GBufferProfilingSampler = new("GBuffer");
|
|
private static readonly ProfilingSampler DepthPyramidGenerationProfilingSampler = new ProfilingSampler("Depth Pyramid Generation");
|
|
|
|
// Textures
|
|
internal static RTWrapper Dummy = new RTWrapper();
|
|
internal static RTWrapper ForwardGBuffer0 = new RTWrapper();
|
|
internal static RTWrapper ForwardGBuffer1 = new RTWrapper();
|
|
internal static RTWrapper ForwardGBuffer2 = new RTWrapper();
|
|
internal static RTWrapper ForwardGBuffer3 = new RTWrapper();
|
|
internal static RTWrapper ForwardRenderLayerMask = new RTWrapper();
|
|
internal static RTWrapper ForwardGBufferDepth = new RTWrapper();
|
|
internal static RTWrapper DepthPyramidRT = new RTWrapper();
|
|
|
|
// MRT Arrays
|
|
internal static RenderTargetIdentifier[] GBufferMRT = null;
|
|
|
|
// Misc
|
|
internal static RenderStateBlock ForwardGBufferRenderStateBlock = new RenderStateBlock(RenderStateMask.Nothing);
|
|
|
|
#region --------------------------- Non Render Graph ---------------------------
|
|
|
|
private ScriptableRenderer _renderer;
|
|
|
|
protected internal void Initialize(ScriptableRenderer renderer)
|
|
{
|
|
_renderer = renderer;
|
|
}
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
[System.Obsolete]
|
|
#endif
|
|
public override void OnCameraSetup(CommandBuffer cmd, ref RenderingData renderingData)
|
|
{
|
|
Setup(renderingData.cameraData.camera, renderingData.cameraData.renderScale, renderingData.cameraData.cameraTargetDescriptor);
|
|
}
|
|
|
|
private static void Setup(Camera camera, float renderScale, RenderTextureDescriptor desc)
|
|
{
|
|
if (HDepthPyramid == null) HDepthPyramid = HExtensions.LoadComputeShader("HDepthPyramid");
|
|
|
|
int width = (int)(camera.scaledPixelWidth * renderScale);
|
|
int height = (int)(camera.scaledPixelHeight * renderScale);
|
|
|
|
if (desc.width != width || desc.height != height)
|
|
desc = new RenderTextureDescriptor(width, height);
|
|
desc.depthBufferBits = 0; // Color and depth cannot be combined in RTHandles
|
|
desc.stencilFormat = GraphicsFormat.None;
|
|
desc.depthStencilFormat = GraphicsFormat.None;
|
|
desc.msaaSamples = 1;
|
|
desc.bindMS = false;
|
|
|
|
var graphicsFormatRenderingLayerMask = GraphicsFormat.R8G8B8A8_UNorm;
|
|
|
|
#if UNITY_6000_2_OR_NEWER
|
|
graphicsFormatRenderingLayerMask = GraphicsFormat.R8G8_UInt;
|
|
#endif
|
|
|
|
ForwardGBuffer0.ReAllocateIfNeeded(_ForwardGBuffer0, ref desc, graphicsFormat: GraphicsFormat.R8G8B8A8_SRGB);
|
|
ForwardGBuffer1.ReAllocateIfNeeded(_ForwardGBuffer1, ref desc, graphicsFormat: GraphicsFormat.R8G8B8A8_UNorm);
|
|
ForwardGBuffer2.ReAllocateIfNeeded(_ForwardGBuffer2, ref desc, graphicsFormat: GraphicsFormat.R8G8B8A8_SNorm);
|
|
ForwardGBuffer3.ReAllocateIfNeeded(_ForwardGBuffer3, ref desc, graphicsFormat: GraphicsFormat.B10G11R11_UFloatPack32);
|
|
ForwardRenderLayerMask.ReAllocateIfNeeded(_ForwardRenderLayerMask, ref desc, graphicsFormat: graphicsFormatRenderingLayerMask);
|
|
DepthPyramidRT.ReAllocateIfNeeded(_DepthPyramid, ref desc, graphicsFormat: GraphicsFormat.R16_SFloat, useMipMap: true);
|
|
|
|
RenderTextureDescriptor depthDesc = desc;
|
|
depthDesc.depthBufferBits = 32;
|
|
depthDesc.depthStencilFormat = GraphicsFormat.None;
|
|
ForwardGBufferDepth.ReAllocateIfNeeded(_ForwardGBufferDepth, ref depthDesc, graphicsFormat: GraphicsFormat.R16_SFloat, useMipMap: false, enableRandomWrite: false);
|
|
}
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
[System.Obsolete]
|
|
#endif
|
|
public override void Configure(CommandBuffer cmd, RenderTextureDescriptor cameraTextureDescriptor)
|
|
{
|
|
}
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
[System.Obsolete]
|
|
#endif
|
|
public override void Execute(ScriptableRenderContext context, ref RenderingData renderingData)
|
|
{
|
|
Camera camera = renderingData.cameraData.camera;
|
|
|
|
var cmd = CommandBufferPool.Get(HNames.HTRACE_GBUFFER_PASS_NAME);
|
|
|
|
int width = (int)(camera.scaledPixelWidth * renderingData.cameraData.renderScale);
|
|
int height = (int)(camera.scaledPixelHeight * renderingData.cameraData.renderScale);
|
|
|
|
var nativeGBuffer0 = Shader.GetGlobalTexture(HShaderParams._GBuffer0);
|
|
var nativeGBuffer1 = Shader.GetGlobalTexture(HShaderParams._GBuffer1);
|
|
var nativeGBuffer2 = Shader.GetGlobalTexture(HShaderParams._GBuffer2);
|
|
var renderLayerMaskTexture = Shader.GetGlobalTexture(HShaderParams._CameraRenderingLayersTexture);
|
|
var screenSpaceOcclusionTexture = Shader.GetGlobalTexture(HShaderParams.g_ScreenSpaceOcclusionTexture);
|
|
|
|
// Set Depth, Color and SSAO to HTrace passes
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceColor, _renderer.cameraColorTargetHandle);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceDepth, _renderer.cameraDepthTargetHandle);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceSSAO, screenSpaceOcclusionTexture == null ? Texture2D.whiteTexture : screenSpaceOcclusionTexture);
|
|
|
|
GBufferGenerationNonRenderGraph(cmd, width, height, nativeGBuffer0, nativeGBuffer1, nativeGBuffer2, renderLayerMaskTexture, _renderer.cameraColorTargetHandle, _renderer.cameraDepthTargetHandle, ref context, ref renderingData);
|
|
|
|
GenerateDepthPyramidShared(cmd, width, height, DepthPyramidRT.rt);
|
|
|
|
context.ExecuteCommandBuffer(cmd);
|
|
cmd.Clear();
|
|
CommandBufferPool.Release(cmd);
|
|
}
|
|
|
|
|
|
private static void GBufferGenerationNonRenderGraph(CommandBuffer cmd, int width, int height, Texture nativeGBuffer0, Texture nativeGBuffer1,
|
|
Texture nativeGBuffer2, Texture renderLayerMask, RTHandle cameraColorBuffer, RTHandle cameraDepthBuffer,
|
|
ref ScriptableRenderContext context, ref RenderingData renderingData)
|
|
{
|
|
HTraceSSGIProfile profile = HTraceSSGISettings.ActiveProfile;
|
|
var camera = renderingData.cameraData.camera;
|
|
using (new ProfilingScope(cmd, GBufferProfilingSampler))
|
|
{
|
|
// Set sky probe management
|
|
SphericalHarmonicsL2 ambientProbe = RenderSettings.ambientProbe;
|
|
cmd.SetGlobalVector(HShaderParams.H_SHAr, new Vector4(ambientProbe[0, 3], ambientProbe[0, 1], ambientProbe[0, 2], ambientProbe[0, 0] - ambientProbe[0, 6]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHAg, new Vector4(ambientProbe[1, 3], ambientProbe[1, 1], ambientProbe[1, 2], ambientProbe[1, 0] - ambientProbe[1, 6]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHAb, new Vector4(ambientProbe[2, 3], ambientProbe[2, 1], ambientProbe[2, 2], ambientProbe[2, 0] - ambientProbe[2, 6]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHBr, new Vector4(ambientProbe[0, 4], ambientProbe[0, 5], ambientProbe[0, 6] * 3, ambientProbe[0, 7]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHBg, new Vector4(ambientProbe[1, 4], ambientProbe[1, 5], ambientProbe[1, 6] * 3, ambientProbe[1, 7]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHBb, new Vector4(ambientProbe[2, 4], ambientProbe[2, 5], ambientProbe[2, 6] * 3, ambientProbe[2, 7]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHC, new Vector4(ambientProbe[0, 8], ambientProbe[1, 8], ambientProbe[2, 8], 1));
|
|
|
|
// Check if GBuffer is valid (e.g. Forward / wrong scale / is not set, etc.)
|
|
bool RequestForwardGBufferRender = false;
|
|
if (nativeGBuffer0 == null || nativeGBuffer1 == null || nativeGBuffer2 == null)
|
|
{ RequestForwardGBufferRender = true; }
|
|
else if ( nativeGBuffer0.width != width || nativeGBuffer0.height != height) // CameraDepthBuffer.rtHandleProperties.currentViewportSize.x
|
|
{ RequestForwardGBufferRender = true; }
|
|
|
|
// Set Render Layer Mask to black dummy in case it's disabled as a feature and we can't render it
|
|
if (renderLayerMask == null)
|
|
renderLayerMask = Texture2D.blackTexture;// Dummy.rt;
|
|
|
|
// RequestForwardGBufferRender = true;
|
|
|
|
// GBuffer can't be rendered because its resolution doesn't match the resolution of Unity's depth buffer. Happens when switching between Scene and Game windows
|
|
if (ForwardGBuffer0.rt.rt.width != cameraDepthBuffer.rt.width || ForwardGBuffer0.rt.rt.height != cameraDepthBuffer.rt.height)
|
|
{
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer0, ForwardGBuffer0.rt);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer1, ForwardGBuffer1.rt);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer2, ForwardGBuffer2.rt);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceRenderLayerMask, ForwardRenderLayerMask.rt);
|
|
return;
|
|
}
|
|
|
|
// Set GBuffer to HTrace passes if valid or render it otherwise
|
|
if (RequestForwardGBufferRender == false)
|
|
{
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer0, nativeGBuffer0);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer1, nativeGBuffer1);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer2, nativeGBuffer2);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceRenderLayerMask, renderLayerMask);
|
|
}
|
|
else
|
|
{
|
|
|
|
if (HRendererURP.RenderGraphEnabled)
|
|
GBufferMRT = new RenderTargetIdentifier[] { ForwardGBuffer0.rt, ForwardGBuffer1.rt, ForwardGBuffer2.rt, ForwardGBuffer3.rt, ForwardGBufferDepth.rt, ForwardRenderLayerMask.rt };
|
|
else
|
|
GBufferMRT = new RenderTargetIdentifier[] { ForwardGBuffer0.rt, ForwardGBuffer1.rt, ForwardGBuffer2.rt, ForwardGBuffer3.rt, ForwardRenderLayerMask.rt };
|
|
|
|
// If CameraDepthBuffer.rt doesn't work for any reason - we can replace it with our ForwardGBufferDepth.rt, but GBuffer rendering performance will suffer.
|
|
CoreUtils.SetRenderTarget(cmd, GBufferMRT, cameraDepthBuffer.rt);
|
|
|
|
CullingResults cullingResults = renderingData.cullResults;
|
|
int layerMask = camera.cullingMask;
|
|
|
|
ForwardGBufferRenderStateBlock.depthState = new DepthState(false, CompareFunction.LessEqual);
|
|
ForwardGBufferRenderStateBlock.mask |= RenderStateMask.Depth;
|
|
|
|
var renderList = new UnityEngine.Rendering.RendererUtils.RendererListDesc(HShaderParams.UniversalGBufferTag, cullingResults, camera)
|
|
{
|
|
rendererConfiguration = PerObjectData.None,
|
|
renderQueueRange = RenderQueueRange.opaque,
|
|
sortingCriteria = SortingCriteria.OptimizeStateChanges,
|
|
layerMask = layerMask,
|
|
stateBlock = ForwardGBufferRenderStateBlock,
|
|
};
|
|
|
|
// Cache the current keyword state set by Unity
|
|
bool RenderLayerKeywordState = Shader.IsKeywordEnabled(HShaderParams._WRITE_RENDERING_LAYERS);
|
|
|
|
// If we don't need render layers we do not touch the keyword at all
|
|
#if UNITY_2023_3_OR_NEWER
|
|
if (profile.GeneralSettings.ExcludeReceivingMask != 0 || profile.GeneralSettings.ExcludeCastingMask != 0)
|
|
CoreUtils.SetKeyword(cmd, HShaderParams._WRITE_RENDERING_LAYERS, true);
|
|
#endif
|
|
|
|
CoreUtils.DrawRendererList(context, cmd, context.CreateRendererList(renderList));
|
|
|
|
// If we altered the keyword, we restore it to the original state
|
|
#if UNITY_2023_3_OR_NEWER
|
|
if (profile.GeneralSettings.ExcludeReceivingMask != 0 || profile.GeneralSettings.ExcludeCastingMask != 0)
|
|
CoreUtils.SetKeyword(cmd, HShaderParams._WRITE_RENDERING_LAYERS, RenderLayerKeywordState);
|
|
#endif
|
|
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer0, ForwardGBuffer0.rt);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer1, ForwardGBuffer1.rt);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer2, ForwardGBuffer2.rt);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceRenderLayerMask, ForwardRenderLayerMask.rt);
|
|
}
|
|
}
|
|
}
|
|
#endregion --------------------------- Non Render Graph ---------------------------
|
|
|
|
#region --------------------------- Render Graph ---------------------------
|
|
|
|
#if UNITY_2023_3_OR_NEWER
|
|
private class PassData
|
|
{
|
|
public TextureHandle[] GBufferTextures;
|
|
public TextureHandle SSAOTexture;
|
|
public TextureHandle ColorTexture;
|
|
public TextureHandle DepthTexture;
|
|
public TextureHandle NormalsTexture;
|
|
public RendererListHandle ForwardGBufferRendererListHandle;
|
|
public UniversalCameraData UniversalCameraData;
|
|
|
|
public TextureHandle ForwardGBuffer0Texture;
|
|
public TextureHandle ForwardGBuffer1Texture;
|
|
public TextureHandle ForwardGBuffer2Texture;
|
|
public TextureHandle ForwardGBuffer3Texture;
|
|
public TextureHandle ForwardRenderLayerMaskTexture;
|
|
public TextureHandle DepthPyramidTexture;
|
|
public TextureHandle DepthPyramidIntermediateTexture;
|
|
public TextureHandle ForwardGBufferDepthTexture;
|
|
}
|
|
|
|
public override void RecordRenderGraph(RenderGraph renderGraph, ContextContainer frameData)
|
|
{
|
|
using (var builder = renderGraph.AddUnsafePass<PassData>(HNames.HTRACE_GBUFFER_PASS_NAME, out var passData, new ProfilingSampler(HNames.HTRACE_GBUFFER_PASS_NAME)))
|
|
{
|
|
UniversalResourceData resourceData = frameData.Get<UniversalResourceData>();
|
|
UniversalCameraData universalCameraData = frameData.Get<UniversalCameraData>();
|
|
UniversalRenderingData universalRenderingData = frameData.Get<UniversalRenderingData>();
|
|
UniversalLightData lightData = frameData.Get<UniversalLightData>();
|
|
|
|
builder.AllowGlobalStateModification(true);
|
|
builder.AllowPassCulling(false);
|
|
|
|
TextureHandle colorTexture = universalRenderingData.renderingMode == RenderingMode.Deferred ? resourceData.activeColorTexture : resourceData.cameraColor;
|
|
TextureHandle depthTexture = universalRenderingData.renderingMode == RenderingMode.Deferred ? resourceData.activeDepthTexture : resourceData.cameraDepth;
|
|
TextureHandle normalsTexture = resourceData.cameraNormalsTexture;
|
|
builder.UseTexture(depthTexture, AccessFlags.Read);
|
|
builder.UseTexture(normalsTexture, AccessFlags.Read);
|
|
|
|
passData.NormalsTexture = resourceData.cameraNormalsTexture;
|
|
passData.ColorTexture = colorTexture;
|
|
passData.DepthTexture = depthTexture;
|
|
passData.UniversalCameraData = universalCameraData;
|
|
passData.GBufferTextures = resourceData.gBuffer;
|
|
passData.SSAOTexture = resourceData.ssaoTexture;
|
|
|
|
if (HDepthPyramid == null) HDepthPyramid = HExtensions.LoadComputeShader("HDepthPyramid");
|
|
|
|
TextureHandle colorTextureHandle = resourceData.cameraColor;
|
|
TextureDesc desc = colorTextureHandle.GetDescriptor(renderGraph);
|
|
desc.clearBuffer = false;
|
|
TextureHandle depthTextureHandle = resourceData.cameraDepthTexture;
|
|
TextureDesc descDepth = depthTextureHandle.GetDescriptor(renderGraph);
|
|
descDepth.clearBuffer = false;
|
|
var graphicsFormatRenderingLayerMask = GraphicsFormat.R8G8B8A8_UNorm;
|
|
|
|
#if UNITY_6000_2_OR_NEWER
|
|
graphicsFormatRenderingLayerMask = GraphicsFormat.R8G8_UInt;
|
|
#endif
|
|
passData.ForwardGBuffer0Texture = ExtensionsURP.CreateTexture(_ForwardGBuffer0, renderGraph, ref desc, format: GraphicsFormat.R8G8B8A8_SRGB);
|
|
builder.UseTexture(passData.ForwardGBuffer0Texture, AccessFlags.Write);
|
|
passData.ForwardGBuffer1Texture = ExtensionsURP.CreateTexture(_ForwardGBuffer1, renderGraph, ref desc, format: GraphicsFormat.R8G8B8A8_UNorm);
|
|
builder.UseTexture(passData.ForwardGBuffer1Texture, AccessFlags.Write);
|
|
passData.ForwardGBuffer2Texture = ExtensionsURP.CreateTexture(_ForwardGBuffer2, renderGraph, ref desc, format: GraphicsFormat.R8G8B8A8_SNorm);
|
|
builder.UseTexture(passData.ForwardGBuffer2Texture, AccessFlags.Write);
|
|
passData.ForwardGBuffer3Texture = ExtensionsURP.CreateTexture(_ForwardGBuffer3, renderGraph, ref desc, format: GraphicsFormat.B10G11R11_UFloatPack32);
|
|
builder.UseTexture(passData.ForwardGBuffer3Texture, AccessFlags.Write);
|
|
passData.ForwardRenderLayerMaskTexture = ExtensionsURP.CreateTexture(_ForwardRenderLayerMask, renderGraph, ref desc, format: graphicsFormatRenderingLayerMask);
|
|
builder.UseTexture(passData.ForwardRenderLayerMaskTexture, AccessFlags.Write);
|
|
passData.DepthPyramidTexture = ExtensionsURP.CreateTexture(_DepthPyramid, renderGraph, ref desc, format: GraphicsFormat.R16_SFloat, useMipMap: true);
|
|
builder.UseTexture(passData.DepthPyramidTexture, AccessFlags.Write);
|
|
|
|
desc.width /= 16;
|
|
desc.height /= 16;
|
|
|
|
passData.ForwardGBufferDepthTexture = ExtensionsURP.CreateTexture(_ForwardGBufferDepth, renderGraph, ref descDepth, format: GraphicsFormat.R16_SFloat, useMipMap: false, enableRandomWrite: false);
|
|
builder.UseTexture(passData.ForwardGBufferDepthTexture, AccessFlags.Write);
|
|
|
|
if (universalRenderingData.renderingMode == RenderingMode.Deferred
|
|
#if UNITY_6000_1_OR_NEWER
|
|
|| universalRenderingData.renderingMode == RenderingMode.DeferredPlus
|
|
#endif
|
|
)
|
|
{
|
|
if (resourceData.ssaoTexture.IsValid())
|
|
builder.UseTexture(resourceData.ssaoTexture, AccessFlags.Read);
|
|
builder.UseTexture(resourceData.gBuffer[0], AccessFlags.Read);
|
|
builder.UseTexture(resourceData.gBuffer[1], AccessFlags.Read);
|
|
builder.UseTexture(resourceData.gBuffer[2], AccessFlags.Read);
|
|
builder.UseTexture(resourceData.gBuffer[3], AccessFlags.Read);
|
|
if (resourceData.gBuffer.Length >= 6 && resourceData.gBuffer[5].IsValid())
|
|
builder.UseTexture(resourceData.gBuffer[5], AccessFlags.Read);
|
|
}
|
|
|
|
|
|
CullingResults cullingResults = universalRenderingData.cullResults;
|
|
ShaderTagId tags = new ShaderTagId("UniversalGBuffer");
|
|
int layerMask = universalCameraData.camera.cullingMask;
|
|
|
|
ForwardGBufferRenderStateBlock.depthState = new DepthState(false, CompareFunction.LessEqual);
|
|
ForwardGBufferRenderStateBlock.mask |= RenderStateMask.Depth;
|
|
|
|
RendererListDesc rendererListDesc = new RendererListDesc(tags, cullingResults, universalCameraData.camera)
|
|
{
|
|
rendererConfiguration = PerObjectData.None,
|
|
renderQueueRange = RenderQueueRange.opaque,
|
|
sortingCriteria = SortingCriteria.OptimizeStateChanges,
|
|
layerMask = layerMask,
|
|
stateBlock = ForwardGBufferRenderStateBlock,
|
|
};
|
|
|
|
passData.ForwardGBufferRendererListHandle = renderGraph.CreateRendererList(rendererListDesc);
|
|
builder.UseRendererList(passData.ForwardGBufferRendererListHandle);
|
|
|
|
builder.SetRenderFunc((PassData data, UnsafeGraphContext context) => ExecutePass(data, context));
|
|
}
|
|
}
|
|
|
|
private static void ExecutePass(PassData data, UnsafeGraphContext rgContext)
|
|
{
|
|
var cmd = CommandBufferHelpers.GetNativeCommandBuffer(rgContext.cmd);
|
|
|
|
int width = (int)(data.UniversalCameraData.camera.scaledPixelWidth * data.UniversalCameraData.renderScale);
|
|
int height = (int)(data.UniversalCameraData.camera.scaledPixelHeight * data.UniversalCameraData.renderScale);
|
|
|
|
// Set Depth, Color and SSAO to HTrace passes
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceDepth, data.DepthTexture);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceColor, data.ColorTexture);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer2, data.NormalsTexture);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceSSAO, data.SSAOTexture.IsValid() ? data.SSAOTexture : Texture2D.whiteTexture);
|
|
|
|
var nativeGBuffer0 = data.GBufferTextures[0];
|
|
var nativeGBuffer1 = data.GBufferTextures[1];
|
|
var nativeGBuffer2 = data.GBufferTextures[2];
|
|
Texture renderLayerMaskTexture = data.GBufferTextures.Length >= 6 ? data.GBufferTextures[5] : null;
|
|
GBufferGenerationRenderGraph(cmd, data, width, height, nativeGBuffer0, nativeGBuffer1, nativeGBuffer2, renderLayerMaskTexture);
|
|
|
|
GenerateDepthPyramidShared(cmd, width, height, data.DepthPyramidTexture);
|
|
}
|
|
|
|
private static void GBufferGenerationRenderGraph(CommandBuffer cmd, PassData data, int width, int height, Texture nativeGBuffer0, Texture nativeGBuffer1,
|
|
Texture nativeGBuffer2, Texture renderLayerMask)
|
|
{
|
|
HTraceSSGIProfile profile = HTraceSSGISettings.ActiveProfile;
|
|
using (new ProfilingScope(cmd, GBufferProfilingSampler))
|
|
{
|
|
// Sky probe management
|
|
SphericalHarmonicsL2 ambientProbe = RenderSettings.ambientProbe;
|
|
cmd.SetGlobalVector(HShaderParams.H_SHAr, new Vector4(ambientProbe[0, 3], ambientProbe[0, 1], ambientProbe[0, 2], ambientProbe[0, 0] - ambientProbe[0, 6]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHAg, new Vector4(ambientProbe[1, 3], ambientProbe[1, 1], ambientProbe[1, 2], ambientProbe[1, 0] - ambientProbe[1, 6]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHAb, new Vector4(ambientProbe[2, 3], ambientProbe[2, 1], ambientProbe[2, 2], ambientProbe[2, 0] - ambientProbe[2, 6]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHBr, new Vector4(ambientProbe[0, 4], ambientProbe[0, 5], ambientProbe[0, 6] * 3, ambientProbe[0, 7]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHBg, new Vector4(ambientProbe[1, 4], ambientProbe[1, 5], ambientProbe[1, 6] * 3, ambientProbe[1, 7]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHBb, new Vector4(ambientProbe[2, 4], ambientProbe[2, 5], ambientProbe[2, 6] * 3, ambientProbe[2, 7]));
|
|
cmd.SetGlobalVector(HShaderParams.H_SHC, new Vector4(ambientProbe[0, 8], ambientProbe[1, 8], ambientProbe[2, 8], 1));
|
|
|
|
// Check if GBuffer is valid (e.g. Forward / wrong scale / is not set, etc.)
|
|
bool requestForwardGBufferRender = false;
|
|
if (nativeGBuffer0 == null || nativeGBuffer1 == null || nativeGBuffer2 == null)
|
|
{ requestForwardGBufferRender = true; }
|
|
else if ( nativeGBuffer0.width != width || nativeGBuffer0.height != height) // CameraDepthBuffer.rtHandleProperties.currentViewportSize.x
|
|
{ requestForwardGBufferRender = true; }
|
|
|
|
// Set Render Layer Mask to black dummy in case it's disabled as a feature and we can't render it
|
|
if (renderLayerMask == null)
|
|
renderLayerMask = Texture2D.blackTexture; // HRenderer.EmptyTexture;
|
|
|
|
// RequestForwardGBufferRender = true;
|
|
|
|
// Set GBuffer to HTrace passes if valid or render it otherwise
|
|
if (requestForwardGBufferRender == false)
|
|
{
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer0, nativeGBuffer0);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer1, nativeGBuffer1);
|
|
// cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer2, nativeGBuffer2);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceRenderLayerMask, renderLayerMask);
|
|
}
|
|
else
|
|
{
|
|
|
|
if (HRendererURP.RenderGraphEnabled)
|
|
GBufferMRT = new RenderTargetIdentifier[] { data.ForwardGBuffer0Texture, data.ForwardGBuffer1Texture, data.ForwardGBuffer2Texture, data.ForwardGBuffer3Texture, data.ForwardGBufferDepthTexture, data.ForwardRenderLayerMaskTexture };
|
|
else
|
|
GBufferMRT = new RenderTargetIdentifier[] { data.ForwardGBuffer0Texture, data.ForwardGBuffer1Texture, data.ForwardGBuffer2Texture, data.ForwardGBuffer3Texture, data.ForwardRenderLayerMaskTexture };
|
|
|
|
// If CameraDepthBuffer.rt doesn't work for any reason - we can replace it with our ForwardGBufferDepth.rt, but GBuffer rendering performance will suffer.
|
|
CoreUtils.SetRenderTarget(cmd, GBufferMRT, data.DepthTexture, ClearFlag.None);
|
|
|
|
// Cache the current keyword state set by Unity
|
|
bool RenderLayerKeywordState = Shader.IsKeywordEnabled(HShaderParams._WRITE_RENDERING_LAYERS);
|
|
|
|
// If we don't need render layers we do not touch the keyword at all
|
|
#if UNITY_2023_3_OR_NEWER
|
|
if (profile.GeneralSettings.ExcludeReceivingMask != 0 || profile.GeneralSettings.ExcludeCastingMask != 0)
|
|
CoreUtils.SetKeyword(cmd, HShaderParams._WRITE_RENDERING_LAYERS, true);
|
|
#endif
|
|
|
|
cmd.DrawRendererList(data.ForwardGBufferRendererListHandle);
|
|
|
|
// If we altered the keyword, we restore it to the original state
|
|
#if UNITY_2023_3_OR_NEWER
|
|
if (profile.GeneralSettings.ExcludeReceivingMask != 0 || profile.GeneralSettings.ExcludeCastingMask != 0)
|
|
CoreUtils.SetKeyword(cmd, HShaderParams._WRITE_RENDERING_LAYERS, RenderLayerKeywordState);
|
|
#endif
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer0, data.ForwardGBuffer0Texture);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer1, data.ForwardGBuffer1Texture);
|
|
// cmd.SetGlobalTexture(HShaderParams.g_HTraceGBuffer2, data.ForwardGBuffer2Texture);
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceRenderLayerMask, data.ForwardRenderLayerMaskTexture);
|
|
}
|
|
}
|
|
}
|
|
#endif
|
|
#endregion --------------------------- Render Graph ---------------------------
|
|
|
|
#region --------------------------- Shared ---------------------------
|
|
|
|
private static void GenerateDepthPyramidShared(CommandBuffer cmd, int width, int height, RTHandle depthPyramidTexture)
|
|
{
|
|
using (new ProfilingScope(cmd, DepthPyramidGenerationProfilingSampler))
|
|
{
|
|
int generate_depth_pyramid_kernel = HDepthPyramid.FindKernel("GenerateDepthPyramid");
|
|
cmd.SetComputeTextureParam(HDepthPyramid, generate_depth_pyramid_kernel, HShaderParams._DepthPyramid_OutputMIP0, depthPyramidTexture, 0);
|
|
cmd.SetComputeTextureParam(HDepthPyramid, generate_depth_pyramid_kernel, HShaderParams._DepthPyramid_OutputMIP1, depthPyramidTexture, 1);
|
|
cmd.SetComputeTextureParam(HDepthPyramid, generate_depth_pyramid_kernel, HShaderParams._DepthPyramid_OutputMIP2, depthPyramidTexture, 2);
|
|
cmd.SetComputeTextureParam(HDepthPyramid, generate_depth_pyramid_kernel, HShaderParams._DepthPyramid_OutputMIP3, depthPyramidTexture, 3);
|
|
cmd.SetComputeTextureParam(HDepthPyramid, generate_depth_pyramid_kernel, HShaderParams._DepthPyramid_OutputMIP4, depthPyramidTexture, 4);
|
|
cmd.DispatchCompute(HDepthPyramid, generate_depth_pyramid_kernel, Mathf.CeilToInt(width / 16.0f), Mathf.CeilToInt(height / 16.0f), HRenderer.TextureXrSlices);
|
|
|
|
cmd.SetGlobalTexture(HShaderParams.g_HTraceDepthPyramidSSGI, depthPyramidTexture);
|
|
}
|
|
}
|
|
|
|
|
|
protected internal void Dispose()
|
|
{
|
|
Dummy?.HRelease();
|
|
ForwardGBuffer0?.HRelease();
|
|
ForwardGBuffer1?.HRelease();
|
|
ForwardGBuffer2?.HRelease();
|
|
ForwardGBuffer3?.HRelease();
|
|
ForwardRenderLayerMask?.HRelease();
|
|
ForwardGBufferDepth?.HRelease();
|
|
DepthPyramidRT?.HRelease();
|
|
}
|
|
|
|
#endregion --------------------------- Shared ---------------------------
|
|
}
|
|
}
|