Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Compilare per Linux, *BSD

Vedi anche

Questa pagina descrive come compilare i binari dell'editor e dei modelli di esportazione per Linux dal codice sorgente. Se invece si desidera esportare il proprio progetto su Linux, consultare Esportazione per Linux.

Requisiti

Per compilare su Linux o altre varianti di Unix, è necessario quanto segue:

  • GCC 9+ o Clang 6+.

  • Python 3.9+.

  • SCons 4.4+ build system.

  • pkg-config (utilizzato per rilevare le librerie di sviluppo elencate di seguito).

  • Librerie di sviluppo:

    • X11, Xcursor, Xinerama, Xi e XRandR.

    • Wayland e wayland-scanner.

    • Mesa.

    • ALSA.

    • PulseAudio.

  • Facoltativo - libudev (compilare con udev=yes).

Vedi anche

Per ottenere il codice sorgente di Godot per la compilazione, consultare Ottenere il codice sorgente.

Per una panoramica generale sull'utilizzo di SCons per Godot, consultare Introduzione al sistema di compilazione.

Righe di comando specifiche per ogni distribuzione

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

Compilazione

Avvia un terminale, andare alla cartella radice del codice sorgente del motore e digitare:

scons platform=linuxbsd

Nota

Prima di Godot 4.0, la destinazione Linux/*BSD si chiamava x11 invece di linuxbsd. Se serve compilare Godot 3.x, assicurarsi di usare il ramo 3.x di questa documentazione.

Suggerimento

Se si sta compilando Godot per apportare modifiche o contribuire al motore, si consiglia di usare le opzioni di SCons dev_build=yes o dev_mode=yes. Consultare Alias di sviluppo e produzione per maggiori informazioni.

Se tutto va bene, il file binario eseguibile risultante verrà inserito nella sottocartella "bin". Questo file eseguibile contiene l'intero motore e funziona senza alcuna dipendenza. Eseguirlo farà apparire il Gestore dei progetti.

Nota

Se si desidera compilare tramite Clang anziché GCC, utilizzare questo comando:

scons platform=linuxbsd use_llvm=yes

L'utilizzo di Clang sembra essere un requisito per OpenBSD, altrimenti i font non si compilano correttamente. Per i dispositivi con architettura RISC-V, utilizzare il compilatore Clang anziché il compilatore GCC.

Nota

Compiling on some platforms such as OpenBSD may require more memory than available by default. To increase the memory limit on OpenBSD within the maximum for the current user, run ulimit -d {new amount in kB}.

Suggerimento

Se si compila Godot per uso in produzione, è possibile rendere l'eseguibile finale più piccolo e veloce aggiungendo l'opzione di SCons production=yes. Ciò abilita ulteriori ottimizzazioni del compilatore e in link-time.

L'esecuzione di LTO richiede un po' di tempo e circa 7 GB di RAM disponibile durante la compilazione. Se si esaurisce la memoria con l'opzione precedente, utilizzare production=yes lto=none o production=yes lto=thin per una versione di LTO più leggera ma meno efficace.

Nota

Se si vogliono usare impostazioni separate dell'editor per le proprie build di Godot e le versioni ufficiali, è possibile abilitare Modalità autonoma creando un file chiamato ._sc_ o _sc_ nella cartella bin/.

Compiling with AccessKit support

AccessKit provides support for screen readers.

By default, Godot is built with AccessKit dynamically linked. You can use it by placing accesskit.so alongside the executable.

Nota

You can use dynamically linked AccessKit with export templates as well, rename the SO to accesskit.{architecture}.so and place them alongside the export template executables, and the libraries will be automatically copied during the export process.

To compile Godot with statically linked AccessKit:

  • Download the pre-built static libraries from godot-accesskit-c-static library, and unzip them.

  • When building Godot, add accesskit_sdk_path={path} to tell SCons where to look for the AccessKit libraries:

    scons platform=linuxbsd accesskit_sdk_path=<...>

Nota

Facoltativamente, è possibile creare autonomamente le librerie godot-angle-static seguendo i seguenti passaggi:

  1. Clone the godot-accesskit-c-static directory and navigate to it.

  2. Eseguire il seguente comando:

cd accesskit-c
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build
cmake --install build

The AccessKit static library should be built using the same compiler you are using for building Godot.

Eseguire una compilazione headless/server

Per eseguire in modalità headless, che fornisce funzionalità dell'editor per esportare progetti in maniera automatica, utilizzare la build normale:

scons platform=linuxbsd target=editor

E poi usa l'argomento della riga di comando --headless:

./bin/godot.linuxbsd.editor.x86_64 --headless

Per compilare una build di server di debug che si può utilizzare con strumenti di debug remoto, utilizzare:

scons platform=linuxbsd target=template_debug

Per compilare una build di server ottimizzata per eseguire server di gioco dedicati, utilizzare:

scons platform=linuxbsd target=template_release production=yes

Compilare modelli di esportazione

Avvertimento

I binari di Linux di solito non funzionano su distribuzioni precedenti a quella su cui sono stati compilati. Se si desidera distribuire binari che funzionano sulla maggioranza delle distribuzioni, è consigliabile compilarli su una distribuzione precedente come Ubuntu 20.04. È possibile utilizzare una macchina virtuale o un container per configurare un ambiente di compilazione adatto.

Per creare modelli di esportazione Linux o *BSD, eseguire il sistema di compilazione con i seguenti parametri:

  • (32 bits)

scons platform=linuxbsd target=template_release arch=x86_32
scons platform=linuxbsd target=template_debug arch=x86_32

  • (64 bits)

scons platform=linuxbsd target=template_release arch=x86_64
scons platform=linuxbsd target=template_debug arch=x86_64

Si noti che la cross-compilazione per i bit opposti (64/32) rispetto alla piattaforma host non è sempre semplice e potrebbe richiedere un ambiente chroot.

Per creare modelli di esportazione standard, i file risultanti nella cartella bin/ devono essere copiati in:

$HOME/.local/share/godot/export_templates/<version>/

e denominati nella seguente maniera (anche per *BSD che è visto come "Linux/X11" da Godot):

linux_debug.arm32
linux_debug.arm64
linux_debug.x86_32
linux_debug.x86_64
linux_release.arm32
linux_release.arm64
linux_release.x86_32
linux_release.x86_64

Tuttavia, se si stanno scrivendo moduli personalizzati o codice C++ personalizzato, si potrebbe voler configurare i binari come modelli di esportazione personalizzati nel menu di esportazione. È necessario abilitare Opzioni avanzate per impostarlo.

../../../_images/lintemplates.webp

Non è nemmeno necessario copiarli, basta fare riferimento ai file risultanti nella cartella bin\ della propria cartella sorgente di Godot, così la prossima volta che si compilerà, si avranno riferiti automaticamente i modelli personalizzati.

Cross-compilazione per i dispositivi RISC-V

Per compilare Godot per dispositivi RISC-V, dobbiamo impostare i seguenti elementi:

  • riscv-gnu-toolchain. Anche se non lo useremo direttamente, ci fornisce una sysroot, così come i file header e le librerie di cui avremo bisogno. Ci sono molte versioni tra cui scegliere, tuttavia, più vecchia è la toolchain, più compatibili saranno i nostri binari finali. Se in dubbio, usare questa versione e scaricare riscv64-glibc-ubuntu-20.04-gcc-nightly-2023.07.07-nightly.tar.gz. Estrarlo da qualche parte e ricordarne il percorso.

  • mold. Questo linker veloce è l'unico che collega correttamente il binario risultante. Scaricarlo, estrarlo e assicurarsi di aggiungere la cartella bin al proprio PATH. Eseguire mold --help | grep support per verificare se la versione di Mold supporta RISC-V. Se RISC-V non appare, potrebbe essere necessario aggiornare Mold.

Per semplificare il riferimento alla nostra toolchain, possiamo impostare una variabile d'ambiente così:

export RISCV_TOOLCHAIN_PATH="path to toolchain here"

In questo modo, non dovremo impostare manualmente il percorso della cartella ogni volta che vogliamo farvi riferimento.

Con tutta la configurazione precedente, siamo pronti per compilare Godot.

Navigare alla radice del codice sorgente ed eseguire il seguente comando di compilazione:

PATH="$RISCV_TOOLCHAIN_PATH/bin:$PATH" \
scons arch=rv64 use_llvm=yes linker=mold lto=none target=editor \
    ccflags="--sysroot=$RISCV_TOOLCHAIN_PATH/sysroot --gcc-toolchain=$RISCV_TOOLCHAIN_PATH -target riscv64-unknown-linux-gnu" \
    linkflags="--sysroot=$RISCV_TOOLCHAIN_PATH/sysroot --gcc-toolchain=$RISCV_TOOLCHAIN_PATH -target riscv64-unknown-linux-gnu"

Nota

RISC-V GCC ha bug nelle sue operazioni atomiche che gli impediscono di compilare Godot correttamente. Ecco perché viene utilizzato Clang. Assicurarsi che possa compilare in RISC-V. È possibile verificarlo eseguendo questo comando clang -print-targets, assicurandosi di vedere riscv64 nell'elenco delle destinazioni.

Avvertimento

Il codice precedente include l'aggiunta di $RISCV_TOOLCHAIN_PATH/bin al PATH, ma solo per il seguente comando scons. Poiché riscv-gnu-toolchain utilizza il proprio Clang situato nella cartella bin, aggiungere $RISCV_TOOLCHAIN_PATH/bin alla variabile d'ambiente PATH utente potrebbe impedire l'accesso a un'altra versione di Clang, se installata. Per questo motivo, non è consigliabile rendere permanente l'aggiunta della cartella bin. È anche possibile omettere la riga PATH="$RISCV_TOOLCHAIN_PATH/bin:$PATH" se si desidera utilizzare scons con la versione auto-installata di Clang, ma potrebbe avere problemi di compatibilità con riscv-gnu-toolchain.

Il comando è simile per natura, ma con alcune modifiche importanti. ccflags e linkflags aggiungono flag in più alla build. --sysroot punta a una cartella che simula un sistema Linux e contiene tutti gli header, le librerie e i file .so che Clang userà. --gcc-toolchain indica a Clang dove si trova la toolchain completa e -target riscv64-unknown-linux-gnu indica a Clang l'architettura di destinazione e il sistema operativo per cui vogliamo compilare.

Se tutto è andato bene, dovrebbe apparire una cartella bin e, al suo interno, un file binario simile al seguente:

godot.linuxbsd.editor.rv64.llvm

Ora si può copiare questo eseguibile sul proprio dispositivo RISC-V preferito, quindi avviarlo facendo doppio clic, il che dovrebbe far apparire il gestore dei progetti.

Se in seguito si decide di compilare i modelli di esportazione, copiare il comando di build sopra riportato ma modificare il valore di target in template_debug per una build di debug o template_release per una build di rilascio.

Utilizzare Clang e LLD per uno sviluppo più rapido

È anche possibile usare Clang e LLD per compilare Godot. Ciò presenta due vantaggi rispetto alla configurazione predefinita GCC + GNU ld:

  • LLD collega Godot parecchio più rapidamente rispetto a GNU ld o gold. Questo porta a tempi di iterazione più rapidi.

  • Clang tende a fornire messaggi di errore più utili rispetto a GCC.

Per farlo, installa Clang e il pacchetto lld dal gestore pacchetti della tua distribuzione, poi usa il seguente comando SCons:

scons platform=linuxbsd use_llvm=yes linker=lld

Dopo che la compilazione è stata completata, verrà creato un nuovo binario con un suffisso .llvm nella cartella bin/.

It's still recommended to use GCC for production builds as it's the compiler used for official builds and is more rigorously tested.

Se si verifica questo errore:

/usr/bin/ld: cannot find -l:libatomic.a: No such file or directory

Ci sono due soluzioni:

  • Nel comando SCons, aggiungere il parametro use_static_cpp=no.

  • Seguire queste istruzioni per configurare, compilare e installare libatomic_ops. Quindi, copiare /usr/lib/libatomic_ops.a in /usr/lib/libatomic.a, oppure creare un collegamento simbolico a libatomic_ops con il comando ln -s /usr/lib/libatomic_ops.a /usr/lib/libatomic.a. Il collegamento simbolico può garantire che sia utilizzata la versione più recente di libatomic_ops senza doverla copiare ogni volta che viene aggiornata.

Utilizzo di mold per uno sviluppo più rapido

Per un collegamento ancora più rapido rispetto a LLD, si può usare mold. mold si può usare sia con GCC sia con Clang.

sudo apt-get update
sudo apt-get install -y mold

Once mold is installed, use the following SCons command when compiling Godot:

scons platform=linuxbsd linker=mold

Utilizzo di librerie del sistema per uno sviluppo più rapido

Godot raggruppa il codice sorgente di varie librerie di terze parti. È possibile scegliere di utilizzare le versioni di sistema delle librerie di terze parti. Ciò rende il binario di Godot più veloce da collegare, poiché le librerie di terze parti sono collegate dinamicamente. Pertanto, non c'è bisogno di collegarle staticamente ogni volta che si compila il motore (anche in caso di piccole modifiche incrementali).

Tuttavia, non tutte le distribuzioni Linux dispongono di pacchetti per le librerie di terze parti (o potrebbero non essere aggiornati).

Passare alle librerie di sistema può ridurre i tempi di collegamento di diversi secondi su CPU lente, ma richiede test manuali a seconda della propria distribuzione Linux. Inoltre, potrebbe non essere possibile utilizzare le librerie di sistema per tutto, a causa di bug nei pacchetti delle librerie di sistema (o nel sistema di compilazione, poiché questa funzionalità è meno testata).

Per compilare Godot con le librerie di sistema, installare queste dipendenze sopra quelle elencate in Righe di comando specifiche per ogni distribuzione:

sudo apt-get update
sudo apt-get install -y \
  libembree-dev \
  libenet-dev \
  libfreetype-dev \
  libpng-dev \
  zlib1g-dev \
  libgraphite2-dev \
  libharfbuzz-dev \
  libogg-dev \
  libtheora-dev \
  libvorbis-dev \
  libwebp-dev \
  libmbedtls-dev \
  libminiupnpc-dev \
  libpcre2-dev \
  libsdl3-dev \
  libzstd-dev \
  libsquish-dev \
  libicu-dev

Dopo aver installato tutti i pacchetti richiesti, usare il seguente comando per compilare Godot:

scons platform=linuxbsd builtin_embree=no builtin_enet=no builtin_freetype=no builtin_graphite=no builtin_harfbuzz=no builtin_libogg=no builtin_libpng=no builtin_libtheora=no builtin_libvorbis=no builtin_libwebp=no builtin_mbedtls=no builtin_miniupnpc=no builtin_pcre2=no builtin_sdl=no builtin_zlib=no builtin_zstd=no

Su Debian stabile, sarà necessario rimuovere builtin_embree=no poiché la versione di Embree fornita dal sistema è troppo vecchia per funzionare con l'ultimo ramo master di Godot (che richiede Embree 4).

È possibile mostrare un elenco di tutte le librerie integrate che includono alternative di sistema eseguendo scons -h, quindi cercando le opzioni che iniziano con builtin_.

Avvertimento

Quando si utilizzano librerie di sistema, il binario risultante non è più portabile tra le distribuzioni Linux. Non utilizzare questo approccio per creare binari che si intende distribuire ad altri, a meno che non si stia creando un pacchetto per una distribuzione Linux.