Referencia rápida de AGSL

AGSL está diseñado para ser altamente compatible con GLSL ES 1.0. Para obtener más información, ver la función equivalente en la Documentación de OpenGL ES Shading Language. Cuando sea posible, en esta documentación se intentarán destacar las diferencias entre AGSL y GLSL.

Tipos

AGSL admite tipos de GLSL ES 1.0 junto con una forma adicional de representar vectores y tipos de matrices. AGSL admite tipos short y half adicionales para representar precisión media.

Tipos básicos

Tipo	Descripción
void	Ninguna función muestra un valor o un parámetro vacío lista. A diferencia de GLSL, las funciones no están vacías. el tipo de datos que se muestra debe mostrar un valor.
bool, bvec2, bvec3, bvec4 (bool2, bool3, bool4)	Escalar o vector booleano
int, ivec2, ivec3, ivec4 (int2, int3, int4)	Número entero o vector con firma de highp
float, vec2, vec3, vec4 (float2, float3, float4)	Punto flotante de highp (precisión simple) escalar/vector
short, short2, short3, short4	equivalente a mediump int firmado número entero/vector
half, half2, half3, half4	equivalente a mediump float escalar/vector
mat2, mat3, mat4 (float2x2, float3x3, float4x4)	Matriz float de 2 × 2, 3 × 3 y 4 × 4
half2x2, half3x3, half4x4	Equivalente a tipos de matrices mediump float

Mínimos de precisión y rango

Estos son los rangos y la precisión mínimos garantizados asociados con cada basado en la especificación de OpenGL ES 2.0. Ya que la mayoría de los dispositivos admiten ES 3.0, tendrán una precisión/rango de highp más garantizado y Rango de int mediump. Los modificadores de precisión pueden aplicarse a variables escalares, vectoriales y variables y parámetros de la matriz. Solo se garantizan los importes mínimos que se indican a continuación. En realidad, lowp no es necesariamente menor que mediump y mediump. no es necesariamente menor que highp. Actualmente, AGSL convierte lowp a mediump en el resultado final.

Modificador	"flotante" rango	"flotante" rango de magnitud	"flotante" precisión	“int” rango
alto	\(\left\{-2^{62},2^{62}\right\}\)	\(\left\{2^{-62},2^{62}\right\}\)	Relativo: \(2^{-16}\)	\(\left\{-2^{16},2^{16}\right\}\)
medio	\(\left\{-2^{14},2^{14}\right\}\)	\(\left\{2^{-14},2^{14}\right\}\)	Relativo: \(2^{-10}\)	\(\left\{-2^{10},2^{10}\right\}\)
bajo	\(\left\{-2,2\right\}\)	\(\left\{2^{-8},2\right\}\)	Absoluto: \(2^{-8}\)	\(\left\{-2^{8},2^{8}\right\}\)

Además de la sintaxis de subíndice numérico del array, p. ej., 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: Se usa cuando se accede a vectores que representan puntos/normales

vect.rgba: Se usa cuando se accede a vectores que representan colores.

vect.LTRB: Se usa cuando el vector representa un rectángulo (no en GLSL).

En AGSL, se pueden usar 0 y 1 para producir una constante 0 o 1 en ese canal. Ej.: vect.rgb1 == vec4(vect.rgb,1)

Estructuras y arrays

Las estructuras se declaran con la misma sintaxis que GLSL, pero AGSL solo admite de estructuras de seguridad a un alcance global.

struct type-name {
 members
} struct-name; // optional variable declaration.

Solo se admiten arrays unidimensionales con un tamaño de array explícito usando sintaxis de estilo C o GLSL:

<tipo de base>[<array size>] nombre de la variable, p. ej.: half[10] x;

<tipo de base> nombre de la variable[<tamaño del array>] - p. ej.: half x[10];

No se pueden mostrar arrays desde una función, copiarlos, asignarlos o compararlos. Las restricciones de array se propagan a las estructuras que contienen arrays. Los arrays pueden solo pueden indexarse con una constante o una variable de bucle.

Clasificatorios

