Eine 3DGS-Szene unter Linux rendern

Dieses Dokument beginnt bei der Installation von Unreal Engine und beschreibt, wie LCC4Unreal installiert, ein C++-Projekt erstellt, LCC-Daten geladen, kompiliert, ausgeführt und eine Linux-Anwendung paketiert wird.

1. Empfohlene Hard- und Softwareumgebung

2. Eine Installationsmethode für Unreal Engine wählen

Unter Linux stehen zwei Installationsmethoden für Unreal Engine zur Verfügung:

Die vorkompilierte Version bevorzugen, wenn nur LCC4Unreal benötigt wird und der Quellcode von Unreal Engine nicht geändert werden muss.

Hinweis: LCC4Unreal wird in vorkompilierter Form ausgeliefert und passt zu den offiziellen Engine-Binaries. Den Engine-Quellcode nicht ändern, denn eine geänderte Engine kann mit dem Plugin inkompatibel sein, was zu Ladefehlern oder unerwartetem Verhalten führt.

2.1 Methode A: Die vorkompilierte Linux-Version von Unreal Engine installieren (empfohlen)

1. Die offizielle Epic-Seite Unreal Engine for Linux öffnen;

2. Mit einem Epic-Games-Konto anmelden;

3. Das .zip-Archiv der benötigten Unreal-Engine-Version herunterladen.

   

   Das benötigte vorkompilierte Linux-Paket von Unreal Engine auf der offiziellen Epic-Games-Seite auswählen und herunterladen

4. Im Dateimanager ein Engine-Verzeichnis anlegen, zum Beispiel:

   /home/[USER]/Unreal/Engines/UnrealEngine
   

5. Alle Dateien und Verzeichnisse aus dem Archiv in dieses Engine-Wurzelverzeichnis entpacken. Nicht nur die einzelne Datei UnrealEditor kopieren, sonst fehlen der Engine die übrigen Inhalte, die zum Ausführen und Bauen nötig sind;

6. Im Dateimanager in das Engine-Wurzelverzeichnis wechseln, mit der rechten Maustaste auf eine leere Stelle klicken und Open in Terminal wählen. Die folgenden Befehle müssen im richtigen Engine-Verzeichnis laufen.

   

   In das vollständig entpackte Wurzelverzeichnis von Unreal Engine wechseln und dort ein Terminal öffnen

7. Den Unreal-Engine-Editor starten.

Allgemeine Form:

"/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor"

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor"

Wenn eine fehlende Ausführungsberechtigung gemeldet wird:

chmod +x "/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor"

Beispiel:
chmod +x "/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor"

2.1.1 Die Toolchain für die C++-Entwicklung vorbereiten

Gemäß dem Schnellstart für die Linux-Entwicklung von Epic Games Folgendes im Unreal-Engine-Verzeichnis ausführen:

cd "/[UE_ROOT]/Engine/Build/BatchFiles/Linux"
./SetupToolchain.sh

Beispiel:
cd "/home/alice/Unreal/Engines/UnrealEngine/Engine/Build/BatchFiles/Linux"
./SetupToolchain.sh

2.2 Methode B: Unreal Engine aus dem Quellcode bauen

Zu Abschnitt 4 springen, wenn ein Source-Build von Unreal Engine bereits läuft.

2.2.1 Den Quellcode beziehen

Von GitHub beziehen: https://github.com/EpicGames/UnrealEngine

Das GitHub-Repository von Epic Games für Unreal Engine besuchen und den Quellcode der benötigten Version beziehen

2.2.2 Abhängigkeiten und die native Toolchain herunterladen

cd "/[UE_ROOT]"
./Setup.sh

Beispiel:
cd "/home/alice/Unreal/Engines/UnrealEngine"
./Setup.sh

Mit Setup.sh die für einen Source-Build nötigen Abhängigkeiten und die native Linux-Toolchain herunterladen

