Rendre une scène 3DGS sous Linux

Ce document part de l'installation d'Unreal Engine et explique comment installer LCC4Unreal, créer un projet C++, charger des données LCC, compiler, exécuter et packager une application Linux.

1. Environnement matériel et logiciel recommandé

2. Choisir une méthode d'installation d'Unreal Engine

Deux méthodes d'installation d'Unreal Engine sont disponibles sous Linux :

Privilégiez la version précompilée si seul LCC4Unreal est nécessaire et si les sources d'Unreal Engine n'ont pas à être modifiées.

Note : LCC4Unreal est distribué sous forme précompilée et correspond aux binaires officiels du moteur. Ne modifiez pas les sources du moteur : un moteur modifié peut être incompatible avec le plugin et provoquer des échecs de chargement ou un comportement anormal.

2.1 Méthode A : installer la version précompilée d'Unreal Engine pour Linux (recommandé)

1. Ouvrez la page officielle Epic Unreal Engine for Linux ;

2. Connectez-vous avec un compte Epic Games ;

3. Téléchargez l'archive .zip de la version d'Unreal Engine souhaitée.

   

   Sélectionnez et téléchargez le paquet précompilé d'Unreal Engine pour Linux depuis la page officielle Epic Games

4. Créez un répertoire pour le moteur dans le gestionnaire de fichiers, par exemple :

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

5. Extrayez tous les fichiers et répertoires de l'archive dans ce répertoire racine du moteur. Ne copiez pas uniquement le fichier UnrealEditor, sinon il manquera au moteur le reste du contenu nécessaire à son exécution et à la compilation ;

6. Ouvrez le répertoire racine du moteur dans le gestionnaire de fichiers, faites un clic droit dans une zone vide et sélectionnez Open in Terminal. Les commandes suivantes doivent être exécutées dans le bon répertoire du moteur.

   

   Placez-vous dans le répertoire racine d'Unreal Engine entièrement extrait et ouvrez un terminal depuis cet emplacement

7. Lancez l'éditeur Unreal Engine.

Forme générale :

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

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

Si un défaut de permission d'exécution est signalé :

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

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

2.1.1 Préparer la chaîne d'outils pour le développement C++

En suivant le démarrage rapide du développement Linux d'Epic Games, exécutez ceci dans le répertoire d'Unreal Engine :

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

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

2.2 Méthode B : compiler Unreal Engine depuis les sources

Passez directement à la section 4 si une version d'Unreal Engine compilée depuis les sources fonctionne déjà.

2.2.1 Obtenir les sources

Récupérez-les sur GitHub : https://github.com/EpicGames/UnrealEngine

Rendez-vous sur le dépôt GitHub Unreal Engine d'Epic Games et récupérez les sources de la version souhaitée

2.2.2 Télécharger les dépendances et la chaîne d'outils native

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

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

Utilisez Setup.sh pour télécharger les dépendances nécessaires à une compilation depuis les sources ainsi que la chaîne d'outils Linux native

Critères de réussite :

• La commande se termine normalement ;
• Aucun message fatal et aucun échec de téléchargement non traité ;
• La chaîne d'outils Unreal Engine correspondante existe dans Engine/Extras/ThirdPartyNotUE/SDKs/HostLinux.

Si ceci apparaît :

fatal: not a git repository

c'est que l'origine des sources, le répertoire courant ou les métadonnées Git posent problème. Ne l'ignorez pas pour poursuivre la compilation. Vérifiez d'abord que le terminal courant se trouve dans le bon répertoire racine d'Unreal Engine.

2.2.3 Générer les fichiers de projet

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

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

Générez les fichiers de projet et le Makefile Linux pour les sources d'Unreal Engine

2.2.4 Compiler UnrealEditor

Limitez le nombre de tâches parallèles lors de la première compilation pour éviter de saturer la mémoire. make -j4 UnrealEditor convient par défaut ; avec seulement 32 GB de mémoire, utilisez plutôt make -j2 UnrealEditor ; si le Makefile du moteur ne fournit pas de cible séparée, utilisez make -j4 :

cd "/[UE_ROOT]"
make -j4 UnrealEditor

# Use this with only 32 GB of memory:
make -j2 UnrealEditor

# Use this when the Makefile provides no separate target:
make -j4

Limitez le nombre de tâches parallèles et compilez la version source d'UnrealEditor