Tipo	Descripción
const	Constante de tiempo de compilación o función de solo lectura parámetro.
uniform	El valor no cambia en la primitiva mientras se procesan. Los uniformes se pasan desde Android usando RuntimeShader métodos para setColorUniform, setFloatUniform, setIntUniform, setInputBuffer y setInputShader
in	Para los parámetros de la función pasados. Es el valor predeterminado.
out	Para parámetros de funciones pasadas. Debe usar la misma precisión que la definición de la función.
inout	Para los parámetros que se pasan de una función. Se debe usar la misma precisión que la definición de la función.

Declaración de una variable

Las declaraciones deben estar en un alcance explícito colocado por llave. La declaración de y en el siguiente ejemplo no está permitido:

if (condition)
    int y = 0;

Aspectos básicos de la matriz, la estructura o el array

Ejemplos de constructor de matriz

Cuando se construye una matriz con un solo valor, todos los valores junto la diagonal recibe ese valor, mientras que al resto se le dan ceros. float2x2(1.0) harían lo siguiente crea una matriz de identidad 2x2.

Cuando una matriz se construye con múltiples valores, las columnas se completan primero (orden de columna principal).

Ten en cuenta que, a diferencia de GLSL, los constructores que reducen el número de componentes de un no se admiten, pero puedes usar swizzling para tener la misma efecto. Para construir un vec3 a partir de un vec4 en AGSL con el mismo comportamiento que GLSL, especifica vec3 nv = quadVec.xyz.

Ejemplo de constructor de estructura

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 la matriz

Accede a los componentes de una matriz con la sintaxis de subíndice del array.

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 estructura

Selecciona campos de estructura con el operador de punto .. Entre los operadores, se incluyen los siguientes:

Operador	Descripción
.	selector de campos
==, !=	igualdad
=	asignación

Elementos de array

Para acceder a los elementos del array, se usa el operador de subíndice del array [ ]. Por ejemplo:

diffuseColor += lightIntensity[3] * NdotL;

Operadores

Numerados en orden de prioridad. Las bases de datos relacionales operadores > < <= >= == != evalúa como un valor booleano. Comparar vectores a nivel de componentes, usa funciones como lessThan(), equal(), etcétera.

	Operador	Descripción	Asociatividad
1	()	agrupación entre paréntesis	N/A
2	[] () . ++ --	subíndice del array llamada a función y estructura de constructor campo o método selector, swizzle postfijo y disminuir	Izquierda a derecha
3	++ -- + - !	incremento de prefijo disminuir unrio	Derecha a izquierda
4	* /	multiplicar y dividir	Izquierda a derecha
5	+ -	sumar y restar	Izquierda a derecha
7	< > <= >=	relacional	Izquierda a derecha
8	== !=	igualdad/desigualdad	Izquierda a derecha
12	&&	AND lógico	Izquierda a derecha
13	^^	XOR lógico	Izquierda a derecha
14	||	OR lógico	Izquierda a derecha
15	?\:	selección (una imagen completa operando)	Izquierda a derecha
16	= += -= *= /=	aritmética de asignaciones aritmética de asignaciones asignación	Izquierda a derecha
17	,	secuencia	Izquierda a derecha

Operaciones de vectores y matrices

Cuando se aplican a valores escalares, los operadores aritméticos dan como resultado un escalar. Para operadores distintos de módulo, si un operando es un escalar y el otro es un vector o matriz, la operación se realiza a nivel de componentes y da como resultado la mismo vector o tipo de matriz. Si ambas operaciones son vectores del mismo tamaño, la se realiza por componentes (y muestra el mismo tipo de vector).

Operación	Descripción
m = f * m	Multiplicación de matrices por componentes por un valor escalar
v = f * v	Multiplicación de vectores por componentes por un valor escalar
v = v * v	Multiplicación de vectores por componentes por un valor de vector
m = m + m	Suma de componentes de matriz
m = m - m	Resta de componentes de la matriz
m = m * m	Multiplicación algebraica lineal

Si un operando es un vector que coincide con el tamaño de fila o columna de nuestra matriz, el se puede usar para hacer multiplicaciones algebraicas de filas y columnas.

