GLSL para quem constrói: um laboratório de shaders que você pode realmente usar

Shaders GLSL se tornam intuitivos quando você pode mudar um número e ver o resultado a 60fps. Este laboratório interativo inclui shaders pré-configurados que você pode modificar em tempo real: ondas senoidais modulando campos de cor, funções de ruído gerando terreno e ray marching construindo cenas 3D apenas com matemática.

Aprendi shaders mudando um número por vez e observando o que acontecia. Ler a matemática me dizia o que uma onda senoidal faz. Mover um slider me mostrava como ela se parece quando uma onda senoidal modula um campo de cor a 60fps. O segundo tipo de entendimento é o que fica. Este laboratório faz parte da série Interactive Explorations e do território mais amplo de design engineering.

O post abaixo inclui um laboratório GLSL ao vivo com shaders pré-configurados que você pode modificar em tempo real. A estrutura é de oficina, não de palestra: iteração rápida, feedback visual e anotação suficiente para você entender o que cada controle faz e por quê.

TL;DR

Se você quer ficar bom em GLSL, pare de ler teoria de shaders passivamente e comece a manipular uniforms agressivamente. Mude um parâmetro por vez, observe como os campos de espaço e tempo se deformam e depois codifique o que aprendeu em padrões reutilizáveis. O laboratório interativo abaixo oferece um ciclo prático: selecione um preset, ajuste Speed, Scale, Detail e Color Shift e construa intuição com feedback visual imediato.1



Por que isso importa no trabalho de produto

Shaders resolvem problemas reais de produto. O post sobre a ciência das cores em interfaces explica como a percepção de cor funciona no nível teórico; os shaders são onde essa teoria vira saída visual em tempo real. Eles são úteis para:

  • fundos com movimento ambiente que continuam leves
  • assinaturas visuais de marca sem distribuir arquivos de vídeo pesados
  • blocos de narrativa interativa dentro de conteúdo editorial
  • sistemas visuais generativos que podem ser parametrizados por campanha

O laboratório desta página é, ele próprio, um exemplo em produção: um componente WebGL sem dependências, embutido em um post de blog renderizado no servidor, sem ferramentas de build, seguindo cada uma das proteções descritas abaixo.

Um caso concreto: o Sorting Visualizer deste site usa um fragment shader em tela cheia como fundo ambiente atrás da animação de ordenação. O shader renderiza um gradiente de movimento lento que responde ao progresso do algoritmo de ordenação: a fase de cor se desloca à medida que as trocas se acumulam, criando uma “temperatura” visual que sobe com o trabalho do algoritmo. A implementação tem 48 linhas de GLSL (uma variante de plasma controlada por um único uniform u_progress, de 0.0 a 1.0). No MacBook Air M1 do autor, o shader acrescenta 0,3 ms por frame ao orçamento de renderização, algo desprezível a 60fps (orçamento de 16,6 ms). Em um iPhone 12 Mini (A14, testado via depuração remota do Safari), o mesmo shader acrescenta 0,8 ms por frame, ainda bem dentro do orçamento. O shader substituiu uma animação de gradiente em CSS que exigia 6 KB de definições de keyframes, não conseguia responder ao estado da aplicação e causava recálculos de layout a cada mudança de cor. A versão em GLSL é menor (1,2 KB), composta pela GPU (custo zero de layout) e parametrizada (o uniform de progresso se conecta a qualquer fonte de dados).

A restrição prática é sempre o desempenho. Se o orçamento de frame desmorona no celular, a ideia visual está morta, por mais elegante que seja a matemática.

O modelo mental que realmente fica

Trate todo fragment shader como três problemas resolvidos em sequência:2

  1. um problema de transformação de coordenadas
  2. um problema de sinal periódico
  3. um problema de mapeamento de cor

Em GLSL, cada etapa corresponde a poucas linhas. Os tipos vec2, vec3 e vec4 são os tipos vetoriais nativos do GLSL, com 2, 3 e 4 componentes de ponto flutuante, usados respectivamente para coordenadas, cores e pixels de saída:

// Step 1: Coordinates, where am I in normalized space?
vec2 uv = gl_FragCoord.xy / u_resolution;  // 0.0 to 1.0
vec2 p = uv * u_scale;                     // scale the coordinate space

// Step 2: Signal, what scalar field exists at this point and time?
float signal = sin(p.x * 6.28 + u_time);   // periodic wave across x-axis

// Step 3: Color, how do I map that scalar to visible output?
vec3 color = vec3(signal * 0.5 + 0.5);      // remap -1..1 to 0..1
gl_FragColor = vec4(color, 1.0);             // WebGL 1.0 (GLSL ES 1.00) output

Os valores u_resolution, u_scale e u_time são uniforms: valores que a CPU envia para a GPU a cada frame. Os uniforms são a superfície de controle. Mudar u_scale aproxima ou afasta o espaço de coordenadas. Mudar u_time anima o sinal. O código do shader continua o mesmo; o comportamento muda porque as entradas mudam. O laboratório abaixo expõe quatro uniforms (Speed, Scale, Detail, Color Shift) para você sentir isso diretamente.

Dá para construir quase tudo a partir desse ciclo de três etapas.

Três presets, três comportamentos

O laboratório traz três comportamentos de shader para você comparar padrões:

  • Plasma: ondas sin() sobrepostas criam padrões de interferência. Três ondas senoidais com frequências e fases diferentes se sobrepõem, produzindo interferência construtiva (faixas claras onde as ondas se alinham) e interferência destrutiva (faixas escuras onde as ondas se cancelam). O uniform Scale controla quantos ciclos de onda cabem na área visível. Aumente-o e o padrão de interferência se aperta em uma granulação fina. Diminua-o e surgem gradientes amplos e orgânicos.3

    glsl float a = sin(p.x + t * 1.1); float b = sin((p.y + t * 0.9) * 1.3); float c = sin((p.x + p.y + t * 0.7) * 0.8); float signal = (a + b + c) / 3.0;

  • Contour Rings: length() calcula a distância radial a partir do centro, criando um gradiente suave que cresce de 0.0 no centro até valores maiores nas bordas. Em seguida, sin() faz essa distância, que cresce continuamente, oscilar em ondas repetidas, pelo mesmo motivo que as ondulações em um lago formam anéis concêntricos. abs() + smoothstep() transformam essas ondas suaves em faixas nítidas, o mesmo efeito visual das curvas de nível em um mapa topográfico. O uniform Detail controla a densidade das faixas multiplicando a distância antes que sin() a envolva: mais detalhe significa anéis mais apertados. O resultado visual lembra uma varredura de radar ou uma leitura topográfica.

    glsl float d = length(p); float wave = sin((d * 18.0 * u_detail) - t * 2.0); float bands = smoothstep(0.1, 0.85, abs(wave));

  • Flow Warp: o shader converte coordenadas cartesianas para a forma polar (atan para o ângulo, length para o raio). As coordenadas polares são a chave: o ângulo aumenta linearmente conforme você gira em torno do centro, então sin(8.0 * angle) cria oito raios radiais (oito ciclos completos de seno em 360 graus). O raio aumenta do centro para fora, então cos(12.0 * radius) cria doze ondulações concêntricas. A soma dos dois produz o padrão de interferência: raios cruzando anéis. Um termo de brilho exponencial (exp(-3.0 * radius)) adiciona uma queda de luminosidade a partir do centro, porque exp(-x) decai rapidamente conforme x cresce. O uniform Color Shift gira o mapeamento de matiz, revelando como o mesmo campo de distorção produz paletas de cores diferentes.

    glsl float angle = atan(p.y, p.x); float radius = length(p); float field = sin(8.0 * angle + t * 2.2) + cos(12.0 * radius - t * 1.7); float glow = exp(-3.0 * radius) * (0.6 + 0.4 * sin(t + radius * 8.0));

Eles compartilham a mesma interface de uniforms (Speed, Scale, Detail, Color Shift), para você sentir como controles idênticos produzem resultados diferentes dependendo do design do sinal.

Estratégia vencedora para aprender rápido

