SIDEQUEST

Game dev track

The study map for my sidequest: math, C++, graphics, physics and a game built from scratch. Each phase shows real progress, straight from the app I use every day.

The track content is in Portuguese.

Live progress shows up here once the study repository is public.

Required topics come first; optional ones after. Click a phase to open it.

Aprender a Aprender e Fundação

3–4 semanas (e um hábito para sempre)

Goal: Aprender a aprender: guardar o que estuda, pensar com método e ganhar autonomia em matemática. Depois, ter o computador pronto e conhecer as limitações da sua plataforma.
Deliverable: Um projeto C++ com CMake que compila e abre uma janela vazia, versionado no Git.
Estimated time: 3–4 semanas (e um hábito para sempre)

requiredComo o aprendizado funciona (a ciência)5 micro tasks

Antes de estudar mais, estude como o cérebro aprende. Reler e grifar dão sensação de progresso, mas retêm pouco; recuperar da memória, espaçar no tempo e misturar assuntos retêm muito mais.

Assistir à primeira semana de Learning How to Learn e anotar 5 ideias
Listar as técnicas de estudo que você usa hoje e classificar cada uma como alta ou baixa utilidade
Fazer um teste sem consulta sobre o último capítulo que leu e anotar o que errou
Ler o resumo do artigo de Dunlosky et al. (2013) e escrever 3 mudanças no seu método
Planejar uma semana com sessões curtas e uma pausa de descanso entre elas

requiredComo estudar com estes livros3 micro tasks

Livros técnicos são para fazer, não para ler. Regra 20/80: 20% lendo, 80% digitando, quebrando e consertando código.

Criar NOTAS.md com uma seção por fase do roadmap
Definir um horário fixo semanal de estudo (mínimo 10 h)
Começar o diário de bugs: registrar o primeiro erro e como o resolveu

requiredRecuperação ativa e repetição espaçada5 micro tasks

Em vez de reler, feche o livro e tente lembrar. Cartões revisados em intervalos crescentes (Anki) guardam o conhecimento por anos com poucos minutos por dia.

Instalar o Anki e criar um baralho 'gamedev'
Criar 20 cartões sobre CMake, Git ou matemática, com uma ideia por cartão
Revisar os cartões todos os dias por 7 dias seguidos
Reescrever 5 cartões ruins para torná-los claros e específicos
Fazer um cartão de código: pedir para escrever uma função de memória

requiredGuardar o conhecimento: notas e segundo cérebro5 micro tasks

Notas que só copiam o livro não ajudam. Notas úteis são escritas com suas palavras, ligadas entre si e voltadas a uma pergunta ou projeto.

Escolher onde ficam as notas (Obsidian ou pasta de docs) e criar a estrutura
Escrever 5 notas permanentes com suas palavras
Ligar 3 notas entre si e explicar a ligação
Resumir um capítulo em 5 linhas sem olhar o livro
Explicar um conceito para um iniciante imaginário (técnica de Feynman) e achar os buracos

requiredPensamento lógico e estratégico: resolver problemas6 micro tasks

Resolver problemas é uma habilidade com método. Entender o enunciado, montar um plano, executar e olhar para trás funciona em matemática, algoritmos e engenharia de jogos.

Ler os 4 passos de Pólya e escrevê-los no topo de NOTAS.md
Resolver 1 problema pequeno aplicando os 4 passos e registrar cada um
Quebrar um problema grande do seu projeto em 5 problemas menores
Fazer um pré-mortem do seu plano de estudo: 5 motivos pelos quais ele falharia
Anotar 3 vieses seus (por exemplo, otimismo no prazo) e uma contramedida para cada
Resolver 3 exercícios no Exercism em C++

Books: A Programmer's Introduction to Mathematics (Jeremy Kun)

requiredAutossuficiência em matemática7 micro tasks

Você não precisa ser bom em matemática hoje. Precisa de um processo: achar a lacuna, voltar ao pré-requisito, fazer exercícios, errar e corrigir. Aqui está o que o ajuda a ficar independente das fórmulas prontas.

Fazer um diagnóstico em Khan Academy para achar suas lacunas
Criar o caderno de erros e registrar os primeiros 5 erros com a causa
Revisar frações, potências e proporções até errar menos de 1 em 10
Assistir ao primeiro episódio de Essence of Linear Algebra e desenhar o que entendeu
Verificar uma fórmula de código (por exemplo, a distância entre dois pontos) com números pequenos
Resolver 5 exercícios em que você cobre a solução antes de olhar
Derivar à mão uma fórmula que você já usa e anotar cada passo

Books: Basic Math / Pre-Algebra All-in-One For Dummies (Mark Zegarelli) · A Programmer's Introduction to Mathematics (Jeremy Kun) · Álgebra Linear (Steinbruch & Winterle)

requiredPrática deliberada e maestria5 micro tasks

Ser extraordinário é fruto de prática no limite da sua habilidade, com feedback, e de projetos reais. Horas repetindo o que já sabe não evoluem. Aqui você aprende a desenhar essa prática.

Escolher uma habilidade e escrever como seria um nível iniciante e um nível extraordinário
Desenhar 3 exercícios de dificuldade crescente para essa habilidade
Fazer um bloco de 45 min sem celular e registrar o que atrapalhou
Ler um trecho de código de um projeto aberto e anotar 3 coisas que aprendeu
Fazer a revisão semanal do app e ajustar a meta da próxima semana

requiredToolchain C++ + CMake + Git5 micro tasks

Compilador (clang/Xcode CLT), CMake, gerenciador de pacotes (vcpkg ou Conan) e Git. Sem isso você perde tempo com tutoriais.

Instalar clang, CMake e Ninja e rodar `cmake --version`
Criar o repositório Git 'gamedev-lab' com .gitignore e primeiro commit
Escrever um CMakeLists.txt que compila um Hello World em C++20
Trazer GLFW ou SDL3 via vcpkg ou FetchContent e abrir uma janela vazia
Colocar um breakpoint no lldb/IDE e inspecionar uma variável

optionalReputação e crescimento de carreira3 micro tasks

Reconhecimento vem de trabalho visível e útil. Publicar o que aprende, de forma honesta, constrói nome ao longo de anos.

Escrever o rascunho de um post curto sobre algo que você aprendeu
Listar 3 comunidades de game dev e entrar em uma
Escolher um projeto aberto pequeno para ler o código

optionalEditor / IDE2 micro tasks

VS Code, CLion ou Xcode. Escolha uma e domine os atalhos de navegação e depuração.

Configurar clang-format e rodar na pasta do projeto
Aprender 5 atalhos: ir para definição, achar usos, renomear, build, depurar

optionalTerminal e shell2 micro tasks

Ajuda a automatizar builds e scripts de assets.

Escrever um script `build.sh` que configura e compila o projeto
Usar grep/rg para achar todos os usos de uma função no projeto

Matemática

3–5 meses (em paralelo com a Fase 2)

Goal: Entender a matemática por trás de posição, rotação, câmera, colisão e iluminação, o suficiente para derivar e depurar fórmulas.
Deliverable: Uma pequena biblioteca de matemática sua (Vec2/Vec3/Mat4/Quat) com testes unitários, e um programa que gira um cubo com ela.
Estimated time: 3–5 meses (em paralelo com a Fase 2)

requiredÁlgebra e funções5 micro tasks

Resolver equações, manipular expressões, entender funções (linear, quadrática, exponencial, log). É a linguagem de tudo que vem depois.

