Nanite Virtualisierte Geometrie

Nanite ist das virtualisierte Geometriesystem der Unreal Engine 5, das ein neues internes Mesh-Format und eine neue Rendering-Technologie verwendet, um pixelgenaue Details und eine hohe Objektanzahl zu rendern. Es arbeitet auf intelligente Weise nur an den Details, die wahrgenommen werden können und nicht mehr. Das Datenformat von Nanite ist ebenfalls stark komprimiert und unterstützt feinkörniges Streaming mit automatischer Detailstufe.

Vorteile von Nanite

• Mehrere Größenordnungen höhere Geometriekomplexität, mehr Dreiecke und Objekte als bisher in Echtzeit möglich
• Frame-Budgets werden nicht mehr durch Polycounts, Draw Calls und Mesh-Speicherverbrauch eingeschränkt
• Jetzt ist es möglich, Quellmaterial in Filmqualität direkt zu importieren, z. B. ZBrush-Skulpturen und Photogrammetrie-Scans
• Verwende High-Poly-Detaillierung, anstatt Details in Normal-Map-Texturen zu baken
• Der Detaillierungsgrad (Level of Detail, LOD) wird automatisch gehandhabt und muss nicht mehr manuell für die LODs der einzelnen Meshs eingestellt werden
• Qualitätsverluste sind selten oder gar nicht vorhanden, insbesondere bei LOD-Übergängen

Auch wenn die Vorteile ein echter Game-Changer sein können, gibt es auch weiterhin praktische Grenzen, die bestehen bleiben. Zum Beispiel sollten die Anzahl der Instanzen, die Dreiecke pro Mesh, die Materialkomplexität, die Ausgabeauflösung und die Performance für jede Kombination aus Inhalt und Hardware sorgfältig bemessen werden. Nanite wird seine Fähigkeiten weiter ausbauen und die Performance in zukünftigen Versionen der Unreal Engine verbessern.

Unterschiede zwischen einem Nanite-Mesh und einem statischen Mesh

Ein Nanite-Mesh ist ein statisches Mesh, in dem Nanite aktiviert ist. Ein Nanite-Mesh ist im Kern immer noch ein Dreieck-Mesh mit einem hohen Detaillierungsgrad und angewandter Komprimierung der Daten. Darüber hinaus verwendet Nanite ein völlig neues System, um dieses Datenformat auf äußerst effiziente Weise darzustellen.

Damit ein statisches Mesh die Vorteile von Nanite nutzen kann, muss es nur mit einem Flag aktiviert werden. Das Erstellen von Inhalten für Nanite unterscheidet sich nicht von herkömmlichen Meshs, mit dem Unterschied, dass Nanite viel mehr Dreiecke und Instanzen verarbeiten kann als herkömmlich gerenderte Geometrie. Wenn du die Kamera nah genug heranführst, zeichnet Nanite die ursprünglichen Quelldreiecke, die importiert wurden.

Nanite-Meshs unterstützen mehrere UVs und Scheitelpunkte. Materialien werden Abschnitten des Meshs zugewiesen, so dass diese Materialien verschiedene Schattierungsmodelle und dynamische Effekte verwenden können, die in den Shadern ausgeführt werden können. Die Materialzuweisung kann wie bei jedem anderen Statischen Mesh dynamisch ausgetauscht werden, und Nanite benötigt keinen Prozess zum Baken der Materialien.

Virtuelle Texturen sind für die Verwendung mit Nanite nicht erforderlich, werden aber dringend empfohlen. Virtuelle Texturen sind ein orthogonales Feature der Unreal Engine mit ähnlichen Zielen für Texturdaten, die Nanite mit Mesh-Daten erreicht.

Die Arbeit mit Nanite sollte den Arbeitsabläufen für statische Meshs ähnlich sein, aber es gibt viele Dinge, die noch nicht unterstützt werden. Mehr dazu findest du im Abschnitt Unterstützte Funktionen auf dieser Seite.

Wie funktioniert Nanite?

Nanite fügt sich so nahtlos wie möglich in bestehende Arbeitsabläufe der Engines ein und verwendet dabei einen neuartigen Ansatz zum Speichern und Rendern von Mesh-Daten.

• Während des Imports werden die Meshs analysiert und in hierarchische Cluster von Dreiecksgruppen unterteilt.
• Während des Renderings werden die Cluster on-the-fly in verschiedenen Detaillierungsgraden ausgetauscht, je nach Kameraperspektive, und verbinden sich perfekt und ohne Risse mit benachbarten Clustern innerhalb desselben Objekts. Die Daten werden auf Abruf gestreamt, so dass nur die sichtbaren Details im Speicher abgelegt werden müssen. Nanite läuft in einem eigenen Rendering-Durchgang, der die traditionellen Draw Calls komplett umgeht. Mit den Visualisierungsmodi kannst du die Nanite-Pipeline überprüfen.

Da Nanite auf die Fähigkeit angewiesen ist, Mesh-Daten auf Abruf schnell von der Festplatte zu streamen. Solid State Drives (oder SSDs) werden für die Speicherung zur Laufzeit empfohlen.

Für welche Arten von Meshs sollte Nanite verwendet werden?

Nanite sollte generell aktiviert werden, wo immer es möglich ist. Jedes statische Mesh, das diese Funktion aktiviert hat, wird in der Regel schneller gerendert und benötigt weniger Platz im Arbeitsspeicher und auf der Festplatte.

Genauer gesagt ist ein Mesh dann ein besonders guter Kandidat für Nanite, wenn es:

• Viele Dreiecke enthält, oder Dreiecke hat, die auf dem Bildschirm sehr klein sind
• Viele Instanzen in der Szene hat
• In hohem Maße andere Nanite-Geometrie verdeckt
• Schatten mit Virtuellen Shadow Maps wirft

Ein Beispiel für eine Ausnahme von diesen Regeln ist eine Himmelskugel: Ihre Dreiecke werden auf dem Bildschirm groß sein, sie verdeckt nichts und es gibt nur eine in der Szene. In der Regel sind diese Ausnahmen selten und die Performance-Einbußen bei der Verwendung von Nanite sind relativ gering. Daher wird empfohlen, sich keine allzu großen Gedanken darüber zu machen, wo Nanite nicht aktiviert werden sollte, wenn Nanite den Anwendungsfall unterstützt.

Einige Anwendungsfälle werden von Nanite derzeit nicht unterstützt. Mehr dazu findest du im Abschnitt Unterstützte Funktionen auf dieser Seite.

Nanite-Unterstützung für Meshs aktivieren

Nanite kann für unterstützte Geometrie auf folgende Weise aktiviert werden:

• Beim Import
• Individuelle Mesh-Editoren verwenden
• Stapelweise Auswahl im Inhaltsbrowser

Die Umwandlung von Geometrie in Nanite erfordert eine gewisse Bearbeitungszeit für jedes Mesh. Bei großen Projekten ist die Verwendung eines gemeinsamen abgeleiteten Daten-Caches (ADC) besonders hilfreich, wenn es viele Nanite Assets gibt. Mehr Informationen findest du in der Dokumentation zum Gemeinsamen ADC.

Importieren eines statischen Meshs

Wenn du ein Mesh importierst, das für uns mit Nanite bestimmt ist, aktiviere das Kästchen Nanite erstellen.

Es wird empfohlen, die Eigenschaft Lightmap-UVs generieren zu deaktivieren, wenn du keine vorberechnete Beleuchtung mit Lightmass verwendest.

Wenn diese Eigenschaft aktiviert ist, dauert der Import und die Erstellung von statischen Mesh-Daten bei sehr detaillierter Geometrie deutlich länger. Die Eigenschaft fügt außerdem einen zusätzlichen UV-Kanal hinzu, der bei sehr dichten Meshs eine beträchtliche Menge an Daten enthält. Wenn dein Projekt keine gebackene Beleuchtung benötigt, musst du diese Kosten nicht tragen.

