UE5-Nanite-Technologie in WebGPU

 (github.com/Scthe)
1 Punkte von GN⁺ 2024-09-06 | 1 Kommentare | Auf WhatsApp teilen

Nanite WebGPU

Zusammenfassung

  • Nanite WebGPU ist ein Projekt, das Nanite mithilfe von WebGPU im Webbrowser implementiert.
  • Es ist nur in Chrome nutzbar.
  • Es umfasst eine Meshlet-LOD-Hierarchie, einen Software-Rasterizer, Billboard-Impostors und mehr.
  • Es unterstützt Frustum- und Occlusion-Culling.
  • Es unterstützt Texturen und Vertex-Normalen.
  • Mit Deno funktioniert es auch offline.

Funktionen

  • Meshlet-LOD-Hierarchie

    • Im Browser werden Meshes mit WebAssembly vorverarbeitet.
    • Es bietet auch eine Funktion zum Exportieren von Dateien.

  • Software-Rasterizer

    • WebGPU unterstützt kein atomic<u64>.
    • Tiefe (u16) und oktaedrisch kodierte Normalen (2 * u8) werden in 32 Bit komprimiert.

  • Billboard-Impostors

    • Je nach Kameraposition werden 12 Bilder gemischt und angezeigt.
    • Ansichten von oben und unten werden nicht verarbeitet.

  • Culling

    • Pro Instanz: Frustum- und Occlusion-Culling.
    • Pro Meshlet: Frustum- und Occlusion-Culling.
    • Pro Dreieck: Hardware-Backface-Culling und z-Buffer.

  • Es kann zwischen GPU-basiertem Rendering und einer CPU-Implementierung umgeschaltet werden.

  • Es unterstützt gleichzeitig Texturmodelle und verschiedene Objekte.

  • Parameter können zur Laufzeit geändert werden.

  • Es liefert Statistiken: Speicher, Geometrie, Anzahl der Meshlets, Anzahl der Dreiecke usw.

  • Es unterstützt ein benutzerdefiniertes Dateiformat.

  • Es unterstützt Quantisierung von Vertex-Positionen und oktaedrisch kodierte Normalen.

  • Es verarbeitet Änderungen der Fenstergröße.

  • Mit Deno funktioniert es auch offline.

  • WebGPU- und WGSL-Code kann in das Projekt kopiert werden.

Ziele

  1. Einfachheit: Beginn mit OBJ-Dateien, wobei alles in der App verarbeitet wird.
  2. Experimente: Verschiedene Einstellungen können geändert werden, um die Performance zu testen.

Demo-Szenen

  • Jinx: 120*120 Instanzen, 640m Dreiecke.
  • Lucy und Drache: 70*70 Instanzen, 1.7b Dreiecke.
  • Lucy: 110*110 Instanzen, 1.2b Dreiecke.
  • Drache: 70*70 Instanzen, 1.2b Dreiecke.
  • Kaninchen: 500*500 Instanzen, 1.2b Dreiecke.
  • Impostor-Vorschau: Vergrößerte Impostor-Texturgröße.

Verwendung

  • Mit den Tasten [W, S, A, D] bewegen, mit [Z, SPACEBAR] nach oben und unten.
  • Durch Umschalten der Culling-Optionen lassen sich Bugs beheben.
  • Mit der Schaltfläche Profile kann die Performance gemessen werden.

FAQ

  • Wichtigste Unterschiede zu Nanite in UE5

    • Die Fehler-Metrik für die Vereinfachung ist simpel.
    • Die Meshlet-Vereinfachung ist simpel.
    • Kein zweistufiges Occlusion-Culling.
    • Keine Arbeits-Queue in den Shadern.
    • Kein Entfernen und Streaming ungenutzter LODs aus dem VRAM.
    • Kein Visibility Buffer.
    • Keine integrierten Schatten/Multiviews.
    • Es kann nicht viele verschiedene Objekte verarbeiten.
    • Kein GPU-Profiler.

  • Was Milliarden von Dreiecken bedeuten

    • Dichte Meshes können sich negativ auf die Performance auswirken.
    • Viele Instanzen verbrauchen viel VRAM.
    • Die Anordnung der Szene beeinflusst die Performance.

  • Überraschende Aspekte von Nanite

    1. Das Ziel des DAG ist nicht, für weit entfernte Objekte wenige Dreiecke zu verwenden.
    2. Für Culling und Meshlet-Arbeit wird mehr Zeit aufgewendet als für Nanite selbst.
    3. Die Meshlet-LOD-Hierarchie funktioniert leicht.
    4. Wenn sich ein Mesh nicht sauber vereinfachen lässt, fällt die Performance ab.

  • Mesh-Vereinfachung

    • Während des Vereinfachungsprozesses können viele Probleme auftreten.
    • UE5 verwendet eigenen Code zur Mesh-Vereinfachung.

  • Fehler-Metrik

    • Die Auswahl eines geeigneten Meshlets ist der Kern von Nanite.

  • Sollte man eine Nanite-Implementierung selbst schreiben?

    • Die Verwendung von UE5 ist der einfachste Weg.
    • Zu Lernzwecken lohnt sich eine eigene Implementierung.

  • Wert von Meshlet-Backface-Cone-Culling

    • Bei dichten Meshes ist es effektiv.
    • Es kann sich mit Occlusion-Culling überschneiden.
    • Durch WebAssembly-Aufrufe kann es zu Performance-Einbußen kommen.