Resolver 10 equações do 1º e 2º grau à mão
Dominar a fórmula quadrática e escrever uma função `solveQuadratic` em C++
Revisar potências, raízes e logaritmos com 10 exercícios
Resolver um sistema 2x2 à mão e conferir em código
Calcular, à mão, se um raio acerta uma esfera (equação quadrática)

Books: Álgebra I Para Leigos (Mary Jane Sterling) · Algebra and Trigonometry (Sheldon Axler) · Pré-Cálculo: Uma Preparação para o Cálculo (Sheldon Axler) · Pré-Cálculo Para Leigos (Deborah Rumsey et al.)

requiredTrigonometria5 micro tasks

Seno, cosseno, tangente, radianos, círculo unitário. Aparece em rotação, ondas, câmera e iluminação.

Converter 10 ângulos entre graus e radianos
Desenhar o círculo unitário de memória com sin/cos de 0°, 30°, 45°, 60°, 90°
Fazer um ponto orbitar outro usando sin/cos
Usar atan2 para fazer um objeto olhar para o mouse
Animar a altura de um objeto com uma onda senoidal (amplitude e frequência ajustáveis)

Books: Trigonometry for Dummies (Mary Jane Sterling) · Pré-Cálculo: Uma Preparação para o Cálculo (Sheldon Axler) · Algebra and Trigonometry (Sheldon Axler)

requiredVetores6 micro tasks

O objeto matemático mais usado em jogos: posição, direção, velocidade, normais. Domine produto escalar e vetorial.

Implementar Vec2 com soma, subtração, escala e comprimento
Adicionar normalize, dot e distância
Implementar Vec3 com cross e verificar a regra da mão direita num desenho
Escrever reflect e projetar um vetor sobre outro
Escrever lerp e fazer um objeto seguir o mouse suavemente
Criar testes unitários para todas as operações

Books: Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Foundations of Game Engine Development, Vol. 1: Mathematics (Eric Lengyel) · Geometria Analítica (Steinbruch & Winterle) · Math for Programmers (3D graphics, ML, simulations) (Paul Orland) · Mathematics of Game Development (Jacob Enfield)

requiredGeometria analítica6 micro tasks

Retas, planos, esferas e interseções. Base de raycasting, colisão e picking com mouse.

Calcular a distância de um ponto a uma reta e a um plano
Escrever a equação do plano a partir de 3 pontos
Implementar interseção raio–plano
Implementar interseção raio–esfera
Implementar interseção raio–triângulo (Möller–Trumbore)
Implementar interseção raio–AABB (slab method)

Books: Geometria Analítica (Steinbruch & Winterle) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Foundations of Game Engine Development, Vol. 1: Mathematics (Eric Lengyel) · Geometry for Programmers (Oleksandr Kaleniuk)

requiredMatrizes e transformações6 micro tasks

Translação, rotação e escala viram multiplicação de matrizes. Model–View–Projection é só isso, em cadeia.

Implementar Mat3 e Mat4 com multiplicação
Criar translate, scale e rotação em torno dos eixos X, Y e Z
Provar que M·N ≠ N·M com um exemplo em código
Implementar transposta e inversa de matrizes ortogonais/afins
Escrever `lookAt` e `perspective`, e comparar a saída com GLM
Desenhar no papel os espaços local → mundo → câmera → clip → NDC → tela

Books: Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Foundations of Game Engine Development, Vol. 1: Mathematics (Eric Lengyel) · Álgebra Linear (Steinbruch & Winterle) · Álgebra Linear com Aplicações (10ª ed.) (Howard Anton & Chris Rorres) · Computer Graphics: Theory and Practice (Gomes, Velho, Sousa et al.)

requiredÁlgebra linear essencial5 micro tasks

Espaços vetoriais, bases, transformações lineares, autovalores. Dá a intuição de por que as matrizes funcionam.

Assistir à série 'Essence of Linear Algebra' (3Blue1Brown) e anotar uma frase por episódio
Resolver sistema linear por eliminação de Gauss à mão
Calcular determinante 2x2 e 3x3 e explicar o que ele mede
Escrever uma transformação linear como matriz e desenhar o efeito num quadrado
Fazer Gram–Schmidt em 3 vetores e verificar a ortogonalidade em código

Books: Álgebra Linear (Steinbruch & Winterle) · Álgebra Linear com Aplicações (10ª ed.) (Howard Anton & Chris Rorres) · Linear Algebra (Jim Hefferon) · Álgebra Linear e suas Aplicações (David C. Lay et al.)

requiredRotações, quaternions e interpolação7 micro tasks

Rotações 3D sem gimbal lock, interpolação suave de câmeras e animações.

Reproduzir gimbal lock com ângulos de Euler numa demo
Implementar Quat: multiplicação, conjugado, normalização
Rotacionar um vetor por um quaternion e comparar com a matriz
Implementar slerp e comparar com lerp normalizado
Converter quaternion ↔ Mat4
Implementar uma curva Bézier cúbica e mover um objeto por ela
Implementar Catmull-Rom por uma lista de pontos

Books: Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Foundations of Game Engine Development, Vol. 1: Mathematics (Eric Lengyel) · Mathematics of Game Development (Jacob Enfield) · Math for Programmers (3D graphics, ML, simulations) (Paul Orland)

requiredCálculo básico (derivada e integral)6 micro tasks

Não é preciso muito, mas física de jogos é cálculo disfarçado: velocidade = derivada da posição; integrar = somar passos no tempo.

Assistir 'Essence of Calculus' (3Blue1Brown) e explicar derivada com suas palavras
Derivar à mão polinômios, sin, cos e exp
Calcular posição a partir de aceleração constante (integral) à mão
Simular uma mola com Euler explícito
Trocar para Euler semi-implícito e comparar a energia ao longo do tempo
Implementar RK4 e comparar com os dois

Books: Pré-Cálculo: Uma Preparação para o Cálculo (Sheldon Axler)

optionalAritmética e pré-álgebra (reforço)2 micro tasks

Só se tiver lacunas em frações, proporções, porcentagens, potências.

Fazer um diagnóstico: 20 exercícios de frações, potências e proporção
Revisar só os assuntos em que errou

Books: Basic Math / Pre-Algebra All-in-One For Dummies (Mark Zegarelli) · Basic Mathematics (Serge Lang)

optionalProbabilidade e estatística3 micro tasks

Para loot, chance de crítico, balanceamento, ruído e geração procedural.

Escrever um RNG com seed (xorshift ou PCG)
Criar uma tabela de loot com pesos e simular 10 mil drops
Implementar value noise 1D e 2D

Books: Math for Programmers (3D graphics, ML, simulations) (Paul Orland)

optionalNúmeros complexos e Fourier2 micro tasks

Úteis para áudio, ondas na água, FFT e para entender quaternions.

Escrever a fórmula de Euler e plotar e^(iθ) como círculo
Implementar uma struct Complex e multiplicar dois números

Books: Pré-Cálculo: Uma Preparação para o Cálculo (Sheldon Axler)

optionalMatemática 'de programador' abstrata2 micro tasks

Provas, polinômios, grafos e otimização. Treina o raciocínio, mas não é urgente.

Ler o primeiro capítulo de um livro de matemática abstrata e resumir em 5 linhas
Resolver 3 exercícios de prova simples (indução, por exemplo)

Books: A Programmer's Introduction to Mathematics (Jeremy Kun) · Geometry for Programmers (Oleksandr Kaleniuk) · Math for Programmers (3D graphics, ML, simulations) (Paul Orland)

C++ e Programação Sólida

3–4 meses (em paralelo com a Fase 1)

