Showcase [Open Source] Screen Space GBuffer Path Tracing in URP 14

Hey, I followed Three-Eyed-Games' ray tracing tutorials and created a screen space path tracing effect in URP 15.

I thought it was unusable because of the noisiness and speed, but surprisingly found that it can be usable in some cases. (Tested on a mobile device with TAA)



It would be nice if it is helpful for your project.

 

Hey, I just found out the reason that I cannot add reflection probes fallback to the effect. (currently the probe will be black or grey)

That's because the current full screen pass renderer feature will always use "Draw Procedural" even if the mode is set to "Blit".




I will test it further once the "Blit" mode works, and I think a box projected probe fallback will greatly improve the stability of this screen space effect.

 

The report is confirmed as a duplicate issue of UUM-2631.

I think it won't be fixed soon, so I tried to manually set reflection probes. (see this thread or this C# script)


If you need to access reflection probes in a URP blit pass, you may try the method mentioned above. Now the effect is much better than before.

Custom Sky Fallback:


[Last Edited] Reflection Probe Fallback: (Probe Intensity set to 0.37)


[Last Edited] Off-Screen Light Plane:


The fall back is not perfect because reflection probes don't capture depth information. But it's enough to provide some off-screen data.

Reflection Probe Preview Only:

 

Hi, I added Forward rendering path support to the repository. (URP forces Forward path on OpenGL platforms)

If you need to render GBuffers (0,1,2) in a Forward path, you can try this renderer feature.


For OpenGL platforms, some extra steps are needed.

 

amazing project！

 

Hi, I've done many improvements to it since the last post. They can be find in the commits page.

The biggest improvement is the real-time accumulation (temporal re-projection).


Most of the artifacts (weird shadows) are fixed by considering back-face in ray marching. These back-faces reuse the front GBuffer to reduce performance cost.
Before:

After:


The back-face now appears in reflection when "Accurate Thickness" (render back-face depth) is enabled. This may not be 100% correct but looks much better than before (with hole).


The next steps might be:

• Move this post-processing effect into object's shader to allow more accurate reflection probe fallback.
• Further reduce ghosting in real-time accumulation.
• Move this post-processing effect into object's shader to see if it's possible to support other lighting models (refraction, ...).

 

nice, very interesting

 

Hey, I'm still looking for a way that is efficient enough (less draw call & overdraw) to implement per object reflection probe fallback.

So I added refraction support to it first. To render refractions, objects need to use "Universal Render Pipeline/Screen Space Path Tracing/Refraction Lit" shader graph, which is provided by the repository, and tick "Support Refraction" in the accumulation renderer feature.


The idea is similar to layered rendering.

Details:

Spoiler

1. Render transparent objects to three transparent GBuffers (0, 1, 2) and write depth to "_CameraDepthAttachment" (camera's depth target).
2. Render both opaque & transparent objects' back-face depth to "_CameraBackDepthTexture".
3. [Optional] Render back-face normals (DepthNormals) rather than rendering back-face depth (DepthOnly).

Now we have these for calculating refractions:
- "_CameraDepthAttachment": Opaque & Transparent Depth Layer 1
- "_CameraBackDepthTexture": Opaque & Transparent Depth Layer 2
- "_CameraDepthTexture": Opaque Depth Layer

This allows calculating the actual thickness of refracting objects, and find intersections for opaque objects that are covered by them.

The "_TransparentGBuffer1" (specular.rgb occlusion.a) is used to store index of refraction (ior.r) and surface type (surfaceType.a). The "occlusion.a" for other transparent objects will be 1.0.

As this effect is based on rasterization, it doesn't support recursive refraction, which means that other refractions cannot be seen in refractions.

For Unity lights, (shadows) transparency uses dithered transparent shadows.


Only path traced shadows (from indirect lighting, emission, ...) can have things like refraction caustics.


It's not perfect yet and I think it can be improved later. (URP transparent motion vectors, ...)

 

I saw a simple but effective open source spatial denoiser on shadertoy, and it works well after porting to URP. It uses different surface data to avoid blurring the edges and colors.

Now it's possible to use recorder to export videos without setting extremely high SPPs.

Temporal Denoise Only (TAA + Real-time Accumulation):

Temporal Spatial Denoise:

TAA causes severe ghosting, maybe need to find a way to replace it.

 

The reflection probe atlas in Forward+ makes accessing all reflection probes in a full screen shader possible. I've tried it and the results were satisfying.

Forward and Deferred:


Forward+:


I haven't pulled it to the repo yet because I think it needs more tests and I'm considering downgrading the repo's editor version to 2022 LTS (from 2023.1b).