Des centaines voire des milliers d'actions lors de la première compilation depuis les sources sont normales. Elles concernent le moteur lui-même, pas les fichiers sources du projet vierge. La durée de compilation dépend du CPU, de la mémoire et du disque.

Vérifiez la réussite :

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

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

Lancez le navigateur de projets :

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

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

Lancez l'Unreal Project Browser une fois la version source d'UnrealEditor compilée

3. Installer et configurer VS Code

3.1 Installer VS Code et les outils de développement C++

Sous Ubuntu, téléchargez et installez depuis le site officiel Visual Studio Code, ou utilisez la méthode de paquet prise en charge par la distribution.

Avant de compiler des projets C++ avec VS Code, terminez l'installation de la chaîne d'outils Linux d'Unreal Engine décrite en section 2 et préparez les outils de base de compilation et de débogage C++. Installez les outils courants tels que build-essential, clang, lldb et cmake selon la version d'Ubuntu et l'environnement de l'équipe ; la version réelle du compilateur suit les exigences de la version d'Unreal Engine utilisée et de la chaîne d'outils installée par SetupToolchain.sh/Setup.sh.

Les extensions VS Code suivantes sont recommandées :

• C/C++ : navigation dans le code, complétion et débogage ;
• C/C++ Extension Pack : capacités supplémentaires courantes pour le développement C++ ;
• CodeLLDB : débogage LLDB sous Linux ;
• Makefile Tools : consulter et exécuter les cibles du Makefile (facultatif).

La documentation officielle d'Epic Games peut aussi servir de référence : Setting up VS Code for Unreal Engine.

3.2 Générer et ouvrir l'espace de travail VS Code

Après la création d'un projet C++, le répertoire du projet contient normalement .vscode/ et <ProjectName>.code-workspace. S'ils sont absents, exécutez :

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

Dans VS Code, sélectionnez File → Open Workspace from File... et ouvrez <ProjectName>.code-workspace. N'ouvrez pas seulement un fichier .cpp isolé.

Ouvrez le fichier .code-workspace généré pour charger la configuration du projet C++ Unreal Engine

4. Créer un projet C++

4.1 Lancer Unreal Engine

Exécutez depuis le terminal :

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

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

4.2 Réglages du navigateur de projets

Dans l'Unreal Project Browser :

1. Sélectionnez Games ;

2. Sélectionnez Blank ;

3. Réglez Project Defaults sur C++ ;

4. Réglez Target Platform sur Desktop ;

5. Pour Quality Preset, sélectionnez Scalable pour un premier test, ou Maximum sur une station de travail performante ;

6. Sélectionnez Starter Content selon vos besoins ;

7. Saisissez l'emplacement du projet :

   /home/[USER]/Unreal/Projects
   

8. Saisissez le nom du projet :

   [PROJECT_NAME]
   

9. Cliquez sur Create.

Sélectionnez le modèle Blank dans la catégorie Games et réglez le type de projet sur C++

Définissez l'emplacement, le nom et les options de plateforme du projet, puis créez le projet C++

Pour le nom et le chemin du projet, n'utilisez que :

• des lettres anglaises ;
• des chiffres ;
• des tirets bas.

N'utilisez pas de caractères chinois, d'espaces, de &, de crochets ni d'autres caractères spéciaux.

4.3 Les versions précompilées et sources se comportent différemment ici

Cas A : version précompilée (Installed Build)

Le déroulement habituel est :

create project → auto-compile <ProjectName>Editor → open VS Code → open the new project editor

L'ancienne fenêtre du navigateur de projets se ferme brièvement, car Unreal Engine démarre un processus d'éditeur qui charge le nouveau .uproject.

Cas B : version compilée depuis les sources

Le déroulement habituel est :

create project → generate Source/, Makefile, .vscode/ → close project browser → open VS Code

Une version d'Unreal Engine compilée depuis les sources peut ne pas compiler et ouvrir automatiquement le nouveau projet, et attendre à la place que le développeur le compile d'abord dans l'IDE ou dans le terminal. Ce n'est pas une erreur de configuration de VS Code et cela ne signifie pas que la création du projet a échoué.

À ce stade, le projet ne contient normalement que :

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

Pas encore présent :

Binaries/Linux/

Cela signifie que les modules du projet n'ont pas été compilés.

5. Première compilation sans le plugin

Compilez une fois le projet vierge sans LCC4Unreal installé, afin de confirmer que Unreal Engine, la chaîne d'outils et le projet lui-même fonctionnent.

5.1 Compiler avec VS Code (recommandé)