Goal: Escrever C++ moderno, seguro e rápido; conhecer as estruturas e algoritmos que jogos usam o tempo todo.
Deliverable: Uma biblioteca pequena e testada de estruturas (vetor dinâmico, pool de objetos, grafo com A*) escrita em C++ moderno.
Estimated time: 3–4 meses (em paralelo com a Fase 1)

requiredC++ moderno (11/14/17/20)7 micro tasks

O suficiente para escrever jogos: RAII, smart pointers, move semantics, templates básicos, STL, lambdas, constexpr.

Ler A Tour of C++ (capítulos básicos) e anotar 10 coisas que você não usava
Escrever uma classe com RAII (arquivo ou buffer) e provar o fechamento com um teste
Trocar new/delete por unique_ptr num trecho do seu código
Implementar move constructor e move assignment num vetor próprio
Escrever um template de função com um concept
Usar `std::variant` + `std::visit` em um exemplo
Usar ranges/algorithms para filtrar e transformar uma lista

Books: A Tour of C++ (3ª ed.) (Bjarne Stroustrup) · C++20 Recipes (Browning & Sutherland) · C++ Memory Management (Patrice Roy)

requiredEstruturas de dados e algoritmos7 micro tasks

O básico que todo jogo usa: arrays, listas, pilhas, filas, hash, árvores, grafos, ordenação, busca, BFS/DFS/Dijkstra/A*.

Ler Grokking Algorithms (busca binária, grafos, Dijkstra)
Implementar busca binária e verificar com testes
Implementar uma hash table simples e comparar com unordered_map
Implementar BFS e DFS num grafo em grade
Implementar uma fila de prioridade (heap)
Implementar Dijkstra
Implementar A* e visualizar a busca

Books: Grokking Algorithms (Aditya Bhargava) · Algoritmos (CLRS, edição em português) (Thomas Cormen et al.) · C Data Structures and Algorithms (Marcin Jamro)

requiredPadrões de projeto para jogos7 micro tasks

Soluções clássicas para problemas de estrutura: loop, estado, comando, componentes, observador, pool.

Ler Game Programming Patterns: Command, Flyweight, Observer
Ler: Prototype, Singleton, State
Ler: Double Buffer, Game Loop, Update Method
Ler: Bytecode, Subclass Sandbox, Type Object
Ler: Component, Event Queue, Service Locator
Ler: Data Locality, Dirty Flag, Object Pool, Spatial Partition
Escolher 2 padrões e aplicá-los num jogo seu

Books: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

requiredMemória e performance6 micro tasks

Cache, stack vs. heap, alocação, layout de dados. Jogos vivem de frames de 16 ms.

Medir o custo de new/delete em loop de 1 milhão de iterações
Implementar um linear (arena) allocator
Implementar um pool allocator
Comparar AoS vs. SoA com 1 milhão de partículas
Rodar um profiler (Tracy ou Instruments) em um programa seu
Ler os capítulos de cache e alocação de C++ High Performance

Books: C++ Memory Management (Patrice Roy) · C++ High Performance (2ª ed.) (Andrist, Sehr, Garney) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

requiredBibliotecas, build e depuração5 micro tasks

Linkar libs de terceiros, ler erros de compilação/linker, usar sanitizers.

Compilar com -fsanitize=address,undefined e achar um bug de propósito
Adicionar Catch2 ou doctest e escrever 5 testes
Criar um macro de ASSERT com mensagem
Criar um sistema de log com níveis
Separar o projeto em bibliotecas via CMake (core, math, app)

optionalConcorrência e multithreading4 micro tasks

Threads, mutex, atomics, job system. Importante em engines, mas só depois do básico.

Criar 4 threads somando partes de um array e juntar o resultado
Provocar uma data race e detectar com ThreadSanitizer
Proteger com mutex e depois com atomic
Escrever um thread pool simples

Books: C++ High Performance (2ª ed.) (Andrist, Sehr, Garney) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

optionalArquitetura de computadores2 micro tasks

Como CPU, cache e memória funcionam por baixo. Ajuda a pensar em performance.

Assistir ao módulo 1 do Nand2Tetris (portas lógicas)
Construir uma ALU simples no simulador

Books: The Elements of Computing Systems (Nand2Tetris) (Nisan & Schocken)

optionalSistemas operacionais2 micro tasks

Processos, threads, memória virtual, arquivos. Só os capítulos relevantes.

Ler o capítulo de processos e threads (resumo de 1 página)
Ler o capítulo de memória virtual e explicar paginação

optionalCompiladores e linguagens de script2 micro tasks

Só se quiser criar uma linguagem de script própria ou um compilador de shaders.

Escrever um lexer para expressões aritméticas
Escrever um parser recursivo e avaliar a expressão

optionalC puro2 micro tasks

Útil para ler código de engines antigas e libs em C (SDL, stb, Vulkan).

Implementar uma lista encadeada em C com malloc/free
Usar valgrind/ASan para achar um vazamento

Books: C Data Structures and Algorithms (Marcin Jamro)

Primeiros Jogos: Game Loop e Mecânicas

1–2 meses

Goal: Aprender o ofício de fazer jogos antes de entrar nos gráficos 3D: loop, input, colisão, estados, game feel. Foco em mecânicas.
Deliverable: 3 jogos 2D curtos e completos (Pong → Breakout → Asteroids ou plataforma), cada um com menu, pontuação e reinício.
Estimated time: 1–2 meses

requiredGame loop com tempo fixo5 micro tasks

O coração de um jogo: ler input, atualizar, desenhar. O passo de tempo fixo torna a física estável e determinística.

Abrir janela e limpar a tela a cada frame
Medir o delta time e mostrar o FPS
Implementar timestep fixo de 60 Hz com acumulador
Limitar o acumulador para evitar a espiral da morte
Interpolar o render entre dois estados de física

Books: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

requiredInput e controles5 micro tasks

Teclado, mouse e gamepad com mapeamento de ações; buffer de input.

Ler teclado e mouse por polling
Criar um mapa de ações (Pular, Mover, Atirar) desacoplado das teclas
Adicionar gamepad com zona morta
Implementar input buffer de 100 ms para o pulo
Implementar coyote time

Books: Game Programming Patterns (Robert Nystrom) · C++ Game Development Cookbook (Druhin Mukherjee)

requiredEntidades e atualização4 micro tasks

Representar jogador, inimigos, projéteis; criar/destruir objetos com segurança.

Criar uma struct Entity com posição, velocidade e sprite
Gerenciar uma lista de entidades com remoção segura no fim do frame
Implementar um object pool de projéteis
Usar IDs/handles em vez de ponteiros crus

Books: Game Programming Patterns (Robert Nystrom) · Mastering C++ Game Development (Mickey MacDonald)

requiredColisão 2D básica5 micro tasks

AABB, círculo, SAT simples; resolução por separação; triggers.

Implementar AABB vs. AABB
Implementar círculo vs. círculo e círculo vs. AABB
Resolver a colisão empurrando pelo menor vetor de separação
Separar triggers de sólidos
Criar o Breakout completo com sua colisão

Books: Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Physics for Game Developers (Bourg & Bywalec) · Physics for JavaScript Games, Animation, and Simulations (Dobre & Ramtal)

requiredMáquinas de estado e fluxo do jogo4 micro tasks

Menu → jogo → pausa → game over. Estados do personagem (idle/run/jump).

Desenhar a máquina de estados do jogo (menu, jogo, pausa, game over)
Implementar a pilha de estados
Implementar uma FSM para o personagem (idle, run, jump)
Adicionar reinício com tecla

Books: Game Programming Patterns (Robert Nystrom) · Programming Game AI by Example (Mat Buckland)

