Kompilieren für Linux, *BSD

Siehe auch

Diese Seite beschreibt, wie man einen Linux-Editor kompiliert und Vorlagen-Binärdateien aus dem Quellcode exportiert. Wenn Sie Ihr Projekt stattdessen nach Linux exportieren wollen, lesen Sie Exportieren für Linux.

Anforderungen

Zum Kompilieren unter Linux oder anderen Unix-Varianten ist Folgendes erforderlich:

  • GCC 9+ oder Clang 6+.

  • Python 3.8+.

  • SCons 4.0+ build system.

  • pkg-config (wird verwendet, um die unten aufgeführten Entwicklungsbibliotheken zu erkennen).

  • Entwicklungsbibliotheken:

    • X11, Xcursor, Xinerama, Xi und XRandR.

    • Wayland und Wayland-Scanner.

    • Mesa.

    • ALSA.

    • PulseAudio.

  • Optional - libudev (Build mit udev=yes).

Siehe auch

Um den Godot-Quellcode zum Kompilieren zu erhalten, siehe Beschaffung des Quellcodes.

Eine allgemeine Übersicht über die Verwendung von SCons für Godot finden Sie unter Einführung in das Buildsystem.

Distro-spezifische Einzeiler

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

Kompilieren

Starten Sie ein Terminal, wechseln Sie zum Stammverzeichnis des Engine-Quellcodes und geben Sie Folgendes ein:

scons platform=linuxbsd

Bemerkung

