Voltar para o Blog
Quest Log

Configurações de Vídeo no Godot 4: Resolução, Tela Cheia e VSync

Tela de configurações de vídeo de um jogo com opções de resolução, tela cheia e sincronização vertical em uma lista lateral

Monte uma tela de configurações de vídeo no Godot 4: troca de resolução, tela cheia, VSync e content scale sem distorcer a UI, com GDScript tipado.

Ferramenta:Godot

Configurações de Vídeo no Godot 4: Resolução, Tela Cheia e VSync

Toda tela de opções de jogo tem uma aba de vídeo, e ela é enganosamente simples de descrever: um botão de tela cheia, uma lista de resoluções, um interruptor de VSync. Só que na hora de montar isso no Godot 4 batem as dúvidas de sempre. Qual a diferença entre os modos de janela? Por que a UI distorce quando troco a resolução? O VSync fica em qual API? Este tutorial monta uma tela de configurações de vídeo no Godot 4 completa, cobrindo troca de resolução, tela cheia em todas as variantes e VSync, com uma UI de opções de verdade e todo o GDScript estaticamente tipado.

A boa notícia é que quase tudo aqui passa por uma única classe, o DisplayServer, mais os enums da classe Window. Depois que você entende esses dois nomes, o resto é ligar um OptionButton e uns CheckButton na lógica. Vamos por partes.

O DisplayServer e os modos de janela

No Godot 4, quem controla a janela do sistema operacional é o singleton DisplayServer. Ele é global, você chama de qualquer lugar, e é por ele que se troca modo de janela, tamanho, posição e VSync. A propriedade central é o modo da janela, que aceita os valores do enum Window:

func aplicar_modo_janela(modo: Window.Mode) -> void:
    DisplayServer.window_set_mode(modo)

Os modos que interessam numa tela de vídeo são quatro:

  • Window.MODE_WINDOWED: janela normal, com borda e barra de título, que o jogador pode mover e redimensionar.
  • Window.MODE_FULLSCREEN: tela cheia "borderless", uma janela sem borda do tamanho do monitor mantendo a resolução do desktop. O alt-tab é instantâneo. É o padrão que a maioria dos jogos deveria usar.
  • Window.MODE_EXCLUSIVE_FULLSCREEN: tela cheia exclusiva. O jogo assume o monitor e pode trocar o modo de vídeo. Às vezes reduz a latência, mas o alt-tab fica mais lento.
  • Window.MODE_MINIMIZED e Window.MODE_MAXIMIZED: existem, mas raramente entram numa aba de vídeo.

Para o modo sem borda (borderless) em janela, o caminho é um pouco diferente: você fica em MODE_WINDOWED e liga a flag de "sem borda" separadamente. Uma função que cobre os quatro casos práticos fica assim:

func trocar_janela(indice: int) -> void:
    match indice:
        0:  # Janela
            DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
            DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, false)
        1:  # Janela sem borda
            DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
            DisplayServer.window_set_flag(DisplayServer.WINDOW_FLAG_BORDERLESS, true)
        2:  # Tela cheia
            DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN)
        3:  # Tela cheia exclusiva
            DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_EXCLUSIVE_FULLSCREEN)

Repare em um detalhe que confunde muita gente: o DisplayServer usa constantes com o prefixo WINDOW_MODE_ (por exemplo, DisplayServer.WINDOW_MODE_FULLSCREEN), enquanto a classe Window usa MODE_ (por exemplo, Window.MODE_FULLSCREEN). Os dois se referem à mesma coisa e têm os mesmos valores numéricos. Se você tiver a referência da janela em mãos, dá pra trocar o modo por ela também:

func tela_cheia_pela_window(ligada: bool) -> void:
    var janela: Window = get_window()
    janela.mode = Window.MODE_FULLSCREEN if ligada else Window.MODE_WINDOWED

Use o que for mais legível no seu contexto. Eu prefiro o DisplayServer na tela de opções porque ela costuma ser um autoload ou um node solto, e nem sempre get_window() aponta pra janela principal.