Erfolgskriterien:

• Der Befehl endet regulär;
• Keine fatal-Meldungen und keine unbehandelten Download-Fehler;
• Die passende Unreal-Engine-Toolchain liegt in Engine/Extras/ThirdPartyNotUE/SDKs/HostLinux.

Wenn Folgendes erscheint:

fatal: not a git repository

liegt ein Problem beim Quellcode-Origin, beim aktuellen Verzeichnis oder bei den Git-Metadaten vor. Das nicht ignorieren und weiterkompilieren. Zuerst bestätigen, dass das aktuelle Terminal im richtigen Wurzelverzeichnis von Unreal Engine steht.

2.2.3 Projektdateien erzeugen

cd "/[UE_ROOT]"
./GenerateProjectFiles.sh

Beispiel:
cd "/home/alice/Unreal/Engines/UnrealEngine"
./GenerateProjectFiles.sh

Projektdateien und das Linux-Makefile für den Quellcode von Unreal Engine erzeugen

2.2.4 UnrealEditor kompilieren

Beim ersten Build die Anzahl der parallelen Jobs begrenzen, damit der Arbeitsspeicher nicht ausgeht. make -j4 UnrealEditor funktioniert standardmäßig; mit nur 32 GB Arbeitsspeicher stattdessen make -j2 UnrealEditor verwenden; wenn das Engine-Makefile kein eigenes Target bereitstellt, make -j4 verwenden:

cd "/[UE_ROOT]"
make -j4 UnrealEditor

# Mit nur 32 GB Arbeitsspeicher dies verwenden:
make -j2 UnrealEditor

# Verwenden, wenn das Makefile kein eigenes Target bereitstellt:
make -j4

Die Anzahl der parallelen Jobs begrenzen und den Source-Build von UnrealEditor kompilieren

Hunderte oder gar tausende Actions beim ersten Source-Build sind normal. Sie gehören zur Engine selbst, nicht zu den Quelldateien des leeren Projekts. Die Build-Dauer hängt von CPU, Arbeitsspeicher und Datenträger ab.

Prüfen, ob es erfolgreich war:

test -x "/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor" \
  && echo "Source build UnrealEditor is ready" \
  || echo "Build not finished"

Beispiel:
test -x "/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor" \
  && echo "Source build UnrealEditor is ready" \
  || echo "Build not finished"

Den Project Browser starten:

"/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor"

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor"

Den Unreal Project Browser starten, nachdem der Source-Build von UnrealEditor kompiliert ist

3. VS Code installieren und konfigurieren

3.1 VS Code und C++-Entwicklungswerkzeuge installieren

Unter Ubuntu von der offiziellen Seite Visual Studio Code herunterladen und installieren oder die von der Distribution unterstützte Paketmethode nutzen.

Vor dem Kompilieren von C++-Projekten mit VS Code die Installation der Linux-Toolchain von Unreal Engine aus Abschnitt 2 abschließen und die grundlegenden Werkzeuge zum Kompilieren und Debuggen von C++ vorbereiten. Übliche Werkzeuge wie build-essential, clang, lldb und cmake passend zur Ubuntu-Version und zur Team-Umgebung installieren; die tatsächliche Compiler-Version richtet sich nach den Anforderungen der aktuellen Unreal-Engine-Version und der von SetupToolchain.sh/Setup.sh installierten Toolchain.

Die folgenden VS-Code-Erweiterungen sind empfohlen:

• C/C++: Code-Navigation, Vervollständigung und Debugging;
• C/C++ Extension Pack: weitere übliche Funktionen für die C++-Entwicklung;
• CodeLLDB: LLDB-Debugging unter Linux;
• Makefile Tools: Makefile-Targets ansehen und ausführen (optional).

Die offizielle Dokumentation von Epic Games kann ebenfalls als Referenz dienen: Setting up VS Code for Unreal Engine.

3.2 Den VS-Code-Workspace erzeugen und öffnen

