Renderizar una escena 3DGS en Linux

Este documento parte de la instalación de Unreal Engine y cubre cómo instalar LCC4Unreal, crear un proyecto C++, cargar datos LCC, compilar, ejecutar y empaquetar una aplicación Linux.

1. Entorno de hardware y software recomendado

2. Elegir un método de instalación de Unreal Engine

En Linux hay dos métodos de instalación de Unreal Engine disponibles:

Preferir la versión precompilada cuando solo se necesita LCC4Unreal y no hay que modificar el código fuente de Unreal Engine.

Nota: LCC4Unreal se distribuye en forma precompilada y coincide con los binarios oficiales del motor. No modificar el código fuente del motor, ya que un motor modificado puede ser incompatible con el plugin y provocar fallos de carga o un comportamiento anómalo.

2.1 Método A: instalar la versión precompilada de Unreal Engine para Linux (recomendado)

1. Abrir la página oficial de Epic Unreal Engine for Linux;

2. Iniciar sesión con una cuenta de Epic Games;

3. Descargar el archivo .zip de la versión de Unreal Engine necesaria.

   

   Seleccionar y descargar el paquete precompilado de Unreal Engine para Linux desde la página oficial de Epic Games

4. Crear un directorio para el motor en el gestor de archivos, por ejemplo:

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

5. Extraer todos los archivos y directorios del paquete en ese directorio raíz del motor. No copiar únicamente el archivo UnrealEditor, porque entonces al motor le falta el resto del contenido necesario para ejecutarse y compilar;

6. Entrar en el directorio raíz del motor en el gestor de archivos, hacer clic derecho en una zona vacía y seleccionar Open in Terminal. Los comandos siguientes deben ejecutarse en el directorio correcto del motor.

   

   Entrar en el directorio raíz de Unreal Engine completamente extraído y abrir un terminal desde ahí

7. Iniciar el editor de Unreal Engine.

Forma general:

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

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

Si se informa de que falta el permiso de ejecución:

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

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

2.1.1 Preparar la toolchain para el desarrollo en C++

Siguiendo el inicio rápido de desarrollo en Linux de Epic Games, ejecutar lo siguiente en el directorio de Unreal Engine:

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

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

2.2 Método B: compilar Unreal Engine desde el código fuente

Pasar directamente a la sección 4 si ya funciona una compilación de Unreal Engine desde el código fuente.

2.2.1 Obtener el código fuente

Obtenerlo desde GitHub: https://github.com/EpicGames/UnrealEngine

Visitar el repositorio de GitHub de Unreal Engine de Epic Games y obtener el código fuente de la versión necesaria

2.2.2 Descargar las dependencias y la toolchain nativa

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

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

Usar Setup.sh para descargar las dependencias necesarias para una compilación desde el código fuente y la toolchain nativa de Linux

Criterios de éxito:

• El comando termina correctamente;
• No hay mensajes fatal ni fallos de descarga sin resolver;
• La toolchain de Unreal Engine correspondiente existe en Engine/Extras/ThirdPartyNotUE/SDKs/HostLinux.

Si aparece lo siguiente:

fatal: not a git repository

hay un problema con el origen del código fuente, con el directorio actual o con los metadatos de Git. No ignorarlo y seguir compilando. Confirmar primero que el terminal actual está en el directorio raíz correcto de Unreal Engine.

2.2.3 Generar los archivos de proyecto

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

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

Generar los archivos de proyecto y el Makefile de Linux para el código fuente de Unreal Engine

2.2.4 Compilar UnrealEditor

Limitar el número de trabajos en paralelo en la primera compilación para no agotar la memoria. make -j4 UnrealEditor funciona por defecto; con solo 32 GB de memoria, usar make -j2 UnrealEditor; si el Makefile del motor no ofrece un target independiente, usar make -j4:

cd "/[UE_ROOT]"
make -j4 UnrealEditor

# Usar esto con solo 32 GB de memoria:
make -j2 UnrealEditor

# Usar esto cuando el Makefile no ofrece un target independiente:
make -j4

Limitar el número de trabajos en paralelo y compilar UnrealEditor desde el código fuente

Es normal que la primera compilación desde el código fuente ejecute cientos o incluso miles de acciones. Pertenecen al motor en sí, no a los archivos fuente del proyecto vacío. El tiempo de compilación depende de la CPU, la memoria y el disco.