Use esta sequência no laboratório:

  1. Comece com Plasma, deixe Scale baixo e depois aumente Speed.
  2. Mude para Contour Rings, aumente o detalhe e reduza a velocidade.
  3. Mude para Flow Warp e arraste o deslocamento de cor para ver o mapeamento de fase.
  4. Pause a animação e compare quadros estáticos entre os presets.
  5. Volte ao seu preset favorito e ajuste-o para um alvo de estilo delimitado (calmo, agressivo, técnico, cinematográfico).

Esse ciclo força decisões de gosto explícitas, não ajustes aleatórios. O mesmo tipo de exploração estética estruturada se aplica à tensão entre beleza e brutalismo no design, em que a restrição revela o caráter.

Exercício: depois da etapa 5, escreva três palavras que descrevam o visual que você criou. Em seguida, leve um slider ao extremo oposto e escreva três palavras novas. Compare as duas descrições. A distância entre elas é a sua superfície de gosto: o leque de resultados visuais que você consegue nomear e alcançar de forma intencional. Repita com presets diferentes para ampliar essa superfície.

Erros comuns ao começar com GLSL

Três erros aparecem em quase todo primeiro shader:

Esquecer de normalizar as coordenadas. gl_FragCoord retorna coordenadas em pixels (de 0 a 1920 em uma tela 1080p). Sem dividir por u_resolution, cada sin() e cos() opera sobre valores enormes, produzindo ruído visual em vez de padrões suaves. A correção é sempre a primeira linha: vec2 uv = gl_FragCoord.xy / u_resolution;

Tratar a faixa de cor como -1 a 1. sin() retorna valores de -1.0 a 1.0, mas os canais de cor esperam de 0.0 a 1.0. Valores de cor negativos são truncados para preto, produzindo faixas duras em vez de gradientes suaves. A fórmula de remapeamento signal * 0.5 + 0.5 converte a faixa -1..1 em 0..1. Todo shader do laboratório acima usa esse padrão.

Animar sem u_time. Um shader que usa apenas coordenadas espaciais produz uma imagem estática. A animação exige um uniform de tempo que a CPU incrementa a cada frame e envia para a GPU. O shader em si nunca acompanha o tempo: ele recebe o tempo atual como uniform e calcula o frame como se aquele momento fosse o único. Cada frame é uma função pura das suas entradas.


Depurando erros de shader

Erros de shader WebGL aparecem no console do navegador. À primeira vista parecem enigmáticos, mas seguem padrões previsíveis. Estes são os três erros que você vai encontrar com mais frequência e o que eles significam:

ERROR: 0:12: 'u_resolution' : undeclared identifier: o shader faz referência a um uniform que nunca foi declarado. Ou a declaração uniform está faltando no código-fonte do shader, ou o nome está escrito errado. Correção: adicione uniform vec2 u_resolution; no topo do fragment shader, antes de void main().

ERROR: 0:8: '' : compilation terminated: o shader tem um erro de sintaxe antes da linha 8. GLSL exige sintaxe no estilo C: ponto e vírgula ao fim de cada instrução, chaves balanceadas e nenhuma vírgula sobrando no final. A causa mais comum é um ponto e vírgula faltando na linha anterior. Correção: verifique as linhas 1-7 em busca de pontos e vírgulas ausentes, parênteses sem par ou nomes de tipo incorretos.

Um canvas preto ou branco sem erros no console: o shader compilou e foi linkado com sucesso, mas os valores de saída estão fora da faixa 0.0-1.0. gl_FragColor espera que cada canal (R, G, B, A) fique entre 0.0 e 1.0. Valores acima de 1.0 são truncados para branco. Valores abaixo de 0.0 são truncados para preto. Correção: adicione a fórmula de remapeamento (signal * 0.5 + 0.5) para deslocar seu sinal da faixa -1..1 para a faixa 0..1. Se o canvas estiver totalmente branco, todos os seus valores estão acima de 1.0. Se estiver totalmente preto, todos estão abaixo de 0.0.

