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...
Compilando para macOS
Nota
Esta página descreve como compilar os binários do editor e do modelo de exportação do macOS a partir do código-fonte. Se você deseja exportar seu projeto para o macOS, leia Exportando para macOS.
Requisitos
Para compilar no macOS, o seguinte é necessário:
Sistema de build SCons 4.4+.
Xcode (ou as ferramentas de linha de comando mais leves Command Line Tools for Xcode).
O Vulkan SDK para o MoltenVK (o macOS não suporta o Vulkan nativamente). A versão mais recente do Vulkan SDK pode ser instalada rapidamente executando
misc/scripts/install_vulkan_sdk_macos.shdentro do repositório de origem do Godot.
Nota
Se você tem o Homebrew instalado, pode facilmente instalar o SCons usando o seguinte comando:
brew install scons
A instalação do Homebrew também buscará as ferramentas de linha de comando para o Xcode automaticamente, caso você já não as tenha.
Da mesma forma, se você tiver o MacPorts instalado, pode facilmente instalar o SCons usando o seguinte comando:
sudo port install scons
Ver também
Para obter o código-fonte do Godot para compilação, consulte Adquirindo o código fonte.
Para uma visão geral do uso do SCons no Godot, veja Introdução ao sistema de compilação.
Compilando
Inicie um terminal, vá para o diretório raiz do código-fonte da engine.
Para compilar para Macs equipados com Intel (x86-64), use:
scons platform=macos arch=x86_64
Para compilar para Macs equipados com Apple Silicon (ARM64), use:
scons platform=macos arch=arm64
Dica
Se você está compilando o Godot para fazer alterações ou contribuir para a engine, você pode querer usar as opções do SCons dev_build=yes ou dev_mode=yes. Veja Aliases de desenvolvimento e produção para mais informações.
Se tudo correr bem, o executável binário resultante será colocado no subdiretório bin/. Este arquivo executável contém toda a engine e roda sem dependências. Executá-lo abrirá o Gerenciador de Projetos.
Nota
O uso de um executável de editor autônomo não é recomendado; ele deve ser sempre empacotado em um pacote .app para evitar problemas de ativação da interface gráfica.
Nota
Se você deseja usar configurações de editor separadas para suas próprias compilações do Godot e lançamentos oficiais, pode ativar o Modo autocontido criando um arquivo chamado ._sc_ ou _sc_ na pasta bin/.
Compilando com suporte ao AccessKit
O AccessKit fornece suporte para leitores de tela.
A compilação com o AccessKit requer a instalação de dependências adicionais. Se desejar pular esta etapa, você pode usar a opção do SCons accesskit=no.
Você pode instalar as dependências necessárias executando python misc/scripts/install_accesskit.py no repositório de origem do Godot. Após executar este script, compile o Godot como de costume.
Nota
Você pode, opcionalmente, compilar as bibliotecas godot-accesskit-static você mesmo com as seguintes etapas:
Clone o diretório godot-accesskit-c-static e navegue até ele.
Execute o seguinte comando:
cd accesskit-c
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release
cmake --build build
cmake --install build
A biblioteca estática do AccessKit deve ser compilada usando o mesmo compilador que você está usando para compilar o Godot.
Para compilar o Godot com uma compilação personalizada do AccessKit, adicione accesskit_sdk_path={path} para dizer ao SCons onde procurar as bibliotecas AccessKit:
scons platform=macos accesskit_sdk_path=<...>
Compilando com suporte ao ANGLE
O ANGLE fornece uma camada de tradução do OpenGL ES 3.x para o Metal e pode ser usado para melhorar o suporte ao renderizador de Compatibilidade em algumas GPUs mais antigas com drivers OpenGL desatualizados.
A compilação com o ANGLE requer a instalação de dependências adicionais. Se desejar pular esta etapa, você pode usar a opção do SCons angle=no.
Você pode instalar as dependências necessárias executando python misc/scripts/install_angle.py no repositório de origem do Godot. Após executar este script, compile o Godot como de costume.
Nota
Você pode, opcionalmente, compilar as bibliotecas godot-angle-static você mesmo com as seguintes etapas:
Clone o diretório godot-angle-static e navegue até ele.
Execute o seguinte comando:
git submodule update --init
./update_angle.sh
scons
Você também pode especificar a arquitetura de compilação usando arch={architecture}.
A biblioteca estática do ANGLE deve ser compilada usando o mesmo compilador que você está usando para compilar o Godot.
Para compilar o Godot com uma compilação personalizada do ANGLE, adicione angle_libs={path} para dizer ao SCons onde procurar as bibliotecas ANGLE:
scons platform=macos angle_libs=<...>
Criação automática de pacotes .app
To criar automaticamente um pacote .app como nas compilações oficiais, use la opção generate_bundle=yes no último comando SCons usado para compilar o editor:
scons platform=macos arch=x86_64
scons platform=macos arch=arm64 generate_bundle=yes
Criação manual de bundle .app
Para suportar ambas as arquiteturas em um único binário "Universal 2", execute os dois comandos acima e depois use o lipo para empacotá-los juntos:
lipo -create bin/godot.macos.editor.x86_64 bin/godot.macos.editor.arm64 -output bin/godot.macos.editor.universal
Para criar um pacote .app, você precisa usar o modelo localizado em misc/dist/macos_tools.app. Normalmente, para um binário de editor otimizado compilado com 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
Nota
Se você estiver compilando o ramo master, também precisará incluir o suporte para a biblioteca de portabilidade Vulkan MoltenVK. Por padrão, ela será vinculada estaticamente a partir da sua instalação do Vulkan SDK para macOS. Você também pode optar por vinculá-la dinamicamente passando use_volk=yes e incluindo a biblioteca dinâmica no seu pacote .app:
mkdir -p <Godot bundle name>.app/Contents/Frameworks
cp <Vulkan SDK path>/macOS/lib/libMoltenVK.dylib <Godot bundle name>.app/Contents/Frameworks/libMoltenVK.dylib
Executando um build headless/servidor
Para rodar no modo headless (sem interface), que fornece funcionalidade de editor para exportar projetos de forma automatizada, use a compilação normal:
scons platform=macos target=editor
E então, use o argumento de linha de comando --headless:
./bin/godot.macos.editor.x86_64 --headless
Para compilar uma build de servidor de depuração que pode ser usada com ferramentas de depuração remota, use:
scons platform=macos target=template_debug
Para compilar uma build de servidor de lançamento que é otimizada para rodar servidores de jogos dedicados, use:
scons platform=macos target=template_release production=yes
Construindo modelos de exportação
Para compilar modelos de exportação do macOS, você deve compilar visando os alvos sem o editor: target=template_release (modelo de lançamento) e target=template_debug.
Os modelos oficiais são binários Universal 2, que suportam tanto as arquiteturas ARM64 quanto Intel x86_64.
Para suportar 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
Para suportar apenas ARM64 (Apple Silicon) (tamanho de arquivo menor, mas menos compatível com hardwares mais antigos):
scons platform=macos target=template_debug arch=arm64 scons platform=macos target=template_release arch=arm64 generate_bundle=yes
Para criar um pacote .app como nas compilações oficiais, você precisa usar o modelo localizado em misc/dist/macos_template.app. Este processo pode ser automatizado usando a opção generate_bundle=yes no último comando SCons usado para compilar os modelos de exportação (para que todos os binários possam ser incluídos). Isso criará um arquivo godot_macos.zip em bin/ e, adicionalmente, cuidará de chamar o lipo para criar um binário Universal 2 a partir de dois binários separados ARM64 e x86_64 (se ambos tiverem sido compilados previamente).
Nota
Você também precisa incluir o suporte para a biblioteca de portabilidade Vulkan MoltenVK. Por padrão, ela será vinculada estaticamente a partir da sua instalação do Vulkan SDK para macOS. Você também pode optar por vinculá-la dinamicamente passando use_volk=yes e incluindo a biblioteca dinâmica no seu pacote .app:
mkdir -p macos_template.app/Contents/Frameworks
cp <Vulkan SDK path>/macOS/libs/libMoltenVK.dylib macos_template.app/Contents/Frameworks/libMoltenVK.dylib
Na maioria dos casos, a vinculação estática deve ser preferida, pois facilita a distribuição. A principal vantagem da vinculação dinâmica é que ela permite atualizar o MoltenVK sem ter que recompilar os modelos de exportação.
Se você criou o .app manualmente, pode compactar a pasta macos_template.app para reproduzir o modelo macos.zip da distribuição oficial do Godot:
zip -r9 macos.zip macos_template.app
Para usar seus modelos de exportação personalizados, você pode selecionar o arquivo godot_macos.zip nas opções avançadas de suas predefinições de exportação:
Alternativamente, se você quiser que todas as suas predefinições usem seu modelo de exportação personalizado, você pode renomear o arquivo godot_macos.zip para macos.zip e movê-lo para o local padrão dos modelos de exportação:
- ::
~/Library/Application Support/Godot/export_templates/<GODOT_VERSION>/macos.zip
Compilação cruzada para macOS a partir do Linux
É possível compilar para macOS em um ambiente Linux (e talvez também no Windows usando o Subsistema Windows para Linux). Para isso, você precisará instalar o OSXCross para poder usar o macOS como alvo. Primeiro, siga as instruções para instalá-lo:
Clone o repositório OSXCross em algum lugar da sua máquina (or baixe um arquivo ZIP e extraia-o em algum lugar), ex.:
git clone --depth=1 https://github.com/tpoechtrager/osxcross.git "$HOME/osxcross"
Siga as instruções para empacotar o SDK: https://github.com/tpoechtrager/osxcross#packaging-the-sdk
Siga as instruções para instalar o OSXCross: https://github.com/tpoechtrager/osxcross#installation
Depois disso, você precisará definir OSXCROSS_ROOT como o caminho para a instalação do OSXCross (o mesmo local onde você clonou o repositório/extraiu o zip), ex.:
export OSXCROSS_ROOT="$HOME/osxcross"
Agora você pode compilar com o SCons como faria normalmente:
scons platform=macos
Se você tiver uma versão do SDK do OSXCross diferente da esperada pelo sistema de build do SCons, você pode especificar uma personalizada com o argumento osxcross_sdk:
scons platform=macos osxcross_sdk=darwin15
Solução de problemas
Erro fatal: arquivo 'cstdint' não encontrado
Se você receber um erro de compilação deste tipo logo no início, é provável que seja porque a instalação das ferramentas de linha de comando do Xcode precisa ser reparada após uma atualização do macOS ou do Xcode:
./core/typedefs.h:45:10: fatal error: 'cstdint' file not found
45 | #include <cstdint>
| ^~~~~~~~~
Execute estes dois comandos para reinstalar as ferramentas de linha de comando do Xcode (insira sua senha de administrador conforme necessário):
sudo rm -rf /Library/Developer/CommandLineTools
sudo xcode-select --install
Se ainda assim não funcionar, tente atualizar o Xcode pela Mac App Store e tente novamente.