Resolução: window_set_size e recentralizar

Trocar a resolução da janela é uma chamada só, window_set_size, que recebe um Vector2i:

func aplicar_resolucao(resolucao: Vector2i) -> void:
    DisplayServer.window_set_size(resolucao)

O problema prático é que, depois de redimensionar, a janela costuma "escorregar" pro canto da tela. A correção é recalcular a posição pra centralizar no monitor onde a janela está. O DisplayServer te dá o tamanho da tela útil (descontando barra de tarefas), então a conta é direta:

func centralizar_janela() -> void:
    var id_tela: int = DisplayServer.window_get_current_screen()
    var tamanho_tela: Vector2i = DisplayServer.screen_get_size(id_tela)
    var tamanho_janela: Vector2i = DisplayServer.window_get_size()
    var pos: Vector2i = (tamanho_tela - tamanho_janela) / 2
    pos += DisplayServer.screen_get_position(id_tela)
    DisplayServer.window_set_position(pos)

Uma observação importante: trocar resolução só faz sentido no modo janela. Em tela cheia, a janela já ocupa o monitor inteiro, e é o content scale (o Stretch, que vou explicar já já) que decide como a arte se encaixa ali. Então na hora de aplicar, o padrão é: se estiver em tela cheia, aplico o modo e ignoro o window_set_size; se estiver em janela, aplico o tamanho e recentralizo.

Content scale: por que a UI não pode distorcer

Aqui está o detalhe que separa uma tela de opções amadora de uma profissional. Se você trocar a resolução e a interface esticar ou achatar, o problema não está no seu código de vídeo, está no Stretch do projeto.

O Godot renderiza o jogo numa resolução "base" (a que você define em Project Settings, Display, Window, Viewport Width e Height) e depois escala isso pra janela real. Como ele escala é decidido por duas opções na mesma seção, dentro de Stretch:

  • Mode: deixe em canvas_items. Assim o Godot escala os elementos de UI e sprites de forma limpa, sem pixelar as fontes. O modo viewport renderiza numa resolução fixa e faz upscale bruto (bom pra pixel art), e o disabled não escala nada (é o que causa a distorção clássica).
  • Aspect: deixe em keep. Isso mantém a proporção da resolução base. Se a janela tem outra proporção, o Godot adiciona barras pretas (letterbox) em vez de deformar a imagem. As alternativas expand, keep_width e keep_height servem pra casos específicos, mas keep é o que garante que nada distorça.

Com canvas_items + keep configurados, você troca a resolução à vontade que a UI acompanha proporcionalmente. O seu código GDScript não precisa fazer nada disso na mão: é configuração de projeto, aplicada uma vez, e vale pra qualquer resolução que o jogador escolher. Vale a mesma lógica de quando você monta o menu de pause do jogo, onde a UI também precisa se manter íntegra em qualquer tamanho de tela.

Curso de Godot
Quer fazer seu primeiro jogo na Godot?

No curso de Godot da CursoGame.Dev você vai do zero ao primeiro jogo, com um desafio prático em cada level e suporte individual no WhatsApp quando travar.

Conhecer o curso de Godot
Suporte no WhatsAppAcesso vitalícioGarantia de 7 dias

VSync: window_set_vsync_mode

O VSync (sincronização vertical) alinha a entrega dos frames à taxa de atualização do monitor, o que elimina o "tearing", aquela linha horizontal de imagem cortada em movimentos rápidos. O custo é limitar o FPS e adicionar um pouco de latência de input. É clássico oferecer como opção, e no Godot 4 mora no DisplayServer:

func aplicar_vsync(ligado: bool) -> void:
    var modo: DisplayServer.VSyncMode = DisplayServer.VSYNC_ENABLED if ligado else DisplayServer.VSYNC_DISABLED
    DisplayServer.window_set_vsync_mode(modo)

