A AGSL foi projetada para ser totalmente compatível com a GLSL ES 1.0. Para mais informações, veja a função equivalente na Documentação da linguagem de sombreamento do OpenGL ES. Quando possível, esta documentação tenta destacar as diferenças entre a AGSL e GLSL.
Tipos
A AGSL é compatível com tipos GLSL ES 1.0, além de uma maneira adicional de representar vetores
e tipos de matriz. A AGSL é compatível com outros tipos short e half para representar
e a precisão média.
Tipos básicos
| Tipo | Descrição |
|---|---|
void
|
Nenhum valor de retorno de função ou parâmetro vazio lista. Diferentemente da GLSL, funções sem uma lacuna tipo de retorno precisa retornar um valor. |
bool, bvec2, bvec3, bvec4 (bool2, bool3, bool4). |
Escalar/vetor booleano |
int, ivec2, ivec3, ivec4 (int2, int3, int4) |
Número inteiro/vetor com sinal de highp
|
float, vec2, vec3, vec4 (float2, float3, float4)
|
Ponto flutuante highp (precisão única)
escalar/vetor |
short, short2, short3, short4
|
equivalente a mediump int assinado
número inteiro/vetor |
half, half2, half3, half4 |
equivalente a mediump float escalar/vetor |
mat2, mat3, mat4 (float2x2, float3x3, float4x4) |
Matriz float 2x2, 3x3, 4x4
|
half2x2, half3x3, half4x4 |
Equivalente a mediump float tipos de matriz |
Mínimos de precisão e intervalo
A precisão e o intervalo mínimos garantidos associados a cada
com base na especificação OpenGL ES 2.0. Como a maioria dos dispositivos
oferecem suporte a ES 3.0, eles terão mais garantia de highp precisão/intervalo
int mediump intervalo. Modificadores de precisão podem ser aplicados a escalares, vetores
variáveis e parâmetros de matriz. Apenas os mínimos listados abaixo são garantidos.
lowp não é necessariamente menor precisão que mediump, e mediump
não é necessariamente menor que highp. A AGSL converte lowp
como mediump na saída final.
| Modificador | "flutuante" intervalo | "flutuante" intervalo de magnitude | "flutuante" precisão | "int" intervalo |
|---|---|---|---|---|
| alta | \(\left\{-2^{62},2^{62}\right\}\) | \(\left\{2^{-62},2^{62}\right\}\) | Relativo: \(2^{-16}\) | \(\left\{-2^{16},2^{16}\right\}\) |
| Médio | \(\left\{-2^{14},2^{14}\right\}\) | \(\left\{2^{-14},2^{14}\right\}\) | Relativo: \(2^{-10}\) | \(\left\{-2^{10},2^{10}\right\}\) |
| baixa | \(\left\{-2,2\right\}\) | \(\left\{2^{-8},2\right\}\) | Absoluto: \(2^{-8}\) | \(\left\{-2^{8},2^{8}\right\}\) |
Além da sintaxe de subscrito numérico da matriz, por exemplo: var[num], names of vector
components for vectors of length 2 - 4 are denoted by a single letter. Components
can be swizzled and replicated. ex:vect.yx,vect.yy`
vect.xyzw: use ao acessar vetores que representam pontos/normais.
vect.rgba: use ao acessar vetores que representam cores.
vect.LTRB: use quando o vetor representar um retângulo (não em GLSL).
Na AGSL, 0 e 1 podem ser usados para produzir uma constante 0 ou 1 nesse canal.
Por exemplo: vect.rgb1 == vec4(vect.rgb,1)
Estruturas e matrizes
As estruturas são declaradas com a mesma sintaxe da GLSL, mas a AGSL só oferece suporte estruturas em escopo global.
struct type-name {
members
} struct-name; // optional variable declaration.
Somente matrizes unidimensionais são suportadas com um tamanho de matriz explícito, usando sintaxe de estilo C ou GLSL:
nome da variável <base type>[<array size>], por exemplo: half[10] x;
<tipo base> nome da variável [<tamanho da matriz>], por exemplo: half x[10];
Matrizes não podem ser retornadas de uma função nem copiadas, atribuídas ou comparadas. As restrições se propagam para estruturas que contêm matrizes. As matrizes podem sejam indexados usando uma constante ou uma variável de loop.
Qualificatórias
| Tipo | Descrição |
|---|---|
const
|
Constante de tempo de compilação ou função somente leitura . |
uniform
|
O valor não muda no primitivo
que estão sendo processados.
Os uniformes são transmitidos do Android usando
RuntimeShader (link em inglês)
métodos para setColorUniform, setFloatUniform,
setIntUniform, setInputBuffer e
setInputShader. |
in
|
Para parâmetros de função transmitidos. Esse é o padrão. |
out
|
Para parâmetros de função transmitidos. Deve usar a mesma precisão que a definição da função. |
inout
|
Para parâmetros que são transmitidos de uma função. Precisa usar a mesma precisão que a definição da função. |
Declaração de variável
As declarações precisam estar em um escopo entre chaves explicitamente. A declaração de y em
o exemplo a seguir não é permitido:
if (condition)
int y = 0;
Noções básicas de matriz/estrutura/matriz
Exemplos de construtores de matrizes
Quando uma matriz é construída com um único valor, todos os valores junto
à diagonal recebem esse valor, enquanto o restante recebe zeros. float2x2(1.0) iria
portanto, crie uma matriz de identidade 2x2.
Quando uma matriz é construída com vários valores, as colunas são preenchidas primeiro (ordem principal da coluna).
Observe que, ao contrário da GLSL, construtores que reduzem o número de componentes de uma
transmitido não são compatíveis, mas é possível usar o swizzling para ter os mesmos
efeito Para criar uma vec3 usando um vec4 na AGSL com o mesmo comportamento que
GLSL: especifique vec3 nv = quadVec.xyz.
Exemplo de construtor de estrutura
struct light { float intensity; float3 pos; };
// literal integer constants auto-converted to floating point
light lightVar = light(3, float3(1, 2, 3.0));
Componentes de matriz
Acesse os componentes de uma matriz com sintaxe de assinatura de matriz.
float4x4 m; // represents a matrix
m[1] = float4(2.0); // sets second column to all 2.0
m[0][0] = 1.0; // sets upper left element to 1.0
m[2][3] = 2.0; // sets 4th element of 3rd column to 2.0
Campos de estrutura
Selecione campos de estrutura usando o operador ponto .. Os operadores incluem:
| Operador | Descrição |
|---|---|
. |
seletor de campo |
==, != |
igualdade |
= |
atribuição |
Elementos de matriz
Os elementos de matriz são acessados usando o operador de subscrito de matriz [ ]. Exemplo:
diffuseColor += lightIntensity[3] * NdotL;
Operadores
Numerados em ordem de precedência. A abordagem relacional e de igualdade
operadores > < <= >= == != avalia como um booleano. Para comparar vetores
por componente, use funções como lessThan(), equal() etc.
| Operador | Descrição | associação | |
|---|---|---|---|
| 1 | () |
agrupamento entre parênteses | N/A |
| 2 | [] () . ++ --
|
subscrito de matriz chamada de função & estrutura do construtor campo ou método seletor, swizzle incremento de postfix e diminuir | Da esquerda para a direita |
| 3 | ++ -- + - !
|
incremento de prefixo e diminuir unário | Da direita para a esquerda |
| 4 | * / |
multiplicar e dividir | Da esquerda para a direita |
| 5 | + - |
somar e subtrair | Da esquerda para a direita |
| 7 | < > <= >= |
relacional | Da esquerda para a direita |
| 8 | == != |
igualdade/desigualdade | Da esquerda para a direita |
| 12 | && |
AND lógico | Da esquerda para a direita |
| 13 | ^^ |
XOR lógico | Da esquerda para a direita |
| 14 | || |
OR lógico | Da esquerda para a direita |
| 15 | ?\:
|
seleção (uma página inteira operando) | Da esquerda para a direita |
| 16 | = += -= *= /=
|
aritmética de atribuição aritmética de atribuição atribuição | Da esquerda para a direita |
| 17 | , |
sequência | Da esquerda para a direita |
Operações de matriz e vetor
Quando aplicados a valores escalares, os operadores aritméticos resultam em um escalar. Para operadores diferentes de módulo, se um operando for escalar e o outro for um vetor ou matriz, a operação é realizada por componentes e resulta no mesmo vetor ou tipo de matriz. Se as duas operações forem vetores do mesmo tamanho, o é realizada por componentes (e retorna o mesmo tipo de vetor).
| Operação | Descrição |
|---|---|
m = f * m |
Multiplicação de matriz por componente por um valor escalar |
v = f * v |
Multiplicação vetorial por componente por um valor escalar |
v = v * v |
Multiplicação vetorial por componente por um valor vetorial |
m = m + m |
Adição de matriz por componente |
m = m - m |
Subtração por componente de matriz |
m = m * m |
Multiplicação algébrica linear |
Se um operando for um vetor que corresponde ao tamanho da linha ou coluna da nossa matriz, o o operador de multiplicação pode ser usado para fazer multiplicação algébrica de linhas e colunas.
| Operação | Descrição |
|---|---|
m = v * m |
Vetor de linha * multiplicação algébrica linear da matriz |
m = m * v |
Matriz * multiplicação algébrica linear do vetor da coluna |
Usar as funções integradas para produto escalar vetorial, multiprodutos e multiplicação por componente:
| Função | Descrição |
|---|---|
f = dot(v, v) |
Vetor escalar produto |
v = cross(v, v) |
Vários produtos vetoriais |
m = matrixCompMult(m, m) |
Multiplicação por componente |
Controle do programa
| Chamada de função | Chamada por valor de retorno |
|---|---|
| Iteração | for (<init>;<test>;<next>) { break, continue } |
| Seleção | if ( ) { } if ( ) { } else { } switch () { break, case }
- último caso padrão |
| Pular | break, continue, return (não é permitido descartar) |
| Entrada | half4 main(float2 fragCoord) |
Limitações de loop "For"
Semelhante à GLSL ES 1.0, "for" os loops são bastante limitados. o compilador precisa
para desenrolar o loop. Isso significa que o inicializador, a condição de teste e o
A instrução next precisa usar constantes para que tudo possa ser calculado na compilação.
tempo de resposta. A instrução next está ainda limitada ao uso de ++, --, +=, or -=.
Funções integradas
GT (tipo genérico) é float, float2, float3, float4 ou
half, half2, half3 e half4.
A maioria dessas funções opera por componente (a função é aplicada por componente). É notado quando esse não é o caso.
Ângulo e funções trigonométricas
Considera-se que os parâmetros de função especificados como um ângulo estão em unidades de radianos. Em nenhum caso nenhuma dessas funções vai resultar em um erro de divisão por zero. Se o divisor de uma razão é 0, então os resultados serão indefinidos.
| Função | Descrição |
|---|---|
GT radians(GT degrees) |
Converte graus em radianos |
GT degrees(GT radians) |
Converte radianos em graus |
GT sin(GT angle) |
Seno padrão |
GT cos(GT angle) |
Coseno padrão |
GT tan(GT angle) |
Tangente padrão |
GT asin(GT x)
|
Retorna um ângulo cujo seno é x na faixa de $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
GT acos(GT x)
|
Retorna um ângulo cujo cosseno é x no faixa de $ \left[0,\pi\right] $ |
GT atan(GT y, GT x)
|
Retorna um ângulo cuja arco trigonométrico é $ \left[{y\over x}\right] $ na faixa de $ \left[-\pi,\pi\right] $ |
GT atan(GT y_over_x)
|
Retorna um ângulo cuja trigonométrica
o arco tangente está y_over_x no intervalo
de $ \left[-{\pi\over 2},{\pi\over 2}\right] $ |
Funções exponenciais
| Função | Descrição |
|---|---|
GT pow(GT x, GT y) |
Retorna $ x^y $ |
GT exp(GT x) |
Retorna $ e^x $ |
GT log(GT x) |
Retorna $ ln(x) $ |
GT exp2(GT x) |
Retorna $ 2^x $ |
GT log2(GT x) |
Retorna $ log_2(x) $ |
GT sqrt(GT x) |
Retorna $ \sqrt{x} $ |
GT inversesqrt(GT x) |
Retorna $ 1\over{\sqrt{x}} $ |
Funções comuns
| Função | Descrição |
|---|---|
GT abs(GT x) |
Valor absoluto |
GT sign(GT x) |
Retorna -1,0, 0,0 ou 1,0 com base no sinal de x |
GT floor(GT x) |
Número inteiro mais próximo <= x |
GT ceil(GT x) |
Número inteiro mais próximo >= x |
GT fract(GT x) |
Retorna a parte fracionária de x |
GT mod(GT x, GT y) |
Retorna o valor do módulo x y |
GT mod(GT x, float y) |
Retorna o valor do módulo x y |
GT min(GT x, GT y) |
Retorna o valor mínimo de x ou y |
GT min(GT x, float y) |
Retorna o valor mínimo de x ou y |
GT max(GT x, GT y) |
Retorna o valor máximo de x ou y |
GT max(GT x, float y) |
Retorna o valor máximo de x ou y |
GT clamp(GT x, GT
minVal, GT maxVal) |
Retorna o x fixado entre minVal e maxVal. |
GT clamp(GT x, float
minVal, float maxVal) |
Retorna o x fixado entre minVal e maxVal |
GT saturate(GT x) |
Retorna o x fixado entre 0,0 e 1,0 |
GT mix(GT x, GT y
GT a) |
Retorna a combinação linear de x e y |
GT mix(GT x, GT y,
float a) |
Retorna a combinação linear de x e y |
GT step(GT edge, GT x) |
Retorna 0,0 se x < borda, caso contrário, 1.0 |
GT step(float edge,
GT x) |
Retorna 0,0 se x < borda, caso contrário, 1.0 |
GT smoothstep(GT edge0,
GT edge1, GT x) |
Realiza interpolação Hermite entre 0 e 1 quando aresta0 < x < borda1 |
GT smoothstep(float
edge0, float edge1,
GT x) |
Realiza interpolação Hermite entre 0 e 1 quando aresta0 < x < borda1 |
Funções geométricas
Essas funções operam nos vetores como vetores, não como componentes. GT é um vetor flutuante/meio-vetor nos tamanhos 2 a 4.
| Função | Descrição |
|---|---|
float/half length
(GT x) |
Retorna o comprimento do vetor |
float/half distance(GT
p0, GT p1) |
Retorna a distância entre os pontos |
float/half dot(GT x,
GT y) |
Retorna o produto escalar |
float3/half3
cross(float3/half3 x,
float3/half3 y) |
Retorna vários produtos |
GT normalize(GT x) |
Normalizar o vetor para o comprimento 1 |
GT faceforward(GT N,
GT I, GT Nref) |
Retorna N se ponto(Nref, I) < 0, caso contrário, -N. |
GT reflect(GT I, GT N) |
Direção do reflexo I - 2 * ponto(N,I) * N. |
GT refract(GT I, GT N,
float/half eta) |
Retorna o vetor de refração |
Funções de matriz
A tapete tipográfica é qualquer tipo de matriz quadrada.
| Função | Descrição |
|---|---|
mat matrixCompMult(mat
x, mat y) |
Multiplicar x por y com os componentes |
mat inverse(mat m) |
Retorna o inverso de m |
Funções relacionais vetoriais
Compare os componentes de x e y. Os tamanhos dos vetores de entrada e retorno para uma chamada específica precisam ser correspondentes. T é a união dos tipos de vetor de número inteiro e de ponto flutuante. BV é um vetor booleano que corresponde ao tamanho dos vetores de entrada.
| Função | Descrição |
|---|---|
BV lessThan(T x, T y) |
x < ano |
BV lessThanEqual(T x,
T y) |
x <= y |
BV greaterThan(T x,
T y) |
x > ano |
BV greaterThanEqual(T
x, T y) |
x >= y |
BV equal(T x, T y) |
x == y |
BV equal(BV x, BV y) |
x == y |
BV notEqual(T x, T y) |
x != y |
BV notEqual(BV x,
BV y) |
x != y |
bool any(BV x) |
true se algum componente de x for true |
bool all(BV x) |
true se todos os componentes de x forem true. |
BV not(BV x) |
complemento lógico de x |
Funções de cor
| Função | Descrição |
|---|---|
vec4 unpremul(vec4
color) |
Converte o valor da cor em valores não pré-multiplicados Alfa |
half3 toLinearSrgb(half3
color) |
Transformação do espaço de cores para SRGB linear |
half3 fromLinearSrgb(half3
color) |
Transformação de espaço de cores |
Amostragem de sombreador (avaliação)
Os tipos de sampler não têm suporte, mas é possível avaliar outros sombreadores. Se você precisar para amostrar uma textura, é possível criar BitmapShader e adicioná-lo como um uniforme. É possível fazer isso para qualquer shader, ou seja, é possível avaliar diretamente qualquer Shader Android sem transformá-lo em um Bitmap primeiro, incluindo outros RuntimeShader. Isso permite para uma enorme flexibilidade, mas sombreadores complexos podem ser caros para avaliar, especialmente em loop.
uniform shader image;
image.eval(coord).a // The alpha channel from the evaluated image shader
Amostragem de buffer bruto
Embora a maioria das imagens contenha cores que devam ser regidas por cores, algumas contêm dados que não são realmente cores, incluindo imagens que armazenam normais, propriedades do material (por exemplo, aspereza), heightmaps ou outras propriedades dados matemáticos que são armazenados em uma imagem. Ao usar esses tipos de imagens na AGSL, é possível usar um BitmapShader como buffer bruto genérico usando RuntimeShader#setInputBuffer. Isso evitará transformações e filtragem do espaço de cores.