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...

Kompilieren für Windows

Siehe auch

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

Anforderungen

Zum Kompilieren unter Windows ist Folgendes erforderlich:

  • A C++ compiler. Use one of the following:

    • Visual Studio Community, version 2019 or later. Visual Studio 2022 is recommended. Make sure to enable C++ in the list of workflows to install. If you've already installed Visual Studio without C++ support, run the installer again; it should present you a Modify button. Supports x86_64, x86_32, and arm64.

    • MinGW-w64 with GCC can be used as an alternative to Visual Studio. Be sure to install/configure it to use the posix thread model. Important: When using MinGW to compile the master branch, you need GCC 9 or later. Supports x86_64 and x86_32 only.

    • MinGW-LLVM with clang can be used as an alternative to Visual Studio and MinGW-w64. Supports x86_64, x86_32, and arm64.

  • Python 3.8+. Make sure to enable the option to add Python to the PATH in the installer.

  • SCons 4.0+ build system. Using the latest release is recommended, especially for proper support of recent Visual Studio releases.

Bemerkung

Wenn Sie Scoop installiert haben, können Sie MinGW und andere Abhängigkeiten einfach mit dem folgenden Befehl installieren:

scoop install gcc python scons make mingw

Bemerkung

Wenn Sie MSYS2 installiert haben, können Sie MinGW und andere Abhängigkeiten einfach mit dem folgenden Befehl installieren:

pacman -S mingw-w64-x86_64-python3-pip mingw-w64-x86_64-gcc  \
    mingw-w64-i686-python3-pip mingw-w64-i686-gcc make

Für jedes MSYS2 MinGW-Subsystem sollten Sie dann pip3 install scons in seiner Shell ausführen.

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.

SCons einrichten

Um SCons zu installieren, öffnen Sie die Eingabeaufforderung und führen Sie den folgenden Befehl aus:

python -m pip install scons

Wenn Sie die Meldung Defaulting to user installation because normal site-packages is not writeable erhalten, müssen Sie den Befehl möglicherweise mit erweiterten Rechten erneut ausführen. Öffnen Sie eine neue Eingabeaufforderung als Administrator und führen Sie den Befehl erneut aus, um sicherzustellen, dass SCons im PATH verfügbar ist.

Um zu überprüfen, ob Sie Python und SCons korrekt installiert haben, können Sie python --version und scons --version in eine Eingabeaufforderung (cmd.exe) eingeben.

Wenn die obigen Befehle nicht funktionieren, stellen Sie sicher, dass Sie Python nach der Installation zu Ihrer PATH-Umgebungsvariablen hinzufügen und überprüfen Sie es dann erneut. Sie können dies tun, indem Sie das Python-Installationsprogramm erneut ausführen und die Option zum Hinzufügen von Python zum PATH aktivieren.

Wenn SCons Ihre Visual Studio-Installation nicht erkennen kann, könnte es sein, dass Ihre SCons-Version zu alt ist. Aktualisieren Sie es auf die neueste Version mit python -m pip install --upgrade scons.

Den Godot-Quellcode herunterladen

Siehe Beschaffung des Quellcodes für detaillierte Anweisungen.

Das Tutorial geht davon aus, dass Sie den Quellcode in C:\godot abgelegt haben.

Warnung

Um Verlangsamungen durch ständiges Virenscannen während der Kompilierung zu vermeiden, fügen Sie den Godot-Quellcode-Ordner zur Liste der Ausnahmen in Ihrer Antiviren-Software hinzu.

Für Windows Defender drücken Sie die Windows-Taste, geben "Windows Sicherheit" ein und drücken dann Enter. Klicken Sie unter Viren- und Bedrohungsschutz auf Einstellungen verwalten und scrollen Sie nach unten zu Ausnahmen. Klicken Sie auf Ausnahmen hinzufügen oder entfernen und fügen Sie den Godot-Quellcode-Ordner hinzu.

Kompilieren

Einen Compiler auswählen

