Material 3D na Godot: texturas e PBR do básico

Material 3D na Godot é o que transforma um modelo cinza importado em algo que parece pertencer ao jogo. O formato do objeto vem da malha, mas tudo que o olho lê como "metal", "madeira velha" ou "plástico barato" vem do material. Na Godot 4 esse trabalho acontece quase todo dentro de um nó de recurso só: o StandardMaterial3D. Entender como ele funciona e o que é PBR resolve a maior parte das cenas que você vai montar.

Este guia é para quem está começando em 3D e quer parar de errar no escuro mexendo em slider aleatório. Vou passar pelo que cada canal do material faz, como mapear as texturas, quando o ORM compensa, uma dica de performance e como aplicar material por código. Sem decoreba: o objetivo é você olhar um material e saber qual valor mexer.

O que é PBR e como o material 3D na Godot usa

PBR é sigla de Physically Based Rendering, renderização baseada em física. A ideia central é descrever a superfície pela forma como ela interage com a luz, e não por uma cor pintada à mão. Você diz à engine "isso é metal áspero" ou "isso é plástico liso", e o material reage de forma coerente a qualquer luz que você jogar na cena. Trocar o sol por uma tocha não exige repintar nada: a física cuida do resto.

Na Godot 4, esse modelo vive no StandardMaterial3D. Ele é organizado em canais, e cada canal responde por um aspecto físico da superfície. Os seis que você vai usar toda hora:

• Albedo: a cor base da superfície, sem sombra e sem brilho embutidos. É a cor "crua" do objeto.
• Metallic: quão metálico o material é. Vai de 0 (dielétrico, tipo madeira ou plástico) a 1 (metal puro). É quase sempre um ou outro, raramente meio termo.
• Roughness: quão áspera é a superfície. Em 0 ela vira espelho; em 1 o reflexo se espalha e some. É o slider que mais muda a sensação do material.
• Normal map: relevo falso. Simula ranhuras e saliências sem adicionar polígonos à malha.
• Ambient Occlusion (AO): escurece cantos e frestas onde a luz indireta não chega, dando profundidade de contato.
• Emission: faz a superfície emitir luz própria. Telas, lava, neon, olhos brilhando.

A beleza do PBR é que esses canais são independentes e previsíveis. Depois que você internaliza o que cada um faz, montar um material novo vira uma decisão rápida em vez de tentativa e erro.

Albedo, metallic e roughness: o trio que define tudo

Se você só tivesse três sliders, seriam estes. A maioria dos materiais convincentes sai só do ajuste desses valores, sem textura nenhuma.

O Albedo é a cor pura. Um detalhe que pega iniciante: não pinte sombra nem brilho no albedo. A luz da cena faz isso. Se você escurecer o albedo "pra dar profundidade", o material fica sujo quando a luz bater nele. Albedo é a cor do objeto sob luz branca neutra, e só.

O Metallic é mais binário do que parece. Na prática, materiais do mundo real são metal (valor 1) ou não são (valor 0). Valores intermediários servem quase só para transições, tipo uma peça de metal com tinta descascando. Metal puro tem uma característica importante: ele quase não tem cor difusa, a cor dele vem do reflexo do ambiente. Por isso um metal com roughness alto e sem nada pra refletir fica apagado e estranho. Metal pede ambiente.

O Roughness é onde o material ganha personalidade. Pense nele como "quão embaçado é o reflexo":

• Roughness baixo (0.0 a 0.2): espelho, metal polido, vidro, piso encerado.
• Roughness médio (0.3 a 0.6): plástico, metal escovado, madeira envernizada.
• Roughness alto (0.7 a 1.0): concreto, tecido, borracha, pedra seca.

Uma rotina que funciona pra material novo: defina o albedo, decida se é metal (0 ou 1), e depois passe o roughness devagar olhando como o reflexo abre. Noventa por cento do caminho está feito aqui.

Mapeando as texturas no StandardMaterial3D