requiredGame feel ('juice')5 micro tasks

O que faz a mecânica ser gostosa: easing, screenshake, partículas, hit stop, som.

Adicionar screenshake ao colidir
Adicionar easing a um movimento de UI
Adicionar hit stop de 50 ms em impacto
Criar um sistema de partículas simples (explosão)
Adicionar 3 sons de feedback

optionalSprites, animação e câmera 2D4 micro tasks

Atlas, animação por frames, câmera que segue, parallax.

Carregar um spritesheet e animar por frames
Implementar câmera 2D que segue o jogador com suavização
Carregar um tilemap do Tiled
Adicionar parallax em 2 camadas

Books: Mastering C++ Game Development (Mickey MacDonald)

optionalÁudio básico3 micro tasks

Tocar efeitos e música, mixagem simples.

Tocar um efeito sonoro com miniaudio
Tocar música em loop e controlar o volume
Variar o pitch aleatoriamente para evitar repetição

Books: C++ Game Development Cookbook (Druhin Mukherjee) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

Computação Gráfica e OpenGL

3–4 meses

Goal: Entender o pipeline gráfico e renderizar uma cena 3D iluminada, texturizada e com modelos carregados de arquivos.
Deliverable: Um visualizador 3D (câmera livre, modelo glTF, luzes Blinn-Phong, sombras, skybox, ImGui) escrito por você.
Estimated time: 3–4 meses

requiredO pipeline gráfico3 micro tasks

O que acontece entre um triângulo na CPU e um pixel na tela: vertex → rasterização → fragment → framebuffer.

Desenhar o pipeline (vertex → raster → fragment) de memória
Explicar o que acontece com um vértice do código até o pixel
Listar os espaços de coordenadas e a matriz de cada passagem

Books: Learn OpenGL (Joey de Vries) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger) · Computer Graphics: Theory and Practice (Gomes, Velho, Sousa et al.)

requiredJanela, contexto e loader4 micro tasks

GLFW (ou SDL) + glad: criar contexto OpenGL e carregar funções.

Criar a janela com GLFW e um contexto OpenGL core
Carregar funções com glad e imprimir a versão do GL
Ativar o debug callback (ou checar glGetError)
Tratar o redimensionamento da janela e o viewport

Books: Learn OpenGL (Joey de Vries) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger)

requiredPrimeiro triângulo (VAO/VBO/EBO)5 micro tasks

Enviar dados para a GPU e desenhar. Aqui você entende de verdade o estado do OpenGL.

Desenhar o triângulo com VBO + VAO
Desenhar um quadrado com EBO
Passar a cor por atributo de vértice
Animar a cor com um uniform de tempo
Compilar shaders lendo de arquivos externos, com log de erros

Books: Learn OpenGL (Joey de Vries) · Learn OpenGL: Beginners guide to 3D rendering (Frahaan Hussain)

requiredTexturas5 micro tasks

Carregar imagens, coordenadas UV, filtros, mipmaps, wrapping.

Carregar uma textura com stb_image
Aplicar coordenadas UV no quadrado
Testar nearest, linear e mipmaps, e ver a diferença
Misturar duas texturas no fragment shader
Testar GL_REPEAT e GL_CLAMP_TO_EDGE

Books: Learn OpenGL (Joey de Vries) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger)

requiredTransformações e câmera5 micro tasks

Aplicar a matemática da Fase 1 na prática: MVP, câmera livre, FPS.

Desenhar um cubo com MVP
Ativar o depth test e desenhar 10 cubos
Implementar câmera livre com WASD + mouse (yaw/pitch)
Usar delta time para velocidade constante
Adicionar zoom (FOV) com o scroll

Books: Learn OpenGL (Joey de Vries) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop)

requiredIluminação (Phong / Blinn-Phong)6 micro tasks

Ambiente + difusa + especular; normais; múltiplas luzes; tipos de luz.

Calcular a matriz normal e passar as normais ao shader
Implementar luz ambiente + difusa
Adicionar a especular (Phong) e depois Blinn-Phong
Adicionar mapas de difusa e especular
Implementar luz direcional, pontual (atenuação) e spot
Usar 4 luzes pontuais ao mesmo tempo

requiredCarregar modelos 3D (glTF)4 micro tasks

Importar malhas, materiais e hierarquias de arquivos reais.

Carregar um .obj com Assimp
Carregar um glTF com submalhas e materiais
Respeitar a hierarquia de nós do glTF
Mostrar o modelo 'Sponza' e navegar nele

Books: Learn OpenGL (Joey de Vries) · Learn OpenGL: Beginners guide to 3D rendering (Frahaan Hussain)

requiredFramebuffers e pós-processamento5 micro tasks

Renderizar para textura: base de sombras, bloom, HDR e efeitos de tela cheia.

Renderizar a cena para uma textura (FBO) e mostrá-la num quad
Aplicar um efeito simples de tela (grayscale, inversão)
Implementar blur (kernel) em pós-processamento
Renderizar em HDR (float) com tone mapping
Implementar bloom

Books: Learn OpenGL (Joey de Vries) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · OpenGL: Build High Performance Graphics (Movania, Wolff et al.)

requiredShadow mapping5 micro tasks

Primeiro efeito 'de verdade' de renderização. Exige FBO, matrizes de luz e bias.

Renderizar o depth map da luz
Calcular a matriz da luz e transformar fragmentos
Aplicar a sombra no shader principal
Corrigir shadow acne com bias
Suavizar com PCF

Books: Learn OpenGL (Joey de Vries) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · OpenGL 4 Shading Language Cookbook (David Wolff) · Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger)

requiredSkybox, cubemaps e reflexão4 micro tasks

Fundo, reflexo e refração com cubemaps.

Carregar um cubemap de 6 imagens
Desenhar o skybox sem escrever profundidade
Implementar reflexão com cubemap
Implementar refração com cubemap

Books: Learn OpenGL (Joey de Vries)

requiredDear ImGui para ferramentas4 micro tasks

Interface imediata para depurar parâmetros em tempo real. Vai salvar horas do seu tempo.

Integrar Dear ImGui com GLFW + OpenGL
Criar um slider para a posição da luz
Criar um color picker para a cor da luz
Mostrar FPS e tempo de frame num painel

optionalPBR e IBL4 micro tasks

Materiais fisicamente baseados (metalness/roughness) e iluminação por imagem.

Implementar a BRDF Cook–Torrance com uma luz pontual
Fazer uma grade de esferas variando metallic e roughness
Adicionar IBL difusa com irradiance map
Adicionar IBL especular (prefilter + BRDF LUT)

Books: Learn OpenGL (Joey de Vries) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · OpenGL 4 Shading Language Cookbook (David Wolff)

optionalInstancing e batching3 micro tasks

Desenhar milhares de objetos com poucas chamadas.

Desenhar 1.000 objetos com glDrawElementsInstanced
Subir para 100 mil e medir o FPS
Comparar com 100 mil draw calls separados

Books: Learn OpenGL (Joey de Vries) · OpenGL: Build High Performance Graphics (Movania, Wolff et al.)

optionalDeferred shading e luzes dinâmicas3 micro tasks

G-buffer para muitas luzes.

Criar o G-buffer com posição, normal e albedo
Passar a iluminação em tela cheia
Renderizar 100 luzes pontuais

Books: Learn OpenGL (Joey de Vries)

optionalNormal mapping, parallax e SSAO3 micro tasks

Detalhe sem geometria extra.

Implementar normal mapping com espaço tangente
Adicionar parallax mapping
Implementar SSAO

Books: Learn OpenGL (Joey de Vries)