Nach dem Erstellen eines C++-Projekts enthält das Projektverzeichnis normalerweise .vscode/ und <ProjectName>.code-workspace. Fehlen sie, Folgendes ausführen:

"/[UE_ROOT]/GenerateProjectFiles.sh" \
  -vscode \
  -project="/[UE_PROJECTS_DIR]/[PROJECT_NAME]/[PROJECT_NAME].uproject" \
  -game \
  -engine

In VS Code File → Open Workspace from File... wählen und <ProjectName>.code-workspace öffnen. Nicht nur eine einzelne .cpp-Datei öffnen.

Die erzeugte .code-workspace öffnen, um die Konfiguration des C++-Projekts von Unreal Engine zu laden

4. Ein C++-Projekt erstellen

4.1 Unreal Engine starten

Aus dem Terminal ausführen:

"/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor"

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor"

4.2 Einstellungen im Project Browser

Im Unreal Project Browser:

1. Games wählen;

2. Blank wählen;

3. Project Defaults auf C++ setzen;

4. Target Platform auf Desktop setzen;

5. Bei Quality Preset für einen ersten Test Scalable wählen, auf einer leistungsstarken Workstation Maximum;

6. Starter Content nach Bedarf wählen;

7. Den Projektpfad eingeben:

   /home/[USER]/Unreal/Projects
   

8. Den Projektnamen eingeben:

   [PROJECT_NAME]
   

9. Auf Create klicken.

Die Vorlage Blank in der Kategorie Games wählen und den Projekttyp auf C++ setzen

Projektpfad, Namen und Plattformoptionen festlegen und dann das C++-Projekt erstellen

Für Projektnamen und Pfad nur Folgendes verwenden:

• Lateinische Buchstaben;
• Ziffern;
• Unterstriche.

Keine chinesischen Zeichen, Leerzeichen, &, Klammern oder andere Sonderzeichen verwenden.

4.3 Vorkompilierte Version und Source-Build verhalten sich hier unterschiedlich

Fall A: Vorkompilierte Version (Installed Build)

Der übliche Ablauf ist:

Projekt erstellen → <ProjectName>Editor automatisch kompilieren → VS Code öffnen → den Editor des neuen Projekts öffnen

Das alte Fenster des Project Browser schließt sich kurz, weil Unreal Engine einen Editor-Prozess startet, der die neue .uproject lädt.

Fall B: Source-Build

Der übliche Ablauf ist:

Projekt erstellen → Source/, Makefile, .vscode/ erzeugen → Project Browser schließen → VS Code öffnen

Ein Source-Build von Unreal Engine baut und öffnet das neue Projekt möglicherweise nicht automatisch und erwartet stattdessen, dass der Entwickler es zuerst in der IDE oder im Terminal kompiliert. Das ist kein Konfigurationsfehler von VS Code und bedeutet nicht, dass das Erstellen des Projekts fehlgeschlagen ist.

An dieser Stelle enthält das Projekt normalerweise nur:

.vscode/
Config/
Content/
Intermediate/
Saved/
Source/
Makefile
[PROJECT_NAME].code-workspace
[PROJECT_NAME].uproject

Noch nicht vorhanden:

Binaries/Linux/

Das bedeutet, dass die Projektmodule nicht kompiliert sind.

5. Erster Build ohne das Plugin

Das leere Projekt einmal ohne installiertes LCC4Unreal kompilieren, um zu bestätigen, dass Unreal Engine, die Toolchain und das Projekt selbst funktionieren.

5.1 Mit VS Code kompilieren (empfohlen)

1. <ProjectName>.code-workspace wie in Abschnitt 3.2 beschrieben erzeugen und öffnen;
2. In der Seitenleiste von VS Code Run and Debug öffnen;
3. In der Konfigurationsliste oben <ProjectName>Editor (Development) wählen;
4. Auf die Startschaltfläche klicken, um den ersten Build auszuführen;
5. Warten, bis der Build abgeschlossen ist, und bestätigen, dass keine C++-Kompilierfehler auftreten. Ein langer erster Build ist normal.