Existem quatro modos no enum DisplayServer.VSyncMode:

  • VSYNC_DISABLED: desligado. FPS livre, com tearing possível.
  • VSYNC_ENABLED: ligado, o padrão. Sem tearing, FPS travado na taxa do monitor.
  • VSYNC_ADAPTIVE: liga quando o FPS está acima da taxa e desliga quando cai abaixo, reduzindo o "stutter" em quedas.
  • VSYNC_MAILBOX: renderiza mais rápido que o monitor e mostra sempre o frame mais recente. Menos latência, mais uso de GPU.

Para uma tela de opções, oferecer só ligado/desligado com um CheckButton já cobre 90% dos casos.

A UI de opções

Agora juntamos tudo numa cena. A ideia é um Control com três controles principais: um OptionButton pra lista de resoluções, um CheckButton pra tela cheia e outro pra VSync. A estrutura fica assim:

VideoOptions (Control)
└── VBoxContainer
    ├── ResolucaoOption (OptionButton)
    ├── TelaCheiaCheck (CheckButton, "Tela cheia")
    ├── VSyncCheck (CheckButton, "VSync")
    └── AplicarButton (Button, "Aplicar")

O script começa declarando as resoluções suportadas como uma lista tipada de Vector2i e populando o OptionButton. Prefira @onready tipado pra pegar os nodes:

extends Control

const RESOLUCOES: Array[Vector2i] = [
    Vector2i(1280, 720),
    Vector2i(1600, 900),
    Vector2i(1920, 1080),
    Vector2i(2560, 1440),
]

@onready var resolucao_option: OptionButton = $VBoxContainer/ResolucaoOption
@onready var tela_cheia_check: CheckButton = $VBoxContainer/TelaCheiaCheck
@onready var vsync_check: CheckButton = $VBoxContainer/VSyncCheck

func _ready() -> void:
    _popular_resolucoes()
    _sincronizar_com_estado_atual()

func _popular_resolucoes() -> void:
    resolucao_option.clear()
    for res: Vector2i in RESOLUCOES:
        resolucao_option.add_item("%d x %d" % [res.x, res.y])

O _sincronizar_com_estado_atual lê a janela na hora que a tela abre e marca os controles conforme o que já está valendo, pra UI não mentir pro jogador:

func _sincronizar_com_estado_atual() -> void:
    var modo_atual: int = DisplayServer.window_get_mode()
    var em_tela_cheia: bool = (
        modo_atual == DisplayServer.WINDOW_MODE_FULLSCREEN
        or modo_atual == DisplayServer.WINDOW_MODE_EXCLUSIVE_FULLSCREEN
    )
    tela_cheia_check.button_pressed = em_tela_cheia

    var vsync_atual: int = DisplayServer.window_get_vsync_mode()
    vsync_check.button_pressed = (vsync_atual != DisplayServer.VSYNC_DISABLED)

    var tamanho_atual: Vector2i = DisplayServer.window_get_size()
    var indice: int = RESOLUCOES.find(tamanho_atual)
    if indice != -1:
        resolucao_option.select(indice)

Com os controles no lugar, falta a função que pega o estado da UI e aplica de fato. Ela concentra a decisão que comentei antes: em tela cheia, aplica o modo; em janela, aplica tamanho e recentraliza. E aplica o VSync sempre.

func _on_aplicar_button_pressed() -> void:
    _aplicar_configuracoes()

func _aplicar_configuracoes() -> void:
    var em_tela_cheia: bool = tela_cheia_check.button_pressed
    var vsync_ligado: bool = vsync_check.button_pressed
    var indice_res: int = resolucao_option.selected
    var resolucao: Vector2i = RESOLUCOES[indice_res]

    # VSync vale pros dois modos
    var modo_vsync: DisplayServer.VSyncMode = (
        DisplayServer.VSYNC_ENABLED if vsync_ligado else DisplayServer.VSYNC_DISABLED
    )
    DisplayServer.window_set_vsync_mode(modo_vsync)

    if em_tela_cheia:
        DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN)
    else:
        DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
        DisplayServer.window_set_size(resolucao)
        _centralizar_janela()