Nanite für Assets aktivieren

Wenn dein Projekt bereits mit Inhalten gefüllt ist, für die du Nanite aktivieren möchtest, hast du zwei Möglichkeiten: Du kannst die Assets mit dem Inhaltsbrowser stapelweise aktivieren oder einzelne Assets über ihre eigenen Editoren aktivieren.

Nanite für Meshs stapelweise aktivieren

Für Stapel statischer Mesh-Assets, für die du Nanite aktivieren möchtest, wähle sie mit dem Inhaltsbrowser alle aus. Klicke mit der rechten Maustaste und wähle Nanite > Aktivieren aus dem Kontextmenü.

Nanite für einzelne Meshs aktivieren

Öffne den Editor eines beliebigen Meshs, das Nanite unterstützt, z. B. Statische Meshs und Geometriesammlungen (Chaos-Physik-gesteuerte Fraktur-Meshs), und aktiviere Nanite über das Details-Panel.

Suche im Statischen-Mesh-Editor nach den Nanite-Einstellungen und aktiviere das Kontrollkästchen Nanite-Unterstützung aktivieren.

Suche im Editor für Geometriesammlungen den Abschnitt Nanite und aktiviere das Kästchen Nanite aktivieren.

Unterstützte Eigenschaften von Nanite

In diesem Abschnitt wird beschrieben, wie du am besten mit Nanite in einem Unreal-Engine-Projekt arbeitest, und es wird erläutert, was unterstützt wird und was nicht und welche Einschränkungen möglich sind.

Geometrie

Nanite kann für statische Meshs und Geometriesammlungen aktiviert werden.

Ein Nanite-aktiviertes Mesh kann mit den folgenden Komponententypen verwendet werden:

• Statisches Mesh
• Instanziiertes Statisches Mesh
• Hierarchisches Instanziiertes Statisches Mesh
• Geometriesammlung
• Laubmaler
• Landschaftsgras

Nanite unterstützt die Verformung von starren Meshs nur begrenzt. Nanite unterstützt die dynamische Verschiebung, Drehung und ungleichmäßige Skalierung dieser Meshs, egal ob es sich um dynamische oder statische Meshs handelt. Das bedeutet, dass jede beliebige Position eines Nanite-Meshs auf eine Art und Weise verschoben werden kann, die mehr als in einer einzigen 4x3-Matrix-Multiplikation ausgedrückt werden kann, die gleichmäßig auf das gesamte Mesh angewendet wird.

Die Verformung wird begrenzt durch:

• (Beta) Weltpositionsversatz in Materialien
  • Die Bounding-Boxen, die für Occlusion-Cull-Cluster verwendet werden, werden bei Verformung nicht aktualisiert oder erweitert. Das bedeutet, dass jedes Mal, wenn eine Oberfläche nach außen verschoben wird, so dass sie die Stelle verdeckt, an der sie vorher war, die Wahrscheinlichkeit groß ist, dass sie sich selbst verdeckt und kaputt aussieht.
  • Laub mit WPO ist weniger problematisch, weil das Laub voller Löcher ist und sich nicht wirklich verdecken kann.

Verformung wird nicht unterstützt mit:

• Skelettanimation
• Morph-Ziele
• Spline-Meshs

Nanite-aktivierte Meshs unterstützen derzeit nicht:

• Benutzerdefinierte Tiefe oder Schablone
• Scheitelpunkte auf Instanzen malen
  • Das bedeutet, dass die Farben pro Instanz mit dem Mesh-Mal-Modus des Editors gemalt werden, aber Nanite unterstützt auch Scheitelpunktfarben auf dem ursprünglichen Mesh.

Die maximale Anzahl der Instanzen, die in der Szene vorhanden sein können, ist auf 16 Millionen Instanzen festgelegt. Das schließt alle Instanzen ein, die gestreamt werden, nicht nur die, die für die Verwendung mit Nanite aktiviert wurden. Nur gestreamte Instanzen werden in die Gesamtzahl eingerechnet.

Tangenten pro Scheitelpunkt werden nicht im Statischen Mesh gespeichert, wenn es für Nanite aktiviert ist. Stattdessen wird der Tangentenraum implizit im Pixelshader abgeleitet. Tangentendaten werden nicht gespeichert, um die Datengröße zu reduzieren. Dieser Unterschied im Tangentenraum könnte bei diesem Ansatz zu Unterbrechungen an den Kanten führen. Dieses Problem hat sich jedoch nicht als signifikant erwiesen, und es ist geplant, Scheitelpunkttangenten in einer zukünftigen Version zu unterstützen.

Materialien

Nanite unterstützt Materialien, deren Überblendmodus auf Undurchsichtig und Maskiert eingestellt ist. Wenn ein nicht unterstützter Materialtyp erkannt wird, wird dem Nanite-aktivierten Mesh ein Standardmaterial zugewiesen und im Output-Log wird eine Warnung mit zusätzlichen Informationen eingetragen.

Anmerkungen zu zusätzlichen Materialmerkmalen:

• Nanite-aktivierte Meshs können Decals erhalten, die auf ihre Oberfläche projiziert werden, aber sie unterstützen keine [Mesh-Decals] (designing-visuals-rendering-and-graphics\materials\tutorials\decals\mesh-decals), für die Materialien einen Durchscheinend-Überblendmodus verwenden müssen.
• Das Wireframe-Kontrollkästchen wird nicht unterstützt.
• Der Scheitelpunkt-Interpolator-Knoten und Benutzerdefinierte UVs werden unterstützt, aber dreimal pro Pixel ausgewertet.

Rendering

Die folgenden Rendering-Funktionen werden derzeit nicht unterstützt:

• Ansichtsspezifische Filterung von Objekten mit:
  • Minimaler Bildschirmradius
  • Distance Culling
• Forward Rendering
• Stereo-Rendering für Virtuelle Realität
• Geteilter Bildschirm
• Multisampling Anti-Aliasing (MSAA)
• Beleuchtungskanäle
• Raytracing gegen Nanite-Meshs
  • Das Fallback-Mesh wird standardmäßig für Nanite-aktivierte Meshs verwendet. Verringere den Parameter Fallback Relativer Fehler im Statischen-Mesh-Editor, um mehr Dreiecke des Quell-Meshs zu verwenden.
  • (Experimentell) Die anfängliche Unterstützung für natives Raytracing von Nanite-Meshs wird mit der Konsolenvariablen r.RayTracing.Nanite.Mode 1 aktiviert. So bleiben alle Details erhalten und es wird deutlich weniger GPU-Speicher benötigt als bei fehlerfreien Fallback-Meshs.

• Einige Visualisierungsansichtsmodi unterstützen noch nicht die Anzeige von Nanite-Meshs

  Bei einigen Visualisierungsmodi im Statischen-Mesh-Editor ist Vorsicht geboten, wenn du sehr detaillierte Geometrie betrachtest. Die Anzeige von Normalen und UV kann zu Problemen mit der Performance des Editors führen.

Unterstützte Plattformen

Nanite wird derzeit auf PlayStation 5, Xbox Series S|X und PCs mit Grafikkarten unterstützt, die diesen Spezifikationen entsprechen und die neuesten Treiber mit DirectX 12 mit Shader Model 6 (SM6) verwenden:

• NVIDIA: Karten der Maxwell-Generation oder neuer
• AMD: Karten der GCN-Generation oder neuer
• Alle neueren Versionen von Windows 10 (neuer als Version 1909.1350) und Windows 11 mit Unterstützung für DirectX 12 Agile SDK werden unterstützt.
  • Windows 10 Version 1909 – Die Revisionsnummer sollte größer oder gleich .1350 sein.
  • Windows 10 Version 2004 und 20H2 – Die Revisionsnummer sollte größer oder gleich .789 sein.
  • DirectX 12 mit Shader Model 6.6 Atomic, oder Vulkan (VK_KHR_shader_atomic_int64)
• Neueste Grafikkartentreiber

PlayStation 4 und Xbox One unterstützen Nanite ebenfalls, aber die Unterstützung auf diesen Plattformen gilt derzeit als experimentell. Es ist zu erwarten, dass die Performance von Nanite auf diesen Plattformen mit sehr anspruchsvollen Inhalten nicht den Anforderungen eines auslieferbaren Spiels entspricht.

Nanite Fallback-Mesh und Präzisionseinstellungen

Statische Meshs enthalten zusätzliche Eigenschaften, die die Genauigkeit der Nanite Darstellung und des aus dem Voll-Detail-Mesh generierten Fallback-Meshs steuern.

Diese Einstellungen befinden sich im Statischen-Mesh-Editor Details-Panel unter dem Abschnitt Nanite Einstellungen.

Die Nanite Einstellungen umfassen die folgenden Eigenschaften:

Scheitelpunktpräzision

Nanite quantisiert die Positionen der Scheitelpunkte des Meshs, um die Speicherdichte zu maximieren und den Platzbedarf auf der Festplatte zu minimieren. Die Quantisierungsschrittgröße ist eine Zweierpotenz, die mit der Eigenschaft Positionsgenauigkeit an die Anforderungen der einzelnen Meshs angepasst werden kann. Standardmäßig wählt Auto die passende Genauigkeit auf der Grundlage der Größe des Meshs und seiner Dreiecksdichte. Du kannst sie manuell überschreiben, indem du eine Präzisionsgröße auswählst, um die Genauigkeit zu verbessern oder den Speicherplatz auf der Festplatte zu optimieren.

Die Quantisierung ist eine Form der verlustbehafteten Komprimierung. Eine verlustbehaftete Komprimierung ist besonders schwierig, wenn du mit modularen Mesh-Teilen oder anderen Meshs arbeitest, die gemeinsame Grenzen haben. Vor allem, wenn diese Grenzen perfekt ausgerichtet sein müssen, damit keine Löcher oder Risse in der Geometrie entstehen.

Um die Konsistenz sicherzustellen, erfolgt die Quantisierung in nicht normalisierten Koordinaten, die um den Ursprung des Meshs zentriert sind. Dies stellt sicher, dass die Quantisierung keine Risse verursacht, wenn das Mesh die gleiche Genauigkeitseinstellung verwendet und die Verschiebung zwischen den Mesh-Mittelpunkten ein Vielfaches dieser Genauigkeit ist.

Daten trimmen

Es kann vorkommen, dass du die Menge der von Nanite gespeicherten Daten reduzieren musst, um sie für die Größe der Festplatte zu optimieren. Nanite enthält Einstellungen, mit denen du die Detaildaten eines gespeicherten Nanite-Mesh jederzeit während der Produktion trimmen kannst. Das bedeutet, dass du die Qualität im Vorfeld sicher überschreiten und später entsprechend anpassen kannst.

Um die Detaildaten zu trimmen, musst du die Eigenschaften Dreieckprozentsatz beibehalten und Relativen Fehler trimmen verwenden. Du kannst sie dir wie eine Option zur Vordezimierung vorstellen, bevor sie als Nanite-Mesh gespeichert werden. Im Fall von Nanite müssen die Details nicht gleichmäßig über das Mesh verteilt sein. Dabei werden die niedrigstwertigen Daten zuerst entfernt, was mehr einer verlustbehafteten Komprimierung ähnelt.

Verwende Dreiecksprozentsatz beibehalten, um den Prozentsatz der Dreiecke festzulegen, die aus dem Quell-Mesh übernommen werden sollen.

Verwende Relativen Fehler trimmen, um den maximalen relativen Fehler festzulegen, der beim Trimmen der Daten aus dem Quell-Mesh zulässig ist. Jedes Dreieck, das beim Entfernen einen relativen Fehler verursachen würde, der unter diesem Wert liegt, wird entfernt. Oder anders ausgedrückt: Alle Details, die weniger visuelle Auswirkungen haben als dieser relative Wert, werden entfernt. Der relative Fehler hat keine Einheitsgröße und bezieht sich auf die Größe des Meshs.

Die Standardeinstellungen für diese beiden Eigenschaften sind so, dass standardmäßig nichts getrimmt wird und Nanite alle Dreiecke des ursprünglichen Meshs speichert.

Das Trimmen der Daten ist wichtig, um die Größe auf der Festplatte zu verkleinern (d. h. die Downloadgröße), nicht um die Performance zu verbessern. Mehr zu diesem Thema findest du im Abschnitt Datengröße weiter unten.

Fallback-Mesh

Viele Teile der Unreal Engine benötigen Zugriff auf den traditionellen Scheitelpunkt-Buffer, der von traditionell gerenderten Meshs bereitgestellt wird. Wenn Nanite für ein statisches Mesh aktiviert ist, wird eine grobe Darstellung (das so genannte Fallback-Mesh) des hochdetaillierten Meshs erzeugt, auf das zugegriffen werden kann und das dort verwendet wird, wo Nanite-Daten nicht verfügbar sind. Das Fallback-Mesh ist das generierte Mesh, das verwendet wird, wenn Nanite-Rendering nicht unterstützt wird. Es wird auch in Situationen verwendet, in denen es nicht ideal wäre, das hochdetaillierte Mesh zu verwenden, z. B. wenn komplexe Kollisionen erforderlich sind, Lightmaps für gebackene Beleuchtung verwendet werden müssen und für Hardware-Raytracing-Reflexionen mit Lumen.

Die Eigenschaft Fallback-Dreiecksprozentsatz gibt an, wie viel Prozent der Dreiecke aus dem ursprünglichen Quell-Mesh für die Erstellung des Fallback-Meshs verwendet werden. Du kannst den Prozentsatz der Dreiecke, die erhalten bleiben sollen, zwischen 0 und 100 Prozent festlegen, wobei bei einem hohen Prozentsatz mehr Details des ursprünglichen Meshs erhalten bleiben.

Der Fallback-Relativfehler legt die maximale Höhe des relativen Fehlers fest, der beim Entfernen von Details aus dem Quell-Mesh zulässig ist. Alle Dreiecke, die beim Entfernen einen relativen Fehler verursachen würden, der unter diesem Wert liegt, werden entfernt, wobei Details mit geringerer visueller Auswirkung zuerst entfernt werden. Der relative Fehler hat keine Einheitsgröße und bezieht sich auf die Größe des Meshs.

Wenn du zum Beispiel möchtest, dass dein Mesh überhaupt nicht dezimiert wird, würdest du einen Fallback-Dreiecksprozentsatz von 100 und einen Fallback-Relativfehler von 0 verwenden.

Im folgenden Vergleich wird das hochdetaillierte Nanite-Mesh, das aus dem Original-Mesh erstellt wurde, mit den Standardeinstellungen eines generierten Nanite-Fallback-Meshs verglichen.

Mit dem Fallback-Relativfehler gibst du an, wie viele Details aus dem ursprünglichen Mesh beibehalten werden, und mit dem Fallback-Prozentsatz legst du fest, wie viele dieser Details verwendet werden.

Im folgenden Vergleich behält das Fallback-Mesh 100 Prozent des Fallback-Dreiecksprozentsatz bei, passt aber den Fallback-Relativfehler an, um mehr Dreiecke aus dem ursprünglichen Quell-Mesh zu verwenden. Wenn du diese Werte anpasst, kannst du die Nanite-Details für Nanite-Dreiecke im Viewport als Indikator für die Änderung ihrer Werte verwenden.