Valores únicos resolvem material liso, mas superfície de verdade varia ponto a ponto. É aí que entram as texturas: em vez de um número para o roughness da peça inteira, você dá um mapa em tons de cinza dizendo onde ela é mais ou menos áspera.

Cada canal do StandardMaterial3D tem um slot de textura no Inspector. O fluxo é abrir a seção do canal (Albedo, Metallic, Roughness, Normal Map, Ambient Occlusion) e arrastar a textura certa pra dentro do campo Texture. Pontos que evitam dor de cabeça:

• Albedo é a única textura em cor. Todas as outras são dados, não imagem. Quando você joga uma textura no slot de metallic, por exemplo, precisa escolher qual canal dela ler (Red, Green, Blue), porque o mapa de dados costuma estar num canal só.
• Normal map exige que a flag Normal Map esteja ligada na importação da textura, senão a Godot trata os dados como cor comum e o relevo sai errado. Se o relevo parecer invertido ou chapado, confira isso primeiro.
• Roughness e Metallic vêm em escala de cinza. Preto é 0, branco é 1. Vale lembrar que o valor do slider multiplica a textura: deixe os sliders em 1.0 quando usar mapa, senão você está escurecendo o mapa inteiro sem querer.

Essas texturas quase nunca encaixam certo sem um bom desempacotamento UV da malha, o passo que diz qual pedaço da imagem vai em cada face. Se você ainda não passou por isso, o fluxo de trazer o modelo já com UV resolvido está em como importar modelo 3D do Blender para a Godot, que é o par natural deste post.

Normal, AO e emission: o acabamento

Com albedo, metallic e roughness no lugar, o material já funciona. Os três canais restantes são acabamento, mas são eles que vendem o detalhe.

O Normal map é o truque mais rentável do 3D. Ele simula relevo sem custar geometria: a textura guarda, em cada ponto, para onde a superfície "aponta", e a engine ilumina como se houvesse ranhuras ali. Um muro de tijolos pode ser um plano chato com um bom normal map e, sob luz rasante, parece modelado. A força do efeito sai no normal_scale: 1.0 é o natural, valores menores suavizam, e dá pra exagerar um pouco em superfícies que precisam gritar o relevo.

O Ambient Occlusion grava em textura aquelas sombras suaves que aparecem onde duas superfícies se encontram, em frestas e cantos fundos. É luz de contato que a iluminação em tempo real nem sempre calcula bem sozinha. O AO do material reforça essa leitura de profundidade de graça, sem bake de cena.

A Emission faz a superfície brilhar por conta própria, ignorando a luz da cena. É o canal de telas, lava, cristais mágicos, faixas de neon. Combinado com o Glow do ambiente, a parte emissiva sangra luz e vira o foco visual da cena. O emission_energy_multiplier acima de 1 é o que empurra o brilho pra faixa onde o glow dispara. Se você quer entender como essa luz se espalha pela cena depois de emitida, o lado da iluminação está em iluminação 3D no Godot.

Quando usar ORM em vez de texturas separadas

Conforme os materiais crescem, começa a pesar carregar uma textura separada pra AO, uma pra roughness e outra pra metallic. É aqui que entra o ORMMaterial3D.

ORM quer dizer Occlusion, Roughness, Metallic. A sacada é empacotar esses três mapas em cinza numa só imagem colorida, usando os canais RGB: o vermelho guarda o AO, o verde guarda o roughness e o azul guarda o metallic. Como os três são dados em cinza, cabem confortavelmente num canal cada, e a GPU lê uma textura em vez de três.

Vantagens práticas: menos arquivos pra gerenciar, menos memória de vídeo e menos amostras de textura por pixel, o que ajuda a performance. A maioria dos geradores de textura PBR (como os de bibliotecas de materiais) já exporta um mapa ORM pronto justamente por isso.

A regra é simples: se o pacote de texturas já vem com um arquivo ORM, use o ORMMaterial3D e jogue esse arquivo no slot ORM. Se os mapas vêm soltos e separados, o StandardMaterial3D comum resolve sem drama. Os dois são o mesmo material por baixo; muda só como os dados de entrada estão organizados.

