Compilando para X11 (Linux, *BSD)

Ver también

Esta página describe cómo compilar los binarios del editor y las plantillas de exportación para Linux desde el código fuente. Si lo que buscas es exportar tu proyecto a Linux, consulta Exportando para Linux.

Requerimientos

Para compilar en Linux u otras variantes de Unix, se requiere lo siguiente:

  • GCC 7+ o Clang 6+.

  • Python 3.5+.

  • Sistema de compilación SCons 3.0 o superior. Si tu distribución utiliza Python 2 por defecto o estás usando una versión de SCons anterior a 3.1.2, necesitarás cambiar la versión de Python que utiliza SCons modificando el shebang (la primera línea) del archivo de script de SCons a #! /usr/bin/python3. Utiliza el comando which scons para encontrar la ubicación del archivo de script de SCons.

  • pkg-config (se utiliza para detectar las dependencias mencionadas a continuación).

  • Las bibliotecas de desarrollo X11, Xcursor, Xinerama, Xi y XRandR.

  • Librerías de desarrollo de MesaGL.

  • Librerías de desarrollo ALSA.

  • Librerías de desarrollo de PulseAudio.

  • Opcional - libudev (compilar con udev=yes).

  • Opcional - yasm (para optimizaciones SIMD de WebM).

Ver también

Para obtener el código fuente de Godot para compilarlo, consulta la sección Consiguiendo el código fuente.

Para obtener una visión general del uso de SCons para Godot, consulta la sección Introducción al sistema de compilación.

Líneas de comandos específicas para cada distribución

Alpine Linux

 
apk add scons pkgconf gcc g++ libx11-dev libxcursor-dev libxinerama-dev libxi-dev libxrandr-dev \
    mesa-dev libexecinfo-dev eudev-dev alsa-lib-dev pulseaudio-dev

Arch Linux

 
pacman -S --needed scons pkgconf gcc libxcursor libxinerama libxi libxrandr mesa glu libglvnd \
    alsa-lib pulseaudio yasm

Debian / Ubuntu

 
sudo apt-get install build-essential scons pkg-config libx11-dev libxcursor-dev libxinerama-dev \
    libgl1-mesa-dev libglu-dev libasound2-dev libpulse-dev libudev-dev libxi-dev libxrandr-dev yasm

Fedora

 
sudo dnf install scons pkgconfig libX11-devel libXcursor-devel libXrandr-devel libXinerama-devel \
    libXi-devel mesa-libGL-devel mesa-libGLU-devel alsa-lib-devel pulseaudio-libs-devel \
    libudev-devel yasm gcc-c++ libstdc++-static libatomic-static

FreeBSD

 
sudo pkg install py37-scons pkgconf xorg-libraries libXcursor libXrandr libXi xorgproto libGLU \
    alsa-lib pulseaudio yasm

Gentoo

 
emerge -an dev-util/scons x11-libs/libX11 x11-libs/libXcursor x11-libs/libXinerama x11-libs/libXi \
    media-libs/mesa media-libs/glu media-libs/alsa-lib media-sound/pulseaudio dev-lang/yasm

Mageia

 
urpmi scons task-c++-devel pkgconfig "pkgconfig(alsa)" "pkgconfig(glu)" "pkgconfig(libpulse)" \
    "pkgconfig(udev)" "pkgconfig(x11)" "pkgconfig(xcursor)" "pkgconfig(xinerama)" "pkgconfig(xi)" \
    "pkgconfig(xrandr)" yasm

OpenBSD

 
pkg_add python scons llvm yasm

openSUSE

 
sudo zypper install scons pkgconfig libX11-devel libXcursor-devel libXrandr-devel libXinerama-devel \
        libXi-devel Mesa-libGL-devel alsa-devel libpulse-devel libudev-devel libGLU1 yasm

NetBSD

 
pkg_add pkg-config py37-scons yasm

Para tener soporte de audio, opcionalmente puedes instalar "pulseaudio".

Solus

 
sudo eopkg install -c system.devel scons libxcursor-devel libxinerama-devel libxi-devel \
    libxrandr-devel mesalib-devel libglu alsa-lib-devel pulseaudio-devel yasm

Compilando

Inicia una terminal, ve al directorio raíz del código fuente del motor y escribe:

scons platform=x11

Si todo va bien, el archivo binario ejecutable resultante se ubicará en el subdirectorio "bin". Este archivo ejecutable contiene todo el motor y se ejecuta sin ninguna dependencia. Al ejecutarlo, aparecerá el administrador de proyectos.

Nota

Si deseas compilar utilizando Clang en lugar de GCC, usa este comando:

scons platform=x11 use_llvm=yes

El uso de Clang parece ser un requisito para OpenBSD, de lo contrario, las fuentes no se compilarían correctamente.

Nota

Si estás compilando Godot para uso en producción, puedes hacer que el ejecutable final sea más pequeño y rápido agregando la opción de SCons target=release_debug.

