Voxel Displacement Renderer – Modernizing the Retro 3D Aesthetic

I agree. To me this is very evocative of the pixel-art/retro look, even moreso than the low-poly Doom/Wolfenstein look.

Imagine a 3D version of Noita with this aesthetic, and perhaps using smoothed particle hydrodynamics to make the falling sand engine scale to 3D.

Warez on the BBSs. Go Eaglesoft!

completely agree with the aesthetics!

my issue with it that it looked so good, but the architecture felt wrong. in the part with the low ceiling, it felt like those blocks hanging from the roof were defying physics

Basically unrelated. He's using geometry shaders to generate voxel mesh details-- perhaps with some LOD optimizations, while Nanite is a GPU-driven rendering technology that adapts triangle density to aim for a given fidelity target.

Nanite can use displacement maps and perform tessellation, but it uses an alternate pathway that's not necessarily more efficient than feeding it a high-poly asset to render.

Iirc Comanche used a ray tracing approach to render the terrain [1]. No Voxels there, just a 2D height map that is sampled.

(They called it "VoxelSpace" ... so some confusion is warranted)

[1] https://github.com/s-macke/VoxelSpace

My guess its the exact same technique used in the Comanche games - or at least the same results can be achieved with it.

Contrary to popular belief, those games didn't use true 3D voxels - they used a heightmap that stored a color and height value in the terrain texture which they raymarched into.

You could recreate the same look with raymarching into the texture in a shader which I suspect would look very similar to what the blog post achieved..

Its hard to say exactly because the OP doesn't go into the runtime mesh used but my guess is its quite different form Nanite.

Nanite assumes high poly authoring of objects and works to stream in simplified chunks such that the rendered triangles are not less than a pixel wide. Displacement maps are a bit redundant because geometry can be naturally very detailed, there's no reason to use a texture map for it. (There is a case for Landscapes but that's a unique case)

This seems to be using a displacement and a low poly mesh to generate high poly but 'voxelized' geo on load.

It's less about being "less work" and more about what GPUs are and are not good at.

Displacement maps can closely approximate the geometric detail of having 1 triangle per pixel. All the work for displacement maps happens on a per-pixel basis inside a fragment shader (in simple terms, a little program that runs for each pixel of a triangle). You can wrap this displacement map over a single, large triangle and get the visual appearance of a much denser mesh.

The alternative approach of subdividing the mesh is orders of magnitude less efficient because GPUs are _very_ bad at drawing tiny polygons. It's just how GPUs and the graphics pipelines are implemented. A 'tiny polygon' is determined from how many pixels it covers, as you start dropping below a couple dozen pixels per triangle you start hitting nasty performance cliffs inside the GPU because of the specific ways triangles are drawn. Displacement maps works around this problem because you're logically only drawing single big polygons but doing the work in a shader where the GPU is much more efficient.

It allows you to defer subdivision of the mesh (maybe down to micropoly level for displacement) until the final render stage, rather than baking in the subdivision earlier and having to deal with dense geometry for things like animation where it's better to have lighter-weight meshes.

I think displacement maps are not that frequently used in game graphics these days. The typical thing is regular geometry with normal maps. However, triangle soup is very difficult to modify in any way. The cool thing about displacement maps is that they can downsampled trivially, so if you're doing runtime tesselation you can get smooth LOD scaling (at least down to your base mesh) which is nice. Less usefully, they can also be tiled, blended, interpolated, scrolled, animated, etc.

On the other hand, UE5's Nanite achieves the same LOD scaling but far better, without the limitation of not being able to scale down past the base mesh and with a built-in workaround for the issues GPUs have with small triangles. It's possible that people might use displacement maps in the authoring process, which can then be baked into static meshes for Nanite. Then it would just be a convenient-ish way for artists to author and distribute complex materials.

The reason that comes to my mind is to save memory to transfer from the CPU to the GPU.

If you do your tesselation inside the vertex shader, then you can send a low-poly mesh to the graphics card, which saves a lot on vertex buffers (e.g. uv coordinates and other per-vertex attributes). The vertex shader still emits the same number of vertices to the rest of the pipeline, but inter-stage bandwidth is more plentiful than CPU-GPU bandwidth so I can see that coming out ahead.

I’m not an expert though. Perhaps someone with a better understanding can clear this up, I’m curious too…

Sometimes the lack of something shifts our focus elsewhere. Could be a feature.

Yeah, thinking it may need a second pass to produce shadows. It's not clear to me that you could "bake them in" since textures are reused.

Stretch goal, dynamic lighting — like someone carrying a torch ahead of you in a tunnel and illuminating as they went.

To be sure though, the retro vibe is 100% nailed as is.

If I read that blog post correctly, it's a model to infer normal maps from textures, not a new way to render geometry.

The article in this thread is more about a small-voxel-based representation of displacement maps. A tool like Deep Bump could conceivably be used to aid in the creation of texture assets for the system discussed in this thread.

As the article points out though, normal maps don't "work" in all situations though, as they don't actually change the geometry just the lighting and the illusion of the geo, so viewed at the edges of meshes displacement is still the better high-fidelity option.

DeepBump might be able to extract 1D (height only, not full 3D vector displacement) maps to use with traditional displacement though.

It's just experience. You start with basics things. There's likely lots of game devs saying "how do you even get into web development, seems difficult as a dirty ol pixel pusher".

There's a lot of tutorials around. You can also join a game jam for some motivation / community.

No, at least not in the "automatic" way the Nvidia RTX Remix does. You would not only need to generate the displacement maps for textures, but the most importantly port the game to this new rendering engine. It's an extremely complicated task if done by reverse engineering and hacking the executable, without ability to read and recompile the source code.

It's not a real voxel engine, the world geometry itself isn't much different from Quake.

The author of Sauerbraten is also working on new voxel game tech: https://store.steampowered.com/app/2283580/Voxlands/

The article has a footnote about Voxel Doom, but more about Voxel Doom's environment approach and not monsters:

Now that I’ve laid out all this context, I want to give a shout out to the Voxel Doom mod for classic Doom. The mod’s author replaced the game’s monsters and other sprites with voxel meshes to give them more depth, some very impressive work. Then, in late 2022, he began experimenting with using parallax mapping to add voxel details to the level geometry. This part of the mod didn’t look as good, in my opinion — not because of the author’s artwork, but because of the fundamental limitations that come from using parallax mapping to render it. This mod wasn’t the inspiration for my project — I was already working on it — but seeing the positive response the mod received online was very encouraging as I continued my own efforts. ↩

It does say though that the approach supports animated doors and stuff so combined with mesh and texture flipbook I think it could be used for original doom looking monsters too, but sharp curvature areas I think have the most artifacts with shell mapping and he mentions limitations to the meshing of levels so maybe not.