1. Générez et ouvrez <ProjectName>.code-workspace comme décrit en section 3.2 ;
2. Ouvrez Run and Debug dans la barre latérale de VS Code ;
3. Sélectionnez <ProjectName>Editor (Development) dans la liste de configurations en haut ;
4. Cliquez sur le bouton de lancement pour exécuter la première compilation ;
5. Attendez la fin de la compilation et vérifiez l'absence d'erreurs de compilation C++. Une première compilation longue est normale.

Sélectionnez la configuration <ProjectName>Editor (Development) et effectuez la première compilation C++ du projet

Après une compilation réussie, VS Code peut lancer directement l'éditeur du projet.

5.2 Facultatif : utiliser le Makefile du projet

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

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

Compilez la cible <ProjectName>Editor via le Makefile du projet

5.3 Ouvrir le projet après une compilation réussie

Méthode graphique : localisez <ProjectName>.uproject dans le gestionnaire de fichiers, faites un clic droit et sélectionnez Open With Unreal Engine Editor. Cette méthode s'applique quand le système associe déjà correctement la version d'Unreal Engine visée.

Faites un clic droit sur le fichier .uproject du projet et choisissez de l'ouvrir avec Unreal Engine Editor

Méthode en ligne de commande : indiquez les chemins complets d'UnrealEditor et du .uproject. C'est la façon la plus fiable d'ouvrir un projet quand plusieurs versions d'Unreal Engine coexistent :

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

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

Une fois le projet ouvert dans l'éditeur, fermez l'éditeur et poursuivez avec l'installation du plugin.

Chargez le projet avec la version d'Unreal Engine indiquée

Le projet C++ vierge compile correctement et s'ouvre dans l'éditeur Unreal Engine

6. Installer LCC4Unreal

La version Linux du plugin n'est pas encore téléchargeable sur la plateforme développeur et doit être demandée par e-mail. Envoyez une demande à sdk@xgrids.com avec le modèle suivant :

• Nom de l'entreprise :
• Cas d'usage : usage prévu du plugin
• Version du moteur : quelle version d'Unreal Engine est nécessaire
• Comment vous nous avez trouvés : où vous avez découvert le plugin

6.1 Fermer les programmes concernés

Avant de copier le plugin :

1. Enregistrez le projet ;
2. Fermez l'éditeur Unreal Engine ;
3. Attendez la fin du processus UnrealEditor en arrière-plan ;
4. VS Code peut rester ouvert, mais ne compilez pas le projet en même temps.

Vérifiez si UnrealEditor tourne encore :

pgrep -a UnrealEditor

Aucune sortie signifie que l'éditeur s'est bien arrêté.

6.2 Copier le plugin complet dans le projet

1. Créez un répertoire Plugins à la racine du projet :

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

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

2. Extrayez le paquet du plugin téléchargé et copiez le dossier LCC4Unreal complet dans le projet. Le répertoire final doit être :

   [PROJECT_ROOT]/Plugins/LCC4Unreal/
   

   Ne copiez pas seulement Binaries, Content ou des fichiers isolés, et ne créez pas de répertoire imbriqué en double comme Plugins/LCC4Unreal/LCC4Unreal/.

3. Vérifiez la présence du fichier descripteur du plugin. Le répertoire doit contenir :

   [PROJECT_ROOT]/Plugins/LCC4Unreal/LCC4Unreal.uplugin
   

   Si le nom réel du fichier .uplugin change d'un paquet à l'autre, vérifiez qu'il se trouve directement sous Plugins/LCC4Unreal/ et non un niveau plus bas.

Copiez le dossier LCC4Unreal complet vers [PROJECT_ROOT]/Plugins/LCC4Unreal et vérifiez le fichier .uplugin

6.3 Redémarrer le projet

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

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

Cette commande indique à la fois quel Unreal Engine utiliser et quel projet ouvrir. Quand plusieurs versions d'Unreal Engine coexistent, elle est plus fiable qu'un double-clic sur le .uproject et n'oblige pas à enregistrer une version comme valeur par défaut globale.

6.4 Que faire quand une invite de recompilation apparaît

L'invite ressemble à ceci :

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

Cela signifie que les bibliothèques dynamiques du projet n'existent pas ou ne correspondent pas à la version d'Unreal Engine utilisée.