Fallback-Mesh-Visualisierung

Im Statischen-Mesh-Editor kannst du zwischen dem detaillierten Nanite-Mesh und dem Nanite-Fallback-Mesh umschalten, indem du die Option Nanite-Fallback des Viewports im Dropdown-Menü Anzeigen benutzt. Alternativ kannst du auch die Tastenkombination Strg + N verwenden, um schnell zwischen den beiden Visualisierungsoptionen umzuschalten.

Benutzerdefinierte Fallback-Mesh-LODs für Nanite-aktivierte Meshs verwenden

Das Fallback-Mesh wird für Engine-Funktionen wie komplexe Kollisionen pro Poly, Raytracing, Light-Baking usw. verwendet. Es wird auch für Plattformen verwendet, die Nanite nicht unterstützen. Bei der Generierung des Fallback-Meshs verwendet ein Nanite-aktiviertes Mesh immer den LOD0-Slot des Quell-Meshs für die automatische Generierung des Fallback-Meshs. Es kann jedoch vorkommen, dass es wünschenswert ist, ein manuell festgelegtes Fallback-Mesh oder eine Reihe von traditionellen LODs zu verwenden, anstatt ein automatisch generiertes Mesh.

Dieses Maß an Kontrolle würde es dir ermöglichen, Nanite in einem Projekt zu verwenden, aber auch direkt die Geometrie zu kontrollieren, die in Raytracing-Reflexionen zu sehen ist, oder auf Plattformen, die Nanite nicht unterstützen.

Gehe folgendermaßen vor, um dein eigenes Fallback-Mesh festzulegen oder eine Reihe von LODs zu verwenden:

1. Setze den Wert Fallback-Dreiecksprozentsatz auf 0, damit das Fallback-Mesh so klein wie möglich ist, da es bei diesem Vorgehen ignoriert wird.
2. Füge dem Mesh einen oder mehrere LODs hinzu, indem du diese [traditionelle LOD-Einrichtung] (setting-up-your-production-pipeline\scripting-and-automating-the-editor\HowTos\CreatingLODs) verwendest.
3. Verwende die Dropdown-Liste LOD-Import, um LOD-Level 1 aus dem Abschnitt LOD-Einstellungen zu importieren.
4. Setze Minimum-LOD im Abschnitt LOD-Einstellungen auf 1. Dadurch wird das Nanite-generierte Fallback-Mesh ignoriert.

Ein Sonderfall ist die komplexe Kollision. Verwende die Eigenschaft LOD für Kollision unter Allgemeine Einstellungen, um festzulegen, welcher LOD für Kollisionen verwendet werden soll. Jeder LOD kann für Kollisionen verwendet werden, auch LOD0.

Dieses spezielle Vorgehen ist möglicherweise nicht praktikabel, um Nanite-Projekte automatisch mit Plattformen kompatibel zu machen, die kein Nanite unterstützen, und sollte für dein Projekt getestet und ausgewertet werden.

Nanite kann sehr effizient mit einer großen Anzahl von Instanzen umgehen, aber wenn Nanite deaktiviert ist, kann es zu einer überwältigenden Anzahl von Draw Calls für die traditionelle Render-Pipeline kommen. Du kannst die Machbarkeit in deinem Projekt testen, indem du die Nanite-Unterstützung mit r.Nanite 0 umschaltest.

Mehr Informationen findest du im Abschnitt Konsolenvariablen und -befehle auf dieser Seite.

Arbeiten mit Nanite-aktivierten Inhalten

In den meisten Fällen skaliert Nanite sehr gut innerhalb der Bildschirmauflösung. Dabei kommen zwei Techniken zum Einsatz: feinkörniger Detaillierungsgrad und Occlusion-Culling. Das bedeutet, dass die Anzahl der Dreiecke, die Nanite tatsächlich auf den Bildschirm zu zeichnen versucht, unabhängig von der geometrischen Komplexität der Ausgangsdaten in der Szene konsistent und proportional zur Anzahl der Pixel ist.

Nanite folgt dem Designprinzip, dass es nicht zweckmäßig ist, viel mehr Dreiecke zu zeichnen als es Pixel gibt.

Es gibt jedoch einige Inhalte, bei denen die Skalierungstechniken von Nanite nicht ausreichen. Das bedeutet aber nicht, dass sie für diese Inhalte überhaupt nicht verwendet werden sollte oder dass sie nicht schneller gerendert werden kann als die herkömmliche Pipeline. Es bedeutet nur, dass für diese Art von Inhalten die Skalierung mit Pixeln – und nicht die Komplexität der Szene – nicht mehr gilt. Nutze die Profilerstellung-Funktionen der Unreal Engine, um diese Art von Situationen zu überwachen, wenn sie auftreten.

Aggregatgeometrie

Aggregatgeometrie ist Geometrie, die viele unzusammenhängende Teile hat, die in der Ferne zu einem Volumen werden, wie Haare, Laub an Bäumen und Gras. Diese Art von Geometrie hebelt den Detaillierungsgrad und die Occlusion-Culling-Techniken von Nanite aus.

Nanite ist eine hierarchische Detaillierungsgradstruktur, die darauf beruht, kleine Dreiecke in größere Dreiecke zu vereinfachen und das gröbere zu wählen, wenn es feststellt, dass der Unterschied geringer ist, als er wahrgenommen werden kann. Für durchgehende Oberflächen funktioniert das gut, aber nicht für Aggregatgeometrien, die aus der Ferne mehr wie eine teilweise undurchsichtige Wolke als eine feste Oberfläche aussehen.

Daher ist es wahrscheinlicher, dass Nanite die Aggregatgeometrie nicht annähernd so aggressiv reduzieren kann wie typische feste Oberflächen, was dazu führt, dass mehr Dreiecke für die gleiche Anzahl von Pixeln gezeichnet werden müssen.

Eine weitere Optimierung, die Aggregatgeometrie aushebelt, ist Occlusion-Culling. Obwohl sie sehr feinkörnig ist, ist sie nicht pixelgenau. Geometrie, die mit Löchern gefüllt ist – und schlimmer noch, Ebenen über Ebenen von Geometrie, die mit Löchern gefüllt sind – führen zu übermäßigem Überzeichnen, weil viele Tiefenschichten aufgebaut werden müssen, bevor der Bereich auf dem Bildschirm alles dahinter verdeckt. Du kannst dir das vorstellen, indem du dir einen Bereich von 8x8 Pixeln auf dem Bildschirm vorstellst und überlegst, wie viele Tiefenschichten gezeichnet werden müssen, bis jedes Pixel gefüllt ist. Übermäßiges Überzeichnen bedeutet, dass Nanite versucht, mehr Dreiecke zu zeichnen, um die gleiche Anzahl von Pixeln abzudecken, wodurch die Darstellung langsamer wird.

Laub ist der offensichtlichste Fall, in dem es zu Problemen mit dem Occlusion-Culling kommt, aber selbst dann bedeutet das nicht, dass Nanite überhaupt nicht auf Laub-Meshs verwendet werden sollte. Mehr erfährst du im Abschnitt Laub mit Nanite weiter unten.

Es ist sinnvoll, mit verschiedenen Anwendungsfällen zu experimentieren und zu ermitteln, was für deine Projekte gut funktioniert. Verwende Werkzeuge zur Profilerstellung, um die gute Performance von Nanite mit diesen Mesh-Typen zu bestätigen.

Eng gestapelte Oberflächen