optionalAnimação esqueletal4 micro tasks

Ossos, skinning e blending de animações.

Carregar ossos e pesos de um glTF
Calcular matrizes de pose por keyframe
Fazer skinning no vertex shader
Misturar duas animações (blend)

Books: Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory) · OpenGL: Build High Performance Graphics (Movania, Wolff et al.)

optionalRenderização de texto3 micro tasks

Fontes bitmap, FreeType, SDF.

Carregar uma fonte com FreeType e gerar um atlas
Desenhar uma string na tela
Gerar uma fonte SDF e escalar sem perder qualidade

Books: Learn OpenGL (Joey de Vries)

optionalRay tracing em software4 micro tasks

Projeto de fim de semana que ensina física da luz e matemática de forma única.

Gerar uma imagem PPM com um gradiente
Adicionar a esfera e as normais
Adicionar materiais difuso, metal e vidro
Adicionar câmera com foco e renderizar a capa do livro

optionalRasterizador em software4 micro tasks

Escreva seu próprio pipeline na CPU: o melhor jeito de entender GPU.

Desenhar linhas com Bresenham
Preencher triângulos com baricêntricas
Adicionar z-buffer
Texturizar e iluminar um modelo .obj

Books: Computer Graphics: Theory and Practice (Gomes, Velho, Sousa et al.)

optionalLivros de referência2 micro tasks

Para quando quiser ver um tema por outro ângulo.

Ler um capítulo do SuperBible sobre um tema que você já viu e comparar
Anotar 3 técnicas que ainda não conhece para estudar depois

Books: OpenGL SuperBible (Sellers, Wright et al.) · Advanced Graphics Programming Using OpenGL (McReynolds & Blythe) · OpenGL: Build High Performance Graphics (Movania, Wolff et al.)

Shaders a Fundo

2 meses (em paralelo com a Fase 4)

Goal: Sair do 'copiar do tutorial' e escrever shaders do zero, entendendo cada linha e a matemática por trás de cada efeito.
Deliverable: Uma galeria de 10 efeitos (dissolve, outline, toon, água, fogo, névoa, holograma, terreno, ruído, distorção) e ao menos 3 shaders do Shadertoy reescritos por você.
Estimated time: 2 meses (em paralelo com a Fase 4)

requiredLinguagem GLSL4 micro tasks

Tipos, vetores, swizzling, funções built-in, uniforms, in/out, precisão.

Ler a seção de funções built-in e testar mix, step, smoothstep, clamp, fract, mod
Treinar swizzling com 10 expressões
Reescrever o shader de iluminação sem olhar o tutorial
Passar dados do vertex ao fragment com interpolação e analisar o resultado

Books: Practical Shader Development (Kyle Halladay) · GLSL Essentials (Jacobo Rodriguez) · OpenGL 4 Shading Language Cookbook (David Wolff)

requiredFunções de forma e SDF4 micro tasks

Moldar valores (smoothstep, easing) e desenhar formas pelo campo de distância.

Desenhar um círculo com `length`/`distance` e `smoothstep`
Desenhar um retângulo e uma estrela por SDF
Combinar formas com união, interseção e subtração
Fazer um logo só com SDFs

Books: Practical Shader Development (Kyle Halladay)

requiredRuído e procedural5 micro tasks

Value noise, Perlin, simplex, fBm. Base de terrenos, nuvens, fogo, água.

Implementar um hash 2D e visualizar como ruído branco
Implementar value noise 2D
Implementar gradient (Perlin) noise
Somar oitavas (fBm) e gerar nuvens
Usar domain warping para fazer fogo/mármore

Books: OpenGL 4 Shading Language Cookbook (David Wolff) · Procedural Content Generation for C++ Game Development (Dale Green)

requiredEfeitos clássicos de jogo6 micro tasks

Os efeitos que valem portfólio: dissolve, outline, toon, hologram, água, fresnel.

Efeito dissolve com ruído e borda brilhante
Outline (inverted hull ou pós-processamento)
Toon shading com degraus de luz
Fresnel/rim light
Água: ondas senoidais + reflexo
Holograma (scanlines + fresnel)

Books: Practical Shader Development (Kyle Halladay) · OpenGL 4 Shading Language Cookbook (David Wolff) · OpenGL: Build High Performance Graphics (Movania, Wolff et al.)

requiredDepuração de shaders4 micro tasks

Sem printf: como investigar o que a GPU faz.

Visualizar normais como cor
Visualizar UVs e profundidade
Capturar um frame com o Xcode GPU Capture ou RenderDoc
Achar um bug de propósito num shader usando só cores de debug

optionalCompute shaders3 micro tasks

GPGPU: partículas, simulação, culling. Não existe em OpenGL no macOS (limite 4.1); use Vulkan/Metal.

Ler como funcionam workgroups e invocations
Escrever um compute que preenche uma imagem
Simular 100 mil partículas em compute

Books: OpenGL 4 Shading Language Cookbook (David Wolff) · Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

optionalGeometry e tessellation2 micro tasks

Gerar geometria na GPU. Menos usado hoje.

Gerar quads a partir de pontos num geometry shader
Aplicar tessellation com displacement de um mapa de altura

Books: Computer Graphics Programming in OpenGL Using C++ (3ª ed.) (Gordon & Clevenger) · OpenGL 4 Shading Language Cookbook (David Wolff)

optionalHLSL / Shader Graph (Unity)2 micro tasks

Se um dia usar Unity ou DirectX.

Converter um shader GLSL simples para HLSL
Montar um efeito no Shader Graph

optionalSPIR-V, Slang e compilação de shaders3 micro tasks

Necessário para Vulkan: GLSL/HLSL/Slang → SPIR-V.

Compilar GLSL para SPIR-V com glslangValidator
Inspecionar o SPIR-V gerado (spirv-dis)
Compilar um shader em Slang

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

optionalDesafio Shadertoy4 micro tasks

Reescrever shaders prontos é a melhor prática depois dos tutoriais.

Escolher e estudar um shader do Shadertoy
Reescrevê-lo sem olhar, em 1 sessão
Mudar 3 constantes e explicar o que cada uma faz
Publicar o seu primeiro shader no Shadertoy

Vulkan (Trilha Recomendada)

3–5 meses · optional track

Goal: Dominar uma API explícita moderna. Opcional para fazer um jogo, mas muito valorizada em vagas de graphics/engine programmer, e é algo que você já quer aprender.
Deliverable: Um renderizador Vulkan que carrega glTF, desenha com iluminação e sombras e roda com validation layers sem erros.
Estimated time: 3–5 meses

requiredDecisão: OpenGL, Vulkan ou outra API?3 micro tasks

Entender o porquê antes do como. Vulkan dá controle total e exige que você gerencie tudo.

Escrever o parágrafo 'por que Vulkan?'
Listar 5 diferenças entre OpenGL e Vulkan
Rodar um exemplo oficial (vkcube) via MoltenVK

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

requiredInstância, dispositivo e swapchain5 micro tasks

Boilerplate fundamental: instance, physical/logical device, queues, surface, swapchain.

Instalar o Vulkan SDK e rodar vulkaninfo
Criar instance com validation layers
Escolher o physical device e as queue families
Criar device, surface e swapchain
Limpar a tela com uma cor, sem erros de validação

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

requiredPipelines, render passes e dynamic rendering4 micro tasks

Descrever todo o estado gráfico antecipadamente.

Compilar shaders para SPIR-V
Criar o graphics pipeline
Usar dynamic rendering
Desenhar o triângulo

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

requiredCommand buffers e sincronização4 micro tasks

