⬅

#gamedev

Configurando MacOS para Desenvolvimento de Jogos

Neste post eu vou compartilhar os passos que uso para configurar meu macOS para o desenvolvimento de jogos em C.

Você pode seguir passo a passo para ter a mesma configuração que a minha ou usar ela como ponto de partida para ter a sua própria configuração.

1. Terminal

O primeiro passo que todo programador faz (ou deveria fazer) é configurar seu ambiente de desenvolvimento com ferramentas leves e direto ao ponto. E a primeira delas é a linha de comando.

Isso inclui configurar as fontes, cores, teclas de atalho e a janela onde você passará a maior parte do seu tempo.

Eu uso o aplicativo iTerm2. Este é o melhor terminal para macOS que conheço.

Agora, ninguém gosta de programar sem o seu toque único. Eu costumo configurar o estilo do meu terminal com o homebrew com a cor verde brilhante como um terminal retrô, ou o clássico tema escuro com textos em branco.

A ideia não é perder muito tempo com esses detalhes, precisa ser objetivo e direto, porque usaremos o terminal apenas para gerenciar nosso projeto e compilar o programa.

Só isso.

1727049032.png

2. Compilador

Para começar a programar um jogo em C, precisamos de um compilador. Existem diversos compiladores que compilam código C em executáveis binários. Aqui no macOS usaremos o clang.

Para ter acesso ao compilador clang é necessário baixar e instalar o Xcode que já vem com o devkit para obter o compilador e habilitá-lo no terminal.

3. Editor de Texto

Eu uso Emacs há alguns anos. O Emacs foi criado em 1976 por Richard Stallman e talvez você esteja pensando: "Nossa, este editor é antigo!".

Mas funciona para mim!

Eu, pessoalmente, sempre usei o Vim desde o meu primeiro ano como programador. Mesmo durante o meu estágio, meu chefe me "ensinou" (leia-se obrigou) programar e navegar rapidamente em qualquer editor. Foi difícil no começo, mas hoje vejo que valeu 100% o esforço em aprendê-lo.

Mas depois de anos usando o Vim (e depois neovim), eu conheci o Emacs e simplesmente decidi ir para esse lado da força.

Configurei bastante, gastando muitas semanas, talvez até meses (alerta nerd), e agora ele se tornou meu editor favorito. Gosto de combinar o poder do Emacs com o Vim através do Evil Mode para simular as combinações de teclas do Vim dentro do Emacs.

Então, caso queira seguir o meu workflow atual (2025), instale o Emacs no MacOS. A versão que baixei enquanto escrevo o texto foi emacs-30.1, mas você pode usar a mais recente disponível.

O Emacs funciona com Elisp escrito no arquivo .emacs que deve ficar na pasta HOME ~/ para inicialização. Você pode encontrar minha versão do arquivo .emacs e da pasta .emacs.d em meu dotfiles. Ela inclui temas, snippets de códigos, scripts e muito mais.

A propósito, caso queira conhecer o tema que criei para a IDE da JetBrains com algumas cores que uso no próprio no Emacs, vou deixar o link aqui de referência. Eu o chamei de Terminator Theme.

Voltemos à parte relacionada aos jogos.

Primeiro Programa

Temos tudo que precisamos para começar.

  1. Terminal
  2. Compilador
  3. Editor de Texto

Agora, crie a pasta src dentro do diretório raiz do projeto com os arquivos macos_<project_name>_main.mm e build.sh.

Eu aprendi a adicionar o nome do projeto no arquivo para evitar conflitos de nomes com bibliotecas de terceiros no C. Por exemplo, um platform.h pode haver em diversos lugares, logo eu usaria <project_name>_platform.h.

build.sh

Você só precisa do arquivo shell para compilar o programa.

Você pode desconsiderar ferramentas como cmake, make e outras ferramentas de compilação. Em vez disso, escreva um arquivo shell simples em myproject/src/build.sh.