Occlusion-Culling mit herkömmlichen Meshs macht Kitbashing-Arbeitsabläufe aufgrund praktischer Einschränkungen in großem Maßstab fast unmöglich. Die feinkörnige Natur des Occlusion-Culling mit Nanite macht es möglich, diese Art von Arbeitsabläufen während der Entwicklung mit weniger Bedenken zu nutzen.

Wie oben im Abschnitt Aggregatgeometrie erklärt, kann Überzeichnen dadurch entstehen, dass verdeckte Oberflächen sehr nah an den sichtbaren Oberflächen darunter liegen. Wenn die Geometrie weit unter der sichtbaren Oberfläche liegt, kann Nanite sie relativ einfach aufspüren und per Culling beseitigen, so dass sie meist als kostenlos angesehen werden kann. Wenn es jedoch gestapelte Geometrie gibt, die in der Nähe der obersten Oberfläche eng beieinander liegt, ist Nanite nicht in der Lage zu bestimmen, was oben und was unten ist, so dass beide gleichzeitig gezeichnet werden.

Dieses spezielle Problem mit dem Culling ist ein Worst-Case-Szenario, bei dem Nanite nicht weiß, welche Oberfläche oben liegt, und stattdessen einfach alle Ebenen zeichnet. Diese Ungenauigkeit hängt von der Bildschirmgröße und der Entfernung ab. Während 10 Zentimeter Abstand zwischen den Schichten in der Nähe der Oberfläche gut aussehen können, kann der Unterschied in der Entfernung kleiner als ein Pixel sein, was zum Überzeichnen führt.

Wenn du im folgenden Beispiel die Kamera nach unten auf den Bereich bewegst, in dem der Character steht, zeigt die Nanite Überzeichnen-Visualisierung, wie diese gestapelten Oberflächen gerendert werden. Hellere Bereiche zeigen an, dass in diesen Bereichen mehr überzeichnet wird als in anderen.

Die Überzeichnungsvisualisierung ist die effektivste Möglichkeit, Überzeichnungsprobleme zu entdecken. Ein gewisses Maß an Überzeichnung ist zwar zu erwarten, aber zu viel davon führt dazu, dass die Kosten für das Culling und die Rasterung von Nanite höher werden und die Skalierung von Nanite unabhängig von der Komplexität der Szene weniger effektiv wird.

Facettierte und hartkantige Normalen

Ein Problem, auf das du achten musst, ist der Import von sehr detaillierten Meshs mit facettierten Normalen, was bedeutet, dass die Normalen zwischen zwei verschiedenen Polygonen nicht geglättet wurden. Dieses Problem ist weit verbreitet und kann leicht übersehen werden. Deshalb sollte man vorsichtig sein, um dieses Problem zu vermeiden, denn wenn nur wenige Scheitelpunkte in einem Mesh geteilt werden, kann dies sowohl die Performance als auch die Datengröße erheblich verteuern.

Idealerweise sollte die Anzahl der Scheitelpunkte für ein Mesh kleiner sein als die Anzahl der Dreiecke, die es hat. Wenn das Verhältnis 2:1 oder höher ist, gibt es wahrscheinlich ein Problem, vor allem, wenn dies zu einer hohen Anzahl von Dreiecken führt. Ein Verhältnis von 3:1 bedeutet, dass das Mesh komplett facettiert ist, d. h. jedes Dreieck hat seine eigenen drei Scheitelpunkte, von denen keines mit einem anderen Dreieck geteilt wird. Meistens liegt das daran, dass die Normalen nicht gleich sind, weil sie nicht geglättet wurden.

Mehr Scheitelpunkte bedeuten also mehr zu speichernde Daten. Das bedeutet auch, dass mehr Scheitelpunkte umgewandelt werden müssen und Verhältnisse von mehr als 2:1 zu langsamen Rendering-Pfaden führen. Bei der Modellierung von harten Oberflächen sollte es keine Probleme geben, und es gibt keinen Grund, sie nicht zu verwenden. Allerdings sind versehentliche vollständig facettierte, sehr dichte Meshs weitaus teurer als beabsichtigt. Eine weitere Sache, auf die du achten solltest, sind importierte Normalen auf dichten, organischen Oberflächen, die in anderen DCC-Paketen erstellt wurden. Diese haben harte Normalenschwellen, die bei Meshs mit niedrigeren Polygonen sinnvoll sein mögen, aber bei Nanite unnötige Kosten verursachen können.

In den beiden Meshs unten hat das linke Mesh zum Beispiel facettierte Normalen, während das rechte geglättete Normalen hat. Wenn du diese mit der Nanite Dreiecke-Visualisierung vergleichst, gibt es deutliche Unterschiede in der Anzahl der Dreiecke, die Nanite zum Zeichnen verwendet. Die facettierte auf der linken Seite zeichnet deutlich mehr Dreiecke als die geglättete auf der rechten Seite.

Laub mit Nanite

Laub mit Nanite gilt als Beta und wird aktiv erforscht und entwickelt. Dieser Abschnitt enthält einige Hinweise zur Verwendung von Laub mit Nanite in der Unreal Engine 5.1.

Bei Assets wie Bäumen mit standardmäßigen Nanite-Einstellungen kann es vorkommen, dass die Baumkronen mit zunehmender Entfernung immer dünner werden. Diese Fälle sind eine besondere Form der Aggregatgeometrie, bei der jedes disjunkte Teil (ein Laubblatt oder ein Grashalm) offene Kanten an seiner Grenze hat. Die Aktivierung von Fläche erhalten ist nützlich, um diese Ausdünnung zu verhindern, wenn Nanite aktiviert ist. Wenn Nanite die Geometrie in der Ferne vereinfacht, indem es die Anzahl der Dreiecke reduziert, muss es schließlich damit beginnen, einige dieser unzusammenhängenden Elemente vollständig zu entfernen. Wenn Nanite nicht über mehr Informationen verfügt, sieht das Ergebnis dünn aus, weil die Oberfläche zu groß geworden ist. Fläche erhalten verteilt die verlorene Fläche auf die verbleibenden Dreiecke, indem es die offenen Begrenzungskanten ausdehnt. Die Dehnung von symmetrischen Formen wie Laubblättern hat denselben Effekt wie die Vergrößerung. In nicht symmetrischen Fällen wie Bändern, z. B. Grashalmen, hat es den Effekt, dass sie dicker werden.

Fläche erhalten wird für alle Laub-Meshs empfohlen, aber nicht für Meshs, die kein Laub sind.

Die Nanite Cluster-Visualisierung bietet einen klareren Blick darauf, wie Fläche erhalten verlorene Fläche umverteilt.

Im Folgenden findest du einige Empfehlungen für die Verwendung und das Authoring von Laub-Assets unter Berücksichtigung von Nanite. Wir experimentieren noch und lernen selbst, was die besten Vorgehensweisen sind. Bisher haben wir herausgefunden, dass Laub mit Nanite anders erstellt werden sollte als bisher, aber wenn du seine Stärken ausspielst, kannst du mit Nanite schnellere und hochwertigere Ergebnisse erzielen.