O assunto mais difícil: fences, semaphores, barriers e frames em voo.

Gravar command buffers por frame
Implementar frames in flight com fences e semaphores
Adicionar uma barrier de layout de imagem e explicá-la
Redimensionar a janela (recriar a swapchain)

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

requiredMemória, buffers e imagens4 micro tasks

Alocar memória GPU com VMA, staging buffers, texturas e mipmaps.

Integrar o VMA
Criar um vertex buffer com staging
Carregar uma textura com mipmaps
Criar o sampler com anisotropia

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

requiredDescritores e uniforms4 micro tasks

Descriptor sets, push constants, buffer device address, bindless.

Criar o descriptor set layout e o pool
Passar um UBO com MVP por frame
Usar push constants para a matriz do modelo
Passar a textura por descriptor

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

requiredCena completa: depth, MSAA, modelos, iluminação6 micro tasks

Port do visualizador da Fase 4 para Vulkan.

Adicionar depth buffer
Adicionar MSAA
Carregar um glTF
Iluminação Blinn-Phong
Shadow map
Zero erros de validação na cena completa

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

optionalRender graph e abstração de renderer2 micro tasks

Organizar passes e recursos como um engine real.

Descrever os passes da cena em uma lista
Implementar barreiras automáticas entre passes

Books: Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory) · Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

optionalGPU-driven, compute e ray tracing3 micro tasks

Culling na GPU, indirect draw, ray tracing KHR.

Rodar um compute shader simples em Vulkan
Fazer frustum culling na GPU
Usar indirect draw

Books: Vulkan 3D Graphics Rendering Cookbook (Kosarevsky, Medvedev et al.)

optionalFerramentas de depuração GPU3 micro tasks

Validation layers, RenderDoc, Nsight, Xcode.

Nomear objetos Vulkan com debug utils
Capturar um frame no RenderDoc (Win/Linux) ou Xcode
Ler 3 mensagens de validação e consertar cada uma

Arquitetura de Engine

2–3 meses

Goal: Organizar tudo que fez até aqui em uma base reutilizável: ECS, recursos, cena, renderer, eventos, ferramentas.
Deliverable: Um 'mini-engine' seu: ECS + renderer + gerenciador de recursos + ImGui + cena carregável, usado para os projetos seguintes.
Estimated time: 2–3 meses

requiredSubsistemas e inicialização4 micro tasks

Ordem de start-up/shutdown, módulos independentes, logging, configuração.

Desenhar o diagrama dos módulos (core, platform, renderer, game)
Criar o log com níveis e arquivo
Ler a configuração de um arquivo JSON
Implementar start-up e shutdown em ordem inversa

Books: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory) · Mastering 3D Game Engine Development with C++ (Andrew M. Jones)

requiredECS e componentes5 micro tasks

Entidade–Componente–Sistema: composição em vez de herança.

Implementar entidades como IDs
Armazenar componentes em sparse sets
Escrever uma query: todas as entidades com Transform + Mesh
Criar 3 sistemas (movimento, render, vida)
Substituir pelo EnTT e comparar

Books: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

requiredGerenciamento de recursos4 micro tasks

Carregar/liberar texturas, malhas, shaders e áudio com handles e cache; hot reload.

Criar handles para texturas e malhas
Evitar carregar o mesmo asset duas vezes (cache)
Implementar hot reload de shaders
Liberar recursos sem uso

Books: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory) · C++ Memory Management (Patrice Roy)

requiredCena e hierarquia de transformação4 micro tasks

Scene graph, transform local/mundo, parent/child.

Implementar transform local e matriz de mundo
Implementar parent/child com atualização suja
Fazer uma torreta filha de um tanque
Salvar e carregar uma cena

Books: Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop)

requiredCamada de renderização4 micro tasks

Abstração: submeter 'draw items', ordenar, agrupar e renderizar.

Criar uma fila de draw items
Ordenar por pipeline/material
Implementar debug draw (linhas, AABB)
Separar a câmera da cena

Books: Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · Mastering 3D Game Engine Development with C++ (Andrew M. Jones)

requiredEventos e mensagens3 micro tasks

Desacoplar sistemas: dispatcher, fila de eventos.

Implementar um event dispatcher tipado
Disparar eventos de dano e morte
Medir o custo de eventos por frame

Books: Game Programming Patterns (Robert Nystrom)

requiredParticionamento espacial e culling4 micro tasks

Grade, quadtree/octree, BVH para colisão e visibilidade.

Implementar uma grade uniforme
Implementar um quadtree
Comparar o tempo de colisão de 10 mil objetos com e sem estrutura
Implementar frustum culling

Books: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory) · Foundations of Game Engine Development, Vol. 2: Rendering (Eric Lengyel) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop)

requiredSerialização e save/load4 micro tasks

Salvar estado do jogo e carregar níveis.

Salvar um componente em JSON
Salvar a cena inteira
Versionar o formato do arquivo
Implementar save/load do jogo

Books: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

optionalJob system e multithreading3 micro tasks

Paralelizar update, animação e culling.

Criar um job system com N threads
Paralelizar o update de partículas
Medir o ganho

Books: C++ High Performance (2ª ed.) (Andrist, Sehr, Garney) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

optionalAllocators custom2 micro tasks

Arena/pool/frame allocators.

Criar um frame allocator reiniciado por frame
Usar em dados temporários do renderer

Books: C++ Memory Management (Patrice Roy) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

optionalScripting (Lua)3 micro tasks

Dados e lógica de gameplay fora do C++.

Embutir Lua com sol2
Expor um componente ao Lua
Escrever um comportamento de inimigo em Lua

optionalÁudio 3D2 micro tasks

Espacialização e mixagem.

Tocar sons posicionais com atenuação
Implementar o mixer de música e efeitos

Books: Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

optionalRede para multiplayer2 micro tasks

Sincronização, predição, lag compensation.

Fazer um servidor/cliente UDP de eco
Sincronizar uma posição entre dois clientes

optionalEditor de níveis3 micro tasks

Ferramenta própria com ImGui para posicionar entidades.

Selecionar entidades com picking
Mover com gizmos
Implementar undo/redo com Command

Books: Game Programming Patterns (Robert Nystrom)

optionalEstudar outro engine para comparar2 micro tasks

Ler código-fonte de engines open source para ver soluções diferentes.

Ler o código do loop principal do Godot
Comparar o ECS dele com o seu

Books: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

Física e Simulação

2 meses

Goal: Fazer corpos se moverem e colidirem de forma crível; entender o que acontece dentro de motores como Box2D e Jolt.
Deliverable: Um sandbox 2D com corpos rígidos (círculos, caixas, polígonos), atrito, restituição, empilhamento e uma mola/junta.
Estimated time: 2 meses

requiredCinemática e integração numérica4 micro tasks

Posição, velocidade, aceleração. Escolher o integrador certo muda a estabilidade.

Simular queda livre com Euler e Verlet e comparar
Adicionar arrasto do ar
Simular órbita de um planeta e medir a deriva da energia
Usar timestep fixo

Books: Physics for Game Developers (Bourg & Bywalec) · Physics for JavaScript Games, Animation, and Simulations (Dobre & Ramtal) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop)

requiredCorpos rígidos4 micro tasks

Massa, inércia, torque, momento linear e angular.

Criar a struct RigidBody (massa, inércia, velocidade, ω)
Aplicar uma força fora do centro e gerar torque
Integrar orientação
Visualizar a velocidade angular

Books: Physics for Game Developers (Bourg & Bywalec) · C++ Game Physics Simulations (Katie Millie) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

requiredDetecção de colisão4 micro tasks

