Recomposed
Shader

Introdução a Shaders

Oct 20, 2026 · 6 min read

Introdução a Shaders

O que um shader realmente é

Um shader é um pequeno programa que a GPU executa, não uma função que você chama uma única vez. Para um , esse programa é executado uma vez por pixel, para cada pixel dentro da área sendo desenhada, em todo e único frame.

AGSL (Android Graphics Shading Language) é a linguagem de shader do Android. Não é uma invenção nova: é um dialeto restrito do , que por sua vez é próximo do GLSL ES. Você o escreve como uma string simples, compila em tempo de execução com RuntimeShader, e usa o resultado como um Brush ou um RenderEffect em qualquer lugar onde o Compose espera um.

A intuição

É fácil imaginar um shader como um filtro que você configura uma vez e aplica a uma imagem inteira, da mesma forma que BlurEffect ou ColorMatrix funcionam. Um shader não é isso. É mais parecido com uma função que não tem nenhuma noção de que uma imagem exista:

  • A GPU invoca a main do seu shader separadamente para cada pixel na área de desenho, em paralelo, sem ordem garantida entre as invocações.
  • Cada invocação só conhece sua própria coordenada de pixel e quaisquer valores que você tenha passado antes da chamada de desenho. Ela não pode ler um pixel vizinho, iterar sobre a imagem, ou lembrar de nada do pixel ao lado ou do frame anterior.
  • Qualquer coisa que um shader "veja" além da sua própria coordenada, uma textura, um gradiente, a saída do último frame, precisa ser explicitamente amostrada, porque nada é compartilhado implicitamente entre invocações.

Essa é toda a mudança mental: um shader descreve a cor de um pixel como uma função pura da sua coordenada e dos seus uniforms, e a GPU é o que executa essa descrição milhões de vezes por frame.

Um shader AGSL minimalista

Aqui está um fragment shader que pinta um campo de plasma animado: cor computada a partir da posição de cada pixel e do tempo atual, recombinando-se em faixas que mudam continuamente. Um Brush.radialGradient pode simular uma vinheta estática, mas nada em Brush pode simular isso, porque a cor em cada pixel é uma função não linear de duas entradas ao mesmo tempo, posição e tempo, recalculada pela GPU a cada frame. O código-fonte AGSL é uma string, não diferente de qualquer outro literal de string do Kotlin:

private const val PLASMA_SHADER = """
    uniform float2 resolution;
    uniform float time;
 
    half4 main(float2 fragCoord) {
        float2 uv = fragCoord / resolution;
        float wave = sin(uv.x * 10.0 + time) + cos(uv.y * 10.0 - time * 1.3);
        float3 color = 0.5 + 0.5 * cos(float3(wave, wave + 2.0, wave + 4.0));
        return half4(color, 1.0);
    }
"""

Observe o que main de fato recebe: fragCoord, o pixel pelo qual essa única invocação é responsável, nada mais. Nem resolution nem time são automáticos, ambos são uniforms que se espera que você mesmo defina, porque o shader não tem uma noção embutida de "o tamanho da coisa em que estou desenhando" ou "quanto tempo o app está em execução".

Conectar isso ao Compose significa compilá-lo uma vez com RuntimeShader, manter ambos os uniforms atualizados, resolution quando o tamanho muda e time em todo e único frame, e entregar o resultado para qualquer API que aceite um Brush:

if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
    val plasmaShader = remember { RuntimeShader(PLASMA_SHADER) }
    val elapsedSeconds by produceState(0f) {
        val start = withFrameMillis { it }
        while (true) {
            withFrameMillis { value = (it - start) / 1000f }
        }
    }
 
    Box(
        modifier = Modifier
            .fillMaxSize()
            .onSizeChanged { size ->
                plasmaShader.setFloatUniform(
                    "resolution",
                    size.width.toFloat(),
                    size.height.toFloat(),
                )
            }
            .drawBehind {
                plasmaShader.setFloatUniform("time", elapsedSeconds)
                drawRect(brush = ShaderBrush(plasmaShader))
            },
    )
}

RuntimeShader compila o código-fonte AGSL imediatamente, então um erro de digitação na string do shader lança uma exceção na construção, não no momento do desenho. ShaderBrush é o que faz a ponte dele para o Compose: ele implementa Brush, então qualquer coisa que pinte com um Brush (background, Canvas.drawRect, uma cor de Text) pode pintar com um shader em vez de uma cor sólida ou um gradiente.

FIG. 01
Animated plasma shader filling a Box: color bands shifting continuously from sin/cos of position and time, something no static Brush gradient can reproduce.

O fundamento

