Renderizzare una scena 3DGS su Linux

Questo documento parte dall'installazione di Unreal Engine e descrive come installare LCC4Unreal, creare un progetto C++, caricare dati LCC, compilare, eseguire ed effettuare il packaging di un'applicazione Linux.

1. Ambiente hardware e software consigliato

2. Scegliere un metodo di installazione di Unreal Engine

Su Linux sono disponibili due metodi di installazione di Unreal Engine:

Preferire la versione precompilata quando serve solo LCC4Unreal e non è necessario modificare il codice sorgente di Unreal Engine.

Nota: LCC4Unreal viene distribuito in forma precompilata e corrisponde ai binari ufficiali del motore. Non modificare il codice sorgente del motore, perché un motore modificato può risultare incompatibile con il plugin e causare errori di caricamento o comportamenti anomali.

2.1 Metodo A: installare la versione precompilata di Unreal Engine per Linux (consigliato)

1. Aprire la pagina ufficiale Epic Unreal Engine for Linux;

2. Accedere con un account Epic Games;

3. Scaricare l'archivio .zip della versione di Unreal Engine richiesta.

   

   Selezionare e scaricare il pacchetto precompilato di Unreal Engine per Linux richiesto dalla pagina ufficiale di Epic Games

4. Creare una directory per il motore nel gestore file, per esempio:

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

5. Estrarre tutti i file e le directory dell'archivio in quella directory radice del motore. Non copiare solo il singolo file UnrealEditor, altrimenti al motore mancano gli altri contenuti necessari all'esecuzione e alla compilazione;

6. Entrare nella directory radice del motore nel gestore file, fare clic con il tasto destro su un'area vuota e selezionare Open in Terminal. I comandi successivi devono essere eseguiti nella directory corretta del motore.

   

   Entrare nella directory radice di Unreal Engine completamente estratta e aprire un terminale da lì

7. Avviare l'editor di Unreal Engine.

Forma generale:

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

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

Se viene segnalata l'assenza del permesso di esecuzione:

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

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

2.1.1 Preparare la toolchain per lo sviluppo C++

Seguendo l'avvio rapido allo sviluppo su Linux di Epic Games, eseguire quanto segue nella directory di Unreal Engine:

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

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

2.2 Metodo B: compilare Unreal Engine da codice sorgente

Passare direttamente alla sezione 4 se una compilazione da codice sorgente di Unreal Engine è già funzionante.

2.2.1 Ottenere il codice sorgente

Ottenerlo da GitHub: https://github.com/EpicGames/UnrealEngine

Visitare il repository GitHub Unreal Engine di Epic Games e ottenere il codice sorgente della versione richiesta

2.2.2 Scaricare le dipendenze e la toolchain nativa

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

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

Usare Setup.sh per scaricare le dipendenze necessarie a una compilazione da codice sorgente e la toolchain Linux nativa

Criteri di successo:

• Il comando termina normalmente;
• Nessun messaggio fatal e nessun errore di download non gestito;
• La toolchain di Unreal Engine corrispondente è presente in Engine/Extras/ThirdPartyNotUE/SDKs/HostLinux.

Se compare quanto segue:

fatal: not a git repository

c'è un problema con l'origine del codice sorgente, con la directory corrente o con i metadati Git. Non ignorarlo e non proseguire con la compilazione. Verificare prima che il terminale corrente si trovi nella directory radice corretta di Unreal Engine.

2.2.3 Generare i file di progetto

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

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

Generare i file di progetto e il Makefile Linux per il codice sorgente di Unreal Engine

2.2.4 Compilare UnrealEditor

Limitare il numero di job paralleli alla prima compilazione per evitare di esaurire la memoria. make -j4 UnrealEditor va bene come impostazione predefinita; con soli 32 GB di memoria usare invece make -j2 UnrealEditor; se il Makefile del motore non fornisce un target separato, usare make -j4:

cd "/[UE_ROOT]"
make -j4 UnrealEditor

# Usare questo con soli 32 GB di memoria:
make -j2 UnrealEditor

# Usare questo quando il Makefile non fornisce un target separato:
make -j4

Limitare il numero di job paralleli e compilare la versione da codice sorgente di UnrealEditor

Centinaia o anche migliaia di azioni alla prima compilazione da codice sorgente sono normali. Appartengono al motore stesso, non ai file sorgente del progetto vuoto. Il tempo di compilazione dipende da CPU, memoria e disco.