SCons will automatically find and use an existing Visual Studio installation. If you do not have Visual Studio installed, it will attempt to use MinGW instead. If you already have Visual Studio installed and want to use MinGW-w64, pass use_mingw=yes to the SCons command line. Note that MSVC builds cannot be performed from the MSYS2 or MinGW shells. Use either cmd.exe or PowerShell instead. If you are using MinGW-LLVM, pass both use_mingw=yes and use_llvm=yes to the SCons command line.

Tipp

Während der Entwicklung ist die Verwendung des Visual Studio-Compilers in der Regel die bessere Idee, da er die Godot-Binärdatei viel schneller als MinGW linkt. Allerdings kann MinGW mit Hilfe der Link-Time-Optimierung (siehe unten) optimiertere Binärdateien erzeugen, so dass es für den Produktiveinsatz die bessere Wahl ist. Dies gilt insbesondere für die GDScript-VM, die mit MinGW viel besser funktioniert als mit MSVC. Daher ist es empfehlenswert, MinGW für die Erstellung von Builds zu verwenden, die Sie an Spieler verteilen.

Alle offiziellen Godot-Binärdateien werden in benutzerdefinierten Containern unter Verwendung von MinGW gebaut.

SCons starten

Nachdem Sie eine Eingabeaufforderung geöffnet haben, wechseln Sie in das Stammverzeichnis des Quellcodes der Engine (mit cd) und geben Sie ein:

C:\godot> scons platform=windows

Bemerkung

Beim Kompilieren mit mehreren CPU-Threads kann SCons eine Warnung über das Fehlen von pywin32 ausgeben. Sie können diese Warnung getrost ignorieren.

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.

If all goes well, the resulting binary executable will be placed in C:\godot\bin\ with the name godot.windows.editor.x86_32.exe or godot.windows.editor.x86_64.exe. By default, SCons will build a binary matching your CPU architecture, but this can be overridden using arch=x86_64, arch=x86_32, or arch=arm64.

Diese ausführbare Datei enthält die gesamte Engine und läuft ohne jegliche Abhängigkeiten. Wenn Sie sie ausführen, wird der Projektmanager angezeigt.

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.

LTO takes some time to run and requires up to 30 GB of available RAM while compiling (depending on toolchain). If you're running out of memory with the above option, use production=yes lto=none or production=yes lto=thin (LLVM only) for a lightweight but less effective form of 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.

Kompilieren mit Unterstützung für Direct3D 12

Godot-Builds enthalten standardmäßig keine Unterstützung für die Direct3D 12-Grafik-API.

You can install the required dependencies by running python misc/scripts/install_d3d12_sdk_windows.py in the Godot source repository. After running this script, add the d3d12=yes SCons option to enable Direct3D 12 support. This will use the default paths for the various dependencies, which match the ones used in the script.

You can find the detailed steps below if you wish to set up dependencies manually, but the above script handles everything for you (including the optional PIX and Agility SDK components).

  • godot-nir-static library. Wir kompilieren die Mesa-Bibliotheken, die Sie benötigen, in eine statische Bibliothek. Laden Sie ihn irgendwo hin herunter, entpacken Sie ihn und merken Sie sich den Pfad zum entpackten Ordner, Sie werden ihn weiter unten benötigen.

Bemerkung

Optional können Sie die godot-nir-static-Bibliotheken mit den folgenden Schritten selbst erstellen:

  1. Installieren Sie das Python-Paket mako, das zur Erzeugung einiger Dateien benötigt wird.

  2. Klonen Sie das Verzeichnis godot-nir-static und navigieren Sie zu diesem Verzeichnis.

  3. Führen Sie das Folgende aus:

    git submodule update --init
./update_mesa.sh
scons

    If you are building with MinGW-w64, add use_mingw=yes to the scons command, you can also specify build architecture using arch={architecture}. If you are building with MinGW-LLVM, add both use_mingw=yes and use_llvm=yes to the scons command.

    If you are building with MinGW and the binaries are not located in the PATH, add mingw_prefix="/path/to/mingw" to the scons command.

    Mesa static library should be built using the same compiler and the same CRT (if you are building with MinGW) you are using for building Godot.