Uma dica de performance que importa cedo

Material barato em 3D quase sempre vem de duas escolhas. Primeira: reaproveite o mesmo recurso de material em vários objetos em vez de criar um por nó. Quando dez caixas compartilham o mesmo StandardMaterial3D, a engine agrupa melhor o desenho delas. Se cada caixa tem uma cópia própria do material, você perde esse agrupamento à toa.

Segunda: ligue só os canais que você usa. Cada recurso extra do material (normal map, AO, emission, rim, clearcoat) adiciona trabalho pra GPU em cada pixel. Um material com cinco texturas num objeto que o jogador só vê de longe é desperdício. Comece no mínimo (albedo, metallic, roughness) e acrescente canal por canal só quando o ganho visual aparecer na tela. Essa disciplina pesa principalmente quando o alvo é mobile ou web.

Aplicando material por código

Montar material no Inspector é o caminho normal, mas às vezes você precisa criar ou trocar o material em runtime: destacar um objeto selecionado, piscar um inimigo que levou dano, gerar variações de cor. Na Godot 4, sempre com tipos explícitos:

extends MeshInstance3D

func _ready() -> void:
    var mat: StandardMaterial3D = StandardMaterial3D.new()
    mat.albedo_color = Color(0.8, 0.1, 0.1)
    mat.metallic = 1.0
    mat.roughness = 0.35
    material_override = mat

O material_override força esse material em toda a malha, ignorando o que estava nas surfaces. É a forma mais direta de trocar o visual inteiro de um objeto por código.

Carregar uma textura e jogá-la no canal de albedo é igualmente direto:

extends MeshInstance3D

func _ready() -> void:
    var mat: StandardMaterial3D = StandardMaterial3D.new()
    var tex: Texture2D = load("res://texturas/metal_albedo.png")
    mat.albedo_texture = tex
    mat.metallic = 1.0
    mat.roughness = 0.5
    material_override = mat

Para efeitos como piscar o objeto ao tomar dano, ligar o canal de emission e animar a energia resolve sem shader nenhum:

extends MeshInstance3D

@export var cor_dano: Color = Color(1.0, 0.2, 0.2)

func _ready() -> void:
    var mat: StandardMaterial3D = StandardMaterial3D.new()
    mat.emission_enabled = true
    mat.emission = cor_dano
    mat.emission_energy_multiplier = 0.0
    material_override = mat

func piscar() -> void:
    var mat: StandardMaterial3D = material_override as StandardMaterial3D
    var tween: Tween = create_tween()
    tween.tween_property(mat, "emission_energy_multiplier", 3.0, 0.05)
    tween.tween_property(mat, "emission_energy_multiplier", 0.0, 0.20)

Quando o StandardMaterial3D não dá conta do efeito que você quer (água, dissolução, distorção), o caminho é escrever um shader de superfície. O ponto de partida está em primeiros passos com shader 3D spatial na Godot. Mas isso é exceção: na esmagadora maioria das cenas, o material padrão resolve.

Fechando

Material 3D na Godot cabe numa sequência curta: albedo pra cor base, metallic pra decidir se é metal, roughness pra ajustar o reflexo, e os canais de normal, AO e emission pra acabamento. As texturas entram como mapas que variam esses valores ponto a ponto, e o ORM empacota três mapas num só quando o pacote já vem nesse formato. Performance vem de reaproveitar material e ligar só o que você usa.

Nada disso exige talento artístico de partida. Exige uma esfera de teste, uma luz decente e paciência pra mexer num slider por vez olhando o resultado. Pegue um modelo cinza qualquer, monte um material do zero seguindo a ordem deste post e veja o objeto ganhar vida. Se o 3D te fisgou e você quer um caminho estruturado em vez de juntar tutorial solto, vale comparar aprender a criar jogos sozinho ou fazer um curso antes de decidir o próximo passo.