Broad phase + narrow phase: AABB, SAT, GJK.

Implementar uma broad phase por grade
Implementar SAT para polígonos convexos 2D
Calcular os pontos de contato
Visualizar normais e profundidade de penetração

Books: Physics for Game Developers (Bourg & Bywalec) · Essential Mathematics for Games and Interactive Applications (2ª ed.) (Van Verth & Bishop) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

requiredResolução de colisão por impulsos5 micro tasks

Calcular impulsos, atrito e restituição; lidar com empilhamento.

Calcular o impulso normal
Adicionar restituição
Adicionar atrito
Iterar vários passes de solver
Empilhar 5 caixas estáveis por 10 s

Books: Physics for Game Developers (Bourg & Bywalec) · C++ Game Physics Simulations (Katie Millie)

requiredCharacter controller4 micro tasks

A física que o jogador sente: andar em rampas, pular, subir degraus, plataformas móveis.

Mover o personagem com colisão deslizante
Subir degraus pequenos
Andar em rampas sem escorregar
Plataforma móvel carregando o jogador

Books: Physics for Game Developers (Bourg & Bywalec) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

requiredUsar Box2D / Jolt no projeto4 micro tasks

Integrar um motor de física profissional ao seu engine.

Integrar o Box2D num protótipo 2D
Integrar o Jolt Physics na cena 3D
Sincronizar a física com os transforms do ECS
Criar um trigger de dano

optionalJuntas e restrições2 micro tasks

Molas, dobradiças, cordas.

Criar uma junta de mola entre dois corpos
Criar uma corrente de corpos

Books: Physics for Game Developers (Bourg & Bywalec)

optionalCorpos moles, tecidos e cordas2 micro tasks

Verlet em malhas.

Simular uma corda com Verlet
Simular um tecido pendurado

Books: Physics for Game Developers (Bourg & Bywalec) · C++ Game Physics Simulations (Katie Millie)

optionalPartículas e fluidos2 micro tasks

Sistemas de partículas, SPH.

Criar um emissor de partículas com gravidade
Simular um SPH 2D simples

Books: C++ Game Physics Simulations (Katie Millie) · OpenGL: Build High Performance Graphics (Movania, Wolff et al.)

optionalFísica 3D de corpos rígidos3 micro tasks

Tensores de inércia, GJK/EPA, quaternions.

Calcular o tensor de inércia de uma caixa
Detectar colisão esfera–caixa em 3D
Estudar GJK numa implementação 2D

Books: Physics for Game Developers (Bourg & Bywalec) · Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

IA e Lógica de Jogo

1,5–2 meses

Goal: Dar vida a inimigos e sistemas: decisão, movimento, navegação e regras de jogo (combate, progressão, inventário).
Deliverable: Inimigos com FSM, steering e pathfinding A* em um mapa, mais um sistema de dados de combate (stats, habilidades, cooldowns) orientado a dados.
Estimated time: 1,5–2 meses

requiredMáquinas de estado e hierárquicas4 micro tasks

A base da IA de 90% dos jogos.

Desenhar a FSM do inimigo
Implementar os estados patrulha, perseguir e atacar
Adicionar o estado fugir com vida baixa
Visualizar o estado atual sobre a cabeça do inimigo

Books: Programming Game AI by Example (Mat Buckland) · Game Programming Patterns (Robert Nystrom)

requiredSteering behaviors5 micro tasks

Seek, flee, arrive, pursuit, wander, evade, separação, alinhamento, coesão (flocking).

Implementar seek e flee
Implementar arrive
Implementar pursuit/evade
Implementar separação, alinhamento e coesão (boids)
Fazer um bando de 200 agentes

Books: Programming Game AI by Example (Mat Buckland)

requiredPathfinding e navegação5 micro tasks

A* em grade, grafos e navmesh; custo de terreno; suavização de caminho.

Criar uma grade de navegação com obstáculos
Rodar A* e desenhar o caminho
Suavizar o caminho
Recalcular o caminho com obstáculos móveis
Testar Recast/Detour num mapa 3D

Books: Programming Game AI by Example (Mat Buckland) · Grokking Algorithms (Aditya Bhargava) · Algoritmos (CLRS, edição em português) (Thomas Cormen et al.)

requiredPercepção e comportamento4 micro tasks

Visão (cone), audição, memória; reação ao jogador.

Implementar um cone de visão
Bloquear a visão com raycast
Adicionar memória da última posição vista
Alertar inimigos próximos

Books: Programming Game AI by Example (Mat Buckland)

requiredSistemas de regras de jogo5 micro tasks

Combate, vida, dano, buffs, cooldowns, inventário e progressão.

Criar a struct de Stats com modificadores
Criar habilidades descritas em JSON (dano, custo, cooldown)
Implementar cooldowns e buffs temporários
Criar um sistema de inventário
Criar uma tabela de loot

Books: Game Programming Patterns (Robert Nystrom) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

requiredDesign de mecânicas4 micro tasks

Core loop, risco/recompensa, curva de dificuldade, balanceamento. É a parte que torna o jogo divertido.

Escrever o pitch do jogo em uma frase
Descrever o core loop em 5 passos
Definir 3 pilares do jogo
Escrever um GDD de 1 página

optionalBehavior Trees2 micro tasks

Comportamento modular e legível para IA mais complexa.

Implementar Sequence e Selector
Reescrever a IA do inimigo como uma BT

Books: Programming Game AI by Example (Mat Buckland)

optionalUtility AI e GOAP2 micro tasks

IA baseada em pontuação ou em planejamento de objetivos.

Implementar uma IA por pontuação de ações
Ajustar as curvas de utilidade com ImGui

optionalGeração procedural4 micro tasks

Masmorras, terrenos, itens: replay infinito com pouco conteúdo.

Gerar salas por BSP
Conectar com corredores
Gerar cavernas com autômato celular
Usar uma seed para reproduzir o mapa

Books: Procedural Content Generation for C++ Game Development (Dale Green)

optionalIA aprendida (ML)2 micro tasks

Apenas curiosidade: raramente usada em jogos shippados.

Treinar uma rede pequena (XOR)
Ler sobre RL em jogos e resumir em 5 linhas

Books: Math for Programmers (3D graphics, ML, simulations) (Paul Orland)

Arte, Áudio e Assets: o Mínimo

2 semanas + contínuo

Goal: Conseguir produzir um jogo bonito o bastante sem ser artista: usar assets prontos com bom gosto e saber ajustar o essencial.
Deliverable: Um pipeline simples: asset (Blender/Kenney) → glTF/PNG → seu engine, com licenças anotadas.
Estimated time: 2 semanas + contínuo

requiredUsar assets prontos4 micro tasks

Onde encontrar e como escolher um estilo coerente.

Escolher um pack de estilo único
Baixar e organizar em assets/
Criar o LICENCAS.md com origem e licença de cada asset
Verificar se a licença permite uso comercial

requiredFormatos e pipeline de assets3 micro tasks

glTF para modelos, PNG/KTX2 para texturas, WAV/OGG para áudio.

Exportar um modelo para glTF/GLB
Gerar atlas de texturas
Escrever um script que valida os assets (tamanho, nomes)

Books: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

requiredBlender: o essencial4 micro tasks

Abrir, ajustar escala/origem, aplicar materiais simples, exportar glTF.

Fazer o tutorial do donut (primeiras 2 partes)
Importar um modelo, corrigir escala e origem
Aplicar um material simples
Exportar para glTF e carregar no seu engine

Books: Blender 3D Basics (Blender 2.7) (Gordon C. Fisher)