Optional können Sie mit den folgenden Optionen kompilieren, um zusätzliche Funktionen zu erhalten:

  • PIX ist eine Anwendung zur Performanceoptimierung und Fehlersuche für Direct3D12-Anwendungen. Wenn Sie die Unterstützung dafür einkompilieren, können Sie über PIX viel detailliertere Informationen erhalten, die Ihnen bei der Optimierung Ihres Spiels und der Behebung von Grafikfehlern helfen. Um es zu verwenden, laden Sie das WinPixEventRuntime-Paket herunter. Sie werden zu einer NuGet-Paketseite weitergeleitet, wo Sie auf "Paket herunterladen" klicken können, um es zu erhalten. Nach dem Herunterladen ändern Sie die Dateierweiterung in .zip und entpacken die Datei in einen beliebigen Pfad.

  • Agility SDK kann verwendet werden, um Zugang zu den neuesten Direct3D 12-Funktionen zu erhalten, ohne auf Treiber-Updates angewiesen zu sein. Um es zu verwenden, laden Sie das neueste Agility SDK-Paket herunter. Sie werden zu einer NuGet-Paketseite weitergeleitet, wo Sie auf "Paket herunterladen" klicken können, um es zu erhalten. Nach dem Herunterladen ändern Sie die Dateierweiterung in .zip und entpacken die Datei in einen beliebigen Pfad.

Bemerkung

Wenn Sie eine Vorabversion des Agility-SDK verwenden, denken Sie daran, den Entwicklermodus in Windows zu aktivieren, da er sonst nicht genutzt werden kann.

Bemerkung

Wenn Sie einen PIX mit MinGW-Build verwenden möchten, navigieren Sie zum PIX-Runtime-Verzeichnis und verwenden Sie die folgenden Befehle, um eine Importbibliothek zu erzeugen:

# For x86-64:
gendef ./bin/x64/WinPixEventRuntime.dll
dlltool --machine i386:x86-64 --no-leading-underscore -d WinPixEventRuntime.def -D WinPixEventRuntime.dll -l ./bin/x64/libWinPixEventRuntime.a

# For ARM64:
gendef ./bin/ARM64/WinPixEventRuntime.dll
dlltool --machine arm64 --no-leading-underscore -d WinPixEventRuntime.def -D WinPixEventRuntime.dll -l ./bin/ARM64/libWinPixEventRuntime.a

Beim Erstellen von Godot müssen Sie SCons mitteilen, dass Direct3D 12 verwendet werden soll und wo die zusätzlichen Bibliotheken zu suchen sind:

C:\godot> scons platform=windows d3d12=yes mesa_libs=<...>

Oder, wenn alle Optionen aktiviert sind:

C:\godot> scons platform=windows d3d12=yes mesa_libs=<...> agility_sdk_path=<...> pix_path=<...>

Bemerkung

Für die DLLs des Agility SDK müssen Sie explizit die Art des Workflows auswählen. Single-arch ist der Standard (DLLs werden nach bin/ kopiert). Wenn Sie agility_sdk_multi_arch=yes an SCons übergeben, entscheiden Sie sich für Multiarch. Die DLLs werden in die entsprechenden bin/<arch>/ Unterverzeichnisse kopiert und zur Runtime wird die richtige DLL geladen.

Kompilieren mit ANGLE-Unterstützung

ANGLE bietet eine Übersetzungsschicht von OpenGL ES 3.x zu Direct3D 11 und kann verwendet werden, um die Unterstützung für den Kompatibilitäts-Renderer auf einigen älteren GPUs mit veralteten OpenGL-Treibern und auf Windows für ARM zu verbessern.

Standardmäßig wird Godot mit dynamisch gelinktem ANGLE gebaut. Sie können es verwenden, indem Sie libEGL.dll und libGLESv2.dll neben die ausführbare Datei legen.

