MJP

Ah yeah pipeline compilation is a very non-trivial problem[1]. Unreal is also struggling with this a lot. I hear you that it's an issue. The Bevy issue you want to follow is https://github.com/bevyengine/bevy/issues/10871. [1]: https://therealmjp.github.io/posts/shader-permutations-part1 + https://therealmjp.github.io/posts/shader-permutations-part2

The classic post on Deferred Texturing is MJP's, if you want to learn more about the technique: https://therealmjp.github.io/posts/bindless-texturing-for-deferred-ren… Also see the recent post here which covers more benchmarks and details: http://filmicworlds.com/blog/visibility-buffer-rendering-with-material…

Human skin is translucent too. Real time Sub-surface scattering has existed for years and is now to making it into games. There's an excellent writeup here: https://therealmjp.github.io/posts/sss-intro/ Realtime reflections seem to be on their way too: https://youtu.be/pNmhJx8yPLk

If you're interested in more background about one user-visible problem being directly attacked by this new GPU architecture, that could be "shader compilation stutter" (although there are many others). These are two excellent posts that go deep on this: The Shader Permutation Problem - Part 1: How Did We Get Here? The Shader Permutation Problem - Part 2: How Do We Fix It? In particular, the second post has the line: We probably should not expect any magic workarounds for static register allocation: if a callable shader requires many registers, we can likely expect for the occupancy of the entire batch to suffer. It’s possible that GPUs could diverge from this model in the future, but that could come with all kinds of potential pitfalls (it’s not like they’re going to start spilling to a stack when executing thousands of pixel shader waves). ... And that is exactly what has been done. https://therealmjp.github.io/posts/shader-permutations-part1/ https://therealmjp.github.io/posts/shader-permutations-part2/

Console vs PC is a red herring since UE games still stutter on consoles, people just notice that less because most games run at 30 fps anyway. You can read Unreal's own blog posts on this and they'll actually explain that this is mostly down to their material system (and game logic/scripts reaching into it) being designed to create nearly infinite shader variations on the fly in response to arbitrary world/game states. This design choice separates engines which have shader stutters from those which do not. https://www.unrealengine.com/tech-blog/game-engines-and-shader-stutter… https://medium.com/@GroundZer0/what-unreal-doesnt-tell-you-about-shade… https://therealmjp.github.io/posts/shader-permutations-part1/

Because GPU developers started to be less lazy :) No T&L meant everything was culled, clipped, transformed and per-vertex divided (perspective, lighting) on CPU. Then you have brute force approach. Voodoo 1/2/3 doesnt employ any obvious speedup tricks in its pipeline. Every single triangle pushed into it is going to get textured (bilinear filtering, per pixel divide), shaded (lighting, blending, FOG applied) and then in the last step the card finally checks Z-buffer to decide between writing all this computed data to buffer or simply throwing it away. It took a while before GPU devs started implementing low-hanging fruit optimizations https://therealmjp.github.io/posts/to-earlyz-or-not-to-earlyz/ Hierarchical-Z, Fast Z clearing, Compressed Z buffer, Compressed Textures, Tiled shading. It all got added slowly one step at a time in early 2000.

The PSO problem is referring to this, right? https://therealmjp.github.io/posts/shader-permutations-part1/

Oh The Danger Zone had essential XNA knowledge ~2010 https://therealmjp.github.io/posts/pix-with-xna/