• Verwende Fläche erhalten (aktiviert im Statisches-Mesh-Editor).
• Verwende Geometrie anstelle von maskierten Karten.
  • Maskierte Materialien sind im Vergleich zu undurchsichtigen Materialien relativ teuer. Die schnellsten Ergebnisse erzielt man wahrscheinlich, wenn man sie gar nicht benutzt.
  • Der traditionelle Kartenansatz (viele Elemente werden mit einer einzigen Karte dargestellt) kann mit Nanite langsamer sein als ohne Nanite. Erwarte nicht, dass die Aktivierung von Nanite auf kartenbasiertem Laub immer eine Performance-Verbesserung bedeutet.
  • Maskierte Pixel kosten fast so viel wie gezeichnete Pixel. Überzeichnen ist bereits bei Aggregaten in Nanite ein Problem. Wenn ein maskiertes Material verwendet wird, gibt dir die Visualisierung der Nanite Überzeichnungsvisualisierung nicht alle Informationen in Bezug auf die Kosten. Überzeichnen ist in diesem Fall ein komplexes Konzept und die Visualisierung zeigt nur einen bestimmten Aspekt davon.
  • Es hat sich gezeigt, dass Geometrie-Laub mit Nanite schneller ist als mit Karten, sowohl mit Nanite-Karten als auch mit Karten ohne Nanite. Es sieht auch besser aus.
  • Das Paket Megascans: Gras auf dem Unreal Engine Marketplace bietet gute Beispiele zum Testen. Das Paket bietet sowohl maskierte High-Poly-Geometrie, bei der jedes Element unabhängig ist, als auch maskierte Low-Poly-Karten, bei denen viele Elemente durch eine einzige Karte dargestellt werden.
• Bei Verwendung von Weltpositionsversatz (WPO) bedeuten mehr Scheitelpunkte höhere Kosten. Die WPO-Logik muss begrenzt und überwacht werden.
• Die im Abschnitt Aggregatgeometrie auf dieser Seite erläuterten Probleme gelten weiterhin. Dichte Wälder (wie in den Beispielen oben) werden viel langsamer gerendert als die gleiche Szene, in der alle Meshs durch massive Formen mit der gleichen Dreiecksanzahl ersetzt wurden.

Hybride Arbeitsabläufe für Nicht-Nanite- und Nanite-Inhalte

Die folgenden Abschnitte heben Arbeitsabläufe hervor, die du in deinen Nanite-Projekten verwenden kannst, die auch Nicht-Nanite-Funktionen und -Plattformen unterstützen müssen, ohne Assets zu duplizieren.

Importieren eines hochauflösenden Meshs für Nanite

Über den Inhaltsbrowser oder den Statisches-Mesh-Editor kannst du ein hochauflösendes Mesh importieren, das als Nanite-Repräsentation für alle vorhandenen statischen Nicht-Nanite-Meshs dient.

Im Inhaltsbrowser kannst du über das Kontextmenü eines statischen Mesh-Assets die Option Detaillierungsgrad > Hochauflösend > Hochauflösend importieren wählen und zu der Datei navigieren, die du importieren möchtest.

Alternativ kannst du auch den Statisches-Mesh-Editor verwenden, um ein hochauflösendes Mesh zu importieren, indem du die Nanite-Einstellungen im Details-Panel verwendest. Klicke auf Importieren und navigiere zu der Datei, die du importieren möchtest.

Bei diesem Arbeitsablauf wird das bereits vorhandene statische Mesh und sein Detaillierungsgrad (LOD) zum Fallback-Mesh, anstatt dass der Importprozess automatisch ein Fallback-Mesh aus der Nanite-Geometrie erzeugt.

Dieser Arbeitsablauf berücksichtigt die Einstellung Nanite verbieten für Statisches-Mesh-Actors in deinen Szenen und wird weiter unten im Abschnitt Statisches-Mesh-Komponente Optionen erklärt.

Material-Arbeitsabläufe

Es gibt zwei Möglichkeiten, wie du deine Arbeitsabläufe mit Materialien ohne Nanite und mit Nanite verbessern kannst: indem du einen Knoten im Material-Diagramm verwendest, um Logikpfade aufzubrechen, oder indem du ein Override-Material verwendest, das nur für das Rendering mit Nanite verwendet wird.

Knoten Nanite-Durchlaufumschaltung

Der Knoten Nanite-Durchlaufumschaltung ermöglicht es dir, ein spezielles Verhalten in einem Material-Diagramm zu definieren, wenn es mit Nanite gerendert wird.

Verwende den Standard-Input beim Rendern in Nicht-Nanite-Durchläufen, um das Material wie gewohnt zu behandeln. Verwende den Nanite-Input für sämtliche Material-Logik, die du vereinfachen oder speziell für Nanite-Durchläufe rendern möchtest. Wenn ein Material zum Beispiel ein Merkmal verwendet, die von Nanite nicht unterstützt wird, kannst du die gleiche Logik für den Standard-Input beibehalten und eine benutzerfreundlichere Logik für den Nanite-Input verwenden.

Nanite Override-Material

Der Slot Nanite Override-Material ist für Materialien und Materialinstanzen verfügbar. Wenn du ein Override-Material festlegst, verwenden alle Meshs mit Nanite-Aktivierung, denen das Material oder die Materialinstanz zugewiesen ist, stattdessen das referenzierte Nanite Override-Material. Das bedeutet, dass du Materialien speziell für Nanite-Arbeitsabläufe erstellen kannst, anstatt die Logik direkt im Material-Diagramm mit dem Knoten Nanite-Durchlaufumschaltung zu verwalten.

In Materialinstanzen ist der Nanite Override-Material-Slot zwangsweise auf Kein voreingestellt, so dass das Festlegen des Overrides in einem übergeordneten Material nicht dazu führt, dass er automatisch an eine der untergeordneten Instanzen dieses Materials vererbt wird.

Im folgenden Beispiel hat das Statisches-Mesh-Asset für die Statue Nanite aktiviert und eine Materialinstanz zugewiesen. Die Materialinstanz hat ihr Nanite Override-Material mit einigen einfachen Farbänderungen zu Demonstrationszwecken eingestellt. Der Statisches-Mesh-Actor auf der linken Seite zeigt das Nanite Override-Material an, da das Mesh mit Nanite gerendert wird. Der Statisches-Mesh-Actor auf der rechten Seite zeigt dasselbe Material an, bis Nanite verbieten für den Actor festgelegt wird, wodurch das Nanite Override-Material deaktiviert wird, um das Nicht-Nanite-Basismaterial der Materialinstanz anzuzeigen.

Statisches-Mesh-Komponente Option: Nanite verbieten

Du kannst festlegen, wann Nanite-aktivierte statische Meshs ihre Nanite-Darstellung verwenden sollen, indem du die Einstellung Nanite verbieten für einzelne Szenen-Actors verwendest. Das bedeutet, dass du eine Mischung aus Nanite- und Nicht-Nanite-Actors haben kannst, die das gleiche Statisches-Mesh-Asset verwenden.

Das folgende Beispiel zeigt ein einzelnes Statisches-Mesh-Asset mit aktiviertem Nanite, bei dem links die Darstellung des Nanite-Meshs und rechts die Option Nanite verbieten aktiviert ist.

Landschaftsterrain

Dies ist eine experimentelle Funktion.

Um Nanite mit deinem Landschaftsterrain zu verwenden, wähle es aus und aktiviere im Details-Panel das Kästchen neben Nanite aktivieren.

Es gibt zwei Möglichkeiten, das Nanite-Mesh aus den Landschaftsdaten zu erstellen.

• Klicke im Details-Panel der Landschaft unter dem Abschnitt Nanite auf die Schaltfläche Neu aufgebaute Daten.
• Wähle im Build-Menü die Option Nur Nanite erstellen.

Je nach Größe der Landschaft oder der Anzahl der Kacheln kann es einen Moment dauern, bis die Nanite-Darstellung erzeugt wird. Anschließend kannst du sie in den Nanite-Visualisierungsmodi ausprobieren.

Die folgenden Konsolenvariablen sind nützlich, wenn du mit Nanite-aktivierten Landschaften arbeitest:

• Landscape.LiveRebuildNaniteOnModification löst einen sofortigen Neuaufbau der Nanite-Darstellung aus, wenn eine Änderung vorgenommen wird. (Standardwert 0)
• Landscape.RenderNanite legt fest, ob die Landschaft mit Nanite gerendert werden soll oder nicht. (Standardwert 1)

Nanite-aktivierte Landschaften haben folgende Einschränkungen:

• Wenn du die Live-Modifikation von Nanite-aktivierten Landschaften aktivierst (Landscape.LiveRebuiltNaniteOnModification 1), wird die Landschaftsmodellierung fast unbrauchbar, da die Nanite-Darstellung aller Landschafts-Actors bei jedem Frame neu aufgebaut wird.
• Die maximale Auflösung des Nanite-Meshs entspricht LOD0 für die Landschaft. Es ist nicht zu erwarten, dass sich die Auflösung durch die Verwendung von Nanite über eine normale Landschaft erhöht. In der jetzigen Form ist dies eine reine Laufzeitoptimierung.
• Das Speichern von Landschafts-Actors mit aktiviertem Nanite, wenn das Nanite-Mesh nicht aktualisiert wurde, ist langsamer, da das Nanite-Mesh vor dem Speichern erst aufgebaut werden muss.

Technische Überlegungen:

• Nanite-Landschaften werden derzeit zusätzlich zum normalen Streaming von Landschaftsdaten gestreamt, da sowohl Nanite- als auch Nicht-Nanite-Daten zur Laufzeit benötigt werden. Letztere werden für virtuelle Texturen zur Laufzeit, das Rendering von Wasser und mehr benötigt. Das bedeutet, dass die Daten zweimal gestreamt werden müssen – ein Datensatz mit Nanite-Streaming und der andere mit dem Textur-Streaming – und sich im Speicher befinden, wenn Nanite aktiviert ist.
• Die Performance während der Laufzeit wird durch das Rendering mit Nanite verbessert, vor allem in Bezug auf die Schattendurchläufe, aber es sind keine visuellen Verbesserungen (oder Verschlechterungen) zu erwarten, da die Ausgangsdaten identisch sind.
• Hierarchischer Detaillierungsgrad (HLOD)/Streaming wird sich voraussichtlich genauso verhalten wie die Landschaft ohne Nanite.

Wenn du Nanite-aktivierte Landschaften bearbeitest, empfehlen wir dir, den Live-Neuaufbau von Nanite-Meshs zu deaktivieren (Landscape.LiveRebuiltNaniteOnModification 0). Das Landschafts-Rendering basiert auf Nicht-Nanite-Landschaften, bis das Nanite-Mesh neu erstellt wurde (entweder beim Speichern oder wenn du die Optionen Nur Nanite erstellen / Alle Landschaften erstellen im Build-Menü verwendest) und auf dem neuesten Stand ist. In diesem Fall wird diese Version zum Rendern verwendet. Da es keine großen visuellen Unterschiede zwischen Nanite- und Nicht-Nanite-Landschaften geben sollte, bedeutet dies, dass die Performance im Editor, während die Nicht-Nanite-Landschaft verwendet wird, nicht repräsentativ für die Laufzeit-Performance in deinem Projekt ist.

Performance von typischen Inhalten