Uma técnica de depuração para qualquer shader: defina gl_FragColor = vec4(uv, 0.0, 1.0); como última linha. Essa linha pinta um gradiente do preto (canto inferior esquerdo, onde uv = 0,0) ao amarelo (canto superior direito, onde uv = 1,1), com vermelho ao longo do eixo x e verde ao longo do eixo y. Se o gradiente parecer correto, seu espaço de coordenadas está funcionando e o problema está no sinal ou no mapeamento de cor. Se o gradiente estiver errado (por exemplo, todo de uma cor só, ou invertido), a transformação de coordenadas tem um bug. A técnica isola qual dos três problemas (coordenada, sinal, cor) contém o erro.


Proteções para produção

Se você publicar shaders em páginas de conteúdo, mantenha estas restrições:

  • limite a resolução do canvas pela proporção de pixels do dispositivo para evitar picos de overdraw
  • exponha apenas uma superfície de controle pequena e significativa
  • ofereça um fallback estático quando WebGL não estiver disponível
  • pause a renderização quando a aba estiver oculta
  • evite branches caros e loops aninhados no código de fragmento

O laboratório segue essas regras, então você pode usá-lo como modelo. No hardware de teste do autor (MacBook Air M1, GPU integrada), esses shaders mantêm 60fps com proporção de pixels de dispositivo 1x; os resultados variam conforme a GPU, mas a complexidade dos shaders é deliberadamente baixa o suficiente para a maioria do hardware. Com DPR 2x em uma tela Retina, a quantidade de pixels quadruplica; limitar em Math.min(dpr, 2) impede que a GPU faça quatro vezes mais trabalho por uma diferença visual que a maioria dos usuários não percebe.8

Este é o padrão de pausa por aba em JavaScript, duas linhas que impedem o shader de queimar ciclos de GPU em uma aba oculta:

document.addEventListener('visibilitychange', () => {
  if (document.hidden) cancelAnimationFrame(frameId);
  else frameId = requestAnimationFrame(render);
});

E o limite de DPR:

const dpr = Math.min(window.devicePixelRatio || 1, 2);
canvas.width = canvas.clientWidth * dpr;
canvas.height = canvas.clientHeight * dpr;

Os dois padrões já estão implementados no laboratório acima. Copie-os diretamente para os seus próprios projetos WebGL.

O que construir em seguida

Bons próximos passos:

  • Copiar uniforms para a área de transferência. Exponha o estado atual { speed, scale, detail, colorShift } como um objeto JSON. Um botão “Copy Preset” grava esse objeto na área de transferência. Restaurar um preset é Object.assign(state, JSON.parse(clipboard)). A serialização de presets importa porque a exploração estética é efêmera por padrão: assim que você move um slider, o estado anterior desaparece. Um preset serializável transforma um visual passageiro em um artefato que pode ser salvo e compartilhado.

  • Exportar snapshots de gradiente. Chame canvas.toDataURL('image/png') para capturar o frame atual como imagem estática. Dimensione o canvas de exportação nas medidas de cards sociais (1200x630 para Open Graph, 1080x1080 para Instagram). O shader produz gradientes únicos e seguros para a marca, sem fotos de banco de imagens.

  • Mapear a posição de rolagem para um uniform. Use IntersectionObserver ou um listener de scroll para calcular um valor de progresso de 0.0 a 1.0 e passá-lo como uniform. O shader responde à posição do leitor na página porque a GPU recebe um valor em mudança contínua que comanda o estado visual: o mesmo mecanismo do slider Speed, mas controlado pela rolagem em vez de um controle de interface. O resultado são transições narrativas em que o visual evolui conforme o conteúdo avança.4

  • Vincular a fase de cor a um estado externo. Passe horário do dia, parâmetros de campanha ou preferências do usuário como uniforms. Um shader que desloca o matiz de acordo com o horário local cria personalização ambiente sem servir arquivos diferentes.

O essencial é passar de “shader como brinquedo” para “shader como primitiva de produto reutilizável”. O interativo de correção de erros de Hamming e o visualizador de tokenização seguem a mesma filosofia: tornar conceitos abstratos tangíveis pela manipulação direta. E o raciocínio espacial que torna os shaders intuitivos se conecta ao mesmo pensamento espacial da topologia do conhecimento por embeddings, em que espaços vetoriais de alta dimensão codificam significado semântico.

Principais conclusões