Verificare se ha avuto successo:

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

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

Avviare il project browser:

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

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

Avviare l'Unreal Project Browser dopo la compilazione della versione da codice sorgente di UnrealEditor

3. Installare e configurare VS Code

3.1 Installare VS Code e gli strumenti di sviluppo C++

Su Ubuntu, scaricare e installare dal sito ufficiale Visual Studio Code, oppure usare il metodo di pacchettizzazione supportato dalla distribuzione.

Prima di compilare progetti C++ con VS Code, completare l'installazione della toolchain Linux di Unreal Engine descritta nella sezione 2 e predisporre gli strumenti di base per la compilazione e il debug C++. Installare strumenti comuni come build-essential, clang, lldb e cmake in base alla versione di Ubuntu e all'ambiente del team; la versione effettiva del compilatore segue i requisiti della versione corrente di Unreal Engine e della toolchain installata da SetupToolchain.sh/Setup.sh.

Sono consigliate le seguenti estensioni di VS Code:

• C/C++: esplorazione del codice, completamento e debug;
• C/C++ Extension Pack: ulteriori funzionalità comuni per lo sviluppo C++;
• CodeLLDB: debug con LLDB su Linux;
• Makefile Tools: visualizzazione ed esecuzione dei target del Makefile (opzionale).

Si può usare come riferimento anche la documentazione ufficiale di Epic Games: Setting up VS Code for Unreal Engine.

3.2 Generare e aprire il workspace di VS Code

Dopo la creazione di un progetto C++, la directory del progetto contiene normalmente .vscode/ e <ProjectName>.code-workspace. Se mancano, eseguire:

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

In VS Code, selezionare File → Open Workspace from File... e aprire <ProjectName>.code-workspace. Non aprire soltanto un singolo file .cpp.

Aprire il file .code-workspace generato per caricare la configurazione del progetto C++ di Unreal Engine

4. Creare un progetto C++

4.1 Avviare Unreal Engine

Eseguire dal terminale:

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

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

4.2 Impostazioni del Project Browser

Nell'Unreal Project Browser:

1. Selezionare Games;

2. Selezionare Blank;

3. Impostare Project Defaults su C++;

4. Impostare Target Platform su Desktop;

5. Per Quality Preset, selezionare Scalable per una prima prova, oppure Maximum su una workstation ad alte prestazioni;

6. Selezionare Starter Content secondo necessità;

7. Inserire la posizione del progetto:

   /home/[USER]/Unreal/Projects
   

8. Inserire il nome del progetto:

   [PROJECT_NAME]
   

9. Fare clic su Create.

Selezionare il template Blank nella categoria Games e impostare il tipo di progetto su C++

Impostare posizione, nome e opzioni di piattaforma del progetto, poi creare il progetto C++

Per il nome e il percorso del progetto, usare soltanto:

• Lettere dell'alfabeto inglese;
• Cifre;
• Trattini bassi.

Non usare caratteri cinesi, spazi, &, parentesi o altri caratteri speciali.

4.3 Qui versione precompilata e compilazione da codice sorgente si comportano in modo diverso

Caso A: versione precompilata (Installed Build)

Il flusso consueto è:

creazione del progetto → compilazione automatica di <ProjectName>Editor → apertura di VS Code → apertura dell'editor del nuovo progetto

La vecchia finestra del project browser si chiude brevemente, perché Unreal Engine avvia un processo dell'editor che carica il nuovo .uproject.

Caso B: compilazione da codice sorgente

Il flusso consueto è:

creazione del progetto → generazione di Source/, Makefile, .vscode/ → chiusura del project browser → apertura di VS Code

Una versione di Unreal Engine compilata da codice sorgente può non compilare e aprire automaticamente il nuovo progetto, aspettandosi invece che sia lo sviluppatore a compilarlo prima nell'IDE o nel terminale. Non è un errore di configurazione di VS Code e non significa che la creazione del progetto sia fallita.

A questo punto il progetto contiene normalmente solo:

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

Non ancora presente:

Binaries/Linux/

Significa che i moduli del progetto non sono stati compilati.

5. Prima compilazione senza il plugin

Compilare una volta il progetto vuoto senza LCC4Unreal installato per confermare che Unreal Engine, la toolchain e il progetto stesso funzionino.