Die Konfiguration <ProjectName>Editor (Development) wählen und den ersten C++-Build des Projekts abschließen

Nach einem erfolgreichen Build kann VS Code den Projekteditor direkt starten.

5.2 Optional: Das Makefile des Projekts verwenden

cd "/[UE_PROJECTS_DIR]/[PROJECT_NAME]"
make "[PROJECT_NAME]Editor"

Beispiel:
cd "/home/alice/Unreal/Projects/Test2"
make "Test2Editor"

Das Target <ProjectName>Editor über das Makefile des Projekts kompilieren

5.3 Das Projekt nach einem erfolgreichen Build öffnen

Grafischer Weg: <ProjectName>.uproject im Dateimanager suchen, mit der rechten Maustaste anklicken und Open With Unreal Engine Editor wählen. Dieser Weg gilt, wenn das System die Ziel-Unreal-Engine-Version bereits korrekt zuordnet.

Die .uproject-Datei des Projekts mit der rechten Maustaste anklicken und zum Öffnen mit dem Unreal Engine Editor auswählen

Weg über die Kommandozeile: die vollständigen Pfade von UnrealEditor und der .uproject angeben. Das ist der zuverlässigere Weg, ein Projekt zu öffnen, wenn mehrere Unreal-Engine-Versionen koexistieren:

"/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor" "/[UE_PROJECTS_DIR]/[PROJECT_NAME]/[PROJECT_NAME].uproject"

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor" "/home/alice/Unreal/Projects/Test2/Test2.uproject"

Sobald das Projekt im Editor geöffnet ist, den Editor schließen und mit der Installation des Plugins fortfahren.

Das Projekt mit der angegebenen Unreal-Engine-Version laden

Das leere C++-Projekt kompiliert erfolgreich und öffnet sich im Unreal-Engine-Editor

6. LCC4Unreal installieren

Die Linux-Version des Plugins steht derzeit nicht auf der Entwicklerplattform zum Download bereit und muss per E-Mail angefordert werden. Senden Sie eine Anfrage an sdk@xgrids.com mit folgender Vorlage:

• Firmenname:
• Verwendungszweck: Einsatzzweck des Plugins
• Engine-Version: benötigte Unreal Engine Version
• Wie Sie uns gefunden haben: wo Sie vom Plugin erfahren haben

6.1 Zugehörige Programme schließen

Vor dem Kopieren des Plugins:

1. Das Projekt speichern;
2. Den Unreal-Engine-Editor schließen;
3. Warten, bis der Hintergrundprozess UnrealEditor beendet ist;
4. VS Code kann geöffnet bleiben, aber das Projekt nicht gleichzeitig bauen.

Prüfen, ob UnrealEditor noch läuft:

pgrep -a UnrealEditor

Keine Ausgabe bedeutet, dass der Editor beendet ist.

6.2 Das vollständige Plugin in das Projekt kopieren

1. Im Projektwurzelverzeichnis ein Verzeichnis Plugins anlegen:

   mkdir -p "/[UE_PROJECTS_DIR]/[PROJECT_NAME]/Plugins"
   

   Beispiel:
   mkdir -p "/home/alice/Unreal/Projects/Test2/Plugins"
   

2. Das heruntergeladene Plugin-Paket entpacken und den vollständigen Ordner LCC4Unreal in das Projekt kopieren. Das endgültige Verzeichnis muss lauten:

   [PROJECT_ROOT]/Plugins/LCC4Unreal/
   

   Nicht nur Binaries, Content oder einzelne Dateien kopieren und kein doppelt verschachteltes Verzeichnis wie Plugins/LCC4Unreal/LCC4Unreal/ anlegen.