Para engenheiros aprendendo GLSL:

  • Manipule uniforms agressivamente, leia teoria passivamente. Mudar um parâmetro por vez e observar o resultado visual constrói intuição mais rápido do que estudar a matemática isoladamente. O laboratório acima existe para tornar esse ciclo rápido.

  • Todo fragment shader resolve três problemas em sequência. Transformação de coordenadas, sinal periódico, mapeamento de cor. Quando esse modelo mental se encaixa, você consegue decompor qualquer shader que encontrar em suas três camadas e entender cada uma de forma independente.

Para equipes que colocam shaders em produção:

  • O design das restrições importa mais do que a complexidade do shader. Limitar o DPR, pausar quando a aba fica oculta, oferecer fallbacks e expor uma superfície de controle pequena são as decisões de produção que determinam se um shader sobrevive ao contato com usuários reais em hardware real.

  • Shaders são primitivas de produto reutilizáveis, não brinquedos. Fundos de marca, visuais específicos de campanha, transições guiadas por rolagem e personalização ambiente são casos de uso em produção que os shaders atendem sem arquivos de vídeo, banda de CDN ou dependências de framework.


Perguntas frequentes

O que é GLSL e como os fragment shaders funcionam no WebGL?

GLSL (OpenGL Shading Language) é a linguagem parecida com C usada para escrever programas de shader que rodam na GPU. WebGL é a API do navegador que dá acesso ao OpenGL ES, que executa esses shaders. Um fragment shader escrito em GLSL roda uma vez por fragmento a cada frame; em um quad simples de tela cheia como o do laboratório acima, cada fragmento corresponde a um pixel, então o shader na prática calcula uma cor para cada pixel com base nas suas coordenadas, no tempo atual e em quaisquer valores de uniform fornecidos pela CPU. O laboratório acima usa WebGL para compilar e executar fragment shaders GLSL diretamente no navegador, sem plugins nem extensões.5

O que são uniforms na programação de shaders?

Uniforms são valores somente leitura enviados da CPU (JavaScript) para a GPU (shader GLSL) a cada frame. Diferente dos atributos de vértice (que variam por vértice) ou dos varyings (que são interpolados ao longo de um triângulo), os uniforms permanecem constantes para todos os pixels em uma única chamada de desenho. Uniforms comuns incluem tempo, resolução, posição do mouse e valores de controle personalizados. O laboratório expõe quatro uniforms (Speed, Scale, Detail, Color Shift) que você pode manipular por sliders para ver, em tempo real, como mudar valores do lado da CPU altera a saída visual do lado da GPU.

Como os shaders alcançam desempenho em tempo real?

Fragment shaders rodam em paralelo em milhares de núcleos de GPU. O cálculo de cada pixel é independente do de todos os outros, o que significa que a GPU os processa simultaneamente, e não em sequência. Um canvas de 1920x1080 tem ~2 milhões de fragmentos. Uma CPU os processa de forma em grande parte sequencial (SIMD ajuda, mas o throughput ainda é ordens de grandeza menor). Uma GPU os distribui por milhares de núcleos e termina em milissegundos. A restrição é que nenhum pixel pode ler o resultado do cálculo de outro pixel na mesma passada, e é por isso que a programação de shaders exige um modelo mental diferente do código sequencial de CPU.6

Posso usar shaders WebGL com segurança em projetos web em produção?

Sim, com restrições. Limite a resolução do canvas em relação à proporção de pixels do dispositivo para evitar overdraw em telas de alto DPI. Pause o loop de animação quando a aba não estiver visível (escute o evento visibilitychange em document). Ofereça uma imagem estática ou um gradiente CSS como fallback quando o WebGL não estiver disponível. Evite operações caras, como loops aninhados, leituras de textura em branches condicionais ou excesso de branches em geral. O laboratório segue todas essas proteções para produção.

O que devo aprender depois deste laboratório?