Vor Godot 4.0 hieß das Linux/*BSD-Target x11 anstelle von linuxbsd. Wenn Sie Godot 3.x kompilieren wollen, stellen Sie sicher, dass Sie den 3.x-Branch dieser Dokumentation verwenden.

Tipp

If you are compiling Godot to make changes or contribute to the engine, you may want to use the SCons options dev_build=yes or dev_mode=yes. See Aliasnamen für Entwicklung und Produktion for more info.

Wenn alles gut geht, wird die resultierende ausführbare Binärdatei im Unterverzeichnis "bin" abgelegt. Diese ausführbare Datei enthält die gesamten Engine und läuft ohne jegliche Abhängigkeiten. Wenn Sie sie ausführen, wird der Projektmanager angezeigt.

Bemerkung

Wenn Sie nicht mit GCC, sondern mit Clang kompilieren möchten, verwenden Sie diesen Befehl:

scons platform=linuxbsd use_llvm=yes

Die Verwendung von Clang scheint eine Voraussetzung für OpenBSD zu sein, andernfalls würden Fonts nicht gebaut werden. Für Geräte mit RISC-V-Architektur sollten Sie den Clang-Compiler anstelle des GCC-Compilers verwenden.

Tipp

Wenn Sie Godot für den Produktivseinsatz kompilieren, können Sie die endgültige ausführbare Datei kleiner und schneller machen, indem Sie die SCons-Option production=yes hinzufügen. Dies ermöglicht zusätzliche Compiler-Optimierungen und Link-Time-Optimierungen.

Die Ausführung von LTO nimmt einige Zeit in Anspruch und erfordert beim Kompilieren etwa 7 GB verfügbaren Arbeitsspeicher. Wenn Ihnen mit der obigen Option der Speicher ausgeht, verwenden Sie production=yes lto=none oder production=yes lto=thin für eine schlanke, aber weniger effektive Form von LTO.

Bemerkung

Wenn Sie getrennte Editoreinstellungen für Ihre eigenen Godot-Builds und die offiziellen Releases verwenden wollen, können Sie den Portabler Modus aktivieren, indem Sie eine Datei namens ._sc_ oder _sc_ im bin/-Ordner anlegen.

Ausführen eines Headless/Server-Builds

Um im headless Modus zu arbeiten, der Editor-Funktionen für den automatisierten Export von Projekten bietet, verwenden Sie den normalen Build:

scons platform=linuxbsd target=editor

Und dann benutzen Sie das --headless Kommandozeilenargument:

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

Um einen Debug-Server-Build zu kompilieren, der mit Remote Debugging-Tools verwendet werden kann, benutzen Sie:

scons platform=linuxbsd target=template_debug

Um einen Server-Build zu kompilieren, der für den Betrieb von dedizierten Spieleservern optimiert ist, benutzen Sie:

scons platform=linuxbsd target=template_release production=yes

Exportvorlagen erstellen

Warnung

Linux-Binärdateien laufen normalerweise nicht auf Distributionen, die älter sind als die Distribution, auf der sie erstellt wurden. Wenn Sie Binärdateien veröffentlichen möchten, die auf den meisten Distributionen funktionieren, sollten Sie sie auf einer alten Distribution wie Ubuntu 16.04 erstellen. Sie können eine virtuelle Maschine oder einen Container verwenden, um eine geeignete Build-Umgebung einzurichten.

Um Linux- oder *BSD-Exportvorlagen zu erstellen, führen Sie das Buildsystem mit den folgenden Parametern aus:

  • (32 Bit)

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

  • (64 Bit)

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

Beachten Sie, dass die Cross-Kompilierung für die gegenüberliegenden Bits (64/32) Ihrer Host-Plattform nicht immer einfach ist und möglicherweise eine chroot-Umgebung erfordert.

Um Standard-Exportvorlagen zu erstellen, müssen die resultierenden Dateien in den Ordner bin/ kopiert werden:

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

...und so benannt werden (sogar für *BSD, das von Godot als "Linux/X11" angesehen wird):

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

Wenn Sie jedoch Ihre benutzerdefinierten Module oder benutzerdefinierten C++-Code schreiben, sollten Sie Ihre Binärdateien hier als benutzerdefinierte Exportvorlagen konfigurieren:

../../../_images/lintemplates.png

Sie brauchen sie nicht einmal zu kopieren, Sie können einfach auf die resultierenden Dateien im bin/-Verzeichnis Ihres Godot-Stammverzeichnisses verweisen, so dass Sie beim nächsten Build automatisch die benutzerdefinierten Vorlagen referenziert haben.

Cross-compiling for RISC-V devices

To cross-compile Godot for RISC-V devices, we need to setup the following items:

  • riscv-gnu-toolchain. While we are not going to use this directly, it provides us with a sysroot, as well as header and libraries files that we will need. There are many versions to choose from, however, the older the toolchain, the more compatible our final binaries will be. If in doubt, use this version, and download riscv64-glibc-ubuntu-18.04-nightly-2021.12.22-nightly.tar.gz. Extract it somewhere and remember its path.

  • mold. This fast linker, is the only one that correctly links the resulting binary. Download it, extract it, and make sure to add its bin folder to your PATH. Run mold --help | grep support to check if your version of Mold supports RISC-V. If you don't see RISC-V, your Mold may need to be updated.

To make referencing our toolchain easier, we can set an environment variable like this:

export RISCV_TOOLCHAIN_PATH="path to toolchain here"

This way, we won't have to manually set the directory location each time we want to reference it.

With all the above setup, we are now ready to build Godot.

Go to the root of the source code, and execute the following build command:

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"

Bemerkung

RISC-V GCC has bugs with its atomic operations which prevent it from compiling Godot correctly. That's why Clang is used instead. Make sure that it can compile to RISC-V. You can verify by executing this command clang -print-targets, make sure you see riscv64 on the list of targets.

Warnung

The code above includes adding $RISCV_TOOLCHAIN_PATH/bin to the PATH, but only for the following scons command. Since riscv-gnu-toolchain uses its own Clang located in the bin folder, adding $RISCV_TOOLCHAIN_PATH/bin to your user's PATH environment variable may block you from accessing another version of Clang if one is installed. For this reason it's not recommended to make adding the bin folder permanent. You can also omit the PATH="$RISCV_TOOLCHAIN_PATH/bin:$PATH" line if you want to use scons with self-installed version of Clang, but it may have compatibility issues with riscv-gnu-toolchain.

The command is similar in nature, but with some key changes. ccflags and linkflags append additional flags to the build. --sysroot points to a folder simulating a Linux system, it contains all the headers, libraries, and .so files Clang will use. --gcc-toolchain tells Clang where the complete toolchain is, and -target riscv64-unknown-linux-gnu indicates to Clang the target architecture, and OS we want to build for.

If all went well, you should now see a bin directory, and within it, a binary similar to the following:

godot.linuxbsd.editor.rv64.llvm

You can now copy this executable to your favorite RISC-V device, then launch it there by double-clicking, which should bring up the project manager.

If you later decide to compile the export templates, copy the above build command but change the value of target to template_debug for a debug build, or template_release for a release build.

Nutzen Sie Clang und LLD für eine schnellere Entwicklung

Sie können auch Clang und LLD verwenden, um Godot zu bauen. Dies hat zwei Vorteile im Vergleich zum Standard-GCC + GNU ld Setup:

  • LLD linkt Godot im Vergleich zu GNU ld oder gold deutlich schneller. Dies führt zu schnelleren Iterationszeiten.

  • Clang gibt im Vergleich zu GCC nützlichere Fehlermeldungen.

Um dies zu tun, installieren Sie Clang und das lld-Paket aus dem Paketmanager Ihrer Distribution und verwenden dann den folgenden SCons-Befehl:

scons platform=linuxbsd use_llvm=yes linker=lld

Nachdem der Build abgeschlossen ist, wird eine neue Binärdatei mit dem Suffix .llvm im Ordner bin/ erstellt.

Es wird immer noch empfohlen, GCC für Produktions-Builds zu verwenden, da sie mit Link-Time-Optimierung kompiliert werden können, wodurch die resultierenden Binärdateien kleiner und schneller werden.

Wenn dieser Fehler auftritt:

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

...gibt es gibt zwei Lösungen:

  • Fügen Sie in Ihrem SCons-Befehl den Parameter use_static_cpp=no hinzu.

  • Folgen Sie diesen Anweisungen, um libatomic_ops zu konfigurieren, zu bauen und zu installieren. Dann kopieren Sie /usr/lib/libatomic_ops.a nach /usr/lib/libatomic.a oder erstellen Sie einen Softlink zu libatomic_ops mit dem Befehl ln -s /usr/lib/libatomic_ops.a /usr/lib/libatomic.a. Der Softlink stellt sicher, dass die neueste Version von libatomic_ops verwendet wird, ohne dass sie jedes Mal kopiert werden muss, wenn sie aktualisiert wird.

Verwendung von mold für eine schnellere Entwicklung

Für noch schnelleres Linken im Vergleich zu LLD können Sie mold verwenden. mold kann entweder mit GCC oder Clang verwendet werden.

Seit Januar 2023 ist mold nicht mehr ohne weiteres in den Repositories der Linux-Distributionen verfügbar, so dass Sie die Binärdateien manuell installieren müssen.

  • Laden Sie die mold-Binärdateien von der Release-Seite herunter.

  • Entpacken Sie die .tar.gz-Datei und verschieben Sie den extrahierten Ordner an einen Ort wie .local/share/mold.

  • Fügen Sie $HOME/.local/share/mold/bin zur PATH-Umgebungsvariable Ihres Benutzers hinzu. Zum Beispiel können Sie die folgende Zeile am Ende Ihrer $HOME/.bash_profile Datei hinzufügen:

PATH="$HOME/.local/share/mold/bin:$PATH"

  • Öffnen Sie ein neues Terminal (oder führen Sie source "$HOME/.bash_profile" aus), dann verwenden Sie den folgenden SCons-Befehl beim Kompilieren von Godot:

    scons platform=linuxbsd linker=mold

Verwendung von Systembibliotheken für eine schnellere Entwicklung

Godot bündelt den Quellcode verschiedener Bibliotheken von Drittanbietern. Sie können stattdessen die Systemversionen der Bibliotheken von Drittanbietern verwenden. Dadurch kann die Godot-Binärdatei schneller gelinkt werden, da die Bibliotheken von Drittanbietern dynamisch gelinkt werden. Daher müssen sie nicht jedes Mal statisch gelinkt werden, wenn Sie die Engine bauen (selbst bei kleinen inkrementellen Änderungen).

Allerdings sind nicht für alle Linux-Distributionen Pakete für Bibliotheken von Drittanbietern verfügbar (oder sie sind nicht aktuell).

Der Wechsel zu Systembibliotheken kann die Link-Zeiten auf langsamen CPUs um mehrere Sekunden verkürzen, erfordert aber je nach Linux-Distribution manuelle Tests. Außerdem kann es sein, dass Sie aufgrund von Bugs in den Systembibliotheks-Paketen (oder im Buildsystem, da dieses Feature weniger getestet wird) nicht für alles Systembibliotheken verwenden können.

To compile Godot with system libraries, install these dependencies on top of the ones listed in the Distro-spezifische Einzeiler:

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 \
  libzstd-dev \
  libsquish-dev \
  libicu-dev

Nachdem Sie alle erforderlichen Pakete installiert haben, verwenden Sie den folgenden Befehl, um Godot zu bauen:

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_zlib=no builtin_zstd=no

On Debian stable, you will need to remove builtin_embree=no as the system-provided Embree version is too old to work with Godot's latest master branch (which requires Embree 4).

Sie können eine Liste aller Built-in-Bibliotheken, die Systemalternativen haben, anzeigen, indem Sie scons -h aufrufen und dann nach Optionen suchen, die mit builtin_ beginnen.

Warnung

When using system libraries, the resulting binary is not portable across Linux distributions anymore. Do not use this approach for creating binaries you intend to distribute to others, unless you're creating a package for a Linux distribution.