3. Bestätigen, dass die Beschreibungsdatei des Plugins existiert. Das Verzeichnis muss enthalten:

   [PROJECT_ROOT]/Plugins/LCC4Unreal/LCC4Unreal.uplugin
   

   Ändert sich der tatsächliche Name der .uplugin-Datei zwischen Release-Paketen, bestätigen, dass sie direkt unter Plugins/LCC4Unreal/ liegt und nicht eine Ebene tiefer.

Den vollständigen Ordner LCC4Unreal nach [PROJECT_ROOT]/Plugins/LCC4Unreal kopieren und die .uplugin-Datei prüfen

6.3 Das Projekt neu starten

"/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor" "/[UE_PROJECTS_DIR]/[PROJECT_NAME]/[PROJECT_NAME].uproject"

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor" "/home/alice/Unreal/Projects/Test2/Test2.uproject"

Dieser Befehl gibt sowohl an, welche Unreal Engine verwendet wird, als auch, welches Projekt geöffnet wird. Wenn mehrere Unreal-Engine-Versionen koexistieren, ist er zuverlässiger als ein Doppelklick auf die .uproject und erfordert nicht, eine Version als globalen Standard zu registrieren.

6.4 Was bei einer Aufforderung zum Rebuild zu tun ist

Die Aufforderung sieht so aus:

The following modules are missing or built with a different engine version.
Would you like to rebuild them now?

Sie bedeutet, dass die dynamischen Bibliotheken des Projekts nicht existieren oder nicht zur aktuellen Unreal-Engine-Version passen.

• Yes/Rebuild wählen, wenn der vollständige Pfad des Unreal-Engine-Wurzelverzeichnisses im Befehl bestätigt korrekt ist;
• Ein schneller Abschluss und ein regulär geöffneter Editor deuten auf einen inkrementellen Build der Projektmodule hin;
• Erscheint die Aufforderung jedes Mal, prüfen, ob jedes Mal eine andere Engine verwendet wird, ob Binaries/Linux beschreibbar ist und ob die Systemzeit korrekt ist;
• In einer Umgebung mit mehreren Engines die Aufforderung zuerst schließen und dann explizit mit dem Befehl Build.sh aus Abschnitt 13 bauen.

7. Den zum Datenformat passenden Actor wählen

Unterschiedliche Datenformate erfordern den passenden Actor:

Die folgenden Schritte verwenden .lcc2-Daten und LCC2Actor als Beispiel. Für andere Formate den passenden Actor aus der Tabelle verwenden.

7.1 LCC2Actor hinzufügen und Daten laden

1. Im Panel von LCC4Unreal auf LCC2Actor klicken, um ihn hinzuzufügen.

   

   LCC2Actor im Panel von LCC4Unreal hinzufügen, passend zum Datenformat .lcc2

2. LCC2Actor im World Outliner auswählen;

3. Actions im Details-Panel suchen;

4. Auf Load klicken;

5. Die .lcc2-Datendatei auswählen.

   

   Die .lcc2-Datendatei aus dem Details-Panel von LCC2Actor laden

6. Warten, bis die Daten fertig geladen sind.

   

   Die .lcc2-Daten erscheinen im Viewport von Unreal Engine, sobald das Laden abgeschlossen ist

Der Editor kann beim Laden großer Daten vorübergehend nicht reagieren. Arbeitsspeicher, Grafikspeicher und das Output Log beobachten statt ihn sofort zwangsweise zu schließen.

8. LCC-Daten als Non-Asset in die Paketierung aufnehmen

.lcc2, .lcc, .sog, .spz und .ply sind normalerweise keine .uasset-Dateien von Unreal Engine. Die Dateien nur in Content abzulegen nimmt sie nicht in das Installationspaket auf.

Empfohlenes Verzeichnis:

/[UE_PROJECTS_DIR]/[PROJECT_NAME]/Content/LCCData/

Öffnen:

Edit → Project Settings → Packaging

Suchen:

Additional Non-Asset Directories To Copy

Hinzufügen:

LCCData

Unter Packaging stehen zwei Einstellungen für Non-Asset-Verzeichnisse zur Verfügung:

Hinweis: wenn Additional Non-Asset Directories To Package verwendet wird um Daten in die pak-Datei zu packen, können Kollisionsdaten nicht korrekt geladen werden. Dies ist ein bekannter Fehler der aktuellen Version und wird im nächsten Release behoben. Bei Bedarf an Kollision Additional Non-Asset Directories To Copy verwenden.

Eingetragen wird ein Verzeichnisname der obersten Ebene unter Content (z. B. LCCData), kein Dateipfad. Das Präfix Content/ ist nicht nötig.

Content/LCCData als Non-Asset-Verzeichnis konfigurieren, das während der Paketierung kopiert wird

Anschließend sicherstellen, dass der vom LCC Actor oder LCC2Actor geladene relative Pfad zum paketierten Verzeichnis passt.

8.1 Die Startkarte festlegen

Öffnen:

Edit → Project Settings → Maps & Modes

Unter Default Maps die Game Default Map auf das Ziel-Level setzen, das den LCC Actor/LCC2Actor und den konfigurierten Datenpfad enthält. Anschließend das Level und die Projektkonfiguration speichern, damit die paketierte Anwendung nicht in einer leeren Karte startet.

Die beim Start der paketierten Anwendung genutzte Game Default Map unter Default Maps in Maps & Modes festlegen

9. Prüfliste vor der Paketierung

Vor der Paketierung jeden Punkt bestätigen:

• [ ] Die richtige Unreal-Engine-Version wird verwendet;
• [ ] Das Paket des LCC4Unreal-Plugins passt zur Unreal-Engine-Version und zur Linux-Architektur;
• [ ] <ProjectName>Editor Linux Development kompiliert erfolgreich;
• [ ] Das Plugin ist aktiviert;
• [ ] Die Pro-Lizenz ist gültig (nur nötig, wenn Funktionen der Pro Edition verwendet werden, siehe Editionen und Lizenzierung);
• [ ] Die LCC-Daten sind im Play des Editors sichtbar;
• [ ] Game Default Map ist gesetzt;
• [ ] Die zu paketierenden Daten sind zu Additional Non-Asset Directories To Copy hinzugefügt;
• [ ] Der Datenträger hat genügend freien Platz;
• [ ] Das Ausgabeverzeichnis ist beschreibbar;
• [ ] Alle Levels und Assets sind gespeichert;
• [ ] Zuerst ein Development-Paket bauen und Shipping erst nach dessen Erfolg versuchen.

10. Mit Project Launcher für Linux paketieren

10.1 Project Launcher öffnen

Im Unreal-Engine-Editor wählen:

Platforms → Project Launcher

Project Launcher über das Menü Platforms öffnen

Klicken:

Add → Create Custom Profile

Das Linux-Paketierungsprofil über Add → Create Custom Profile erstellen

10.2 Das Profil konfigurieren

1. Im eigenen Profil Linux als Zielplattform wählen und das Schema der Inhaltspaketierung auf Pak-Datei setzen;

2. Die Archivierung des Build-Ergebnisses aktivieren und ein beschreibbares Archivverzeichnis wählen. In diesem Verzeichnis wird die verteilbare Version nach der Paketierung tatsächlich gespeichert.

   

   Die Zielplattform auf Linux setzen, Pak-Datei wählen, Archivierung aktivieren und das Ausgabeverzeichnis der Paketierung angeben

3. Auf das Startsymbol rechts neben dem eigenen Profil klicken.

Die Paketierung umfasst normalerweise:

Build → Cook → Stage → Package → Archive