Bemerkung

Sie können auch dynamisch gelinkte ANGLE mit Exportvorlagen verwenden. Benennen Sie die oben genannten DLLs in libEGL.{Architektur}.dll und libGLESv2.{Architektur}.dll um und platzieren Sie sie neben den ausführbaren Dateien der Exportvorlagen, und die Bibliotheken werden während des Exportvorgangs automatisch kopiert.

Um Godot mit statisch gelinktem ANGLE zu kompilieren:

  • Laden Sie die gebauten statischen Bibliotheken von godot-angle-static library herunter und entpacken Sie sie.

  • Wenn Sie Godot bauen, fügen Sie angle_libs={path} hinzu, um SCons mitzuteilen, wo es nach den ANGLE-Bibliotheken suchen soll:

    scons platform=windows angle_libs=<...>

Bemerkung

Optional können Sie die godot-angle-static-Bibliotheken mit den folgenden Schritten selbst erstellen:

  1. Klonen Sie das Verzeichnis godot-angle-static und navigieren Sie zu diesem Verzeichnis.

  2. Führen Sie den folgenden Befehl aus:

    git submodule update --init
./update_angle.sh
scons

    If you are buildng with MinGW, add use_mingw=yes to the command, you can also specify build architecture using arch={architecture}. If you are building with MinGW-LLVM, add both use_mingw=yes and use_llvm=yes to the scons command.

    If you are building with MinGW and the binaries are not located in the PATH, add mingw_prefix="/path/to/mingw" to the scons command.

    ANGLE static library should be built using the same compiler and the same CRT (if you are building with MinGW) you are using for building Godot.

Entwickeln in Visual Studio

Die Verwendung einer IDE ist für die Kompilierung von Godot nicht erforderlich, da SCons sich um alles kümmert. Wenn Sie jedoch beabsichtigen, den C++-Code der Engine zu weiterzuentwickeln oder zu debuggen, sind Sie möglicherweise an der Konfiguration eines Code-Editors oder einer IDE interessiert.

Ordnerbasierte Editoren erfordern keine besondere Einrichtung, um mit der Codebasis von Godot zu arbeiten. Um Projekte mit Visual Studio zu bearbeiten, müssen sie als Solution eingerichtet werden.

Sie können eine Visual Studio-Solution über SCons erstellen, indem Sie SCons mit dem Parameter vsproj=yes starten, wie folgt:

scons platform=windows vsproj=yes

Sie können jetzt den Quellcode von Godot in einer Visual Studio-Solution öffnen und Godot mit dem Build-Button von Visual Studio bauen.

Siehe auch

Siehe Visual Studio für weitere Details.

Cross-Kompilierung für Windows von anderen Betriebssystemen

If you are a Linux or macOS user, you need to install MinGW-w64, which typically comes in 32-bit and 64-bit variants, or MinGW-LLVM, which comes as a single archive for all target architectures. The package names may differ based on your distribution, here are some known ones:

Arch Linux

 
pacman -Sy mingw-w64

Debian / Ubuntu

 
apt install mingw-w64

Fedora

 
dnf install mingw64-gcc-c++ mingw64-winpthreads-static \
            mingw32-gcc-c++ mingw32-winpthreads-static

MacOS

 
brew install mingw-w64

Mageia

 
urpmi mingw64-gcc-c++ mingw64-winpthreads-static \
      mingw32-gcc-c++ mingw32-winpthreads-static

Bevor die Kompilierung durchgeführt wird, sucht SCons nach den folgenden Binärdateien in Ihrer PATH-Umgebungsvariable:

# for MinGW-w64
i686-w64-mingw32-gcc
x86_64-w64-mingw32-gcc

# for MinGW-LLVM
aarch64-w64-mingw32-clang
i686-w64-mingw32-clang
x86_64-w64-mingw32-clang

