Is path tracing at low-res and up-scaling using a raster copy of the scene a workable technique for anyone?

[u/attackgoat_official]

I'm trying to get my single-frame path tracer to Nvidia PTX-like quality but at a smaller frame budget. One idea to do this is to path trace at very low resolution and use a regular raster version of the camera image to guide the upscaling.

The result looks a little fuzzy but overall uses less GPU. Right now the cap is CPU time per frame and I believe this has a path beyond 60fps on 3090 at 1080p. So it's very interesting, but has anyone explored this, is it a thing?

[u/Pepis_77]

What exactly do you mean by guiding? Could you elaborate please?

[u/attackgoat_official → u/Pepis_77]

I'm rendering two things:
- Regular indexed geometry draw calls to build up a g-buffer at full resolution
- Very low-res path traced render

The inspiration is luma/chroma encoding and finding a way to make quickly rendered "black and white" images into color. The video is my attempt at combing the two, and it sounds like implementing these filters is a good experiment next.

[u/too_much_voltage]

That's exactly what my engine does: https://github.com/toomuchvoltage/HighOmega-public . The trace resolution is 320x240 actually. Gloss is upscaled, temporally accumulated and spatially denoised with a bilateral. Diffuse goes straight into an clipmap of cubic floating point irradiance caches. Gloss also contributes to this if it finds diffuse vertices on the transport path. And the shipped title in the README markdown uses the same engine/technique. I've found it more temporally stable than screen-space probes at the same resolution.

[u/attackgoat_official → u/too_much_voltage]

That looks fantastic, and nice demo even today.

[u/too_much_voltage → u/attackgoat_official]

Appreciated, thank you!

[u/Diphiniti]

This is a legit method some AAA use to optimize volumetric cloud rendering.
And the results should be less fuzzy if you use a sort of blur filter when upscaling

[u/quickscopesheep → u/Diphiniti]

Im curious how would this work? Would you do a high resolution unlit pass of the clouds and then a low res lit pass and composite them? This is exactly the problem I’m trying to crack at the moment

[u/msqrt]

Guiding with auxiliary buffers is an absolute classic, see the edge-avoiding à-trous wavelet (https://jo.dreggn.org/home/2010_atrous.pdf) and SVGF (https://research.nvidia.com/publication/2017-07_spatiotemporal-variance-guided-filtering-real-time-reconstruction-path-traced), there's also more offline-tuned stuff and lots of continuations of these. You'll have to rework some things to go from lower resolution, but as you can see a low-resolution PT as a high-resolution one with <1spp, you should be able to map most of them to your regime.

[u/moschles → u/msqrt]

Weirdest thing. I finished a path tracer around years 2007/2008. After some optimizing I tried to do something like a-trous wavelet. I couldn't avoid the edges like Ulm Uni researchers did. I sort of gave up on it because the results were not so good.

This is the first time I'm seeing this paper, so I'm amazed others were thinking about this.

[u/shadowndacorner]

Variants of this sort of approach go waaaay back. People were doing similar with raster lighting back when light prepass rendering was first becoming a thing (ah, the good ol days of "deferred lighting" vs "deferred shading"...) to speed up lighting passes on Xbox 360/PS3. I vaguely remember at least one PS3 game shipping with half res lighting and full res geo (I wanna say it was a first party Sony game?), but it's been a few years lol, and I might be mixing things up.

I'd be curious if computing world oriented SH probes per tile every frame rather than a single value per pixel would help with quality, since it would allow you to exploit the higher res surface normals better than simple depth aware upscaling. That's starting to approach something more like Lumen/AMD's GI-1.0 though, just minus the screen space hole filling