Um shader é um programa por pixel, sem estado, paralelo em dados. "Paralelo em dados" significa que o mesmo programa é executado de forma independente em muitos pixels ao mesmo tempo, em vez de iterar sobre eles um por vez. "Sem estado" significa que cada invocação começa do zero: sem memória de outros pixels, sem memória do último frame, a menos que você explicitamente a realimente como um uniform ou uma textura amostrada.

Onde isso aparece em apps reais

O campo de plasma acima é deliberadamente um brinquedo. O mesmo modelo por pixel é o que de fato roda por trás de efeitos que você já viu em produção:

  • Diálogos com vidro fosco / blur-behind: o shader amostra um snapshot do que está por trás dele e aplica blur por pixel, que é como funciona o blur de diálogo e de notification-shade do Android 12+ sob RenderEffect.
  • Correção de cor e filtros LUT: o RGB de cada pixel é remapeado através de uma função de lookup, a mesma ideia usada por filtros no estilo Instagram ou Lightroom, só que expressa como matemática AGSL em vez de um ColorMatrix fixo.
  • Ripple de toque e feedback de distorção: o shader amostra seu próprio shader de conteúdo em um deslocamento calculado a partir da distância até o toque e do tempo decorrido, produzindo um "squish" de ondulação de água conforme o dedo se move, a mesma família de efeito por trás de interações customizadas de pull-to-refresh e liquid swipe (não o RippleDrawable nativo do Android, que é uma simples revelação circular de alfa sem nenhum shader envolvido).
  • Texturas procedurais e grain: fundos, ruído e padrões de dither gerados a partir de matemática pura no momento do desenho, como o campo de plasma deste post, em vez de distribuir um asset de bitmap que precisa escalar e repetir em tile.
  • Aberração cromática e efeitos de glitch: os canais vermelho, verde e azul são amostrados em deslocamentos de coordenada ligeiramente diferentes, um efeito estilístico comum em apps de câmera e edição de fotos.

Cada um desses é o mesmo modelo mental deste post aplicado a uma função por pixel diferente: só a matemática dentro de main muda.

Em outros lugares: o mesmo fundamento, framework diferente

  • GLSL (OpenGL/WebGL): a linguagem de shading da qual tanto AGSL quanto SkSL descendem. O void main() de um fragment shader WebGL escrevendo em gl_FragColor é exatamente o mesmo modelo por pixel, sem estado, só com as convenções de binding do OpenGL em vez das do RuntimeShader.
  • HLSL (Direct3D, Unity): mesmo ponto de entrada por pixel, sintaxe e modelo de binding diferentes. A função frag de um fragment shader do Unity recebe dados por pixel interpolados e retorna uma cor exatamente da mesma forma que a main do AGSL.
  • Metal Shading Language (iOS/macOS): uma função anotada fragment que é executada uma vez por pixel/fragmento, lendo argumentos explícitos para qualquer coisa de que precise, sem acesso implícito à saída vizinha.
  • SkSL (Skia): não apenas uma analogia, o verdadeiro pai do AGSL. O Skia usa SkSL internamente para seus próprios efeitos, e AGSL é o subconjunto público, ligeiramente restrito, dele exposto ao código do app.

Onde isso realmente pega as pessoas de surpresa

  • Dá crash em tempo de execução abaixo da API 33, não em tempo de compilação. RuntimeShader requer Android 13 (Tiramisu). Não há aviso de compilação ao chamá-lo em um minSdk mais antigo, o crash só acontece na primeira vez que esse caminho de código é executado, então a verificação de Build.VERSION.SDK_INT não é boilerplate opcional, ela é estrutural.
  • O shader compila mas a saída fica preta ou totalmente transparente. A causa mais comum é um uniform não atualizado: resolution tem como padrão (0, 0) até você chamar setFloatUniform, então fragCoord / resolution divide por zero no primeiro frame se você o definir depois do primeiro desenho em vez de antes.
  • AGSL usa por padrão precisão float total, não o mediump do GLSL ES. Portar um fragment shader GLSL ES que depende da faixa mais estreita do mediump float para um efeito intencional de banding ou wraparound não reproduzirá o mesmo artefato em AGSL, a menos que você leve em conta explicitamente a precisão padrão mais ampla.

Modelo mental para de fato usar

Pare de perguntar "o que esse shader vê". Pergunte em vez disso: "o que esse pixel sabe?" Um shader nunca vê a imagem, a tela, ou o frame anterior, ele só vê sua própria coordenada e quaisquer uniforms que você lembrou de definir, o que é também exatamente por que ele pode executar um milhão de vezes por frame sem pisar em si mesmo.

Keep reading

Related reads

Receba novos posts no seu e-mail