5.1 Compilare con VS Code (consigliato)

1. Generare e aprire <ProjectName>.code-workspace come descritto nella sezione 3.2;
2. Aprire Run and Debug nella barra laterale di VS Code;
3. Selezionare <ProjectName>Editor (Development) nell'elenco delle configurazioni in alto;
4. Fare clic sul pulsante di avvio per eseguire la prima compilazione;
5. Attendere il termine della compilazione e verificare che non vi siano errori di compilazione C++. Una prima compilazione lunga è normale.

Selezionare la configurazione <ProjectName>Editor (Development) e completare la prima compilazione C++ del progetto

Dopo una compilazione riuscita, VS Code può avviare direttamente l'editor del progetto.

5.2 Opzionale: usare il Makefile del progetto

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

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

Compilare il target <ProjectName>Editor attraverso il Makefile del progetto

5.3 Aprire il progetto dopo una compilazione riuscita

Metodo grafico: individuare <ProjectName>.uproject nel gestore file, farvi clic con il tasto destro e selezionare Open With Unreal Engine Editor. Questo metodo si applica quando il sistema associa già correttamente la versione di Unreal Engine desiderata.

Fare clic con il tasto destro sul file .uproject del progetto e scegliere di aprirlo con Unreal Engine Editor

Metodo da riga di comando: specificare i percorsi completi sia di UnrealEditor sia del .uproject. È il modo più affidabile per aprire un progetto quando coesistono più versioni di Unreal Engine:

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

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

Una volta che il progetto si apre nell'editor, chiudere l'editor e proseguire con l'installazione del plugin.

Caricare il progetto con la versione di Unreal Engine specificata

Il progetto C++ vuoto viene compilato con successo e si apre nell'editor di Unreal Engine

6. Installare LCC4Unreal

La versione Linux del plugin non è attualmente disponibile per il download sulla piattaforma per sviluppatori e deve essere richiesta via e-mail. Inviare una richiesta a sdk@xgrids.com con il seguente modello:

• Nome dell'azienda:
• Utilizzo: scopo di utilizzo del plugin
• Versione del motore: quale versione di Unreal Engine è necessaria
• Come ci avete trovato: dove avete saputo del plugin

6.1 Chiudere i programmi correlati

Prima di copiare il plugin:

1. Salvare il progetto;
2. Chiudere l'editor di Unreal Engine;
3. Attendere l'uscita del processo in background UnrealEditor;
4. VS Code può restare aperto, ma non compilare il progetto nello stesso momento.

Verificare se UnrealEditor è ancora in esecuzione:

pgrep -a UnrealEditor

Nessun output significa che l'editor è uscito.

6.2 Copiare il plugin completo nel progetto

1. Creare una directory Plugins nella radice del progetto:

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

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

2. Estrarre il pacchetto del plugin scaricato e copiare la cartella LCC4Unreal completa nel progetto. La directory finale deve essere:

   [PROJECT_ROOT]/Plugins/LCC4Unreal/
   

   Non copiare solo Binaries, Content o singoli file, e non creare una directory annidata duplicata come Plugins/LCC4Unreal/LCC4Unreal/.

3. Verificare che il file descrittore del plugin esista. La directory deve contenere:

   [PROJECT_ROOT]/Plugins/LCC4Unreal/LCC4Unreal.uplugin
   

   Se il nome effettivo del file .uplugin cambia tra i pacchetti di rilascio, verificare che si trovi direttamente sotto Plugins/LCC4Unreal/ e non un livello più in basso.

Copiare la cartella LCC4Unreal completa in [PROJECT_ROOT]/Plugins/LCC4Unreal e controllare il file .uplugin

6.3 Riavviare il progetto

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

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

Questo comando specifica sia quale Unreal Engine usare sia quale progetto aprire. Quando coesistono più versioni di Unreal Engine, è più affidabile del doppio clic sul .uproject e non richiede di registrare una versione come predefinita globale.

6.4 Cosa fare quando compare la richiesta di ricompilazione

La richiesta si presenta così:

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

Significa che le librerie dinamiche del progetto non esistono o non corrispondono alla versione corrente di Unreal Engine.