Isso facilita muito nossos sistema de build, nem sei se posso chamar de sistema de tão enxuto que ele é XD.

Isso é possível porque vamos utilizar o método de compilação com um único translation unit.

Muito bem, dentro do arquivo shell script, adicionei uma flag de debugging para o compilador com -g e criei um novo diretório build para gerar os executáveis. 

#!/bin/bash
mkdir -p ../build
pushd ../build > /dev/null
clang++ -g -o <project_name>.debug ../src/macos_<project_name>_main.mm -framework AppKit
popd > /dev/null
  • mkdir -p: Cria um novo diretório se ele não existir;
  • pushd/popd: Navega e persiste no histórico como pilha;
  • > /dev/null: Usado para silenciar o output do comando push/pod
  • clang++: Compilador c++;
  • -g: A flag de debugging;
  • -o: Nome do executável de saída;
  • -framework: Adicionando o framework da Apple (AppKit) para o alerta funcionar;

Se estiver usando o meu .emacs, pode compilar diretamente de dentro do Emacs com o atalho M-x m ou chamar o script build.sh no terminal.

Main (entry-point)

Crie o ponto de entrada em macos_<project_name>_main.mm com main e use o NSAlert (ou printf) para testar o Hello World.

Precisamos compilar em Objective-C++ para poder incluir código C++ e Objective-C durante o desenvolvimento no macOS. Visto que a API da Apple é criada com Objective-C. 

#include <stdio.h>
int main(int argc, char **argv) {
    // printf("hello world\n");
    NSAlert *alert = [[NSAlert alloc] init];
    alert.messageText = @"Hello world";
    alert.informativeText = @"Informative text";
    [alert runModal];
    return 0;
}

Executando o Programa com Debugging

Você pode executar o executável a partir do terminal no caminho build/<project_name>.debug ou usando o lldb para fins de depuração (você também pode usar o Xcode como ferramenta de debugging).

Como compilamos nosso programa com flags de debugging, o lldb reconhece o código-fonte.

Navegue até a pasta de compilação e inicie o lldb: 

lldb <project_name>.debug

Agora, defina o ponto de interrupção com base no número de linhas do arquivo. Por exemplo, linha 4: 

b macos_<project_name>_main.mm:4

É possível passar o nome da função para definir um breakpoint: b main

A letra b significa breakpoint.

1727132924.png

Depois disso, digite r e enter para iniciar o programa.

Quando o programa atingir a linha, você verá um trecho de código. Para ir para a próxima linha, use a tecla n e depois enter.

Para entrar em uma função (step into), use a tecla s.

Para soltar o breakpoint e deixar o programar rodar normalmente, use a tecla c.

Com bt, você pode ver o backtrace (pilha) do seu programa. Isso é útil para descobrir bugs.

A tecla q ou Control + D interrompe o lldb e sai.

Crie uma pasta na raiz chamada data. Esta pasta será útil ao executar o jogo no futuro como caminho relativo.

Conclusão

O artigo parece grande, mas não é. Ao seguir o passo a passo, você notará que esse fluxo de trabalho é muito simples, rápido e produtivo.

Você só precisa:

  1. Abrir o terminal;
  2. Abrir o Emacs;
  3. Escrever o código;
  4. Compilar;
  5. Testar com Debugging;

A estrutura final é bem simples. 

project_name
├── data
├── build
└── src
    ├── build.sh
    └── macos_project_name_main.mm

Meu Acesso Rápido

  • Instalar o iTerm2
  • Configurar o terminal com fontes e cores
  • Instalar o Xcode
  • Instalar o Emacs e configurar .emacs no diretório home
  • Escrever o arquivo principal com o ponto de entrada main e um 'Hello World' com printf ou NSAlert
  • Escrever o build.sh para compilar o programa
  • Testar a depuração com lldb
  • Configurar a pasta data para o futuro diretório do game