Não esqueça de ligar os sinais no editor (ou por código) do AplicarButton.pressed pra _on_aplicar_button_pressed. Se quiser aplicar na hora, sem botão "Aplicar", conecte também o item_selected do OptionButton e o toggled de cada CheckButton às mesmas funções. A função _centralizar_janela é a mesma que mostrei lá em cima, só copiada pra dentro deste script.

Persistindo as escolhas

Aqui vem o ponto que pega muita gente de surpresa: nada disso é salvo. Quando o jogador fecha o jogo, o DisplayServer esquece tudo, porque ele só mexe na janela da sessão atual. Na próxima abertura, o jogo volta pro que está definido no Project Settings.

A solução é gravar as três escolhas (modo de janela, resolução e VSync) num arquivo quando o jogador aplica, e ler esse arquivo logo no início do jogo pra reaplicar. O caminho padrão no Godot pra isso é o ConfigFile, que grava um .cfg legível em user://. O fluxo é: no _aplicar_configuracoes, além de mexer no DisplayServer, você chama uma função que salva os valores; e num autoload de boot, você lê e reaplica antes da primeira cena aparecer. Montei esse lado do sistema em detalhe em como salvar as opções do jogador com ConfigFile, então aqui deixo só o gancho: separe bem a camada que "aplica na janela" da que "grava em disco", porque são responsabilidades diferentes e você vai reusar a de aplicar no boot.

Um esqueleto mínimo da parte de salvar, pra fechar o raciocínio:

func salvar_video() -> void:
    var config: ConfigFile = ConfigFile.new()
    config.set_value("video", "tela_cheia", tela_cheia_check.button_pressed)
    config.set_value("video", "vsync", vsync_check.button_pressed)
    config.set_value("video", "resolucao", RESOLUCOES[resolucao_option.selected])
    config.save("user://opcoes.cfg")

No boot, você faz o caminho inverso: config.load("user://opcoes.cfg"), lê cada get_value com um valor padrão e chama as mesmas funções de aplicação. Assim a tela de vídeo e o carregamento inicial compartilham a lógica.

Reaplicando no boot com um autoload

O lado de salvar é só metade do ciclo. Se você não ler o arquivo logo na abertura, o jogo sempre começa no que está no Project Settings e só obedece o jogador depois que ele abre a tela de opções de novo. A ferramenta certa pra isso é um autoload (singleton) que roda antes da primeira cena e reaplica tudo direto no DisplayServer. Crie um script, registre em Project Settings, Autoload, e deixe ele cuidar só do carregamento:

extends Node

const CAMINHO: String = "user://opcoes.cfg"

func _ready() -> void:
    _carregar_video()

func _carregar_video() -> void:
    var config: ConfigFile = ConfigFile.new()
    var erro: int = config.load(CAMINHO)
    if erro != OK:
        return  # primeira execucao: mantem o padrao do projeto

    var tela_cheia: bool = config.get_value("video", "tela_cheia", false)
    var vsync: bool = config.get_value("video", "vsync", true)
    var resolucao: Vector2i = config.get_value("video", "resolucao", Vector2i(1280, 720))

    DisplayServer.window_set_vsync_mode(
        DisplayServer.VSYNC_ENABLED if vsync else DisplayServer.VSYNC_DISABLED
    )
    if tela_cheia:
        DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN)
    else:
        DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
        DisplayServer.window_set_size(resolucao)

O detalhe que salva horas de dor de cabeça é o if erro != OK: return. Na primeira vez que o jogo roda, o arquivo não existe, e config.load devolve um código diferente de OK. Se você ignorar isso e tentar ler os valores mesmo assim, os get_value caem nos padrões que você passou, então nada quebra, mas tratar o retorno deixa a intenção explícita e evita reaplicar lixo. Repare também que o autoload não precisa de nenhuma UI: ele só traduz o arquivo em chamadas de DisplayServer, exatamente as mesmas que a tela de opções faz quando o jogador clica em "Aplicar".

Oferecendo só as resoluções que o monitor aceita