Passe para The Book of Shaders, de Patricio Gonzalez Vivo e Jen Lowe, um currículo estruturado que cobre funções de ruído, campos de distância e técnicas mais avançadas de GLSL.1 Para técnicas de campos de distância especificamente, os artigos de Inigo Quilez sobre funções de distância com sinal são a referência canônica.7 Quando estiver à vontade com fragment shaders, explore vertex shaders (manipulação de geometria) e compute shaders (computação de uso geral na GPU).



  1. Patricio Gonzalez Vivo e Jen Lowe, The Book of Shaders, thebookofshaders.com. O recurso interativo canônico para aprender GLSL. Cobre fragment shaders desde a saída de cor básica até ruído, fractais e processamento de imagem, com exemplos editáveis ao vivo. ↩↩

  2. Esta decomposição em três etapas (coordenada, sinal, cor) simplifica o modelo apresentado em The Book of Shaders, capítulos 5-7, que tratam funções de modelagem, cores e formas como camadas sequenciais da construção de um fragment shader. ↩

  3. O preset plasma demonstra a síntese de Fourier: construir um padrão complexo somando ondas senoidais de frequências diferentes. O teorema de Fourier afirma que qualquer sinal periódico complexo pode ser construído a partir de (ou decomposto em) ondas senoidais de frequências e fases diferentes. Adicionar mais termos senoidais produz padrões de interferência mais complexos. Veja também: Gonzalez Vivo, “Shaping Functions”, thebookofshaders.com/05/. ↩

  4. Animações de shader guiadas por rolagem usam o mesmo princípio do scroll-timeline do CSS, mas com visuais arbitrários calculados pela GPU. O uniform recebe uma posição de rolagem normalizada (0.0 no topo, 1.0 no fim) e o shader interpola entre estados visuais. A MDN documenta a API de evento de rolagem subjacente: developer.mozilla.org/en-US/docs/Web/API/Document/scroll_event. ↩

  5. O WebGL 1.0 (baseado no OpenGL ES 2.0) é suportado por mais de 98% dos navegadores no mundo. Veja caniuse.com/webgl. O WebGL 2.0 (baseado no OpenGL ES 3.0) adiciona transform feedback, múltiplos render targets e outros recursos, mas não é necessário para trabalho com fragment shaders como o do laboratório acima. Compute shaders estão disponíveis pelo WebGPU, não pelo WebGL. ↩

  6. O modelo de execução paralela das GPUs é o motivo pelo qual a programação de shaders proíbe a comunicação entre pixels dentro de uma única chamada de desenho. John Owens et al., “A Survey of General-Purpose Computation on Graphics Hardware”, Computer Graphics Forum, Vol. 26, No. 1, pp. 80-113, 2007. Essa restrição molda todo o modelo de programação GLSL. ↩

  7. Inigo Quilez, “Distance Functions”, iquilezles.org/articles/distfunctions2d/. O catálogo de funções de distância com sinal 2D e 3D de Quilez é a referência padrão para geometria procedural em shaders. ↩

  8. O modelo de execução paralela da GPU que torna os fragment shaders rápidos também restringe a forma como eles funcionam. Akenine-Moller, T., Haines, E., e Hoffman, N., Real-Time Rendering, 4ª edição, A K Peters/CRC Press, 2018, Capítulo 3 (The Graphics Processing Unit). O livro oferece o tratamento mais abrangente da arquitetura de GPU para programadores gráficos, incluindo a relação entre throughput de fragmentos, fill rate e DPR. O Khronos Group mantém a especificação GLSL ES que define a linguagem usada neste laboratório: registry.khronos.org/OpenGL/specs/es/2.0/GLSL_ES_Specification_1.00.pdf. ↩

Artigos relacionados

Códigos de Hamming: como os computadores corrigem seus próprios erros

Toda vez que você usa memória RAM, lê um QR code ou recebe dados do espaço, os códigos de Hamming corrigem erros. Uma ex…

7 min de leitura

De Boids a Agentes: Regras de Agrupamento para Sistemas de IA

O algoritmo boids de Craig Reynolds (1986) gera comportamento de bando com três regras locais — os mesmos princípios e f…

14 min de leitura

The Shader Gallery That Lied: Debugging 216 WebGL Presets

A user said the shader playground looked broken. Pixel-readback testing found 30 dead presets, 11 that never compiled, a…

14 min de leitura