Comprobar si ha tenido éxito:

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

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

Iniciar el explorador de proyectos:

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

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

Iniciar el Unreal Project Browser una vez compilado UnrealEditor desde el código fuente

3. Instalar y configurar VS Code

3.1 Instalar VS Code y las herramientas de desarrollo en C++

En Ubuntu, descargarlo e instalarlo desde el sitio oficial de Visual Studio Code, o usar el método de paquetes que admita la distribución.

Antes de compilar proyectos C++ con VS Code, completar la instalación de la toolchain de Unreal Engine para Linux de la sección 2 y preparar las herramientas básicas de compilación y depuración de C++. Instalar herramientas habituales como build-essential, clang, lldb y cmake según la versión de Ubuntu y el entorno del equipo; la versión real del compilador sigue los requisitos de la versión actual de Unreal Engine y de la toolchain instalada por SetupToolchain.sh/Setup.sh.

Se recomiendan las siguientes extensiones de VS Code:

• C/C++: navegación por el código, autocompletado y depuración;
• C/C++ Extension Pack: capacidades adicionales habituales de desarrollo en C++;
• CodeLLDB: depuración con LLDB en Linux;
• Makefile Tools: consultar y ejecutar targets del Makefile (opcional).

También se puede consultar la documentación oficial de Epic Games como referencia: Setting up VS Code for Unreal Engine.

3.2 Generar y abrir el workspace de VS Code

Después de crear un proyecto C++, el directorio del proyecto normalmente contiene .vscode/ y <NombreDelProyecto>.code-workspace. Si faltan, ejecutar:

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

En VS Code, seleccionar File → Open Workspace from File... y abrir <NombreDelProyecto>.code-workspace. No abrir únicamente un archivo .cpp.

Abrir el .code-workspace generado para cargar la configuración del proyecto C++ de Unreal Engine

4. Crear un proyecto C++

4.1 Iniciar Unreal Engine

Ejecutar desde el terminal:

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

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

4.2 Ajustes del Project Browser

En el Unreal Project Browser:

1. Seleccionar Games;

2. Seleccionar Blank;

3. Establecer Project Defaults en C++;

4. Establecer Target Platform en Desktop;

5. En Quality Preset, seleccionar Scalable para una primera prueba, o Maximum en una estación de trabajo de alto rendimiento;

6. Seleccionar Starter Content según sea necesario;

7. Introducir la ubicación del proyecto:

   /home/[USER]/Unreal/Projects
   

8. Introducir el nombre del proyecto:

   [PROJECT_NAME]
   

9. Hacer clic en Create.

Seleccionar la plantilla Blank en la categoría Games y establecer el tipo de proyecto en C++

Establecer la ubicación, el nombre y las opciones de plataforma del proyecto, y crear el proyecto C++

Para el nombre y la ruta del proyecto, usar únicamente:

• Letras del alfabeto inglés;
• Dígitos;
• Guiones bajos.

No usar caracteres chinos, espacios, &, corchetes ni otros caracteres especiales.

4.3 Aquí la versión precompilada y la compilada desde el código fuente se comportan de forma distinta

Caso A: versión precompilada (Installed Build)

El flujo habitual es:

crear el proyecto → compilar automáticamente <NombreDelProyecto>Editor → abrir VS Code → abrir el editor del nuevo proyecto

La ventana antigua del explorador de proyectos se cierra brevemente, porque Unreal Engine inicia un proceso de editor que carga el nuevo .uproject.

Caso B: compilación desde el código fuente

El flujo habitual es:

crear el proyecto → generar Source/, Makefile, .vscode/ → cerrar el explorador de proyectos → abrir VS Code

Una compilación de Unreal Engine desde el código fuente puede no compilar ni abrir el nuevo proyecto automáticamente, y espera que el desarrollador lo compile primero en el IDE o en el terminal. Esto no es un error de configuración de VS Code y no significa que la creación del proyecto haya fallado.

En este punto el proyecto normalmente contiene solo:

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

Todavía no está presente:

Binaries/Linux/

Eso significa que los módulos del proyecto no se han compilado.

5. Primera compilación sin el plugin

Compilar una vez el proyecto vacío sin LCC4Unreal instalado para confirmar que Unreal Engine, la toolchain y el propio proyecto funcionan.

