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...
Compiler pour macOS
Note
Cette page décrit comment compiler les binaires de l'éditeur macOS et les modèles d'exportation à partir du code source. Si vous souhaitez plutôt exporter votre projet vers macOS, lisez Exportation de macOS.
Pré-requis
Pour la compilation sous macOS, les éléments suivants sont nécessaires :
SCons 4.0+ build system.
Xcode (ou les outils en ligne de commande plus légers pour Xcode).
Vulkan SDK for MoltenVK (macOS doesn't support Vulkan out of the box). The latest Vulkan SDK version can be installed quickly by running
misc/scripts/install_vulkan_sdk_macos.shwithin the Godot source repository.
Note
If you have Homebrew installed, you can easily install SCons using the following command:
brew install scons
L'installation de Homebrew permet également de récupérer automatiquement les outils de ligne de commande pour Xcode si vous ne les avez pas déjà.
Similarly, if you have MacPorts installed, you can easily install SCons using the following command:
sudo port install scons
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.
Compilation
Démarrez un terminal et allez au répertoire racine du code source du moteur.
Pour compiler pour les Macs équipés Intel (x86-64), utilisez :
scons platform=macos arch=x86_64
Pour compiler pour les Macs équipés Apple Silicon (ARM64), utilisez :
scons platform=macos arch=arm64
Astuce
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 Development and production aliases
for more info.
If all goes well, the resulting binary executable will be placed in the
bin/ subdirectory. This executable file contains the whole engine and
runs without any dependencies. Executing it will bring up the Project
Manager.
Note
Using a standalone editor executable is not recommended, it should be always packaged into an
.app bundle to avoid UI activation issues.
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/.
Automatic .app bundle creation
To automatically create an .app bundle like in the official builds, use the generate_bundle=yes option on the last
SCons command used to build editor:
scons platform=macos arch=x86_64
scons platform=macos arch=arm64 generate_bundle=yes
Manual .app bundle creation
Pour prendre en charge les deux architectures dans un seul binaire "Universal 2", exécutez les deux commandes ci-dessus et utilisez ensuite lipo pour les regrouper :
lipo -create bin/godot.macos.editor.x86_64 bin/godot.macos.editor.arm64 -output bin/godot.macos.editor.universal
To create an .app bundle, you need to use the template located in misc/dist/macos_tools.app. Typically, for an optimized
editor binary built with dev_build=yes:
cp -r misc/dist/macos_tools.app ./bin/Godot.app
mkdir -p bin/Godot.app/Contents/MacOS
cp bin/godot.macos.editor.universal bin/Godot.app/Contents/MacOS/Godot
chmod +x bin/Godot.app/Contents/MacOS/Godot
codesign --force --timestamp --options=runtime --entitlements misc/dist/macos/editor.entitlements -s - bin/Godot.app
Note
If you are building the master branch, you also need to include support
for the MoltenVK Vulkan portability library. By default, it will be linked
statically from your installation of the Vulkan SDK for macOS.
You can also choose to link it dynamically by passing use_volk=yes and
including the dynamic library in your .app bundle:
mkdir -p <Godot bundle name>.app/Contents/Frameworks
cp <Vulkan SDK path>/macOS/lib/libMoltenVK.dylib <Godot bundle name>.app/Contents/Frameworks/libMoltenVK.dylib
Running a headless/server build
To run in headless mode which provides editor functionality to export projects in an automated manner, use the normal build:
scons platform=macos target=editor
And then use the --headless command line argument:
./bin/godot.macos.editor.x86_64 --headless
Pour compiler un build de débogage serveur qui peut être utilisé avec les outils de débogage à distance, utilisez : :
scons platform=macos target=template_debug
Pour compiler un build serveur release qui est optimisé pour faire fonctionner des serveurs de jeu dédiés, utilisez :
scons platform=macos target=template_release production=yes
Création de modèles d'exportation
To build macOS export templates, you have to compile using the targets without
the editor: target=template_release (release template) and
target=template_debug.
Official templates are Universal 2 binaries which support both ARM64 and Intel x86_64 architectures.
To support ARM64 (Apple Silicon) + Intel x86_64:
scons platform=macos target=template_debug arch=arm64 scons platform=macos target=template_release arch=arm64 scons platform=macos target=template_debug arch=x86_64 scons platform=macos target=template_release arch=x86_64 generate_bundle=yes
To support ARM64 (Apple Silicon) only (smaller file size, but less compatible with older hardware):
scons platform=macos target=template_debug arch=arm64 scons platform=macos target=template_release arch=arm64 generate_bundle=yes
To create an .app bundle like in the official builds, you need to use the
template located in misc/dist/macos_template.app. This process can be automated by using
the generate_bundle=yes option on the last SCons command used to build export templates
(so that all binaries can be included). This option also takes care of calling lipo to create
an Universal 2 binary from two separate ARM64 and x86_64 binaries (if both were compiled beforehand).
Note
You also need to include support for the MoltenVK Vulkan portability
library. By default, it will be linked statically from your installation of
the Vulkan SDK for macOS. You can also choose to link it dynamically by
passing use_volk=yes and including the dynamic library in your .app
bundle:
mkdir -p macos_template.app/Contents/Frameworks
cp <Vulkan SDK path>/macOS/libs/libMoltenVK.dylib macos_template.app/Contents/Frameworks/libMoltenVK.dylib
In most cases, static linking should be preferred as it makes distribution easier. The main upside of dynamic linking is that it allows updating MoltenVK without having to recompile export templates.
You can then zip the macos_template.app folder to reproduce the macos.zip
template from the official Godot distribution:
zip -r9 macos.zip macos_template.app
Compilation croisée pour macOS à partir de Linux
Il est possible de compiler pour macOS dans un environnement Linux (et peut-être aussi dans Windows en utilisant le sous-système Windows pour Linux). Pour cela, vous devrez installer OSXCross pour pouvoir utiliser macOS comme cible. Tout d'abord, suivez les instructions pour l'installer :
Clonez le dépôt OSXCross quelque part sur votre machine (ou téléchargez un fichier ZIP et extrayez-le quelque part), par exemple :
git clone --depth=1 https://github.com/tpoechtrager/osxcross.git "$HOME/osxcross"
Suivez les instructions pour empaqueter le SDK : https://github.com/tpoechtrager/osxcross#packaging-the-sdk
Suivez les instructions pour installer OSXCross : https://github.com/tpoechtrager/osxcross#installation
Ensuite, vous devrez définir OSXCROSS_ROOT comme le chemin vers l'installation d'OSXCross (le même endroit où vous avez cloné le dépôt/extrait le zip), par exemple :
export OSXCROSS_ROOT="$HOME/osxcross"
Vous pouvez maintenant compiler avec SCons comme vous le feriez normalement :
scons platform=macos
Si vous avez une version du SDK OSXCross différente de celle attendue par le système de construction(build) SCons, vous pouvez en spécifier une personnalisée avec l'argument osxcross_sdk :
scons platform=macos osxcross_sdk=darwin15