Operación	Descripción
m = v * m	Vector de filas × multiplicación algebraica lineal de matriz
m = m * v	Matriz * multiplicación algebraica lineal del vector de columna

Usar las funciones integradas para vector punto product, producto cruzado y multiplicación por componentes:

Función	Descripción
f = dot(v, v)	Vector.producto escalar
v = cross(v, v)	Producto cruzado vectorial
m = matrixCompMult(m, m)	Multiplicación por componente

Control del programa

Llamada a función	Llamada según el valor de retorno
Iteración	for (<init>;<test>;<next>) { break, continue }
Selección	if ( ) { } if ( ) { } else { } switch () { break, case } - Primer caso predeterminado
Saltar	break, continue, return (no se permite descartar)
Entrada	half4 main(float2 fragCoord)

Para limitaciones de bucle

Similar a GLSL ES 1.0, "for" los bucles son bastante limitados; el compilador debe poder para desenrollar el bucle. Esto significa que el inicializador, la condición de la prueba y el La sentencia next debe usar constantes para que todo se pueda procesar en la compilación tiempo. La sentencia next está aún más limitada al uso de ++, --, +=, or -=.

Funciones integradas

GT (tipo genérico) es float, float2, float3, float4 o half, half2, half3 y half4.

La mayoría de estas funciones operan a nivel de componentes (la función se aplica por componente). Se nota cuando ese no es el caso.

Ángulo y funciones trigonométricas

Se supone que los parámetros de función especificados como un ángulo están en unidades de radianes. En ningún caso, ninguna de estas funciones dará como resultado un error de división por cero. Si el botón divisor de una proporción es 0, los resultados serán indefinidos.

Función	Descripción
GT radians(GT degrees)	Convierte grados en radianes.
GT degrees(GT radians)	Convierte radianes en grados.
GT sin(GT angle)	Seno estándar
GT cos(GT angle)	Coseno estándar
GT tan(GT angle)	Tangente estándar
GT asin(GT x)	Devuelve un ángulo cuyo seno es x en el rango de $ \left[-{\pi\over 2},{\pi\over 2}\r8] $
GT acos(GT x)	Devuelve un ángulo cuyo coseno es x en el rango de $ \left[0,\pi\right] $
GT atan(GT y, GT x)	Devuelve un ángulo cuyo arcotangente trigonométrica es $ \left[{y\over x}\right] $ en el rango de $ \left[-\pi,\pi\right] $
GT atan(GT y_over_x)	Devuelve un ángulo cuya forma trigonométrica la arcotangente está y_over_x en el rango de $ \left[-{\pi\over 2},{\pi\over 2}\r8] $

Funciones exponenciales

Función	Descripción
GT pow(GT x, GT y)	Devuelve $ x^y $
GT exp(GT x)	Devuelve $ e^x $
GT log(GT x)	Devuelve $ ln(x) $
GT exp2(GT x)	Devuelve $ 2^x $
GT log2(GT x)	Devuelve $ log_2(x) $
GT sqrt(GT x)	Devuelve $ \sqrt{x} $
GT inversesqrt(GT x)	Devuelve $ 1\over{\sqrt{x}} $

Funciones comunes

Función	Descripción
GT abs(GT x)	Valor absoluto
GT sign(GT x)	Muestra -1.0, 0.0 o 1.0 sobre el signo de x
GT floor(GT x)	Número entero más cercano <= x
GT ceil(GT x)	Número entero más cercano >= x
GT fract(GT x)	Devuelve la parte fraccionaria de x
GT mod(GT x, GT y)	Devuelve el valor de x módulo y
GT mod(GT x, float y)	Devuelve el valor de x módulo y
GT min(GT x, GT y)	Devuelve el valor mínimo de x o y.
GT min(GT x, float y)	Devuelve el valor mínimo de x o y.
GT max(GT x, GT y)	Devuelve el valor máximo de x o y.
GT max(GT x, float y)	Devuelve el valor máximo de x o y.
GT clamp(GT x, GT minVal, GT maxVal)	Muestra x fijado entre minVal y maxVal.
GT clamp(GT x, float minVal, float maxVal)	Muestra x fijado entre minVal y maxVal
GT saturate(GT x)	Muestra x fijado entre 0.0 y 1.0
GT mix(GT x, GT y GT a)	Devuelve una combinación lineal de x e y
GT mix(GT x, GT y, float a)	Devuelve una combinación lineal de x e y
GT step(GT edge, GT x)	Muestra 0.0 si x < perímetro, else 1.0
GT step(float edge, GT x)	Muestra 0.0 si x < perímetro, else 1.0
GT smoothstep(GT edge0, GT edge1, GT x)	Realiza la interpolación Hermite entre 0 y 1 cuando el perímetro 0 sea menor que x < borde1
GT smoothstep(float edge0, float edge1, GT x)	Realiza la interpolación Hermite entre 0 y 1 cuando el perímetro 0 sea menor que x < borde1

