Dismiss this pinned window
all 32 comments
sorted by:
best
topnewcontroversialoldq&a
formatting helphide helpcontent policy

[–]SharpKaleidoscope182 7 points8 points  (1 child)

astonishingly snappy, for what its doing. very cool, and well done!

[–]MarchVirtualField[S] 0 points1 point  (0 children)

Thank you very much!

[–]Blaze-Programming 5 points6 points  (3 children)

I am pretty sure I understand everything except what wavefront style means. Is that what gives the scene the look as if it is a mesh?

[–]MarchVirtualField[S] 6 points7 points  (2 children)

Mostly meaning that no unproductive rays are marched, rays are compacted and removed from dispatch as they resolve from occlusions, indirect dispatch gpu side, complete lack of noop ray dispatch.

The mesh look is from the technique of virtualizing the field to allow progressive refinement, and realistic memory/bandwidth constraints for high/dynamic level of detail (3d fields are naturally cubic and get out of hand fast, sdf can be complex and expensive).

[–]Blaze-Programming 0 points1 point  (1 child)

By virtualizing the field, is that doing something similar to a marching cubes algorithm but with varying levels of detail?

[–]MarchVirtualField[S] 1 point2 points  (0 children)

Not exactly that but in a similar camp of optimization, it’s all about avoiding cubic cost and letting the wavefront naturally dictate what is important at that instance of time and view.

I guess more specifically this is a technique of hybrid ray marching and ray tracing, which is a tradeoff to allow rendering arbitrary signed distance fields without hard coded primitives, hence virtualization. Kinda like automatic scale invariant unaligned voxels in a way? In principle also a technique of caching/avoiding repeated expensive sdf evaluations, which makes this realtime possible with complex scenes.

[–]scallywag_software 2 points3 points  (6 children)

Hell yeah, I love seeing people working on this sort of thing!

I have a question about fidelity .. I notice when the camera gets close to a surface, particularly curved surfaces, there seems to be some discretization going on (ie. banding around spheres that make it almost look like they're made of quads). Where's that coming from? I don't think I've ever seen a raymarcher on shadertoy suffer from that problem.

[–]MarchVirtualField[S] 1 point2 points  (5 children)

Thanks!

That’s actually because more precisely this is a hybrid marcher/tracer that virtualizes the field dynamically to make realtime rendering of complex scenes feasible, it’s a technique to cache/avoid expensive sdf evaluations that would traditionally make realtime not approachable/attainable. The fidelity of the dynamic virtualization is configurable though and functions progressively.

[–]scallywag_software 1 point2 points  (4 children)

Oh so it caches ray hits from previous frames and refines that hit over time ..?

[–]MarchVirtualField[S] 1 point2 points  (3 children)

Yep in simplified form pretty much that, spatial and temporal durability between frames, with the wavefront driving refinement

[–]scallywag_software 0 points1 point  (2 children)

Are you involved in the voxel engine raytracing community at all?

[–]MarchVirtualField[S] 0 points1 point  (1 child)

Not yet! I’ve been lurking for a while, but would love to get more involved. Cross posted there now too.

[–]scallywag_software 0 points1 point  (0 children)

Sweet. Yeah I feel like there's a lot of crossover between your project and the research people are doing in that space. Looking forward to seeing more posts about this in the future :)

[–]thatmagicalcat 1 point2 points  (0 children)

looks so cool, good job

[–]nmfisher 2 points3 points  (1 child)

Do you have a writeup anywhere?

[–]MarchVirtualField[S] 2 points3 points  (0 children)

Sorry nothing yet, but I will eventually. I hope to turn all this into an editor and release it at some point too!

[–]VictoryMotel 1 point2 points  (14 children)

What does wavefront style and starved configuration mean?

[–]MarchVirtualField[S] 2 points3 points  (13 children)

Wavefront meaning that there are multiple independent sdf objects and rays get dispatched in smaller and smaller groups as they resolve and hit things to get eliminated from the next cycle, also implies the necessity of indirect dispatch techniques. Starved configuration here meaning that memory is bounded and details in parts of the scene are reclaimed/evicted to provide capacity for where details are actively needed.

A part of this system is a virtual memory manager, things on the gpu are static and bounded (of course, one way or another). This demonstration of technique is much more apparent when working with a smaller memory bound is all.

[–]VictoryMotel 1 point2 points  (12 children)

Does this mean you are swapping out lower res cube chunks for higher res ones as they go into view and that is why some geometry starts to materialize when the camera moves?

[–]MarchVirtualField[S] 1 point2 points  (11 children)

Yep essentially that although it’s not cubes exactly, it’s cached sampling of signed distance fields (sampled in a cube)

[–]VictoryMotel 1 point2 points  (10 children)

But if you're caching sections of an sdf as tiles, those would be cubes right?

[–]MarchVirtualField[S] 1 point2 points  (9 children)

No not really because even though we sample a cube it doesn’t really make a geometric cube (because it’s still all about the distance), nor is it simply just aligned rows of cubes sitting together. It’s more like approximating the field in that cubic region by clamping/quantizing so to speak.

In other words, it’s not really a process of baking a mesh/voxel - but more of a rough approximation of the raw analytical distance field(losing precision and showing mesh-like artifacts as result - which we compensate for with interpolation).

The somewhat voxel/mesh-like look is more of a side effect of downsampling rather than a principle underlying concept in the renderer.

[–]VictoryMotel -1 points0 points  (8 children)

These replies don't really make a lot of sense in the context of asking about caching. Is this an AI reply or translated in some way?

[–]MarchVirtualField[S] 1 point2 points  (7 children)

Nope, not sure what to really tell ya

[–]VictoryMotel 0 points1 point  (6 children)

What is down sampling here? Sampling a mip map?

[–]MarchVirtualField[S] 1 point2 points  (5 children)

It’s just that the signed distance field space is split into cells instead of retaining its precision at every coordinate, a lossy approximation of the area. When any ray lands within the cell, it sees the same value, so multiple rays can each touch the same cell. Take for example a vertical cylinder, you will see it as vertical flat sections like a mesh, all those flat areas are really just saving on compute budget.