Listar 2560x1440 fixo no OptionButton é um problema se o jogador está num monitor de 1920x1080: a janela fica maior que a tela e some parcialmente pra fora. O DisplayServer sabe o tamanho do monitor atual, então dá pra filtrar a lista antes de popular o OptionButton e mostrar só o que cabe:

func resolucoes_validas() -> Array[Vector2i]:
    var id_tela: int = DisplayServer.window_get_current_screen()
    var tamanho_tela: Vector2i = DisplayServer.screen_get_size(id_tela)
    var validas: Array[Vector2i] = []
    for res: Vector2i in RESOLUCOES:
        if res.x <= tamanho_tela.x and res.y <= tamanho_tela.y:
            validas.append(res)
    return validas

Com isso, troque o for res: Vector2i in RESOLUCOES do _popular_resolucoes por um for res: Vector2i in resolucoes_validas() e guarde essa lista filtrada num campo do script pra usar na hora de aplicar, em vez de indexar a constante RESOLUCOES direto. Assim o índice selecionado sempre bate com uma resolução que o monitor comporta. Se o jogador tem vários monitores, window_get_current_screen devolve o índice da tela onde a janela está agora, e screen_get_size te dá o tamanho dela especificamente, então a lista se ajusta ao monitor certo.

Travando o FPS junto do VSync

VSync e limite de FPS são coisas diferentes, e oferecer as duas separadas evita confusão. O VSync amarra a entrega à taxa do monitor; o limite de FPS é um teto que você define, útil pra reduzir calor e consumo em menus ou pra padronizar a física em máquinas muito rápidas. No Godot 4 o teto fica em Engine.max_fps, um inteiro, onde 0 significa "sem limite":

func aplicar_limite_fps(limite: int) -> void:
    Engine.max_fps = limite  # 0 = sem limite, 60 = teto de 60 quadros

Numa tela de opções, um OptionButton com valores tipo Sem limite, 30, 60, 120 e 144 cobre bem. Guarde a escolha no mesmo ConfigFile, na seção video, e reaplique no autoload de boot junto com o resto. Vale lembrar que, com o VSync ligado, o FPS já fica limitado à taxa do monitor de qualquer jeito, então o teto manual só tem efeito visível quando ele for menor que essa taxa ou quando o VSync estiver desligado.

Confirmando a troca com reversão automática

Tem um detalhe de robustez que os jogos grandes têm e os caseiros esquecem: e se o jogador escolher uma resolução ou um modo que o monitor dele não exibe direito? A tela fica preta ou cortada, ele não enxerga o botão "Aplicar" e não tem como voltar. A solução padrão é aplicar a mudança, mostrar uma contagem regressiva e, se o jogador não confirmar a tempo, reverter sozinho pro que estava antes.

A receita tem duas partes: guardar o estado anterior antes de aplicar e disparar um temporizador que desfaz a troca se ninguém confirmar. O SceneTreeTimer do Godot 4 serve bem, porque você espera por ele com await sem travar o jogo:

var _modo_anterior: int = DisplayServer.WINDOW_MODE_WINDOWED
var _tamanho_anterior: Vector2i = Vector2i(1280, 720)
var _confirmado: bool = false

func aplicar_com_confirmacao() -> void:
    _modo_anterior = DisplayServer.window_get_mode()
    _tamanho_anterior = DisplayServer.window_get_size()
    _confirmado = false
    _aplicar_configuracoes()

    var prazo: SceneTreeTimer = get_tree().create_timer(10.0)
    await prazo.timeout
    if not _confirmado:
        _reverter()

func _on_manter_button_pressed() -> void:
    _confirmado = true
    salvar_video()

func _reverter() -> void:
    DisplayServer.window_set_mode(_modo_anterior)
    if _modo_anterior == DisplayServer.WINDOW_MODE_WINDOWED:
        DisplayServer.window_set_size(_tamanho_anterior)

A lógica é direta: antes de aplicar, você fotografa o modo e o tamanho atuais. O botão "Manter" da caixa de confirmação marca _confirmado como true e grava no ConfigFile. Se o jogador clicar a tempo, o prazo vence com _confirmado já verdadeiro e nada acontece. Se ele não enxergar nada e ficar parado, o await solta depois dos 10 segundos, _confirmado ainda é false e o _reverter devolve a janela ao estado seguro, sem gravar lixo em disco.