Wenn sich die Binaries nicht im PATH befinden (z.B. /usr/bin), können Sie die folgenden Umgebungsvariablen definieren, um dem Buildsystem einen Hinweis zu geben:

export MINGW_PREFIX="/path/to/mingw"

Dabei ist /path/to/mingw der Pfad, der das bin-Verzeichnis enthält, in dem sich i686-w64-mingw32-gcc und x86_64-w64-mingw32-gcc befinden (z.B. /opt/mingw-w64, wenn sich die Binaries in /opt/mingw-w64/bin befinden).

Um sicherzugehen, dass Sie alles richtig machen, sollten Sie folgendes in der Shell ausführen, um einen funktionierenden Compiler zu erhalten (die Ausgabe der Version kann je nach System unterschiedlich sein):

${MINGW_PREFIX}/bin/x86_64-w64-mingw32-gcc --version
# x86_64-w64-mingw32-gcc (GCC) 13.2.0

Bemerkung

If you are building with MinGW-LLVM, add use_llvm=yes to the scons command.

Bemerkung

When cross-compiling for Windows using MinGW-w64, keep in mind only x86_64 and x86_32 architectures are supported. MinGW-LLVM supports arm64 as well. Be sure to specify the right arch= option when invoking SCons if building from a different architecture.

Fehlersuche

Das Cross-Compiling von einigen Ubuntu-Versionen kann zu diesem Bug führen, da die Standardkonfiguration keine Unterstützung für POSIX-Threading bietet.

Sie können die Konfiguration gemäß diesen Anweisungen für 64-Bit ändern:

sudo update-alternatives --config x86_64-w64-mingw32-gcc
<choose x86_64-w64-mingw32-gcc-posix from the list>
sudo update-alternatives --config x86_64-w64-mingw32-g++
<choose x86_64-w64-mingw32-g++-posix from the list>

Und für 32 Bit:

sudo update-alternatives --config i686-w64-mingw32-gcc
<choose i686-w64-mingw32-gcc-posix from the list>
sudo update-alternatives --config i686-w64-mingw32-g++
<choose i686-w64-mingw32-g++-posix from the list>

Erstellen von Windows-Exportvorlagen

Windows-Exportvorlagen werden durch Kompilieren von Godot ohne Editor und mit den folgenden Flags erstellt:

C:\godot> scons platform=windows target=template_debug arch=x86_32
C:\godot> scons platform=windows target=template_release arch=x86_32
C:\godot> scons platform=windows target=template_debug arch=x86_64
C:\godot> scons platform=windows target=template_release arch=x86_64
C:\godot> scons platform=windows target=template_debug arch=arm64
C:\godot> scons platform=windows target=template_release arch=arm64

Wenn Sie vorhaben, die Standard-Exportvorlagen zu ersetzen, kopieren Sie diese an den folgenden Ort, wobei Sie <Version> durch die Versionskennung ersetzen (wie 4.2.1.stable oder 4.3.dev):

%APPDATA%\Godot\export_templates\<version>\

Mit den folgenden Namen:

windows_debug_x86_32_console.exe
windows_debug_x86_32.exe
windows_debug_x86_64_console.exe
windows_debug_x86_64.exe
windows_debug_arm64_console.exe
windows_debug_arm64.exe
windows_release_x86_32_console.exe
windows_release_x86_32.exe
windows_release_x86_64_console.exe
windows_release_x86_64.exe
windows_release_arm64_console.exe
windows_release_arm64.exe

Wenn Sie jedoch benutzerdefinierte Module oder benutzerdefinierten Engine-Code verwenden, können Sie Ihre Binärdateien hier als benutzerdefinierte Exportvorlagen konfigurieren:

../../../_images/wintemplates.webp

Select matching architecture in the export config.

Sie brauchen sie in diesem Fall nicht zu kopieren, sondern referenzieren einfach die resultierenden Dateien im Verzeichnis bin\ Ihres Godot-Quellordners, so dass Sie beim nächsten Build automatisch die benutzerdefinierten Vorlagen referenziert haben.