[olaulaja]

For a bit of reference, a full frame of Crysis (benchmark scene) was around 300k vertices or triangles (memory is fuzzy), so 3-10 log piles depending on which way my memory is off and how bad the vertex/triangle ratio is in each.

[paavohtl]

Author here: I never bothered counting the total vertices used per frame because I couldn't figure out an easy way to do it in Renderdoc. However someone on Reddit measured the total vertex count with ReShade and it can apparently reach hundreds of millions and up to 1 billion vertices in closeups in large cities.

Edit: Checked the vert & poly counts with Renderdoc. The example scene in the article processes 121 million vertices and over 40 million triangles.

[jiggawatts]

“If you’ve used more triangles than there are pixels on the screen, you’ve messed up.”

I call this kind of thing the “kilobyte rule” because a similar common problem is shoving tens of megabytes of JSON down the wire to display about a kilobyte of text in a browser.

[Sohcahtoa82]

I'd think today's problem is tens of megabytes of JavaScript to display a couple kilobytes of text.

[kgabis]

Well, not anymore, Epic's Nanite is basically a triangle per pixel rendering.

[jiggawatts]

It’s actually very nearly optimal: using as many triangles as needed to display as much detail as possible while staying under the one triangle per pixel limit.

That’s the opposite of using 10K pixels to render two pixels on the screen.

[westurner]

> The issues are luckily quite easy to fix, both by creating more LOD variants and by improving the culling system

How many polygons are there with and without e.g. AutoLOD/InstaLOD?

An LLM can probably be trained to simplify meshes and create LOD variants with e.g. UnityMeshSimplifier?

Whinarn/UnityMeshSimplifier: https://github.com/Whinarn/UnityMeshSimplifier :

> Mesh simplification for Unity. The project is deeply based on the Fast Quadric Mesh Simplification algorithm, but rewritten entirely in C# and released under the MIT license.

Mesh.Optimize: https://docs.unity3d.com/ScriptReference/Mesh.Optimize.html

Unity-Technologies/AutoLOD: https://github.com/Unity-Technologies/AutoLOD

"Unity Labs: AutoLOD - Experimenting with automatic performance improvements" https://blog.unity.com/technology/unity-labs-autolod-experim...

InstaLOD: https://github.com/InstaLOD

"Simulated Mesh Simplifier": https://github.com/Unity-Technologies/AutoLOD/issues/4 :

> Yes, we had started work on a GPU-accelerated simplifier using QEM, but it was not robust enough to release.

"Any chance of getting official support now that Unreal has shown off it's AutoLOD?" https://github.com/Unity-Technologies/AutoLOD/issues/71#issu... :

> "UE4 has had automatic LOD generation since it first released - I was honestly baffled when I realized that Unity was missing what I had assumed to be a basic feature.*

> Note that Nanite (which I assume you're referring to) is not a LOD system, despite being similar in the basic goal of not rendering as many polygons for distant objects.

"Unity: Feature Request: Auto - LOD" (2023-05) https://forum.unity.com/threads/auto-lod.1440610/

"Discussion about Virtualized Geometry (as introduced by UE5)" https://github.com/godotengine/godot-proposals/issues/2793

UE5 Unreal Engine 5 docs > Rendering features > Nanite: https://docs.unrealengine.com/5.0/en-US/RenderingFeatures/Na...

Unity-GPU-Based-Occlusion-Culling: https://github.com/przemyslawzaworski/Unity-GPU-Based-Occlus...

[westurner]

What are some other solutions to the cited problems?

[ReactiveJelly]

Sounds right. I remember seeing "1M Triangles" in the performance HUD and thinking, that's crazy, a million triangles. Probably very few shared vertices once you account for edge splits, billboards, etc.