5.1 Compilar con VS Code (recomendado)

1. Generar y abrir <NombreDelProyecto>.code-workspace como se describe en la sección 3.2;
2. Abrir Run and Debug en la barra lateral de VS Code;
3. Seleccionar <NombreDelProyecto>Editor (Development) en la lista de configuraciones de la parte superior;
4. Hacer clic en el botón de lanzamiento para ejecutar la primera compilación;
5. Esperar a que termine la compilación y confirmar que no hay errores de compilación de C++. Es normal que la primera compilación tarde mucho.

Seleccionar la configuración <NombreDelProyecto>Editor (Development) y completar la primera compilación de C++ del proyecto

Una vez compilado correctamente, VS Code puede iniciar directamente el editor del proyecto.

5.2 Opcional: usar el Makefile del proyecto

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

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

Compilar el target <NombreDelProyecto>Editor a través del Makefile del proyecto

5.3 Abrir el proyecto después de una compilación correcta

Método gráfico: localizar <NombreDelProyecto>.uproject en el gestor de archivos, hacer clic derecho y seleccionar Open With Unreal Engine Editor. Este método sirve cuando el sistema ya asocia correctamente la versión de Unreal Engine deseada.

Hacer clic derecho en el archivo .uproject del proyecto y seleccionar abrirlo con Unreal Engine Editor

Método por línea de comandos: indicar las rutas completas de UnrealEditor y del .uproject. Esta es la forma más fiable de abrir un proyecto cuando coexisten varias versiones de Unreal Engine:

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

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

Una vez que el proyecto se abre en el editor, cerrar el editor y continuar con la instalación del plugin.

Cargar el proyecto con la versión de Unreal Engine indicada

El proyecto C++ vacío compila correctamente y se abre en el editor de Unreal Engine

6. Instalar LCC4Unreal

La versión de Linux del plugin actualmente no está disponible para descargar en la plataforma para desarrolladores y debe solicitarse por correo electrónico. Envíe una solicitud a sdk@xgrids.com con la siguiente plantilla:

• Nombre de la empresa:
• Uso: propósito del plugin
• Versión del motor: qué versión de Unreal Engine se necesita
• Cómo nos encontró: dónde se enteró del plugin

6.1 Cerrar los programas relacionados

Antes de copiar el plugin:

1. Guardar el proyecto;
2. Cerrar el editor de Unreal Engine;
3. Esperar a que termine el proceso en segundo plano UnrealEditor;
4. VS Code puede quedarse abierto, pero no compilar el proyecto al mismo tiempo.

Comprobar si UnrealEditor sigue en ejecución:

pgrep -a UnrealEditor

Si no hay salida, el editor ha terminado.

6.2 Copiar el plugin completo en el proyecto

1. Crear un directorio Plugins en la raíz del proyecto:

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

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

2. Extraer el paquete descargado del plugin y copiar la carpeta LCC4Unreal completa en el proyecto. El directorio final debe ser:

   [PROJECT_ROOT]/Plugins/LCC4Unreal/
   

   No copiar únicamente Binaries, Content o archivos aislados, y no crear un directorio anidado duplicado como Plugins/LCC4Unreal/LCC4Unreal/.

3. Confirmar que el archivo descriptor del plugin existe. El directorio debe contener:

   [PROJECT_ROOT]/Plugins/LCC4Unreal/LCC4Unreal.uplugin
   

   Si el nombre real del archivo .uplugin cambia entre paquetes publicados, confirmar que se encuentra directamente bajo Plugins/LCC4Unreal/ y no un nivel más abajo.

Copiar la carpeta LCC4Unreal completa en [PROJECT_ROOT]/Plugins/LCC4Unreal y comprobar el archivo .uplugin

6.3 Reiniciar el proyecto

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

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

Este comando indica a la vez qué Unreal Engine usar y qué proyecto abrir. Cuando coexisten varias versiones de Unreal Engine, es más fiable que hacer doble clic en el .uproject y no requiere registrar una versión como predeterminada global.

6.4 Qué hacer cuando aparece un aviso de recompilación

El aviso tiene este aspecto:

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

Significa que las bibliotecas dinámicas del proyecto no existen o no coinciden con la versión actual de Unreal Engine.

