desempenho-godot

Encontre e corrija problemas de desempenho no Godot 4.7 – profilers e monitores, orçamentos de quadro, MultiMesh e APIs de servidor para milhares de objetos, WorkerThreadPool e grupos de thread, caminhos críticos em GDScript/C#, chamadas de draw, luzes, LOD, custo de física, carregamento e vazamentos de memória. Use quando o jogo engasgar, o FPS estiver baixo, o carregamento estiver lento ou a memória crescer.

O que é desempenho-godot?

Esta skill ensina como diagnosticar e otimizar o desempenho de jogos no Godot 4.7, cobrindo desde ferramentas de profiling embutidas, como o Profiler e o Visual Profiler, até técnicas avançadas para reduzir o trabalho da CPU e da GPU, gerenciar threads com WorkerThreadPool e evitar vazamentos de memória. Ela é essencial para desenvolvedores que enfrentam engasgos, baixo FPS, carregamento lento ou consumo crescente de memória, funcionando em todas as plataformas suportadas pelo Godot (mobile, desktop, web e console). A skill explica como usar Monitores para rastrear chamadas de draw, nós órfãos e tempo de física; como substituir milhares de nós individuais por MultiMesh e dados orientados a arrays; e como paralelizar tarefas com WorkerThreadPool ou grupos de thread para subtrees da cena. Além disso, aborda otimizações de GPU (luzes, sombras, overdraw, LOD, shaders) e boas práticas de carregamento e memória, incluindo dicas específicas para GDScript e C#. O conteúdo é baseado na documentação oficial do Godot 4.7 e inclui referências a padrões implementados nos testes, como um crowd com MultiMesh, uma task paralela em grupo e balas do lado do servidor.

Funciona com~Claude Code~Codex CLI~Cursor
npx skills add https://github.com/EL4CTEO/godot-skills/tree/main/skills/godot-performance

Installed? Explore more Programação e Desenvolvimento skills: steipete/bluebubbles, steipete/eightctl, steipete/blucli · View all 6 →

Perguntar na sua IA favorita

Abre um novo chat com esta habilidade de agente já pré-carregada.

Documentação

Desempenho (4.7)

Meça primeiro. Nunca otimize às cegas. Um orçamento de 16,6 ms por quadro (60 FPS) ou 8,3 ms (120 FPS) cobre script, física, renderização na CPU e GPU.

Ferramentas

  • Depurador do Editor: Profiler (funções do script; inicie-o, jogue e então ordene por tempo próprio), Visual Profiler (CPU vs GPU por passe de renderização), Monitores (FPS, tempo de processo/física, objetos, nós, nós órfãos, chamadas de draw, memória de vídeo), Network Profiler e instantâneos do ObjectDB (4.6+: compare dois instantâneos para encontrar vazamentos).
  • Código: Performance.get_monitor(Performance.TIME_PROCESS), RENDER_TOTAL_DRAW_CALLS_IN_FRAME, OBJECT_NODE_COUNT, OBJECT_ORPHAN_NODE_COUNT. Adicione seus próprios com Performance.add_custom_monitor(&"game/enemies", callable).
  • Profilers nativos (4.6+): Tracy, Perfetto (padrão do Android) e Apple Instruments podem ver quadros de GDScript, C# e GDExtension. Use-os para picos de tempo de quadro.
  • CLI: --profiling, --gpu-profile, --print-fps, --benchmark. Use --fixed-fps 60 --quit-after N para execuções repetíveis.
  • Vazamentos: nós órfãos são nós removidos da árvore, mas nunca liberados. Node.print_orphan_nodes(), get_orphan_node_ids() (4.5+).

CPU: faça menos trabalho

  • Desative o processamento que você não precisa: set_process(false)/set_physics_process(false) quando ocioso. VisibleOnScreenEnabler2D/3D pausa atores fora da tela. Timers são melhores que polling por quadro.
  • Código por quadro é o caminho crítico. Armazene nós em cache com @onready/_Ready. Use literais StringName (&"jump") para ações, grupos e nomes de métodos. Não chame get_tree().get_nodes_in_group() a cada quadro. Use GDScript tipado (opcodes tipados são mais rápidos).
  • Sinais e call_group são baratos para eventos, mas não os emita por entidade por quadro para milhares de entidades.
  • Milhares de coisas: pare de usar um Nó por coisa.
    • Visuais: MultiMeshInstance3D/2D (uma chamada de draw; escreva multimesh.buffer em lote), ou partículas de GPU.
    • Lógica: arrays simples e structs em um script gerenciador (orientado a dados), não um script por entidade.
    • Física: corpos e áreas do PhysicsServer2D/3D sem nós, ou um lote de raycasts por quadro.
    • Renderização sem nós: instâncias do RenderingServer e canvas items.
  • Física: mantenha physics_ticks_per_second em 60, a menos que o jogo precise de mais. Use formas primitivas simples e evite ConcavePolygonShape3D em corpos em movimento. Camadas e máscaras reduzem verificações de pares. Deixe corpos dormirem (can_sleep).