Si estás compilando Godot con GCC, puedes hacer que el binario sea aún más pequeño y rápido agregando la opción use_lto=yes en SCons. Dado que la optimización en tiempo de enlace (LTO) requiere una cantidad significativa de memoria, necesitarás alrededor de 7 GB de RAM disponible durante la compilación.

Nota

Si deseas utilizar configuraciones de editor separadas para tus propias compilaciones de Godot y las versiones oficiales, puedes habilitar Modo autónomo creando un archivo llamado ._sc_ o _sc_ en la carpeta bin/.

Compilación de una versión sin interfaz / para servidor

Para compilar una versión headless que proporciona funcionalidad de editor para exportar proyectos de manera automatizada, usa:

scons platform=server tools=yes target=release_debug

Para compilar una versión servidor con depuración que se puede utilizar con herramientas de depuración remota, utiliza:

scons platform=server tools=no target=release_debug

Para compilar una versión servidor que está optimizada para ejecutar servidores de juegos dedicados, utiliza:

scons platform=server tools=no target=release

Construyendo plantillas de exportación

Advertencia

Las binarias de Linux generalmente no se ejecutarán en distribuciones más antiguas que la distribución en la que fueron compiladas. Si deseas distribuir binarios que funcionen en la mayoría de las distribuciones, debes compilarlos en una distribución antigua como Ubuntu 16.04. Puedes utilizar una máquina virtual o un contenedor para configurar un entorno de compilación adecuado.

Para compilar plantillas de exportación para X11 (Linux, *BSD), ejecuta el sistema de compilación con los siguientes parámetros:

  • (32 bits)

scons platform=x11 tools=no target=release bits=32
scons platform=x11 tools=no target=release_debug bits=32

  • (64 bits)

scons platform=x11 tools=no target=release bits=64
scons platform=x11 tools=no target=release_debug bits=64

Ten en cuenta que la compilación cruzada para bits opuestos (64/32) a los de tu plataforma de host no siempre es sencilla y puede requerir un entorno chroot.

Para crear plantillas de exportación estándar, los archivos resultantes deben copiarse en:

$HOME/.local/share/godot/templates/[gd-version]/

y nombrados de la siguiente manera (incluso para *BSD que es reconocido como "Linux X11" por Godot):

linux_x11_32_debug
linux_x11_32_release
linux_x11_64_debug
linux_x11_64_release

Sin embargo, si estás escribiendo tus propios módulos personalizados o código C++ personalizado, es posible que desees configurar tus binarios como plantillas de exportación personalizadas aquí:

../../_images/lintemplates.png

Ni siquiera necesitas copiarlos, simplemente puedes hacer referencia a los archivos resultantes en el directorio bin/ de la carpeta de origen de Godot, de esta manera, la próxima vez que construyas, automáticamente tendrás las plantillas personalizadas referenciadas.

Utilizando Clang y LLD para un desarrollo más rápido

También puedes usar Clang y LLD para compilar Godot. Esto tiene dos ventajas en comparación con la configuración predeterminada de GCC + GNU ld:

  • LLD enlaza Godot significativamente más rápido en comparación con GNU ld o gold. Esto lleva a tiempos de iteración más rápidos.

  • Clang tiende a proporcionar mensajes de error más útiles en comparación con GCC.

Para hacerlo, instala Clang y el paquete lld desde el administrador de paquetes de tu distribución y luego utiliza el siguiente comando de SCons:

scons platform=x11 use_llvm=yes use_lld=yes

Después de que se complete la compilación, se creará un nuevo archivo binario con el sufijo .llvm en la carpeta bin/.

Todavía se recomienda usar GCC para las compilaciones de producción, ya que se pueden compilar utilizando la optimización en tiempo de enlace, lo que hace que los archivos binarios resultantes sean más pequeños y rápidos.

Usando Pyston para un desarrollo mas rápido

Puedes usar Pyston para ejecutar SCons. Pyston es una implementación habilitada para JIT (Just-In-Time) del lenguaje Python (en el que está escrito SCons). Actualmente solo es compatible con Linux. Pyston puede acelerar significativamente las compilaciones incrementales, a menudo en un factor entre 1.5× y 2×. Pyston se puede combinar con Clang y LLD para obtener compilaciones aún más rápidas.

  • Descarga la última versión portátil de Pyston.

  • Extrae el archivo portátil .tar.gz en una ubicación específica, como por ejemplo $HOME/.local/opt/pyston/ (crea las carpetas si es necesario).

  • Utiliza cd para acceder a la carpeta extraída de Pyston desde una terminal, luego ejecuta ./pyston -m pip install scons para instalar SCons dentro de Pyston.

  • Para facilitar la ejecución de SCons a través de Pyston, crea un enlace simbólico del script de envoltura en una ubicación de tu variable de entorno PATH:

    ln -s ~/.local/opt/pyston/bin/scons ~/.local/bin/pyston-scons

  • En lugar de ejecutar scons <argumentos de compilación>, ejecuta pyston-scons <argumentos de compilación> para compilar Godot.

Si no puedes ejecutar pyston-scons después de crear el enlace simbólico, asegúrate de que $HOME/.local/bin/ forme parte de la variable de entorno PATH de tu usuario.