Enquanto o temporizador corre, atualize um Label com os segundos restantes pra dar o feedback visual da contagem. Esse padrão vale pra toda a tela de opções, não só o vídeo, e é o tipo de polimento que separa um menu caseiro de um profissional no CursoGame.Dev. Se você ainda está montando a estrutura por trás disso, veja como criar o menu principal no Godot pra ter a base de navegação, e centralize o carregamento das preferências num autoload singleton. Todos os tutoriais da engine ficam reunidos no hub do Godot.

Atalho de teclado pra alternar tela cheia

Quase todo jogador espera apertar uma tecla e ir pra tela cheia sem abrir menu nenhum. No PC o costume é F11 e Alt+Enter, e dá pra ter os dois funcionando em qualquer cena, não só na tela de opções. O jeito certo não é ler a tecla crua no _input, é registrar uma ação no Input Map e escutar essa ação, porque assim você troca o atalho depois sem mexer no código.

Primeiro, em Project Settings, Input Map, crie uma ação chamada alternar_tela_cheia e associe a ela F11 e Alt+Enter. Com a ação no lugar, um node de boot (o mesmo autoload que recarrega as opções serve bem) escuta em _unhandled_input, que só dispara quando nenhum controle de UI consumiu o evento antes:

func _unhandled_input(evento: InputEvent) -> void:
    if evento.is_action_pressed("alternar_tela_cheia"):
        _alternar_tela_cheia()
        get_viewport().set_input_as_handled()

func _alternar_tela_cheia() -> void:
    var modo_atual: int = DisplayServer.window_get_mode()
    var em_tela_cheia: bool = (
        modo_atual == DisplayServer.WINDOW_MODE_FULLSCREEN
        or modo_atual == DisplayServer.WINDOW_MODE_EXCLUSIVE_FULLSCREEN
    )
    if em_tela_cheia:
        DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_WINDOWED)
    else:
        DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN)

O set_input_as_handled evita que o mesmo toque dispare duas vezes se outro node também escutar a ação. Repare que a função lê o modo atual antes de decidir, em vez de guardar um bool próprio: isso impede o atalho de dessincronizar do estado real da janela, que é o erro mais comum aqui. Se você mantém um bool paralelo e o jogador trocou a janela por outro caminho (a tela de opções, por exemplo), o atalho passa a inverter pro lado errado.

Fica faltando um fio de coerência: se o atalho mudou a janela, a tela de opções precisa refletir isso quando abrir. Como o _sincronizar_com_estado_atual daquela cena lê o DisplayServer direto, o CheckButton de tela cheia já vai marcar certo na próxima vez que o jogador abrir as opções, sem código extra. Um checklist pra fechar o atalho: ação criada no Input Map com as duas combinações, escuta em _unhandled_input e não no _input, decisão baseada no window_get_mode e não num bool guardado, e set_input_as_handled pra não repetir. Se você quer que a troca pelo atalho também persista, chame a mesma função de salvar com ConfigFile que a tela de opções usa, pra não perder a escolha no próximo boot.

Oferecendo a resolução nativa como opção

Um detalhe que jogos comerciais trazem e os caseiros esquecem: uma opção "Nativa" que casa com a resolução real do monitor, em vez de obrigar o jogador a caçar o número certo na lista. O DisplayServer entrega esse valor, então dá pra montar a opção sozinho:

func resolucao_nativa() -> Vector2i:
    var id_tela: int = DisplayServer.window_get_current_screen()
    return DisplayServer.screen_get_size(id_tela)

Com isso, você adiciona um item "Nativa" no topo do OptionButton e, quando ele estiver selecionado, aplica resolucao_nativa() em vez de um valor fixo da constante:

func _resolucao_escolhida() -> Vector2i:
    if resolucao_option.selected == 0:
        return resolucao_nativa()
    return RESOLUCOES[resolucao_option.selected - 1]

