A Deep Dive into Nanite Virtualized Geometry

The answer to that is in this hour-long SIGGRAPH video.[1] Some of the operations needed are not done well, or at all, by the GPU. [1] ▶ this video

in “UE5 Nanite in WebGPU” · View on HN

There's a lot of techniques applied. It's not really "one new revolutionary thing" but a bunch of things and research over the past 20-30 years put together to make nanite possible. This video might shed some light ▶ this video

in “Why Unreal Engine 5.3 is a BIG Deal [video]” · View on HN

Yeah, but they had to go through hell to make it happen. It took a lot more effort than you might think. ▶ this video Some highlights: Seam staggering between levels for smooth swaps Current hardware rasterizers chug on small polys so they made a GPU software rasterizer (!) Actually it's a hybrid rasterizer, and gnarly features like derivatives are supported on both sides The GPU scheduler chugged so they abused Z-test wave repacking Streaming compression

in “Unreal Engine 5 is now available” · View on HN

No, but it is a full time job. It's getting much more complicated. Here's an hour long talk on how Unreal Engine 5's Nanite works.[1] This is a huge breakthrough in level of detail theory. Things that used to be O(N) are now O(1). With enough pre-computation, rendering cost does not go up with scene size. See this demo.[2] You can download the demo for Xbox X/S and PlayStation 5, and soon, in source form for PCs. Explore 16 square kilometers of photorealistic city in which you can see a close-up view of anything. The format of assets in memory for Nanite becomes far more complicated. GPUs need a redesign again; UE5 has to do more of the rendering on the CPUs than they'd like. What they need to do is simple but not well suited to current GPU designs. It's such a huge win this approach will take over, despite that. New game engines will need to have something comparable. Maybe using the same format. Epic doesn't seem to be making patent claims, and the code for all this is in the Unreal Engine 5 download. (Basic concept of how this works: A mesh becomes a hierarchy of meshes, allowing zoom in and out of on level of detail. The approach to subdivision is seamless. You divide the mesh into cells of about 20 triangles. Then, each cell is cut by one or two new long edges across the cell. These become the boundaries of a simpler cell with about half as many triangles, but no new vertices. The lower-resolution cell has no more edges than the higher-resolution cell. There's a neat gra

in “Finding your home in game graphics programming” · View on HN

If you want to see this sort of brilliant hacking on a modern system, I recommend taking a closer look at Unreal Nanite. It isn't just auto-LOD. Oh no. That's the core, but they had to do this same sort of "work around the tools they are given" to make it actually happen. Tiny triangles chug in modern GPU hardware raster pipelines -- so they wrote a GPGPU software rasterizer. They needed more bandwidth, so they wrote a compression engine. Their shaders needed better scheduling, so they abused the Z-test to do it. It's nuts! ▶ this video

in “War stories: how Crash Bandicoot hacked the original Playstation (2020)” · View on HN

So I would say skill at GPU assembly is in-demand for the elite tier of GPU performance work. Not necessarily writing much of it (though see [1] for an example, this is the kernel of multisplit as used in Nvidia's Onesweep implementation), but definitely in being able to read it so you can understand what the compiled code is actually doing. I'll also cite as evidence of that the incredible work of the engineers on Nanite. They describe writing the core of the microtriangle software renderer in HLSL but analyzing the assembler output to optimize down to the cycle level, as described in their "deep dive into Nanite virtualized geometry" talk (timestamp points to the reference to instruction-level micro-optimization). [1]: [link] [2]: ▶ this video

in “Learning Assembly for Fun, Performance and Profit” · View on HN

I think the SIGGRAPH talk you referred to is: "A Deep Dive into Nanite Virtualized Geometry" ( ▶ this video ) There's also this short high-level intro (2.5 min) that I thought was decent: "What is virtualized micropolygon geometry? An explainer on Nanite" ( [link] )

in “UE5 Nanite in WebGPU” · View on HN

I heard Unreal Nanite built a job queue system on compute threads ( ▶ this video ), would that help with your use case or not?

in “ROCm Is AMD's #1 Priority, Executive Says” · View on HN

Full disclosure: I'm a software performance nerd who is building a deeper understanding of hardware using whatever tools are I work with a lot of assembly traces emitted from CPU sims in Verilator. These traces can be several gigabytes in size, with tens of millions of entries. I've found the typical interactive matplotlib backends to not work the best with tens of millions of points on my M1 Macbook Pro. This is no slight against Matplotlib, or cairo, or agg, or the default macOS backend—they prioritize cross-platform "It Just Works" support over extreme performance. But it does irk me that there seems to be such a gap between the amount of data we can visualize in the gaming domain in comparison to the scientific domain[1]. The difference between 50 million and 5 billion is 100X. I'd be ecstatic if I could get within 10X difference. I understand that this gap exists for lots of reasons, of which I'd be happy to hear in detail in the replies to this comment. 1: ▶ this video

in “ImPlot: Interactive plotting library, ImGui style” · View on HN

I think there does in fact exist a recent major breakthrough in real time rendering: Virtualized geometry. [link] ▶ this video It was invented by Brian Karis at Epic. Virtualized geometry allows for unbounded geometric detail while retaining the conventional rasterization approach with polygons and textures. It works like a dynamic LOD, where the game engine dynamically adapts the rendered geometric detail based on visibility and screen resolution. Essentially the maximum rendering cost only depends on resolution and frame rate, not on the detail of the underlying meshes. However, the solution by Epic, dubbed Nanite, does not yet work for animated meshes. So virtualized geometry is not possible e.g. for game characters. Brian Karis says this is a solvable problem though.

in “The Next Generation in Graphics, Part 1: Three Dimensions in Software” · View on HN

Oh, I think you're right. The nested FOR loops of the "Micropoly software rasterizer" are running on the GPU.[1] I think. I though that was CPU code at first. They're iterating over one or two pixels, not a big chunk of screen. For larger triangles, they use the GPU fill hardware. The key idea is to have triangles be about pixel sized. If triangles are bigger than 1-2 pixels, and there's more detail available, use smaller triangles. [1] ▶ this video

in “Finding your home in game graphics programming” · View on HN

> OpenGL is not dead until Khronos comes up with an API that is actually usable without an EE degree on GPU design and shader compilers. That isn't going to happen because everyone is, in fact, moving away from the idea of a "graphics API" altogether and simply allowing the compute systems to calculate everything. See: the Nanite renderer from EPIC: ▶ this video To a first and second order approximation, no one cares about graphics that aren't related to games.

in “WebGPU computations performance in comparison to WebGL” · View on HN

Screen-space reflections are faster and require no new scene draws, but they won't show you "new angles" on reflected objects and they won't go around corners. Planar reflections require a new scene draw, but that's actually pretty modest: non-planar reflections require six scene-draws for a cubemap or full on raytracing. In general, lots of things in games require re-rendering the scene multiple times per frame, so game engines are really, really good at this. Shadows, projections, transparency / translucency, motion/depth blur, indirect lighting, deferred lighting, even things like hit testing (though for dependency + latency reasons that's a prime candidate for offloading to the CPU). Anything that requires less visual fidelity will have its performance tuned accordingly: fewer pixels, simpler shaders, lower LOD geometry, lower framerates. Nobody will notice if the fuzzy bounce lights are calculated once every five frames and blended. Ray tracing is conceptually simpler but (so far) slower at any given level of cleverness -- you'll often hear that it has asymptotic benefits, but those same benefits can be pulled out of rasterizers with effort comparable to what is required to make the raytracing practical. Here is a writeup of the passes you might expect to see in a modern engine: [link] Here's an overview of a modern geometry pipeline: ▶ this video

in “The bullet effects in Terminator 2 weren’t CGI” · View on HN

Unreal Engine's Nanite technology has the same problem. They want to walk a LoD/culling tree but have to resort to the CPU just to schedule new tasks on the GPU. I wouldn't be surprised if future GPUs eliminate this requirement as it will make all Nanite Unreal Engine games run a little faster. Kind of like how a couple years after Quake came out, every GPU got fast z-buffers. ▶ this video

in “Prefix sum on portable compute shaders” · View on HN