Efeito de Brilho (Glow e Bloom) na Godot 4

O efeito de brilho (glow e bloom) na Godot 4 é o que faz um neon parecer neon, um projétil parecer energia pura e uma partícula parecer faísca de verdade. Sem ele, uma cor forte é só uma cor forte. Com ele, a luz vaza para fora do objeto e contamina os pixels ao redor, exatamente como acontece quando uma fonte muito brilhante bate na lente de uma câmera ou no seu olho. Neste tutorial você vai montar o glow do zero, entender a parte que mais confunde iniciante (o tal do limiar de brilho) e ligar isso tanto no 3D quanto no 2D, além de controlar o efeito por código numa cutscene ou num flash de dano.

Faço software há mais de 20 anos e a lição que trago para gamedev é que efeito bonito quase nunca é um botão mágico. Glow é um bom exemplo: são três ou quatro propriedades bem ajustadas em cima de uma cena que já foi pensada para ter pixels brilhantes. Se a cena não tem nada acima do limiar, você pode empurrar todos os controles e não vai ver halo nenhum.

Como o efeito de brilho (glow e bloom) na Godot 4 funciona por baixo

O glow na Godot 4 não é uma propriedade de um objeto individual. Ele é uma propriedade do recurso Environment, que descreve o clima geral da renderização (céu, névoa, ajuste de tom e, sim, o brilho). Esse Environment entra na cena de duas formas: por um nó WorldEnvironment, que vale para o mundo inteiro, ou pelo campo Environment de uma Camera3D. Na prática, para começar, o WorldEnvironment é o caminho mais direto.

O ponto que trava quase todo mundo é este: o glow reage a pixels brilhantes, não a objetos marcados. O motor olha a imagem já renderizada, seleciona os pixels cujo brilho passa de um limiar (o glow_hdr_threshold), borra essa seleção em vários tamanhos e soma o resultado de volta na tela. Ou seja, o halo nasce do pixel ter brilho suficiente, e não de você dizer "esse aqui brilha". Guarde isso, porque é a chave para tudo dar certo depois.

Como o efeito precisa de pixels acima de 1.0 para funcionar bem, ele mora no mundo do HDR (high dynamic range). No 3D isso vem naturalmente de materiais emissivos e de luzes. No 2D você precisa habilitar o HDR na mão, e é por isso que tanta gente reclama que "o glow não funciona no 2D". Vamos resolver os dois casos.

As propriedades do glow que importam

Antes de sair clicando, vale conhecer os controles reais do Environment. São estes:

• glow_enabled: liga ou desliga o efeito.
• glow_intensity: o quanto o brilho somado aparece na imagem final. É o controle mais direto de "força" visual.
• glow_strength: a força de cada passada de blur antes da soma.
• glow_bloom: empurra a cena inteira em direção ao glow, deixando até pixels abaixo do limiar contribuírem. Use com parcimônia, senão a tela fica lavada.
• glow_blend_mode: como o brilho é combinado com a imagem. O enum tem GLOW_BLEND_MODE_ADDITIVE, GLOW_BLEND_MODE_SCREEN, GLOW_BLEND_MODE_SOFTLIGHT, GLOW_BLEND_MODE_REPLACE e GLOW_BLEND_MODE_MIX. Additive é o mais "estoura luz". Screen é mais suave. Softlight é o mais discreto.
• glow_hdr_threshold: o limiar. Só pixels acima desse brilho geram halo. Este é o controle que decide o que brilha e o que não brilha.
• glow_hdr_scale: escala aplicada ao brilho que passa do limiar.
• glow_levels/*: são os sete níveis de tamanho do blur. Níveis baixos dão halo apertado e nítido, níveis altos dão um brilho largo e difuso. Ligar mais níveis custa mais performance.
• glow_normalized: normaliza a contribuição dos níveis para o brilho ficar mais estável quando você mistura vários tamanhos.

Não decore tudo. Na prática você vai mexer em quatro coisas: glow_hdr_threshold, glow_intensity, glow_bloom e o glow_blend_mode. O resto é ajuste fino.

Passo a passo: ligando o glow no 3D

O 3D é o caso fácil, porque materiais emissivos e luzes já produzem HDR sozinhos. Vamos montar.

Primeiro, adicione um nó WorldEnvironment à sua cena. No inspetor, crie um novo recurso Environment no campo Environment dele. Com o Environment selecionado, abra a seção Glow e marque a opção que corresponde a glow_enabled.

Agora a parte que faz o halo aparecer: você precisa de algo brilhante na cena. Pegue um MeshInstance3D (uma esfera serve bem), dê a ele um StandardMaterial3D e ligue a emissão. No material, marque emission_enabled, escolha uma cor de emissão e suba o emission_energy_multiplier para um valor acima de 1, tipo 3 ou 4. Esse multiplicador é o que empurra o brilho do pixel acima do glow_hdr_threshold.

De volta ao Environment, ajuste nesta ordem:

1. Baixe o glow_hdr_threshold até o objeto emissivo começar a vazar luz. Se você abaixar demais, a cena inteira começa a brilhar, então suba de novo até só o que deve brilhar brilhar.
2. Ajuste glow_intensity para calibrar a força do halo.
3. Escolha o glow_blend_mode. Para neon e energia, GLOW_BLEND_MODE_ADDITIVE costuma vender melhor.
4. Se quiser um clima mais sonhador e lavado, suba um pouco o glow_bloom. Se quiser precisão, deixe perto de zero.

Um erro comum é achar que o glow está fraco e detonar o glow_intensity. Quase sempre o problema real é que o material não é brilhante o bastante. O brilho nasce no pixel, então mexa no emission_energy_multiplier primeiro.

Passo a passo: ligando o glow no 2D (a parte que confunde)

No 2D não existe emissão de material 3D, então o brilho tem que vir de cor acima de 1.0. E, por padrão, o pipeline 2D nem sequer guarda valores acima de 1.0. Por isso o setup tem um passo extra que quase ninguém descobre sozinho.

Vá em Project Settings, aba Rendering, seção Viewport, e ligue o HDR 2D (a configuração use_hdr_2d). Sem isso, qualquer cor acima de 1.0 é cortada para 1.0 antes de chegar no glow, e o efeito simplesmente não tem o que espalhar.

Com o HDR 2D ligado, adicione um WorldEnvironment na cena 2D também, crie o Environment e ligue o glow do mesmo jeito que no 3D. A diferença é como você deixa um objeto brilhante: você usa cor acima de 1.0. Duas formas comuns:

• No modulate de um Sprite2D, use um valor maior que 1 em algum canal. Uma cor branca com energia 2 já estoura.
• Num CanvasItemMaterial ou num shader, produza cores com componentes acima de 1.

Para deixar isso explícito por código, dá para multiplicar a cor de um sprite e ver o halo nascer:

extends Sprite2D

@export var brilho: float = 2.5

func _ready() -> void:
    # Uma cor com energia acima de 1.0 passa do glow_hdr_threshold
    # e faz o sprite estourar de luz (precisa do HDR 2D ligado).
    modulate = Color(1.0, 0.4, 0.1) * brilho

Repare no * brilho: multiplicar um Color por um float acima de 1 gera componentes acima de 1.0, que é o que o glow precisa. Esse padrão é ótimo para neon de cenário, para o rastro de um projétil ou para dar aquele acabamento em partículas. Se você já trabalha com partículas com GPUParticles2D, basta dar ao material do processo uma cor com energia acima de 1 que cada faísca passa a estourar de luz sozinha.

Vale lembrar que glow é global: ele afeta tudo que passa do limiar na tela. Isso combina muito bem com uma cena escura. Se você já montou a iluminação 2D na Godot com um ambiente fechado, o neon brilhando no escuro fica com uma leitura muito mais forte do que num fundo claro, onde o halo se perde.

Controlando o glow por código

O Environment é um recurso comum, então dá para animar as propriedades dele em tempo de execução. Isso serve para cutscenes, para um pico de brilho num momento de dano ou para acender uma sala aos poucos. Guarde a referência ao Environment e mexa no que precisar:

extends WorldEnvironment

func _ready() -> void:
    # Garante que o glow começa ligado.
    environment.glow_enabled = true

func pulso_de_brilho() -> void:
    # Sobe a intensidade rapidinho e volta, tipo um flash de energia.
    var tween: Tween = create_tween()
    tween.tween_property(environment, "glow_intensity", 3.0, 0.08)
    tween.tween_property(environment, "glow_intensity", 0.8, 0.35)

Esse pulso_de_brilho é ótimo para acompanhar um golpe forte ou uma explosão. Ele conversa bem com efeitos de impacto no próprio personagem: se você já usa um shader de flash de dano (hit flash) quando o inimigo toma dano, disparar um pulso de glow no mesmo quadro dá um peso extra ao acerto sem precisar de nova arte.

Para uma cutscene, o mesmo raciocínio vale para o glow_hdr_threshold. Baixar o limiar aos poucos faz a cena inteira ir "ganhando luz", como se os olhos se acostumassem ou como se um portal fosse abrindo:

func revelar_portal(duracao: float) -> void:
    var tween: Tween = create_tween()
    # Baixa o limiar: mais pixels passam a brilhar, a cena "acende".
    tween.tween_property(environment, "glow_hdr_threshold", 0.6, duracao)

Uma disciplina importante: animar propriedade de Environment é barato, mas mudar de material ou recriar recursos todo quadro não é. Prefira guardar a referência uma vez, no _ready, e só atribuir valores depois.

Custo de performance e alternativas leves

Glow é pós-processamento de tela cheia. Ele faz várias passadas de blur em resoluções decrescentes e depois soma tudo de volta, então custa banda de memória e escala mal em telas grandes e em mobile. Se o seu alvo é celular, trate o glow como um luxo que precisa de teste no aparelho, não como algo garantido.

Três formas de aliviar:

• Reduza a quantidade de glow_levels ativos. Menos níveis, menos passadas de blur. Muitas vezes dois ou três níveis já dão o visual que você quer.
• Evite glow_intensity e glow_bloom altos combinados com resolução cheia. O efeito fica caro e, pior, fica feio (tela lavada).
• Se você só precisa que um objeto pontual brilhe, considere não ligar o glow global. Um sprite de halo (uma textura suave e radial) por cima do objeto, com blend aditivo, dá a impressão de brilho por um custo ridículo e sem tocar no pipeline de pós. É a velha ideia de fingir o caro com algo barato bem colocado.

Regra prática: use o glow real quando o brilho faz parte do clima da cena inteira (uma pista cyberpunk, um nível espacial). Use o halo falso quando é só um item ou dois que precisam brilhar.

Próximo passo

Monte uma cena escura, ligue o WorldEnvironment com glow, coloque um único objeto emissivo (3D) ou um sprite com cor acima de 1.0 (2D com HDR ligado) e brinque só com o glow_hdr_threshold e o glow_intensity até achar o ponto. Depois disso, plugue o pulso_de_brilho num evento do seu jogo (um golpe, uma coleta, uma explosão) e sinta a diferença que um brilho bem cronometrado faz. A partir daí é repertório: quanto mais você observa referência de luz real, melhor calibra o halo.