• Sélectionnez Yes/Rebuild si le chemin racine complet d'Unreal Engine indiqué dans la commande est bien correct ;
• Une fin rapide suivie d'une ouverture normale de l'éditeur indique une compilation incrémentale des modules du projet ;
• Si l'invite apparaît à chaque fois, vérifiez si un moteur différent est utilisé à chaque lancement, si Binaries/Linux est accessible en écriture et si l'heure système est correcte ;
• Dans un environnement multi-moteurs, écartez d'abord l'invite puis compilez explicitement avec la commande Build.sh de la section 13.

7. Choisir l'Actor adapté au format de données

Chaque format de données nécessite l'Actor correspondant :

Les étapes ci-dessous prennent comme exemple des données .lcc2 et LCC2Actor. Pour les autres formats, utilisez l'Actor correspondant du tableau.

7.1 Ajouter LCC2Actor et charger les données

1. Cliquez pour ajouter LCC2Actor dans le panneau LCC4Unreal.

   

   Ajoutez LCC2Actor dans le panneau LCC4Unreal pour correspondre au format de données .lcc2

2. Sélectionnez LCC2Actor dans le World Outliner ;

3. Repérez Actions dans le panneau Details ;

4. Cliquez sur Load ;

5. Sélectionnez le fichier de données .lcc2.

   

   Chargez le fichier de données .lcc2 depuis le panneau Details de LCC2Actor

6. Attendez la fin du chargement des données.

   

   Les données .lcc2 apparaissent dans le viewport Unreal Engine dès la fin du chargement

L'éditeur peut devenir momentanément insensible pendant le chargement de données volumineuses. Surveillez la mémoire, la mémoire vidéo et l'Output Log plutôt que de le forcer à quitter immédiatement.

8. Inclure les données LCC non-asset dans le packaging

Les fichiers .lcc2, .lcc, .sog, .spz et .ply ne sont normalement pas des fichiers .uasset d'Unreal Engine. Les placer dans Content ne suffit pas à les inclure dans le paquet d'installation.

Répertoire recommandé :

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

Ouvrez :

Edit → Project Settings → Packaging

Repérez :

Additional Non-Asset Directories To Copy

Ajoutez :

LCCData

Deux réglages de répertoires non-asset sont disponibles sous Packaging :

Note : les deux options prennent en charge l'ensemble des fonctionnalités. Dans les versions antérieures, les modèles PLY et les données de collision ne se chargeaient pas lorsqu'ils étaient intégrés au fichier pak via Additional Non-Asset Directories To Package ; ce problème est corrigé.

La valeur à saisir est un nom de répertoire de premier niveau sous Content (par exemple LCCData), pas un chemin de fichier. N'ajoutez pas le préfixe Content/ ni de nom de fichier précis.

Configurez Content/LCCData comme répertoire non-asset copié lors du packaging

Assurez-vous ensuite que le chemin relatif chargé par le LCC Actor ou le LCC2Actor correspond au répertoire packagé.

8.1 Définir la map de démarrage

Ouvrez :

Edit → Project Settings → Maps & Modes

Sous Default Maps, réglez Game Default Map sur le niveau cible qui contient le LCC Actor/LCC2Actor et le chemin de données configuré. Enregistrez ensuite le niveau et la configuration du projet, afin que l'application packagée ne démarre pas sur une map vide.

Définissez la Game Default Map utilisée au démarrage de l'application packagée, sous Default Maps dans Maps & Modes

9. Liste de vérification avant packaging

Vérifiez chaque point avant de packager :