Der erste Paketierungslauf ist langsamer als ein inkrementeller. Ihn nicht zwangsweise abbrechen, weil er kurz auf einem Prozentwert stehen bleibt. Bei Erfolg erscheint eine Ausgabe ähnlich der folgenden:

BUILD SUCCESSFUL

10.3 Wenn dauerhaft „Querying“ angezeigt wird

Folgendes in dieser Reihenfolge prüfen:

1. Warten, bis Unreal Engine die Erkennung von Plattform und SDK abgeschlossen hat;
2. Window → Developer Tools → Output Log öffnen;
3. Nach Turnkey, SDK, Linux, Error suchen;
4. Bestätigen, dass der aktuelle Host Linux ist und die Zielplattform ebenfalls Linux;
5. Bestätigen, dass die Abhängigkeiten und die Toolchain eines Source-Builds von Unreal Engine per Setup.sh installiert wurden;
6. Bestätigen, dass SetupToolchain.sh für die vorkompilierte Version ausgeführt wurde;
7. Doppelte Fenster von Project Launcher schließen und ihn erneut öffnen;
8. Dasselbe Projekt nicht gleichzeitig in einem anderen Terminal bauen.

11. Über die Kommandozeile paketieren (optional)

Sobald die grafische Paketierung stabil ist, kann RunUAT verwendet werden:

mkdir -p "/[UE_PROJECTS_DIR]/[PROJECT_NAME]/Packaged"

"/[UE_ROOT]/Engine/Build/BatchFiles/RunUAT.sh" BuildCookRun \
  -project="/[UE_PROJECTS_DIR]/[PROJECT_NAME]/[PROJECT_NAME].uproject" \
  -noP4 \
  -targetplatform=Linux \
  -clientconfig=Development \
  -build \
  -cook \
  -stage \
  -pak \
  -archive \
  -archivedirectory="/[UE_PROJECTS_DIR]/[PROJECT_NAME]/Packaged"

Beispiel:
mkdir -p "/home/alice/Unreal/Projects/Test2/Packaged"

"/home/alice/Unreal/Engines/UnrealEngine/Engine/Build/BatchFiles/RunUAT.sh" BuildCookRun \
  -project="/home/alice/Unreal/Projects/Test2/Test2.uproject" \
  -noP4 \
  -targetplatform=Linux \
  -clientconfig=Development \
  -build \
  -cook \
  -stage \
  -pak \
  -archive \
  -archivedirectory="/home/alice/Unreal/Projects/Test2/Packaged"

Mit -archive und -archivedirectory die endgültige ausführbare Version im angegebenen Archivverzeichnis suchen statt anzunehmen, dass sie in Saved/StagedBuilds/Linux liegt.

Verwendet das Projekt bestimmte Karten, Kartenbeschränkungen gemäß den Projekteinstellungen und den Befehlsparametern der aktuellen Unreal Engine ergänzen. Einsteiger sollten zuerst Project Launcher verwenden, um unvollständige Pakete durch fehlende Befehlsparameter zu vermeiden.

12. Das Paketierungsergebnis ausführen

12.1 Das archivierte Ergebnis ausführen

Wenn die Archivierung in Project Launcher aktiviert wurde oder RunUAT mit -archive -archivedirectory="..." gelaufen ist, in das tatsächlich konfigurierte Archivverzeichnis wechseln. Unterschiedliche Unreal-Engine-Versionen können dort ein zusätzliches Unterverzeichnis Linux anlegen, daher zuerst das Startskript des Projekts finden und es dann ausführen:

cd "/[ARCHIVE_DIR]"
find . -maxdepth 3 -type f -name "*.sh" -print

chmod +x "./[SUBDIR]/[PROJECT_NAME].sh"
"./[SUBDIR]/[PROJECT_NAME].sh"

Beispiel (archiviertes Ergebnis in Packaged/Linux):
cd "/home/alice/Unreal/Projects/Test2/Packaged"
find . -maxdepth 3 -type f -name "*.sh" -print
chmod +x "./Linux/Test2.sh"
"./Linux/Test2.sh"

