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
maindo 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.
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
ColorMatrixfixo. - 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
RippleDrawablenativo 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 emgl_FragColoré exatamente o mesmo modelo por pixel, sem estado, só com as convenções de binding do OpenGL em vez das doRuntimeShader. - HLSL (Direct3D, Unity): mesmo ponto de entrada por pixel,
sintaxe e modelo de binding diferentes. A função
fragde um fragment shader do Unity recebe dados por pixel interpolados e retorna uma cor exatamente da mesma forma que amaindo AGSL. - Metal Shading Language (iOS/macOS): uma função anotada
fragmentque é 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.
RuntimeShaderrequer Android 13 (Tiramisu). Não há aviso de compilação ao chamá-lo em umminSdkmais antigo, o crash só acontece na primeira vez que esse caminho de código é executado, então a verificação deBuild.VERSION.SDK_INTnã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:
resolutiontem como padrão(0, 0)até você chamarsetFloatUniform, entãofragCoord / resolutiondivide por zero no primeiro frame se você o definir depois do primeiro desenho em vez de antes. - AGSL usa por padrão precisão
floattotal, não omediumpdo GLSL ES. Portar um fragment shader GLSL ES que depende da faixa mais estreita domediump floatpara 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.