Zum Vergleich wurden die folgenden GPU-Timings aus der technischen Demo der Unreal Engine 5 [Lumen in the Land of Nanite] (https://www.youtube.com/watch?v=qC5KtatMcUw) auf einer PlayStation 5 entnommen:

• Durchschnittliche Rendering-Auflösung von 1400p, temporär hochgerechnet auf 4K.
• ~2,5 Millisekunden (ms) für das Culling und Rastern aller Nanite-Meshs (was in dieser Demo fast alles war)
  • Fast alle verwendeten Geometrien waren ein Nanite-Mesh
  • Nahezu keine CPU-Kosten, da 100% GPU-gesteuert
• ~2 ms zur Auswertung der Materialien für alle Nanite-Meshs
  • Geringe CPU-Kosten mit 1 Draw Call pro Material in der Szene.

Wenn du diese GPU-Zeiten zusammenrechnest, sind es etwa 4,5 ms für das, was dem Tiefenvordurchlauf der Unreal Engine 4 plus dem Basisdurchlauf entsprechen würde. Damit eignet sich Nanite besonders gut für Spieleprojekte, die 60 FPS anstreben.

Solche Zahlen sollten von Inhalten erwartet werden, die nicht unter den in den vorherigen Abschnitten beschriebenen Performance-Problemen leiden. Eine sehr hohe Anzahl von Instanzen und eine große Anzahl einzigartiger Materialien kann ebenfalls zu erhöhten Kosten führen und ist ein Bereich der Nanite-Entwicklung, an dem aktiv gearbeitet wird.

Datengröße

Aufgrund der mikroskopisch kleinen Details, die Nanite erreichen kann, könnte man annehmen, dass dies mit einem gewaltigen Anstieg der Geometriedaten einhergeht, was zu größeren Paketen und Downloads für die Spieler führt. Doch die Realität ist nicht so schlimm. Das Mesh-Format von Nanite ist aufgrund der speziellen Mesh-Kodierung von Nanite deutlich kleiner als das Standardformat statischer Meshs.

Bei der Unreal-Engine-5-Demo "Valley of the Ancient" sind die Nanite-Meshs im Durchschnitt 14,4 Byte pro Input-Dreieck groß. Das bedeutet, dass ein durchschnittliches Nanite-Mesh mit einer Million Dreiecken ~13,8 Megabyte (MB) auf der Festplatte belegt.

Wenn du ein herkömmliches Low-Poly-Mesh plus Normal Map mit einem High-Poly-Nanite-Mesh vergleichst, würdest du etwa Folgendes feststellen:

Die Größe der komprimierten Pakete entspricht jedoch nicht der gesamten Größe des Assets. Es gibt auch einzigartige Texturen, die nur von diesem Mesh verwendet werden und die berücksichtigt werden müssen. Viele der Materialien, die von Meshs verwendet werden, haben ihre eigenen einzigartigen Texturen, die aus verschiedenen Normal-, BaseColor-, metallischen, spiegelnden, Rauheits- und Maskentexturen bestehen.

Dieses Asset verwendet nur zwei Texturen (BaseColor und Normal) und verbraucht daher nicht so viel Platz auf der Festplatte wie ein Asset mit vielen anderen einzigartigen Texturen. Das Nanite-Mesh mit ~1,5 Millionen Dreiecken ist mit 19,64 MB kleiner als eine 4K-Normal-Map-Textur.

Die Gesamtgröße der komprimierten Pakete für dieses Mesh und seine Texturen beträgt:

• Low-Poly-Mesh: 31,04 MB
• High-Poly-Mesh: 49,69 MB

Da das Nanite-Mesh bereits sehr detailliert ist, können wir versuchen, die einzigartige Normal Map durch eine Kachelung mit Detailnormalen zu ersetzen, die mit anderen Assets geteilt wird. Obwohl dies in diesem Fall zu einem gewissen Qualitätsverlust führt, ist dieser ziemlich gering und sicherlich viel kleiner als der Qualitätsunterschied zwischen der Low-Poly- und der High-Poly-Version. So kann ein Nanite-Mesh mit 1,5 Mio. Dreiecken sowohl besser aussehen als auch kleiner sein als ein Low-Poly-Mesh mit einer 4K-Normal-Map.

Gesamtgröße der komprimierten Pakete für das Nanite-aktivierte Mesh und die Texturen: 27,83 MB

Es gibt viele Experimente mit der Texturauflösung und den Detail-Normal-Maps, aber dieser spezielle Vergleich soll zeigen, dass die Datengrößen von Nanite-Meshs sich nicht allzu sehr von den Daten unterscheiden, mit denen die Anwender bereits vertraut sind.

Schließlich können wir die Nanite-Komprimierung mit dem gewöhnlichen statischen Mesh vergleichen, indem wir das High-Poly-Format verwenden, wo beide bei LOD0 identisch sind.

Im Vergleich dazu ist die Nanite-Komprimierung von vorhin mit einer Größe von 19,64 MB 7,6x kleiner als die Komprimierung des gewöhnlichen statischen Meshs mit 4 LODs.

Die Nanite-Komprimierung und die Datengrößen sind ein wichtiger Bereich, der in zukünftigen Versionen der Unreal Engine verbessert werden soll.

Allgemeine Hinweise zur Datengröße

Nanite und Systeme für die virtuelle Texturierung, gekoppelt mit schnellen SSDs, haben die Bedenken über Laufzeit-Budgets für Geometrie und Texturen verringert. Der größte Engpass ist nun, wie man diese Daten den Benutzern bereitstellt.

Die Datengröße auf der Festplatte ist ein wichtiger Faktor, wenn es darum geht, wie die Inhalte bereitgestellt werden – auf physischen Medien oder heruntergeladen über das Internet – und die Komprimierungstechnologie kann nur einen Teil davon übernehmen. Die Internet-Bandbreite, die Größe der optischen Medien und die Größe der Festplatten sind beim durchschnittlichen Endanwender nicht in gleichem Maße gestiegen wie die Bandbreite und Zugriffslatenz der Festplatten, die GPU-Rechenleistung und Softwaretechnologien wie Nanite. Die Weitergabe dieser Daten an die Benutzer ist eine Herausforderung.

Das effiziente Rendern von hochdetaillierten Meshs ist mit Nanite weniger problematisch, aber die Speicherung der Daten auf der Festplatte ist jetzt der wichtigste Bereich, der unter Kontrolle gehalten werden muss.

Visualisierungsmodi

Nanite bietet eine Reihe von Visualisierungsmodi zur Untersuchung der Daten in der aktuellen Szene.

Bewege den Mauszeiger im Level-Viewport in der Dropdown-Liste Ansichtsmodi über Nanite-Visualisierung und wähle aus der Auswahl.

Die Visualisierung Übersicht zeigt die gerenderte Szene in der Mitte des Bildes mit ausgewählten Nanite-Visualisierungen als Referenzen an.

Die folgenden Nanite-Visualisierungsmodi stehen zur Auswahl:

Nanite enthält einen Erweiterten Visualisierungsmodus, der zusätzliche Visualisierungsoptionen im Menü Nanite-Visualisierung aktiviert. Diese Visualisierungen sind nützlich für Programmierer, die verschiedene Low-Level-Aspekte von Nanite debuggen oder für die entsprechende Profilerstellung.

Aktiviere diesen erweiterten Modi mit der Konsolenvariablen r.Nanite.Visualize.Advanced 1.

Konsolenvariablen und Befehle

Die folgenden Statistiken und Konsolenvariablen sind für das Debugging und die Konfiguration von Nanite verfügbar.

Das Nanite-Rendering kann zur Laufzeit mit der Konsolenvariablen r.Nanite 0 global aktiviert und deaktiviert werden. Die Deaktivierung von Nanite ist eine gute Möglichkeit, Plattformen zu emulieren, auf denen es nicht unterstützt wird.

Nanite Fallback-Rendering-Modi

Nanite bietet Fallback-Mesh-Rendering-Modi, wenn Nanite entweder deaktiviert ist oder von einer Plattform nicht unterstützt wird. Du kannst mit der Konsolenvariablen r.Nanite.ProxyRenderMode steuern, welcher Modus verwendet wird.

• 0 ist der Standardmodus und greift auf das Rendering von Fallback-Meshs oder Bildschirmraum-gesteuerten LODs zurück, wenn diese eingestellt sind. Dazu gehört auch die Erkennung von Min LOD in den Eigenschaften des Statisches-Mesh-Editors (beschrieben im Abschnitt Fallback-Mesh oben).
• 1 deaktiviert das gesamte Rendering von Nanite-aktivierten Meshs.
• 2 funktioniert ähnlich wie Modus 1, ermöglicht aber die Visualisierung Anzeigen > Nanite-Fallback im Statisches-Mesh-Editor, um ein Nanite-Fallback zu rendern.

Die Fallback-Rendering-Modi 1 und 2 sind nützlich für Szenen, die viel mehr Instanzen haben, als ohne Nanite unterstützt werden können. Sie ermöglichen es, die Szene im Editor auf Plattformen zu öffnen, die Nanite nicht unterstützen.

Im Unreal-Engine-5-Beispielprojekt "Valley of the Ancient" zum Beispiel würde die Deaktivierung von Nanite dazu führen, dass zehntausende von regelmäßigen Draw Calls stattfinden, was es schwierig macht, die Karte auf einer nicht unterstützenden Plattform zu öffnen.

Befehl Nanitestats

Der Befehl Nanitestats fügt oben rechts im Viewport eine Überlagerung von Nanite-Culling-Statistiken ein.

Mit den Befehlsargumenten kannst du festlegen, welche Statistiken Nanite auf dem Bildschirm anzeigt. Wenn kein Argument angegeben wird, wird die primäre Ansicht verwendet.

Verwende Nanitestats List, um alle verfügbaren Ansichten in der Debugging-Ausgabe anzuzeigen:

• Primär
• VirtualShadowMaps

Du kannst auch andere Statistiken für ShadowAtlas und CubemapShadows sehen, wenn sie verfügbar sind. Wähle eine Ansicht aus, indem du den Befehl gefolgt von dem Namen der Statistikliste eingibst, die du ansehen möchtest. Du würdest zum Beispiel NaniteStats VirtualShadowMaps eingeben.

Bei Ansichten mit Two-Pass-Occlusion-Culling werden die Statistiken in separate Buckets für Main und Post-Pass aufgeteilt.

Steuerung der Nanite-Streaming-Pool-Größe

Steuere den Speicherplatz für Nanite Streaming-Daten mit der Konsolenvariablen r.Nanite.Streaming.StreamingPoolSize. Die Verwendung größerer Pools reduziert den IO- und Dekomprimierungsaufwand, wenn du dich in der Szene bewegst, allerdings auf Kosten eines höheren Speicherbedarfs.

Wenn der Pool nicht groß genug ist, um alle für eine Ansicht benötigten Daten aufzunehmen, kann es zu Cache-Thrashing kommen, bei dem sich das Streaming auch bei einer statischen Ansicht nie einpendelt.

Diese Konsolenvariable kann während der Laufzeit nicht geändert werden und muss in einer Konfigurationsdatei (.ini) angegeben werden.

Maximale Anzahl von Clustern in einem Durchlauf einstellen

Mit den Konsolenvariablen r.Nanite.MaxCandidateClusters und r.Nanite.MaxVisibleClusters kannst du die maximale Anzahl an Kandidaten- und sichtbaren Clustern festlegen, die in einem einzigen Durchlauf verwendet werden. Ihre Werte werden für die Größenbestimmung von Zwischenbuffern verwendet und ihre Standardwerte wurden so gewählt, dass sie für gängige Rendering-Szenarien geeignet sind.

Es gibt keinen Mechanismus, um die Größe dieser Buffer dynamisch zu ändern und/oder die Qualität bei Überlauf automatisch zu verringern. Dies kann zu Artefakten führen, wenn die Buffer für die Komplexität der Szene zu klein sind, was sich in der Regel durch fehlende oder blinkende Geometrie äußert. Wenn diese Art von Artefakten auftritt, kannst du mit Nanitestats konservative Grenzen für Kandidaten und sichtbare Cluster bestimmen. Sieh dir insbesondere die Statistiken für ClustersSW und ClustersHW an. Die Speicherkosten eines Kandidaten-Clusters betragen derzeit 12 Byte und die eines sichtbaren Clusters 16 Byte.

Diese Konsolenvariable kann während der Laufzeit nicht geändert werden und muss in einer Konfigurationsdatei (.ini) angegeben werden.