• Selezionare Yes/Rebuild quando il percorso completo della radice di Unreal Engine nel comando è confermato corretto;
• Un completamento rapido e l'apertura normale dell'editor indicano una compilazione incrementale dei moduli del progetto;
• Se la richiesta compare ogni volta, verificare se venga usato un motore diverso ogni volta, se Binaries/Linux sia scrivibile e se l'ora di sistema sia corretta;
• In un ambiente con più motori, chiudere prima la richiesta e poi compilare esplicitamente con il comando Build.sh della sezione 13.

7. Scegliere l'Actor corretto per il formato dei dati

Formati di dati diversi richiedono l'Actor corrispondente:

I passi seguenti usano come esempio dati .lcc2 e LCC2Actor. Per gli altri formati, usare l'Actor corrispondente indicato nella tabella.

7.1 Aggiungere LCC2Actor e caricare i dati

1. Fare clic per aggiungere LCC2Actor nel pannello LCC4Unreal.

   

   Aggiungere LCC2Actor nel pannello LCC4Unreal per corrispondere al formato dei dati .lcc2

2. Selezionare LCC2Actor nel World Outliner;

3. Individuare Actions nel pannello Details;

4. Fare clic su Load;

5. Selezionare il file di dati .lcc2.

   

   Caricare il file di dati .lcc2 dal pannello Details di LCC2Actor

6. Attendere il completamento del caricamento dei dati.

   

   I dati .lcc2 compaiono nel viewport di Unreal Engine al termine del caricamento

L'editor può diventare temporaneamente non responsivo durante il caricamento di dati di grandi dimensioni. Tenere d'occhio memoria, memoria video e Output Log invece di forzarne subito la chiusura.

8. Includere nel packaging i dati LCC che non sono asset

.lcc2, .lcc, .sog, .spz e .ply normalmente non sono file .uasset di Unreal Engine. Collocare i file in Content non basta a includerli nel pacchetto di installazione.

Directory consigliata:

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

Aprire:

Edit → Project Settings → Packaging

Individuare:

Additional Non-Asset Directories To Copy

Aggiungere:

LCCData

In Packaging sono disponibili due impostazioni per le directory non-asset:

Nota: quando si usa Additional Non-Asset Directories To Package per includere i dati nel file pak, i dati di collisione non vengono caricati correttamente. Si tratta di un difetto noto nella versione corrente e sarà corretto nel prossimo rilascio. Usare Additional Non-Asset Directories To Copy quando serve la collisione.

Il valore da inserire è il nome di una directory di primo livello sotto Content (ad es. LCCData), non un percorso di file. Non aggiungere il prefisso Content/.

Configurare Content/LCCData come directory non-asset copiata durante il packaging

Assicurarsi poi che il percorso relativo caricato dall'LCC Actor o dall'LCC2Actor corrisponda alla directory inclusa nel pacchetto.

8.1 Impostare la mappa di avvio

Aprire:

Edit → Project Settings → Maps & Modes

In Default Maps, impostare Game Default Map sul livello di destinazione che contiene l'LCC Actor/LCC2Actor e il percorso dei dati configurato. Salvare poi il livello e la configurazione del progetto, così l'applicazione pacchettizzata non si avvia su una mappa vuota.

Impostare la Game Default Map usata all'avvio dell'applicazione pacchettizzata in Default Maps di Maps & Modes

9. Elenco di controllo prima del packaging

Verificare ogni voce prima del packaging:

• [ ] Viene usata la versione corretta di Unreal Engine;
• [ ] Il pacchetto del plugin LCC4Unreal corrisponde alla versione di Unreal Engine e all'architettura Linux;
• [ ] <ProjectName>Editor Linux Development viene compilato con successo;
• [ ] Il plugin è abilitato;
• [ ] La licenza Pro è valida (necessaria solo quando si usano funzionalità dell'edizione Pro, vedere Edizioni e licenze);
• [ ] I dati LCC sono visibili in Play nell'editor;
• [ ] Game Default Map è impostata;
• [ ] I dati da includere nel pacchetto sono aggiunti a Additional Non-Asset Directories To Copy;
• [ ] Il disco ha spazio sufficiente;
• [ ] La directory di output è scrivibile;
• [ ] Tutti i livelli e gli asset sono salvati;
• [ ] Creare prima un pacchetto Development, poi provare Shipping dopo il successo.

10. Effettuare il packaging per Linux con Project Launcher

10.1 Aprire Project Launcher

Nell'editor di Unreal Engine, selezionare:

Platforms → Project Launcher

Aprire Project Launcher dal menu Platforms

Fare clic su:

Add → Create Custom Profile

Creare il profilo di packaging per Linux con Add → Create Custom Profile

10.2 Configurare il profilo

1. Nel profilo personalizzato, selezionare Linux come piattaforma di destinazione e impostare lo schema di packaging dei contenuti su file Pak;

2. Abilitare l'archiviazione del risultato della compilazione e selezionare una directory di archivio scrivibile. In quella directory viene effettivamente salvata la versione distribuibile dopo il packaging.

   

   Impostare la piattaforma di destinazione su Linux, selezionare il file Pak, abilitare l'archiviazione e specificare la directory di output del packaging

3. Fare clic sull'icona di avvio a destra del profilo personalizzato.

Il packaging normalmente comprende:

Build → Cook → Stage → Package → Archive

La prima esecuzione del packaging è più lenta di una incrementale. Non interromperla forzatamente perché resta per un po' sulla stessa percentuale. In caso di successo compare un output simile al seguente:

BUILD SUCCESSFUL

10.3 Se continua a mostrare "Querying"

Verificare quanto segue nell'ordine:

1. Attendere che Unreal Engine completi il rilevamento della piattaforma e dell'SDK;
2. Aprire Window → Developer Tools → Output Log;
3. Cercare Turnkey, SDK, Linux, Error;
4. Verificare che l'host corrente sia Linux e che anche la piattaforma di destinazione sia Linux;
5. Verificare che le dipendenze e la toolchain di una versione di Unreal Engine compilata da codice sorgente siano state installate da Setup.sh;
6. Verificare che SetupToolchain.sh sia stato eseguito per la versione precompilata;
7. Chiudere le finestre duplicate di Project Launcher e riaprirlo;
8. Non compilare lo stesso progetto in un altro terminale nello stesso momento.

11. Effettuare il packaging da riga di comando (opzionale)

Una volta che il packaging grafico è stabile, si può usare RunUAT:

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"

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

Con -archive e -archivedirectory, cercare la versione eseguibile finale nella directory di archivio specificata invece di dare per scontato che si trovi in Saved/StagedBuilds/Linux.

Se il progetto usa mappe specifiche, aggiungere le restrizioni sulle mappe in base alle impostazioni del progetto e ai parametri di comando della versione corrente di Unreal Engine. Chi inizia dovrebbe usare prima Project Launcher, per evitare pacchetti incompleti causati da parametri di comando mancanti.

12. Eseguire il risultato del packaging

12.1 Eseguire il risultato archiviato

Se l'archiviazione è stata abilitata in Project Launcher, oppure RunUAT ha usato -archive -archivedirectory="...", entrare nella directory di archivio effettivamente configurata. Versioni diverse di Unreal Engine possono creare al suo interno un'ulteriore sottodirectory Linux, quindi individuare prima lo script di avvio del progetto e poi eseguirlo:

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

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

Esempio (risultato archiviato 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"

Entrare nella directory di archivio configurata in Project Launcher o RunUAT e avviare lo script del progetto

12.2 Eseguire l'output di staging non archiviato

Eseguire dalla directory seguente solo quando l'archiviazione non è stata effettuata e il risultato di staging deve essere controllato direttamente:

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

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

Verificare dopo l'esecuzione:

• Si avvia;
• La mappa predefinita è corretta;
• I dati LCC sono visibili;
• Nessun processo residuo resta attivo dopo la chiusura dell'applicazione.

Avviare l'applicazione Linux pacchettizzata e verificare la mappa predefinita, i dati LCC e le funzionalità coperte dalla licenza

13. Riferimento dei comandi

[UE_ROOT], [UE_PROJECTS_DIR], [PROJECT_NAME] e [ARCHIVE_DIR] nei comandi seguenti sono segnaposto. Sostituirli con i percorsi completi e i nomi effettivi prima dell'esecuzione.

Avviare il project browser:

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

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

Generare i file di progetto per VS Code:

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

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

Compilare il target Editor del progetto:

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

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

Aprire un progetto specifico con un Unreal Engine specifico:

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

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

Eseguire il risultato archiviato:

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

Eseguire l'output di staging non archiviato:

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

Esempio (output di staging non archiviato):
cd "/home/alice/Unreal/Projects/Test2/Saved/StagedBuilds/Linux"
chmod +x "./Test2.sh"
"./Test2.sh"