• Seleccionar Yes/Rebuild cuando se haya confirmado que la ruta raíz completa de Unreal Engine del comando es correcta;
• Si termina rápido y el editor se abre con normalidad, se trata de una compilación incremental de los módulos del proyecto;
• Si el aviso aparece siempre, comprobar si se usa un motor distinto cada vez, si Binaries/Linux tiene permisos de escritura y si la hora del sistema es correcta;
• En un entorno con varios motores, descartar primero el aviso y compilar después de forma explícita con el comando Build.sh de la sección 13.

7. Elegir el Actor adecuado para el formato de datos

Cada formato de datos requiere el Actor correspondiente:

Los pasos siguientes usan datos .lcc2 y LCC2Actor como ejemplo. Para otros formatos, usar el Actor correspondiente de la tabla.

7.1 Añadir LCC2Actor y cargar los datos

1. Hacer clic para añadir LCC2Actor en el panel de LCC4Unreal.

   

   Añadir LCC2Actor en el panel de LCC4Unreal para el formato de datos .lcc2

2. Seleccionar LCC2Actor en el World Outliner;

3. Localizar Actions en el panel Details;

4. Hacer clic en Load;

5. Seleccionar el archivo de datos .lcc2.

   

   Cargar el archivo de datos .lcc2 desde el panel Details de LCC2Actor

6. Esperar a que termine la carga de los datos.

   

   Los datos .lcc2 aparecen en el viewport de Unreal Engine cuando termina la carga

El editor puede dejar de responder temporalmente mientras carga datos grandes. Vigilar la memoria, la memoria de vídeo y el Output Log en lugar de cerrarlo a la fuerza de inmediato.

8. Incluir los datos LCC no-asset en el empaquetado

.lcc2, .lcc, .sog, .spz y .ply normalmente no son archivos .uasset de Unreal Engine. Colocar los archivos en Content no basta para incluirlos en el paquete de instalación.

Directorio recomendado:

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

Abrir:

Edit → Project Settings → Packaging

Localizar:

Additional Non-Asset Directories To Copy

Añadir:

LCCData

En Packaging hay dos ajustes de directorios no-asset disponibles:

Nota: cuando se usa Additional Non-Asset Directories To Package para incluir los datos en el archivo pak, los datos de colisión no se cargan correctamente. Este es un defecto conocido de la versión actual y se corregirá en la próxima versión. Usar Additional Non-Asset Directories To Copy cuando se necesite la colisión.

El valor a introducir es un nombre de directorio de primer nivel bajo Content (por ejemplo, LCCData), no una ruta de archivo. No añadir el prefijo Content/.

Configurar Content/LCCData como directorio no-asset que se copia durante el empaquetado

Después, asegurarse de que la ruta relativa que carga el LCC Actor o el LCC2Actor coincide con el directorio empaquetado.

8.1 Establecer el mapa de inicio

Abrir:

Edit → Project Settings → Maps & Modes

En Default Maps, establecer Game Default Map en el nivel de destino que contiene el LCC Actor/LCC2Actor y la ruta de datos configurada. Guardar después el nivel y la configuración del proyecto, para que la aplicación empaquetada no arranque en un mapa vacío.

Establecer el Game Default Map usado al iniciar la aplicación empaquetada en Default Maps de Maps & Modes

9. Lista de comprobación previa al empaquetado

Confirmar cada punto antes de empaquetar:

• [ ] Se usa la versión correcta de Unreal Engine;
• [ ] El paquete del plugin LCC4Unreal coincide con la versión de Unreal Engine y la arquitectura de Linux;
• [ ] <NombreDelProyecto>Editor Linux Development compila correctamente;
• [ ] El plugin está activado;
• [ ] La licencia Pro es válida (necesaria solo cuando se usan funciones de la edición Pro, consultar Ediciones y licencias);
• [ ] Los datos LCC se ven al ejecutar Play en el editor;
• [ ] Game Default Map está establecido;
• [ ] Los datos que se van a empaquetar están añadidos en Additional Non-Asset Directories To Copy;
• [ ] El disco tiene espacio suficiente;
• [ ] El directorio de salida tiene permisos de escritura;
• [ ] Todos los niveles y recursos están guardados;
• [ ] Generar primero un paquete Development y probar Shipping después de que funcione.

10. Empaquetar para Linux con Project Launcher

10.1 Abrir Project Launcher

En el editor de Unreal Engine, seleccionar:

Platforms → Project Launcher

Abrir Project Launcher desde el menú Platforms

Hacer clic en:

Add → Create Custom Profile

Crear el perfil de empaquetado para Linux mediante Add → Create Custom Profile

10.2 Configurar el perfil

1. En el perfil personalizado, seleccionar Linux como plataforma de destino y establecer el esquema de empaquetado de contenido en archivo Pak;

2. Activar el archivado del resultado de la compilación y seleccionar un directorio de archivado con permisos de escritura. Ese directorio es donde se guarda realmente la versión distribuible después del empaquetado.

   

   Establecer la plataforma de destino en Linux, seleccionar archivo Pak, activar el archivado e indicar el directorio de salida del empaquetado

3. Hacer clic en el icono de lanzamiento a la derecha del perfil personalizado.

El empaquetado normalmente incluye:

Build → Cook → Stage → Package → Archive

El primer empaquetado es más lento que uno incremental. No detenerlo a la fuerza porque se quede un momento en un mismo porcentaje. Si tiene éxito, aparece una salida similar a esta:

BUILD SUCCESSFUL

10.3 Si se queda en "Querying"

Comprobar lo siguiente en orden:

1. Esperar a que Unreal Engine termine la detección de plataformas y SDK;
2. Abrir Window → Developer Tools → Output Log;
3. Buscar Turnkey, SDK, Linux, Error;
4. Confirmar que el equipo actual es Linux y que la plataforma de destino también es Linux;
5. Confirmar que Setup.sh instaló las dependencias y la toolchain de la compilación de Unreal Engine desde el código fuente;
6. Confirmar que se ejecutó SetupToolchain.sh en el caso de la versión precompilada;
7. Cerrar las ventanas duplicadas de Project Launcher y volver a abrirlo;
8. No compilar el mismo proyecto en otro terminal al mismo tiempo.

11. Empaquetar desde la línea de comandos (opcional)

Una vez que el empaquetado gráfico es estable, se puede usar 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"

Ejemplo:
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 y -archivedirectory, buscar la versión ejecutable final en el directorio de archivado indicado en lugar de dar por hecho que está en Saved/StagedBuilds/Linux.

Si el proyecto usa mapas concretos, añadir las restricciones de mapa según la configuración del proyecto y los parámetros de comando de la versión actual de Unreal Engine. Quien empieza debería usar primero Project Launcher, para evitar paquetes incompletos por parámetros de comando ausentes.

12. Ejecutar el resultado empaquetado

12.1 Ejecutar el resultado archivado

Si se activó el archivado en Project Launcher, o si RunUAT usó -archive -archivedirectory="...", ir al directorio de archivado realmente configurado. Distintas versiones de Unreal Engine pueden crear ahí un subdirectorio Linux adicional, así que localizar primero el script de inicio del proyecto y ejecutarlo después:

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

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

Ejemplo (resultado archivado en 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"

Entrar en el directorio de archivado configurado en Project Launcher o RunUAT y lanzar el script del proyecto

12.2 Ejecutar la salida staged sin archivar

Ejecutar desde el directorio siguiente solo cuando no se haya archivado y haya que comprobar directamente el resultado staged:

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

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

Comprobar después de ejecutarlo:

• Arranca;
• El mapa predeterminado es el correcto;
• Los datos LCC se ven;
• No quedan procesos residuales después de cerrar la aplicación.

Lanzar la aplicación Linux empaquetada y verificar el mapa predeterminado, los datos LCC y las funciones con licencia

13. Referencia de comandos

[UE_ROOT], [UE_PROJECTS_DIR], [PROJECT_NAME] y [ARCHIVE_DIR] en los comandos siguientes son marcadores de posición. Sustituirlos por las rutas completas y los nombres reales antes de ejecutarlos.

Iniciar el explorador de proyectos:

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

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

Generar los archivos de proyecto de VS Code:

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

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

Compilar el target Editor del proyecto:

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

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

Abrir un proyecto concreto con un Unreal Engine concreto:

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

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

Ejecutar el resultado archivado:

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

Ejecutar la salida staged sin archivar:

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

Ejemplo (salida staged sin archivar):
cd "/home/alice/Unreal/Projects/Test2/Saved/StagedBuilds/Linux"
chmod +x "./Test2.sh"
"./Test2.sh"