Threads

  • WorkerThreadPool.add_task(callable) / add_group_task(callable, count) (parallel for), então wait_for_task_completion(id). Isso é melhor que Thread cru para a maioria dos trabalhos.
  • Regra da árvore de cena: nós dentro da árvore só podem ser tocados pela thread principal, a menos que estejam em um grupo de thread (process_thread_group = PROCESS_THREAD_GROUP_SUB_THREAD, que processa aquela subárvore em paralelo e usa call_deferred_thread_group para chamadas entre grupos). De threads de trabalho, devolva resultados com call_deferred / Callable.call_deferred(). Afirme com Thread.is_main_thread() (4.7).
  • Dados compartilhados: proteja-os com Mutex, ou dê a cada trabalhador sua própria fatia e mescle na thread principal.
  • Carregamento em segundo plano: ResourceLoader.load_threaded_request(path, "", true) usa sub-threads para dependências.

GPU e renderização

  • Chamadas de draw: mescle malhas estáticas e compartilhe materiais, porque cada material único em uma superfície de malha adiciona chamadas. Use MultiMesh para repetições e atlas de textura em 2D.
  • Luzes e sombras são os consumidores habituais de GPU. Use poucas luzes omni e spot com sombra, mantenha directional_shadow_max_distance pequeno e asse a iluminação estática (LightmapGI).
  • Overdraw: grandes partículas transparentes e alpha em tela cheia. Use alpha scissor ou hash para folhagem e quads de partículas menores.
  • Escala de detalhe: LOD (mesh_lod_threshold), visibility_range_*, oclusão de oclusão e escala de resolução (FSR, MetalFX) em GPUs fracas. Escolha o renderizador certo: Mobile ou Compatibility para baixo desempenho (veja godot-3d-rendering).
  • Engasgos de shader: baker de shader (opção de exportação), menos variantes de material.

Carregamento e memória

  • preload carrega no carregamento do script e bloqueia. Use apenas para coisas pequenas que você sempre precisa. load é preguiçoso. O carregamento em thread é adequado para níveis.
  • ResourceLoader armazena recursos em cache. Reutilize-os e não duplicate() recursos compartilhados a menos que você precise de estado por instância.
  • Texturas: importação compactada em VRAM (padrão para 3D; ative para 2D grande). Mipmaps para 3D. Limite o tamanho máximo por plataforma. Áudio: streams Ogg para trilhas longas.
  • Libere o que você cria: queue_free() e pools para balas. Observe que a contagem de órfãos permanece estável.

GDScript vs C#

  • GDScript é bom para gameplay. Mova loops matemáticos apertados (pathfinding, procgen, simulações) para C# ou GDExtension, e ainda assim lote chamadas de API.
  • C#: evite alocações por quadro (LINQ, closures, formatação de string, new Godot.Collections.Array). Toda chamada de API do Godot cruza uma fronteira de interop, então lote-as. Arrays empacotados copiam quando cruzam essa fronteira.

Orçamentos por plataforma (regra prática)

Dispositivo móvel: < 100–150 chamadas de draw, 1 luz com sombra, renderizador Mobile ou Compatibility, alvo de 30–60 FPS. Web: renderizador Compatibility, single-threaded a menos que a exportação use threads (precisa de cabeçalhos de isolamento de mesma origem) e mantenha os downloads pequenos. Desktop ou console: Forward+, profile no hardware de especificação mínima.

HUD de desempenho + monitores personalizados, multidão com MultiMesh, tarefa paralela em grupo, balas do lado do servidor (compiladas pelos testes): references/patterns.md

Individual skills in this repo

This repo contains 4 individual skills — each has its own dedicated page.

Habilidades Relacionadas