Ein Navigation Mesh in einer 3DGS-Szene erzeugen

Unterstützung des Navigation System

Geltungsbereich

Dieses Dokument richtet sich an Szenen, die Navigation aus LCC-Kollisionsdaten aufbauen, es gilt daher nur für ALCCActor und ALCC2Actor: Nur die Formate .lcc und .lcc2 liefern Kollisionsdaten mit, siehe Kollision.

.sog, .spz und .ply enthalten keine Kollisionsdaten, begehbare Bereiche müssen daher manuell mit Blocking Volumes oder einem Näherungs-Mesh aufgebaut werden. Solche Geometrie besteht aus regulären UE-Objekten, und die Navigation wird über den offiziellen Workflow von Unreal Engine konfiguriert, der die Besonderheiten dieses Dokuments nicht betrifft.

Überblick

Das Navigation System von Unreal Engine stellt KI-Charakteren über ein NavMesh begehbare Bereiche bereit. Die Erzeugung des NavMesh beruht auf Geometrie in der Szene, die die Navigation beeinflussen kann und gültige Kollision besitzt.

LCC-Kollision wird dynamisch in Chunks geladen: Es werden nur die Kollisions-Chunks innerhalb eines bestimmten Umkreises um die Kamera geladen, und sie werden mit der Kamerabewegung ein- und ausgelagert (zum Mechanismus siehe Kollision: Lademechanismus). Das bestimmt die Strategie zur Konfiguration der Navigation unmittelbar:

• Das Ein- und Auslagern von Kollisions-Chunks zur Laufzeit löst NavMesh-Neuaufbauten aus und verursacht Ruckeln
• Die Kollision des Zielbereichs sollte daher in einem Durchgang vollständig geladen werden, bevor die Navigation im Modus Static aufgebaut wird

Für LCC-Szenen ist Static die empfohlene Runtime Generation. Dynamic reagiert fortlaufend auf Änderungen der Kollision und baut das NavMesh neu auf, was zusammen mit chunkweise geladener Kollision häufig Neuaufbauten auslöst und in großen Szenen deutliche CPU-Kosten und Ruckeln verursacht.

Voraussetzungen

Die Ladedistanz der Kollision und NavMeshBoundsVolume steuern unterschiedliche Bereiche: Erstere entscheidet, welche Bereiche Kollisionsdaten haben, letzteres entscheidet, innerhalb welcher Grenzen die Engine das NavMesh aufbaut. Beide müssen den Zielbereich abdecken, damit dort ein nutzbares NavMesh entsteht.

Schritte

1. LCC-Kollision aktivieren und prüfen

ALCCActor oder ALCC2Actor auswählen und im Details-Panel Enable Collision (bEnableCollision) aktivieren, oder aus Code aktivieren:

LCCComponent->SetLCCCollisionEnable(true);

Gleichzeitig CanEverAffectNavigation = true am Actor prüfen, damit seine Kollision am Aufbau der Navigation teilnehmen kann.

Nach dem Laden der LCC-Daten im View Mode Player Collision oder Visibility Collision auswählen und prüfen, ob im Zielbereich Kollisionskörper erschienen sind. Die Kollision nutzt asynchrones Backen der Physik, es kann daher noch einige Sekunden dauern, nachdem das 3DGS-Bild bereits gerendert wird.

Über den Modus Player Collision oder Visibility Collision prüfen, ob die LCC-Kollisionskörper im Zielbereich der Navigation geladen sind

2. Den Laderadius der Kollision konfigurieren

LCC-Kollision wird nur innerhalb des durch Max Load Collision Distance(m) angegebenen Umkreises geladen, standardmäßig 300 Meter.

Bei Verwendung mit Navigation diesen Wert so erhöhen, dass er den gesamten Aktivitätsbereich der KI abdeckt, damit die gesamte Kollision in einem Durchgang lädt. Andernfalls werden Kollisions-Chunks zur Laufzeit mit der Kamerabewegung fortlaufend ein- und ausgelagert, was ständig NavMesh-Neuaufbauten auslöst und deutliches Ruckeln verursacht. Bei ausreichend großem Umkreis gibt es zur Laufzeit keine Änderungen der Kollision, die Navigation wird also nie neu aufgebaut.

Der Preis sind eine längere Ladezeit beim Start und ein höherer Arbeitsspeicherbedarf. Über Collision Data Usage in stat xgrids prüfen, ob der Arbeitsspeicher nach vollständigem Laden akzeptabel ist, siehe Kollision: Alle Kollisionen auf einmal laden.

Runtime Generation nicht auf Dynamic ändern, um eine zu geringe Kollisionsdistanz zu umgehen. Dynamic erweitert den Laderadius der Kollision nicht, und Bereiche jenseits dieser Distanz haben weiterhin keine Kollision für den Aufbau der Navigation.