Funciones geométricas

Estas funciones operan en vectores como vectores, no a nivel de componentes. GT es un vector de número de punto flotante/medios en tamaños 2-4.

Función	Descripción
float/half length (GT x)	Devuelve la longitud de un vector
float/half distance(GT p0, GT p1)	Devuelve la distancia entre puntos
float/half dot(GT x, GT y)	Devuelve el producto punto
float3/half3 cross(float3/half3 x, float3/half3 y)	Devuelve productos cruzados
GT normalize(GT x)	Normalizar vector a longitud 1
GT faceforward(GT N, GT I, GT Nref)	Muestra N si punto(Nref, I) < 0, else -N.
GT reflect(GT I, GT N)	Dirección de reflexión I: 2 * punto(N,I) * N.
GT refract(GT I, GT N, float/half eta)	Muestra el vector de refracción

Funciones de matriz

El tipo mat es cualquier tipo de matriz cuadrada.

Función	Descripción
mat matrixCompMult(mat x, mat y)	Multiplicar x por y a nivel de componentes
mat inverse(mat m)	Devuelve el inverso de m

Funciones relacionales de vectores

Compara componentes x e y. Deben coincidir los tamaños de los vectores de entrada y de retorno para una llamada en particular. T es la unión de los tipos de vectores de número entero y punto flotante. BV es un vector booleano que coincide con el tamaño de los vectores de entrada.

Función	Descripción
BV lessThan(T x, T y)	x < año
BV lessThanEqual(T x, T y)	x <= y
BV greaterThan(T x, T y)	x > año
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 si algún componente de x es true.
bool all(BV x)	true si todos los componentes de x son true.
BV not(BV x)	complemento lógico de x

Funciones de color

Función	Descripción
vec4 unpremul(vec4 color)	Convierte el valor de color en no multiplicado previamente alfa
half3 toLinearSrgb(half3 color)	Transformación del espacio de color a SRGB lineal
half3 fromLinearSrgb(half3 color)	Transformación del espacio de color

Muestreo de sombreadores (evaluación)

Los tipos de Sampler no son compatibles, pero puedes evaluar otros sombreadores. Si necesitas para probar una textura, puedes crear una BitmapShader y agregarlo como archivo. uniforme. Puedes hacer esto para cualquier sombreador, lo que significa que puedes evaluar directamente cualquier sombreador de Android sin convertirlo en Bitmap primero, incluido otro Objetos RuntimeShader. Esto permite gran flexibilidad, pero puede ser costoso de usar sombreadores complejos. evaluar, especialmente en un bucle.

uniform shader image;

image.eval(coord).a   // The alpha channel from the evaluated image shader

Muestreo de búfer sin procesar

Aunque la mayoría de las imágenes contienen colores que se deben administrar, algunas imágenes contienen datos que en realidad no son colores, como imágenes que almacenan normales propiedades de material (por ejemplo, aspereza), mapas de altura u otros atributos exclusivamente datos matemáticos que están almacenados en una imagen. Cuando uses estos tipos de imágenes en AGSL, puedes usar un BitmapShader como un búfer genérico sin procesar usando RuntimeShader#setInputBuffer. Esto evitará transformaciones y filtros de espacio de color.