• [ ] La bonne version d'Unreal Engine est utilisée ;
• [ ] Le paquet du plugin LCC4Unreal correspond à la version d'Unreal Engine et à l'architecture Linux ;
• [ ] <ProjectName>Editor Linux Development compile correctement ;
• [ ] Le plugin est activé ;
• [ ] La licence Pro est valide (nécessaire uniquement si des fonctionnalités de l'édition Pro sont utilisées, voir Éditions et licences) ;
• [ ] Les données LCC sont visibles en mode Play dans l'éditeur ;
• [ ] Game Default Map est défini ;
• [ ] Les données à packager sont ajoutées dans Additional Non-Asset Directories To Copy ;
• [ ] Le disque dispose d'assez d'espace ;
• [ ] Le répertoire de sortie est accessible en écriture ;
• [ ] Tous les niveaux et assets sont enregistrés ;
• [ ] Générez d'abord un paquet Development, puis essayez Shipping une fois qu'il réussit.

10. Packager pour Linux avec Project Launcher

10.1 Ouvrir Project Launcher

Dans l'éditeur Unreal Engine, sélectionnez :

Platforms → Project Launcher

Ouvrez Project Launcher depuis le menu Platforms

Cliquez sur :

Add → Create Custom Profile

Créez le profil de packaging Linux via Add → Create Custom Profile

10.2 Configurer le profil

1. Dans le profil personnalisé, sélectionnez Linux comme plateforme cible et réglez le mode de packaging du contenu sur fichier Pak ;

2. Activez l'archivage du résultat de build et sélectionnez un répertoire d'archive accessible en écriture. C'est dans ce répertoire que la version distribuable est réellement enregistrée après le packaging.

   

   Réglez la plateforme cible sur Linux, sélectionnez le fichier Pak, activez l'archivage et indiquez le répertoire de sortie du packaging

3. Cliquez sur l'icône de lancement à droite du profil personnalisé.

Le packaging comprend normalement :

Build → Cook → Stage → Package → Archive

La première exécution du packaging est plus lente qu'une exécution incrémentale. Ne l'interrompez pas brutalement parce qu'elle reste un moment sur le même pourcentage. En cas de réussite, une sortie de ce type apparaît :

BUILD SUCCESSFUL

10.3 Si l'état reste bloqué sur « Querying »

Vérifiez les points suivants dans l'ordre :

1. Attendez que Unreal Engine termine la détection des plateformes et des SDK ;
2. Ouvrez Window → Developer Tools → Output Log ;
3. Recherchez Turnkey, SDK, Linux, Error ;
4. Vérifiez que la machine hôte est bien Linux et que la plateforme cible est également Linux ;
5. Vérifiez que les dépendances et la chaîne d'outils d'une version d'Unreal Engine compilée depuis les sources ont bien été installées par Setup.sh ;
6. Vérifiez que SetupToolchain.sh a été exécuté pour la version précompilée ;
7. Fermez les fenêtres Project Launcher en double et rouvrez-le ;
8. Ne compilez pas le même projet dans un autre terminal en parallèle.

11. Packager en ligne de commande (facultatif)

Une fois le packaging graphique stabilisé, RunUAT peut être utilisé :

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"

Exemple :
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"

Avec -archive et -archivedirectory, cherchez la version exécutable finale dans le répertoire d'archive indiqué, plutôt que de supposer qu'elle se trouve dans Saved/StagedBuilds/Linux.

Si le projet utilise des maps spécifiques, ajoutez les restrictions de map selon les paramètres du projet et les paramètres de commande de la version d'Unreal Engine utilisée. Les débutants devraient d'abord utiliser Project Launcher, pour éviter des paquets incomplets dus à des paramètres de commande manquants.

12. Exécuter le résultat du packaging

12.1 Exécuter le résultat archivé

Si l'archivage a été activé dans Project Launcher, ou si RunUAT a utilisé -archive -archivedirectory="...", rendez-vous dans le répertoire d'archive réellement configuré. Selon la version d'Unreal Engine, un sous-répertoire Linux supplémentaire peut y être créé ; localisez donc d'abord le script de lancement du projet, puis exécutez-le :

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

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

Exemple (résultat archivé dans 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"

Entrez dans le répertoire d'archive configuré dans Project Launcher ou RunUAT et lancez le script du projet

12.2 Exécuter la sortie staged non archivée

N'exécutez depuis le répertoire suivant que si aucun archivage n'a été effectué et que le résultat staged doit être vérifié directement :

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

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

À vérifier après l'exécution :

• L'application démarre ;
• La map par défaut est la bonne ;
• Les données LCC sont visibles ;
• Aucun processus résiduel ne subsiste après la fermeture de l'application.

Lancez l'application Linux packagée et vérifiez la map par défaut, les données LCC et les fonctionnalités sous licence

13. Référence des commandes

[UE_ROOT], [UE_PROJECTS_DIR], [PROJECT_NAME] et [ARCHIVE_DIR] dans les commandes ci-dessous sont des espaces réservés. Remplacez-les par les chemins complets et les noms réels avant l'exécution.

Lancer le navigateur de projets :

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

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

Générer les fichiers de projet VS Code :

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

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

Compiler la cible Editor du projet :

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

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

Ouvrir un projet précis avec un Unreal Engine précis :

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

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

Exécuter le résultat archivé :

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

Exécuter la sortie staged non archivée :

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

Exemple (sortie staged non archivée) :
cd "/home/alice/Unreal/Projects/Test2/Saved/StagedBuilds/Linux"
chmod +x "./Test2.sh"
"./Test2.sh"