O - 1 existe porque o item "Nativa" ocupa o índice 0 e empurra a lista fixa um lugar pra frente. Na hora de persistir, salve no ConfigFile um marcador (por exemplo a string nativa) em vez do Vector2i, pra que o jogo respeite o monitor mesmo que o jogador troque de tela depois. É o tipo de detalhe que faz a tela de opções parecer feita por quem joga, não só por quem programa.

Fechando

Uma tela de configurações de vídeo no Godot 4 se resume a três ferramentas: DisplayServer.window_set_mode com os enums de Window pra alternar janela e tela cheia, window_set_size mais o recentralizar pra resolução, e window_set_vsync_mode pro VSync. O Stretch em canvas_items + keep garante que a UI não distorça, e o ConfigFile fecha o ciclo persistindo tudo. Note que nenhuma dessas peças é complicada isolada; o trabalho é conectá-las com estados coerentes e uma UI que reflete o que está valendo.

Se você está montando o menu de opções do zero, faz sentido ter a base de UI e sinais bem firme antes. Caso ainda esteja começando, vale seguir uma trilha de Godot para iniciantes pra não ficar tropeçando em Control nodes no meio do caminho. Com a fundação no lugar, essa tela de vídeo vira quase um exercício de encaixe. Quando a lógica estiver pronta e você quiser tirar o visual padrão da engine, o passo seguinte é estilizar a interface no Godot com Theme e StyleBox, que deixa esses botões e painéis com a identidade do seu jogo.

Perguntas frequentes

Como colocar o jogo em tela cheia no Godot 4?

Use DisplayServer.window_set_mode(DisplayServer.WINDOW_MODE_FULLSCREEN) ou, quando você tem a referência da janela, atribua get_window().mode = Window.MODE_FULLSCREEN. Para tela cheia exclusiva (que troca o modo de vídeo do monitor), use WINDOW_MODE_EXCLUSIVE_FULLSCREEN. Voltar pro modo janela é WINDOW_MODE_WINDOWED.

Como trocar a resolução da janela no Godot 4?

A resolução da janela se troca com DisplayServer.window_set_size(Vector2i(largura, altura)). Depois vale recentralizar a janela com window_set_position. Para a arte do jogo escalar junto sem distorcer, configure o Stretch em Project Settings, Display, Window com o modo canvas_items e aspect keep.

Qual a diferença entre tela cheia e tela cheia exclusiva no Godot?

A tela cheia normal (WINDOW_MODE_FULLSCREEN) é uma janela sem borda do tamanho do monitor, mantendo a resolução do desktop, e o alt-tab é instantâneo. A exclusiva (WINDOW_MODE_EXCLUSIVE_FULLSCREEN) assume o controle do monitor e pode trocar o modo de vídeo, o que às vezes reduz a latência mas deixa o alt-tab mais lento.

Como ligar e desligar o VSync no Godot 4?

Use DisplayServer.window_set_vsync_mode com DisplayServer.VSYNC_ENABLED para ligar e DisplayServer.VSYNC_DISABLED para desligar. Existem ainda VSYNC_ADAPTIVE e VSYNC_MAILBOX para casos específicos. O VSync elimina o tearing na tela ao custo de limitar o FPS à taxa de atualização do monitor.

Por que a interface distorce quando eu troco a resolução no Godot?

Isso acontece quando o modo de Stretch está em disabled ou o aspect está em ignore, fazendo a UI esticar junto com a janela. A correção é ir em Project Settings, Display, Window, Stretch e usar o modo canvas_items com aspect keep, assim o conteúdo escala proporcionalmente com barras pretas em vez de deformar.

As configurações de vídeo do Godot são salvas sozinhas?

Não. Trocar o modo da janela ou a resolução em tempo de execução não persiste nada em disco. Você precisa gravar as escolhas do jogador em um arquivo, tipicamente com ConfigFile, e ler esse arquivo no início do jogo para reaplicar tudo. O DisplayServer só mexe na janela da sessão atual.