requiredÁudio mínimo3 micro tasks

Efeitos e música livres, sons retrô gerados.

Gerar 5 efeitos com sfxr
Normalizar o volume
Escolher uma trilha com licença livre

requiredUI/HUD simples3 micro tasks

Barras de vida, menus e texto legíveis.

Desenhar a barra de vida
Desenhar o texto de pontuação
Testar a UI em 3 resoluções

optionalAnimação com Mixamo / rigging2 micro tasks

Animações prontas para personagens humanoides.

Baixar uma animação do Mixamo
Carregar e reproduzir no engine

Books: Game Engine Architecture, Vol. II (4ª ed.) (Jason Gregory)

optionalModelagem 3D própria2 micro tasks

Low poly simples.

Modelar um objeto low poly simples
Fazer o UV unwrap e texturizar

Books: Blender 3D Basics (Blender 2.7) (Gordon C. Fisher)

optionalPixel art2 micro tasks

Se escolher 2D.

Desenhar um sprite 16x16
Animar em 4 frames

optionalCompor música2 micro tasks

LMMS, BeepBox.

Compor um loop de 8 compassos
Exportar e testar no jogo

Projeto Final: Jogo Funcional

3–6 meses

Goal: Aplicar tudo para entregar um jogo completo, jogável do início ao fim, com seu motor, seus shaders, sua matemática e sua IA.
Deliverable: Um jogo publicado (ao menos no itch.io) com menu, 20–30 minutos de conteúdo, áudio, save e build para pelo menos duas plataformas.
Estimated time: 3–6 meses

requiredEscolher escopo e ideia3 micro tasks

Uma mecânica, um loop, uma página de GDD.

Listar 3 ideias e avaliar cada uma (escopo, risco, diversão)
Escolher UMA e escrever o pitch
Fixar o prazo e a lista 'precisa / seria bom / sonho'

requiredIdeias de jogo para o projeto final3 micro tasks

Opções que combinam com gráficos 3D + mecânicas + IA.

Listar o que cada ideia exercita (render, física, IA, PCG)
Escolher a ideia final e criar as 3 primeiras tarefas
Criar o repositório e o quadro de tarefas

Books: Procedural Content Generation for C++ Game Development (Dale Green) · Programming Game AI by Example (Mat Buckland) · Physics for Game Developers (Bourg & Bywalec) · Mastering C++ Game Development (Mickey MacDonald)

requiredProtótipo em 'greybox'5 micro tasks

Mecânica jogável com formas simples antes de qualquer arte.

Fazer o personagem se mover e interagir com formas simples
Implementar a mecânica central
Jogar 30 minutos e anotar o que não funciona
Gravar um vídeo curto do protótipo
Decidir seguir ou cortar

Books: Game Programming Patterns (Robert Nystrom)

requiredVertical slice4 micro tasks

Uma fase completa com qualidade final: prova que o jogo funciona de ponta a ponta.

Definir as dimensões do nível vertical slice
Aplicar a arte e o áudio finais nesse nível
Adicionar UI, feedback e juice
Passar o nível do menu à vitória sem bugs graves

requiredProdução de conteúdo3 micro tasks

Replicar o que funciona: mais níveis, inimigos, itens e variação.

Criar a ferramenta/arquivo de dados para níveis
Fazer 5 níveis (ou 3 inimigos novos)
Ajustar a curva de dificuldade

requiredMenu, configurações, save e polimento5 micro tasks

O que separa protótipo de produto.

Criar o menu principal e a pausa
Criar as configurações de áudio e vídeo
Implementar save/load
Adicionar a tela de créditos
Tratar os erros de arquivos ausentes sem travar

Books: Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

requiredProfiling e otimização4 micro tasks

Medir primeiro; caçar gargalos de CPU e GPU.

Medir o frame time com Tracy
Achar os 3 maiores gargalos
Corrigir um gargalo e medir de novo
Estabilizar 60 FPS no hardware-alvo

Books: C++ High Performance (2ª ed.) (Andrist, Sehr, Garney) · Game Engine Architecture, Vol. I (4ª ed.) (Jason Gregory)

requiredBuild, empacotamento e distribuição4 micro tasks

Gerar executáveis para outras máquinas e testar em máquina limpa.

Gerar o build Release
Empacotar os assets junto
Testar em um computador limpo
Configurar o CI para gerar os builds

requiredPlaytest e correções4 micro tasks

Observe pessoas jogando em silêncio. Os problemas ficam óbvios.

Chamar 5 pessoas para jogar
Observar em silêncio e anotar onde travam
Listar os 10 maiores problemas
Corrigir os 5 mais graves

optionalMultiplayer local/online2 micro tasks

Fora do escopo do primeiro jogo, na maioria dos casos.

Adicionar o segundo jogador local
Definir o modelo de rede (se online)

optionalGamepad, localização e acessibilidade3 micro tasks

Diferenciais baratos de profissionalismo.

Suportar o gamepad em toda a UI
Traduzir os textos para PT/EN
Adicionar legendas ou modo daltônico

optionalConquistas e integração com Steam2 micro tasks

Steamworks SDK.

Integrar o Steamworks SDK de teste
Criar 3 conquistas

Carreira e Publicação

contínuo

Goal: Transformar o que você construiu em oportunidade: emprego em estúdio ou jogo próprio publicado.
Deliverable: Portfólio público (GitHub + vídeos), página no itch.io e, se quiser, página na Steam.
Estimated time: contínuo

requiredPortfólio técnico5 micro tasks

3 projetos fortes com vídeo curto, README claro e código limpo.

Criar um README para cada projeto, com GIF ou vídeo
Gravar um vídeo de 60 s por projeto
Escrever um post técnico sobre algo que aprendeu
Organizar o GitHub (pins, descrição, licença)
Escrever um currículo de 1 página

requiredGame jams4 micro tasks

Treinam escopo, prazo e finalização. Melhor atalho para terminar jogos.

Escolher a primeira game jam e se inscrever
Definir um escopo de 48 h
Entregar o jogo
Escrever o pós-mortem

requiredPublicar no itch.io4 micro tasks

Primeiro lançamento, grátis, ótimo feedback.

Criar a conta no itch.io
Preparar capturas de tela e uma descrição
Subir os builds para cada plataforma
Publicar e divulgar com um devlog

requiredSteam e lançamento comercial4 micro tasks

Se for vender: página, wishlists e prazos.

Ler os requisitos do Steamworks e a taxa atual
Criar a página 'Coming soon'
Gravar um trailer de 30 s
Planejar a data de lançamento e o Next Fest

optionalAprender Unreal ou Unity3 micro tasks

A maioria dos estúdios usa um dos dois. C++ + Unreal é uma combinação muito empregável.

Criar um projeto C++ no Unreal e abrir o template
Reproduzir uma mecânica sua no Unreal
Listar as 5 diferenças do seu engine

optionalComunidade e networking3 micro tasks

Eventos, Discords, LinkedIn, GDC talks.

Entrar em 2 comunidades de dev de jogos
Postar o seu progresso uma vez por semana
Assistir a 3 palestras do GDC Vault sobre seu tema

optionalAbrir a própria empresa3 micro tasks

Aspectos legais e financeiros se for vender: MEI/ME, contabilidade, direitos autorais, contratos.

Pesquisar o MEI/ME para desenvolvimento de jogos
Conversar com um contador
Ler sobre licenças e direitos autorais de assets

optionalMarketing e devlog3 micro tasks

Divulgar durante o desenvolvimento, não só no fim.

Criar um canal para o devlog
Postar 3 GIFs do jogo
Criar um Discord ou newsletter