I recently added a rendering pass in my engine to compute volumetric shapes via raymarching.

[waitforpresent@mastodon.gamedev.place]

@froyok what about variable rate compute shader dispatch? https://youtu.be/mvCoqCic3nE

[froyok@mastodon.gamedev.place]

@breakin Thank for sharing that idea still ! That's sounds interesting ! :)

[froyok@mastodon.gamedev.place]

@blurple I haven't tried the checkerboard, but I tried different combination of bilinear and nearest filtering with custom weights. No luck so far.

[froyok@mastodon.gamedev.place]

@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@mastodon.gamedev.place]

To illustrate a bit, In the worst-case scenario this is how it looks like:

[froyok@mastodon.gamedev.place]

I use a 3x3 bilateral filter, each sample is weighted by both spatial distance (sub-pixel position within the half-res grid) and depth
similarity (to prevent light bleeding across silhouettes).

[breakin@mastodon.gamedev.place]

@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/

[mirth@mastodon.sdf.org]

@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.

[froyok@mastodon.gamedev.place]

@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 ?

[mirth@mastodon.sdf.org]

@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@mastodon.gamedev.place]

@mirth I will scratch my head a bit about it ;)

[mirth@mastodon.sdf.org]

@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:

[mirth@mastodon.sdf.org]

@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)

[froyok@mastodon.gamedev.place]

@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.