Zusammenfassung von GN⁺

  • Nanite WebGPU ist ein interessantes Projekt, das Nanite im Webbrowser implementiert.
  • Es optimiert die Performance durch verschiedene Culling-Techniken und einen Software-Rasterizer.
  • Im Vergleich zu UE5 gibt es Unterschiede bei Vereinfachung und Fehler-Metrik.
  • Für Lernzwecke lohnt sich eine eigene Implementierung, für reale Projekte könnte UE5 jedoch die bessere Wahl sein.
  • Ein ähnliches Projekt mit vergleichbaren Funktionen ist Nanite in Unreal Engine 5.

Verwandte Beiträge

1 Kommentare

 
GN⁺ 2024-09-06
Hacker-News-Kommentar

  • Die Third-Party-Implementierung von Nanite ist interessant

    • Nanite ist eine sehr clevere Methode, Grafik-Meshes darzustellen
    • Wiederholungen werden über Links verarbeitet, und Submeshes können rekursiv gemeinsam genutzt werden
    • Es unterstützt Detailstufen innerhalb des Meshes, sodass kleine Submeshes entfernt werden
    • Wiederholte Inhalte in großem Maßstab lassen sich mit wenig Daten schnell rendern
    • Das aktuelle GPU-Design passt nicht zu Nanite, und neue Hardware-Arbeit ist erforderlich
    • Die Unreal-Engine-Demo zeigt eine Szene, in der dieselbe Statue wiederholt verwendet wird
    • Das Erstellen von Nanite-Meshes ist komplex und derzeit nur im Editor von Unreal Engine möglich
    • Interne Offsets des Formats könnten eine Angriffsfläche bieten

  • Auch Bevy hat mit Virtual Geometry eine Umsetzung der Nanite-Ideen

    • Der Autor von Bevy könnte Fragen direkt beantworten
    • Scthe hat zu Verbesserungen am Bevy-Code beigetragen

  • Es ist keine gute Idee, die Kompatibilität anhand des User-Agent-Strings zu bestimmen

    • Feature-Kompatibilität sollte einzeln erkannt und genutzt werden
    • Ich nutze Chromium und verwende WebGPU häufig, aber die Demo verlangt Chrome

  • Auf dem iPhone 12 Pro Max funktioniert WebGPU nicht

    • WebGPU wurde in den experimentellen Funktionen aktiviert, funktioniert aber auf anderen Websites
    • Es wäre gut, wenn die Web-App mehr Informationen zur Ursache des Fehlers liefern würde

  • Um den Mangel an 64-Bit-Atomics in WebGPU zu umgehen, waren Kompromisse nötig

    • Auf Hardware der Desktop-Klasse wird dies fast universell unterstützt

  • Name und Beschreibung sind verwirrend und könnten eine Markenverletzung darstellen

    • Es hat nichts mit dem echten Nanite zu tun und wurde von jemandem implementiert, der nichts mit UE5 zu tun hat
    • Bevy's Virtual Geometry könnte nützlicher sein

  • Vergleich der LOD-Systeme anderer Engines

    • Godot bietet automatisches LOD
    • In Unity müssen LOD-Modelle manuell erstellt werden
    • NeoAxis hat einen interessanten Ansatz, aber die Performance ist nicht gut
    • Unreal ist beim Anzeigen vieler Objekte auf dem Bildschirm weit voraus

  • Ich habe im three.js-Forum eine interessante Diskussion über die Implementierung virtueller Geometrie gelesen

    • Die Diskussion über Webgrafik-Implementierungen und Trade-offs war interessant

  • Frage zur Behauptung, ein Software-Rasterizer sei schneller als ein Hardware-Rasterizer

    • Der Zweck der GPU ist es, die Rasterisierung zu beschleunigen
    • Das ist schwer nachzuvollziehen, außer wenn der Software-Rasterizer auf der GPU läuft

  • Beim Ausführen der jinx-Demo auf einem M2 Max tritt ein WebGPU-Fehler auf

    • Fehlermeldung: "Fill size (7398781) is not a multiple of 4 bytes"