In das in Project Launcher oder RunUAT konfigurierte Archivverzeichnis wechseln und das Projektskript starten

12.2 Die nicht archivierte Staging-Ausgabe ausführen

Nur dann aus folgendem Verzeichnis ausführen, wenn keine Archivierung erfolgt ist und das Staging-Ergebnis direkt geprüft werden soll:

cd "/[UE_PROJECTS_DIR]/[PROJECT_NAME]/Saved/StagedBuilds/Linux"
chmod +x "./[PROJECT_NAME].sh"
"./[PROJECT_NAME].sh"

Beispiel:
cd "/home/alice/Unreal/Projects/Test2/Saved/StagedBuilds/Linux"
chmod +x "./Test2.sh"
"./Test2.sh"

Nach dem Ausführen prüfen:

• Es startet;
• Die Standardkarte ist korrekt;
• Die LCC-Daten sind sichtbar;
• Nach dem Schließen der Anwendung bleiben keine Prozesse zurück.

Die paketierte Linux-Anwendung starten und Standardkarte, LCC-Daten und lizenzpflichtige Funktionen prüfen

13. Befehlsreferenz

[UE_ROOT], [UE_PROJECTS_DIR], [PROJECT_NAME] und [ARCHIVE_DIR] in den folgenden Befehlen sind Platzhalter. Sie vor dem Ausführen durch die tatsächlichen vollständigen Pfade und Namen ersetzen.

Den Project Browser starten:

"/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor"

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor"

Projektdateien für VS Code erzeugen:

"/[UE_ROOT]/GenerateProjectFiles.sh" \
  -vscode \
  -project="/[UE_PROJECTS_DIR]/[PROJECT_NAME]/[PROJECT_NAME].uproject" \
  -game \
  -engine

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/GenerateProjectFiles.sh" \
  -vscode \
  -project="/home/alice/Unreal/Projects/Test2/Test2.uproject" \
  -game \
  -engine

Das Editor-Target des Projekts kompilieren:

"/[UE_ROOT]/Engine/Build/BatchFiles/Linux/Build.sh" \
  "[PROJECT_NAME]Editor" Linux Development \
  -Project="/[UE_PROJECTS_DIR]/[PROJECT_NAME]/[PROJECT_NAME].uproject" \
  -WaitMutex

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/Engine/Build/BatchFiles/Linux/Build.sh" \
  "Test2Editor" Linux Development \
  -Project="/home/alice/Unreal/Projects/Test2/Test2.uproject" \
  -WaitMutex

Ein bestimmtes Projekt mit einer bestimmten Unreal Engine öffnen:

"/[UE_ROOT]/Engine/Binaries/Linux/UnrealEditor" "/[UE_PROJECTS_DIR]/[PROJECT_NAME]/[PROJECT_NAME].uproject"

Beispiel:
"/home/alice/Unreal/Engines/UnrealEngine/Engine/Binaries/Linux/UnrealEditor" "/home/alice/Unreal/Projects/Test2/Test2.uproject"

Das archivierte Ergebnis ausführen:

cd "/[ARCHIVE_DIR]"
find . -maxdepth 3 -type f -name "*.sh" -print
chmod +x "./[SUBDIR]/[PROJECT_NAME].sh"
"./[SUBDIR]/[PROJECT_NAME].sh"

Die nicht archivierte Staging-Ausgabe ausführen:

cd "/[UE_PROJECTS_DIR]/[PROJECT_NAME]/Saved/StagedBuilds/Linux"
chmod +x "./[PROJECT_NAME].sh"
"./[PROJECT_NAME].sh"

Beispiel (nicht archivierte Staging-Ausgabe):
cd "/home/alice/Unreal/Projects/Test2/Saved/StagedBuilds/Linux"
chmod +x "./Test2.sh"
"./Test2.sh"