3. Das NavMeshBoundsVolume platzieren und anpassen

Ein NavMeshBoundsVolume in der Szene platzieren, dann verschieben und skalieren, sodass es den vollständigen Bereich abdeckt, in dem sich die KI bewegen soll.

Das NavMeshBoundsVolume platzieren und skalieren, damit die Build-Grenzen der Navigation den vollständigen Aktivitätsbereich der KI abdecken

Erneut prüfen, dass beide Bereiche die Anforderung erfüllen:

• Max Load Collision Distance(m): entscheidet, ob im Zielbereich geladene LCC-Kollision vorhanden ist.
• NavMeshBoundsVolume: entscheidet, innerhalb welcher Grenzen Unreal Engine das NavMesh aufbaut.

Nur einen der beiden zu erweitern löst den Bereich nicht, den der andere nicht abdeckt.

4. Das Navigation System konfigurieren

Wann Dynamic zu verwenden ist

Dynamic nur in Betracht ziehen, wenn das NavMesh tatsächlich automatisch neu aufgebaut werden muss, während sich Geometrie zur Laufzeit ändert, etwa in einer interaktiven Szene, in der sich begehbare Bereiche während des Spiels ändern.

Bei Dynamic zusammen mit LCC-Kollision besonders vorsichtig sein: Die Kollision selbst wird dynamisch in Chunks geladen, und jedes Ein- oder Auslagern eines Kollisions-Chunks gilt als Geometrieänderung und löst einen Neuaufbau der Navigation aus, was in großen Szenen fortlaufende CPU-Kosten und Ruckeln erzeugen kann. Wenn Dynamic wirklich nötig ist, zusätzlich den Laderadius der Kollision so erhöhen, dass er den gesamten Aktivitätsbereich abdeckt, damit zur Laufzeit keine Änderungen der Kollision auftreten.

Dynamic nicht allein deshalb aktivieren, um die Kollisionsdistanz oder die Abdeckung der Navigation zu erweitern.

5. Auf die Kollision warten und das statische NavMesh aufbauen

Im empfohlenen Modus Static diese Reihenfolge einhalten:

1. Die LCC-Daten laden und prüfen, dass das 3DGS-Bild dargestellt wird.
2. Auf den Abschluss des asynchronen Backens der Kollision warten.
3. Über den Modus Player Collision oder Visibility Collision prüfen, dass die Kollision im Zielbereich geladen ist.
4. Prüfen, dass Collision Load Max Distance und NavMeshBoundsVolume den Zielbereich abdecken.
5. Im Hauptmenü von Unreal Engine Build → Build Paths ausführen.
6. Auf den Abschluss des Navigation-Builds warten.
7. Das Level und die Navigationsdaten speichern.

Prüfung und Fehlerbehebung

P drücken, um das NavMesh im Viewport anzuzeigen:

• Grüne Bereiche: Ein begehbares NavMesh ist erzeugt;
• Kein grüner Bereich: An dieser Stelle ist kein NavMesh erzeugt, in der folgenden Reihenfolge prüfen.

P drücken, um das NavMesh zu prüfen; grüne Abdeckung bedeutet, dass in diesem Bereich begehbare Navigationsdaten erzeugt sind

Wenn an der Zielstelle kein grünes NavMesh vorhanden ist, der Reihe nach prüfen:

1. Ob die Daten Kollision enthalten: prüfen, dass .lcc oder .lcc2 verwendet wird und die passende Kollisionsdatei im Datenverzeichnis existiert; Einzeldateiformate enthalten keine Kollision und können diesen Workflow nicht nutzen.
2. Ob die Kollision aktiviert und geladen ist: prüfen, dass bEnableCollision = true und CanEverAffectNavigation = true gilt und dass die Kollisionskörper an der Zielstelle im Modus Player Collision oder Visibility Collision sichtbar sind.
3. Ob der Laderadius der Kollision groß genug ist: liegt die Zielstelle jenseits des Laderadius, Max Load Collision Distance(m) erhöhen und erneut warten, bis die Kollision bereit ist.
4. Ob das NavMeshBoundsVolume die Zielstelle abdeckt: das Volume verschieben oder skalieren, damit die Build-Grenzen der Navigation den Zielbereich vollständig abdecken.
5. Ob das statische NavMesh neu aufgebaut wurde: sobald Kollision und Bereiche geprüft sind, Build → Build Paths ausführen, auf den Abschluss warten und Level sowie Navigationsdaten speichern.
6. Erneut P drücken, um die grüne Abdeckung zu prüfen.

Wenn alles Vorstehende korrekt ist und die Erzeugung dennoch fehlschlägt, das Output Log weiter auf Fehler zu Navigation, Recast und Kollision prüfen und sicherstellen, dass das aktuelle Level gespeichert ist.