Compilation pour X11 (Linux, *BSD)

Voir aussi

This page describes how to compile Linux editor and export template binaries from source. If you're looking to export your project to Linux instead, read Exporter pour Linux.

Pré-requis

Pour la compilation sous Linux ou d'autres variantes Unix, les éléments suivants sont requis :

  • GCC 7+ ou Clang 6+.

  • Python 3.5+.

  • Système de compilation SCons 3.0+. Si votre distribution utilise Python 2 par défaut, ou si vous utilisez une version de SCons antérieure à 3.1.2, vous devrez changer la version de Python que SCons utilise en changeant le shebang (la première ligne) du fichier de script SCons en #! /usr/bin/python3. Utilisez la commande which scons pour trouver l'emplacement du fichier de script SCons.

  • pkg-config (utilisé pour détecter les dépendances ci-dessous).

  • Bibliothèques de développement X11, Xcursor, Xinerama, Xi et XRandR.

  • Bibliothèques de développement MesaGL.

  • Bibliothèques de développement ALSA.

  • Bibliothèques de développement PulseAudio.

  • Facultatif - libudev (construit(build) avec udev=yes).

  • Facultatif - yasm (pour optimisations WebM SIMD).

Voir aussi

Pour récupérer le code source de Godot pour le compiler, voir Obtenir la source.

Pour un aperçu général de l'utilisation de SCons pour Godot, voir Introduction au buildsystem.

Lignes uniques spécifiques à la distribution

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

Pour le support audio, vous pouvez optionnellement installer 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

Compilation

Démarrez un terminal, allez à la racine du code source du moteur et tapez :

scons -j8 platform=x11

Une bonne règle de base pour le drapeau -j (jobs), est d'avoir au moins autant de threads compilant Godot que de cœurs dans votre CPU, sinon un ou deux de plus. N'hésitez pas à ajouter l'option -j à n'importe quelle commande SCons que vous voyez ci-dessous.

Si tout se passe bien, l'exécutable binaire résultant sera placé dans le sous-répertoire "bin". Ce fichier exécutable contient l'ensemble du moteur et fonctionne sans aucune dépendance. En l'exécutant, le gestionnaire de projet apparaîtra.

Note

Si vous souhaitez compiler en utilisant Clang plutôt que GCC, utilisez cette commande :

scons platform=x11 use_llvm=yes

L'utilisation de Clang semble être une exigence pour OpenBSD, sinon les polices de caractères ne seraient pas construites(build).

Note

Si vous compilez Godot pour une utilisation en production, alors vous pouvez rendre l'exécutable final plus petit et plus rapide en ajoutant l'option SCons target=release_debug.

Si vous compilez Godot avec GCC, vous pouvez rendre le binaire encore plus petit et plus rapide en ajoutant l'option SCons use_lto=yes. L'optimisation du temps de connexion étant un processus gourmand en mémoire, cela nécessitera environ 7 Go de RAM disponible lors de la compilation.

Note

Si vous souhaitez utiliser des paramètres d'édition séparés pour vos propres constructions Godot et vos versions officielles, vous pouvez activer Mode autonome en créant un fichier appelé ._sc_ ou _sc_ dans le dossier bin/.

Compilation d'une version sans headless/serveur

Pour compiler un build headless qui fournit la fonctionnalité d'éditeur pour exporter des projets de manière automatisée, utilisez :

scons -j8 platform=server tools=yes target=release_debug

Pour compiler un build de débogage serveur qui peut être utilisé avec les outils de débogage à distance, utilisez : :

scons -j8 platform=server tools=no target=release_debug

Pour compiler un build serveur qui est optimisé pour faire fonctionner des serveurs de jeu dédiés, utilisez :

scons -j8 platform=server tools=no target=release

Création de modèles d'exportation

Avertissement

Les binaires Linux ne fonctionnent généralement pas sur des distributions plus anciennes que celle sur laquelle ils ont été construits(build). Si vous souhaitez distribuer des binaires qui fonctionnent sur la plupart des distributions, vous devez les construire(build) sur une ancienne distribution telle que Ubuntu 16.04. Vous pouvez utiliser une machine virtuelle ou un conteneur pour mettre en place un environnement de compilation approprié.

Pour construire(build) des modèles d'exportation X11 (Linux, *BSD), exécutez le système de construction(build) avec les paramètres suivants :

  • (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

Notez que la compilation croisée pour les bits opposés (64/32) à votre plate-forme hôte n'est pas toujours simple et peut nécessiter un environnement chroot.

Pour créer des modèles d'exportation standard, les fichiers résultants doivent être copiés vers :

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

et nommé ainsi (même pour *BSD qui est considéré comme "Linux X11" par Godot) :

linux_x11_32_debug
linux_x11_32_release
linux_x11_64_debug
linux_x11_64_release

Cependant, si vous écrivez vos modules personnalisés ou du code C++ personnalisé, vous pouvez plutôt configurer vos binaires comme modèles d'exportation personnalisés ici :

../../_images/lintemplates.png

Vous n'avez même pas besoin de les copier, vous pouvez simplement référencer les fichiers résultants dans le répertoire bin/ de votre dossier source Godot, de sorte que la prochaine fois que vous construirez(build), vous aurez automatiquement les modèles personnalisés référencés.

Utiliser Clang et LLD pour un développement plus rapide

Vous pouvez également utiliser Clang et LLD pour construire(build) Godot. Cela présente deux avantages par rapport à la configuration par défaut de GCC + GNU ld :

  • LLD relie(links) Godot beaucoup plus rapidement que GNU ld ou gold. Cela conduit à des temps d'itération plus rapides.

  • Clang a tendance à donner des messages d'erreur plus utiles que GCC.

Pour ce faire, installez Clang et le paquet lld du gestionnaire de paquets de votre distribution puis utilisez la commande SCons suivante :

scons platform=x11 use_llvm=yes use_lld=yes

Une fois la compilation terminée, un nouveau binaire avec un suffixe .llvm sera créé dans le dossier bin/.

Il est toujours recommandé d'utiliser GCC pour les constructions builds de production car ils peuvent être compilés en utilisant l'optimisation du temps de liaison, ce qui rend les binaires résultants plus petits et plus rapides.

Utiliser Pyston pour un développement plus rapide

Vous pouvez utiliser Pyston pour exécuter SCons. Pyston est une implémentation compatible JIT du langage Python (dans lequel SCons est écrit). Il n'est actuellement compatible qu'avec Linux. Pyston peut accélérer les constructions incrémentales de manière significative, souvent par un facteur compris entre 1,5× et 2×. Pyston peut être combiné avec Clang et LLD pour obtenir des constructions encore plus rapides.

  • Download the latest portable Pyston release.

  • Extrayez le fichier portable .tar.gz vers un emplacement défini, tel que $HOME/.local/opt/pyston/ (créez des dossiers si nécessaire).

  • Utilisez cd pour atteindre le dossier Pyston extrait depuis un terminal, puis exécutez ./pyston -m pip install scons pour installer SCons dans Pyston.

  • Pour faciliter l'exécution de SCons via Pyston, créez un lien symbolique de son script wrapper vers un emplacement de votre variable d'environnement PATH : :

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

  • Au lieu d'exécuter ``scons <build arguments>`, exécutez ``pyston-scons <build arguments>` pour compiler Godot.

Si vous ne pouvez pas exécuter pyston-scons après avoir créé le lien symbolique, assurez-vous que HOME/.local/bin/ fait partie de la variable d'environnement PATH de votre utilisateur.