FroyokI recently added a rendering pass in my engine to compute volumetric shapes via raymarching. Mostly to cast volumetric shadows with spot lights.
I render them at half resolution to save a bit on performance and keep it cheap. However I'm struggling to find a good upscale algorithm. Bilateral weights based on the differences on the depth buffer isn't enough.
I'm not sure what I could do better, without temporal anti-aliasing. I'm open to suggestions ☺️
Anders Lindqvist@froyok Do you have access to the zbuffer when you do it? Maybe you can do it like msaa and only do full res at edges maybe? Not sure what the best way to to get coherency though…
This only works if edges are the problem though. Upscaling and noise doesn’t play well together sometimes.
@breakin I have the zbuffer yes, but I can't toy with msaa unfortunately. Here the issue is around edges of geometry, noise isn't a problem.
@froyok Ah I was thinking that when you do say half res you could check 4 pixels in zbuffer to see if they are close enough for half res. Otherwise put that pixel id in a buffer. Do you have atomics? Then a second pass does full res for things in buffer. I mean you could redo edge-pixels during upsampling to see if that solves quality first bur sounds slow.
Somewhat like manual msaa.
@froyok Pleanty of tricks like you do volumetric to the closest z value then you can continue from there for you per-pixel rays. I know the edge pixels are the mest expensive ones so maybe a bad idea from that perspective.
@froyok This recent link would help if you had sdfs. Maybe some inspiration in sharing work https://pointersgonewild.com/2026-03-06-a-recursive-algorithm-to-render-signed-distance-fields/
Jan@froyok Have you tried this: https://c0de517e.blogspot.com/2016/02/downsampled-effects-with-depth-aware.html
The important parts are using a min/max depth checkerboard pattern for the downscaled depth and then choosing between bilinear/bilateral upsampling based on depth discontinuity for a given pixel.
Also randomly offsetting the rays with blue noise and then running a bilateral blur over the volumetric target before upsampling helps. Allows to get away with huge steps during raymarching.
WaitForPresent@froyok what about variable rate compute shader dispatch? https://youtu.be/mvCoqCic3nE
Variable-Rate Compute Shaders in DOOM: The Dark Ages
@WaitForPresent Not doable with the framework I'm working with I believe, plus I'm sticking to OpenGL currently. Or I would need to emulate it myself in compute.
@froyok not sure what you are referring to, VRCS only really needs glDispatchComputeIndirect. It is not an api level feature.
@WaitForPresent Not sure it's exposed in my framework, but I will check that out. Thanks for the clarification!
mirth@froyok If instead of 2x2 binning (aka half resolution) would it work to do two versions like 1x8 and 8x1, and then accumulate those into the full resolution final result? Directly inspired by box blur.
@mirth Hmm, I not sure I see how I could transcribe the effect into this method. What would be the point of making it separable it, outside of the performance cost ?
@froyok Performance and a full resolution if blurry result, potentially solving the upscale question. I know a lot more about vision than graphics so not sure if this would be a sensible trade off.
@froyok Trying a version of this rescaling + threshold on a 2D black and white silhouette image I think gives a rough idea of the behavior:
@froyok The math would take some thought but it might be possible to sample the vertical and horizontally squished versions at render time, do the threshold, and skip the larger intermediate texture entirely Then the shadows would have fewer artifacts and the overall memory bandwidth used should be smaller.
(this feels like the kind of idea that one of the elder graphics people will chime in and be able to point out some prior art and improvements from 25 years ago)
@mirth Given the critical part here is the edges, the demonstration you propose doesn't help on this issue.
Then one solution could be compute bits at half-res where there isn't edges (so edges are at full res), but this sounds a bit like the MSAA or Variable rate solution that were proposed in other replies, they are unfortunately difficult to implement in my engine.
Then one solution could be compute bits at half-res where there isn't edges (so edges are at full res), but this sounds a bit like the MSAA or Variable rate solution that were proposed in other replies, they are unfortunately difficult to implement in my engine.
@froyok I see, so edge detail is important (not just crispness on simple shapes)... I checked to see to what degree a small convolution can compensate for the artifacts but I don't think it'll be good enough to do what you're looking for. Example below is the same two squished renders, but then combined into an upsampled 256x256 image, a 7x7 convolution, threshold, and then bicubic down to 128x128 (this simulates antialiasing). Hard I think to get much better quality with this approach.
Very Human Robot@froyok have you tried DLSS?
@StompyRobot No, but if I go with temporal I will cook my own. :)