Attention: Here be dragons

This is the latest (unstable) version of this documentation, which may document features not available in or compatible with released stable versions of Godot.

Checking the stable version of the documentation...

Built-in shader functions

Godot supports a large number of built-in shader functions, conforming roughly to the GLSL ES 3.0 specification.

Nota

Os seguintes aliases de tipo são usados apenas na documentação para reduzir declarações repetitivas de funções. Cada um deles pode se referir a qualquer um de vários tipos reais.

alias	tipos reais	alias da documentação glsl
vec_type	float, vec2, vec3, ou vec4	genType
vec_int_type	int, ivec2, ivec3, ou ivec4	genIType
vec_uint_type	uint, uvec2, uvec3, ou uvec4	genUType
vec_bool_type	bool, bvec2, bvec3, ou bvec4	genBType
mat_type	mat2, mat3, ou mat4	mat
gvec4_type	vec4, ivec4, ou uvec4	gvec4
gsampler2D	sampler2D, isampler2D, ou uSampler2D	gsampler2D
gsampler2DArray	sampler2DArray, isampler2DArray, ou uSampler2DArray	gsampler2DArray
gsampler3D	sampler3D, isampler3D, ou uSampler3D	gsampler3D

Se qualquer um destes for especificado para múltiplos parâmetros, todos devem ser do mesmo tipo, a menos que indicado de outra forma.

Nota

Muitas funções que aceitam um ou mais vetores ou matrizes executam a função descrita em cada componente do vetor/matriz. Alguns exemplos:

Operação	Operação Escalar Equivalente
`sqrt(vec2(4, 64))`	`vec2(sqrt(4), sqrt(64))`
`min(vec2(3, 4), 1)`	`vec2(min(3, 1), min(4, 1))`
`min(vec3(1, 2, 3),vec3(5, 1, 3))`	`vec3(min(1, 5), min(2, 1), min(3, 3))`
`pow(vec3(3, 8, 5 ), 2)`	`vec3(pow(3, 2), pow(8, 2), pow(5, 2))`
`pow(vec3(3, 8, 5), vec3(1, 2, 4))`	`vec3(pow(3, 1), pow(8, 2), pow(5, 4))`

A Especificação da Linguagem GLSL diz na seção 5.10 Operações de Vetores e Matrizes:

Com poucas exceções, as operações são componente por componente. Normalmente, quando um operador atua em um vetor ou matriz, ele está operando independentemente em cada componente do vetor ou matriz, de maneira componente por componente. [...] As exceções são matriz multiplicada por vetor, vetor multiplicado por matriz e matriz multiplicada por matriz. Estas não operam componente por componente, mas realizam a multiplicação algébrica linear correta.

Estas descrições de funções foram adaptadas e modificadas a partir da documentação oficial do OpenGL publicada originalmente pelo Khronos Group sob a Open Publication License. Cada descrição de função possui um link para a documentação oficial correspondente do OpenGL. O histórico de modificações desta página pode ser encontrado no GitHub.

Funções trigonométricas

Tipo de retorno	Função	Descrição / Valor de Retorno
vec_type	radians(vec_type degrees)	Converte graus para radianos.
vec_type	degrees(vec_type radians)	Converte radianos para graus.
vec_type	sin(vec_type x)	Seno.
vec_type	cos(vec_type x)	Cosseno.
vec_type	tan(vec_type x)	Tangente.
vec_type	asin(vec_type x)	Arco seno.
vec_type	acos(vec_type x)	Arco cosseno.
vec_type vec_type	atan(vec_type y_over_x) atan(vec_type y, vec_type x)	Arco tangente.
vec_type	sinh(vec_type x)	Seno hiperbólico.
vec_type	cosh(vec_type x)	Cosseno hiperbólico.
vec_type	tanh(vec_type x)	Tangente hiperbólica.
vec_type	asinh(vec_type x)	Arco seno hiperbólico.
vec_type	acosh(vec_type x)	Arco cosseno hiperbólico.
vec_type	atanh(vec_type x)	Arco tangente hiperbólica.

Descrições das funções trigonométricas

vec_type radians(vec_type degrees) 🔗

Component-wise Function.

Converte uma quantidade especificada em graus para radianos, com a fórmula degrees * (PI / 180).

param graus:

A quantidade, em graus, a ser convertida para radianos.

return:

O valor de entrada em degrees convertido para radianos.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/radians.xhtml

vec_type degrees(vec_type radians) 🔗

Component-wise Function.

Converte uma quantidade especificada em radianos para graus, com a fórmula radians * (180 / PI)

param radians (radianos):

A quantidade, em radianos, a ser convertida para graus.

return:

O valor de entrada em radians convertido para graus.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/degrees.xhtml

vec_type sin(vec_type angle) 🔗

Component-wise Function.

Retorna o seno trigonométrico de angle.

param angle (ângulo):

A quantidade, em radianos, da qual retornar o seno.

return:

O seno de angle.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/sin.xhtml

vec_type cos(vec_type angle) 🔗

Component-wise Function.

Retorna o cosseno trigonométrico de angle.

param angle (ângulo):

A quantidade, em radianos, da qual retornar o cosseno.

return:

O cosseno de angle.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/cos.xhtml

vec_type tan(vec_type angle) 🔗

Component-wise Function.

Retorna a tangente trigonométrica de angle.

param angle (ângulo):

A quantidade, em radianos, da qual retornar a tangente.

return:

A tangente de angle.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/tan.xhtml

vec_type asin(vec_type x) 🔗

Component-wise Function.

Arco seno, ou inverso do seno. Calcula o ângulo cujo seno é x e que está no intervalo [-PI/2, PI/2]. O resultado é indefinido se x < -1 ou x > 1.

param x:

O valor do qual retornar o arco seno.

return:

O ângulo cujo seno trigonométrico é x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/asin.xhtml

vec_type acos(vec_type x) 🔗

Component-wise Function.

Arco cosseno, ou inverso do cosseno. Calcula o ângulo cujo cosseno é x e que está no intervalo [0, PI].

O resultado é indefinido se x < -1 ou x > 1.

param x:

O valor do qual retornar o arco cosseno.

return:

O ângulo cujo cosseno trigonométrico é x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/acos.xhtml

vec_type atan(vec_type y_over_x) 🔗

Component-wise Function.

Calcula o arco tangente dado um valor de tangente de y/x.

Nota

Devido à ambiguidade do sinal, a função não pode determinar com certeza em qual quadrante o ângulo se encontra apenas pelo seu valor de tangente. Se você precisar saber o quadrante, use atan(vec_type y, vec_type x).

param y_over_x:

A fração da qual retornar o arco tangente.

return:

O arco tangente trigonométrico de y_over_x, que está no intervalo [-PI/2, PI/2].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/atan.xhtml

vec_type atan(vec_type y, vec_type x) 🔗

Component-wise Function.

Calcula o arco tangente dados um numerador e um denominador. Os sinais de y e x são usados para determinar o quadrante em que o ângulo se encontra. O resultado é indefinido se x == 0.

Equivalente a atan2() no GDScript.

param y:

O numerador da fração da qual retornar o arco tangente.

param x:

O denominador da fração da qual retornar o arco tangente.

return:

O arco tangente trigonométrico de y/x, que está no intervalo [-PI, PI].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/atan.xhtml

vec_type sinh(vec_type x) 🔗

Component-wise Function.

Calcula o seno hiperbólico usando (e^x - e^-x)/2.

param x:

O valor cujo seno hiperbólico será retornado.

return:

O seno hiperbólico de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/sinh.xhtml

vec_type cosh(vec_type x) 🔗

Component-wise Function.

Calcula o cosseno hiperbólico usando (e^x + e^-x)/2.

param x:

O valor cujo cosseno hiperbólico será retornado.

return:

O cosseno hiperbólico de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/cosh.xhtml

vec_type tanh(vec_type x) 🔗

Component-wise Function.

Calcula a tangente hiperbólica usando sinh(x)/cosh(x).

param x:

O valor cuja tangente hiperbólica será retornada.

return:

A tangente hiperbólica de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/tanh.xhtml

vec_type asinh(vec_type x) 🔗

Component-wise Function.

Calcula o arco seno hiperbólico de x, ou o inverso de sinh.

param x:

O valor cujo arco seno hiperbólico será retornado.

return:

O arco seno hiperbólico de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/asinh.xhtml

vec_type acosh(vec_type x) 🔗

Component-wise Function.

Calcula o arco cosseno hiperbólico de x, ou o inverso não negativo de cosh. O resultado é indefinido se x < 1.

param x:

O valor cujo arco cosseno hiperbólico será retornado.

return:

O arco cosseno hiperbólico de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/acosh.xhtml

vec_type atanh(vec_type x) 🔗

Component-wise Function.

Calcula o arco tangente hiperbólica de x, ou o inverso de tanh. O resultado é indefinido se abs(x) > 1.

param x:

O valor cujo arco tangente hiperbólica será retornada.

return:

A arco tangente hiperbólica de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/atanh.xhtml

Funções exponenciais e matemáticas

Tipo de retorno	Função	Descrição / Valor de Retorno
vec_type	pow(vec_type x, vec_type y)	Potência (indefinido se `x < 0` ou se `x == 0` e `y <= 0`).
vec_type	exp(vec_type x)	Exponencial de base e.
vec_type	exp2(vec_type x)	Exponencial de base 2.
vec_type	log(vec_type x)	Logaritmo natural (base e).
vec_type	log2(vec_type x)	Logaritmo de base 2.
vec_type	sqrt(vec_type x)	Raiz quadrada.
vec_type	inversesqrt(vec_type x)	Inverso da raiz quadrada.
vec_type vec_int_type	abs(vec_type x) abs(vec_int_type x)	Valor absoluto (retorna valor positivo se for negativo).
vec_type	sign(vec_type x)	Retorna `1.0` se for positivo, `-1.0` se for negativo, `0.0` caso contrário.
vec_int_type	sign(vec_int_type x)	Retorna `1` se for positivo, `-1` se for negativo, `0` caso contrário.
vec_type	floor(vec_type x)	Arredonda para o número inteiro abaixo.
vec_type	round(vec_type x)	Arredonda para o número inteiro mais próximo.
vec_type	roundEven(vec_type x)	Arredonda para o número inteiro par mais próximo.
vec_type	trunc(vec_type x)	Truncamento.
vec_type	ceil(vec_type x)	Arredonda para o número inteiro acima.
vec_type	fract(vec_type x)	Fracionário (retorna `x - floor(x)`).
vec_type vec_type	mod(vec_type x, vec_type y) mod(vec_type x, float y)	Módulo (resto da divisão).
vec_type	modf(vec_type x, out vec_type i)	Parte fracionária de `x`, com `i` como parte inteira.
vec_type vec_type vec_int_type vec_int_type vec_uint_type vec_uint_type	min(vec_type a, vec_type b) min(vec_type a, float b) min(vec_int_type a, vec_int_type b) min(vec_int_type a, int b) min(vec_uint_type a, vec_uint_type b) min(vec_uint_type a, uint b)	Menor valor entre `a` e `b`.
vec_type vec_type vec_int_type vec_int_type vec_uint_type vec_uint_type	max(vec_type a, vec_type b) max(vec_type a, float b) max(vec_int_type a, vec_int_type b) max(vec_int_type a, int b) max(vec_uint_type a, vec_uint_type b) max(vec_uint_type a, uint b)	Maior valor entre `a` e `b`.
vec_type vec_type vec_int_type vec_int_type vec_uint_type vec_uint_type	clamp(vec_type x, vec_type min, vec_type max) clamp(vec_type x, float min, float max) clamp(vec_int_type x, vec_int_type min, vec_int_type max) clamp(vec_int_type x, int min, int max) clamp(vec_uint_type x, vec_uint_type min, vec_uint_type max) clamp(vec_uint_type x, uint min, uint max)	Limita `x` entre `min` e `max` (inclusive).
vec_type vec_type vec_type	mix(vec_type a, vec_type b, vec_type c) mix(vec_type a, vec_type b, float c) mix(vec_type a, vec_type b, vec_bool_type c)	Interpolação linear entre `a` e `b` por `c`.
vec_type	fma(vec_type a, vec_type b, vec_type c)	Operação combinada de multiplicação e adição (fused multiply-add): `(a * b + c)`
vec_type vec_type	step(vec_type a, vec_type b) step(float a, vec_type b)	`b < a ? 0.0 : 1.0`
vec_type vec_type	smoothstep(vec_type a, vec_type b, vec_type c) smoothstep(float a, float b, vec_type c)	Interpolação de Hermite entre `a` e `b` por `c`.
vec_bool_type	isnan(vec_type x)	Retorna `true` se o escalar ou componente do vetor for `NaN`.
vec_bool_type	isinf(vec_type x)	Retorna `true` se o escalar ou componente do vetor for `INF`.
vec_int_type	floatBitsToInt(vec_type x)	Cópia de bits de `float` para `int`, sem conversão.
vec_uint_type	floatBitsToUint(vec_type x)	Cópia de bits de `float` para `uint`, sem conversão.
vec_type	intBitsToFloat(vec_int_type x)	Cópia de bits de `int` para `float`, sem conversão.
vec_type	uintBitsToFloat(vec_uint_type x)	Cópia de bits de `uint` para `float`, sem conversão.

Descrições de funções exponenciais e matemáticas

vec_type pow(vec_type x, vec_type y) 🔗

Component-wise Function.

Eleva x à potência de y.

The result is undefined if x < 0, or if x == 0 and y <= 0.

param x:

O valor a ser elevado à potência y.

param y:

A potência à qual x será elevado.

return:

O valor de x elevado à potência y.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/pow.xhtml

vec_type exp(vec_type x) 🔗

Component-wise Function.

Raises e to the power of x. Also known as the natural exponentiation.

Equivalente a pow(e, x).

param x:

O valor a ser exponenciado.

return:

A exponenciação natural de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/exp.xhtml

vec_type exp2(vec_type x) 🔗

Component-wise Function.

Eleva 2 à potência de x.

Equivalente a pow(2.0, x).

param x:

O valor da potência à qual 2 será elevado.

return:

2 raised to the power of x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/exp2.xhtml

vec_type log(vec_type x) 🔗

Component-wise Function.

Retorna o logaritmo natural de x, ou seja, o valor y que satisfaz x == pow(e, y). O resultado é indefinido se x <= 0.

param x:

O valor do qual calcular o logaritmo natural.

return:

O logaritmo natural de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/log.xhtml

vec_type log2(vec_type x) 🔗

Component-wise Function.

Retorna o logaritmo na base 2 de x, ou seja, o valor y que satisfaz x == pow(2, y). O resultado é indefinido se x <= 0.

param x:

O valor do qual calcular o logaritmo na base 2.

return:

O logaritmo de base 2 de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/log2.xhtml

vec_type sqrt(vec_type x) 🔗

Component-wise Function.

Retorna a raiz quadrada de x. O resultado é indefinido se x < 0.

param x:

O valor do qual calcular a raiz quadrada.

return:

A raiz quadrada de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/sqrt.xhtml

vec_type inversesqrt(vec_type x) 🔗

Component-wise Function.

Retorna o inverso da raiz quadrada de x, ou 1.0 / sqrt(x). O resultado é indefinido se x <= 0.

param x:

O valor do qual calcular o inverso da raiz quadrada.

return:

O inverso da raiz quadrada de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/inversesqrt.xhtml

vec_type abs(vec_type x) 🔗

vec_int_type abs(vec_int_type x) 🔗

Component-wise Function.

Retorna o valor absoluto de x. Retorna x se x for positivo, caso contrário retorna -1 * x.

param x:

O valor do qual retornar o absoluto.

return:

O valor absoluto de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/abs.xhtml

vec_type sign(vec_type x) 🔗

vec_int_type sign(vec_int_type x) 🔗

Component-wise Function.

Retorna -1 se x < 0, 0 se x == 0 e 1 se x > 0.

param x:

O valor do qual extrair o sinal.

return:

O sinal de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/sign.xhtml

vec_type floor(vec_type x) 🔗

Component-wise Function.

Retorna um valor igual ao número inteiro mais próximo que seja menor ou igual a x.

param x:

O valor para arredondar para baixo.

return:

O número inteiro mais próximo que seja menor ou igual a x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/floor.xhtml

vec_type round(vec_type x) 🔗

Component-wise Function.

Arredonda x para o número inteiro mais próximo.

Nota

Rounding of values with a fractional part of 0.5 is implementation-dependent. This includes the possibility that round(x) returns the same value as roundEven(x) for all values of x.

param x:

O valor para arredondar.

return:

O valor arredondado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/round.xhtml

vec_type roundEven(vec_type x) 🔗

Component-wise Function.

Arredonda x para o número inteiro mais próximo. Um valor com uma parte fracionária de 0.5 sempre será arredondado em direção ao número inteiro par mais próximo. Por exemplo, tanto 3.5 quanto 4.5 serão arredondados para 4.0.

param x:

O valor para arredondar.

return:

O valor arredondado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/roundEven.xhtml

vec_type trunc(vec_type x) 🔗

Component-wise Function.

Trunca x. Retorna um valor igual ao número inteiro mais próximo de x cujo valor absoluto não seja maior que o valor absoluto de x.

param x:

O valor para avaliar.

return:

O valor truncado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/trunc.xhtml

vec_type ceil(vec_type x) 🔗

Component-wise Function.

Retorna um valor igual ao número inteiro mais próximo que seja maior ou igual a x.

param x:

O valor para avaliar.

return:

O valor teto (arredondado para cima).

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/ceil.xhtml

vec_type fract(vec_type x) 🔗

Component-wise Function.

Retorna a parte fracionária de x.

Isso é calculado como x - floor(x).

param x:

O valor para avaliar.

return:

A parte fracionária de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/fract.xhtml

vec_type mod(vec_type x, vec_type y) 🔗

vec_type mod(vec_type x, float y) 🔗

Component-wise Function.

Retorna o valor de x modulo y. Isso também é chamado às vezes de resto.

Isso é calculado como x - y * floor(x/y).

param x:

O valor para avaliar.

return:

O valor de x modulo y.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/mod.xhtml

vec_type modf(vec_type x, out vec_type i) 🔗

Component-wise Function.

Separa um valor de ponto flutuante x em suas partes inteira e fracionária.

A parte fracionária do número é retornada pela função. A parte inteira (como uma quantidade em ponto flutuante) é retornada no parâmetro de saída i.

param x:

O valor para separar.

param out i:

Uma variável que recebe a parte inteira de x.

return:

A parte fracionária do número.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/modf.xhtml

vec_type min(vec_type a, vec_type b) 🔗

vec_type min(vec_type a, float b) 🔗

vec_int_type min(vec_int_type a, vec_int_type b) 🔗

vec_int_type min(vec_int_type a, int b) 🔗

vec_uint_type min(vec_uint_type a, vec_uint_type b) 🔗

vec_uint_type min(vec_uint_type a, uint b) 🔗

Component-wise Function.

Retorna o mínimo de dois valores a e b.

Retorna b se b < a, caso contrário retorna a.

param a:

O primeiro valor para comparar.

param b:

O segundo valor para comparar.

return:

O valor mínimo.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/min.xhtml

vec_type max(vec_type a, vec_type b) 🔗

vec_type max(vec_type a, float b) 🔗

vec_uint_type max(vec_uint_type a, vec_uint_type b) 🔗

vec_uint_type max(vec_uint_type a, uint b) 🔗

vec_int_type max(vec_int_type a, vec_int_type b) 🔗

vec_int_type max(vec_int_type a, int b) 🔗

Component-wise Function.

Retorna o máximo de dois valores a e b.

Retorna b se b > a, caso contrário retorna a.

param a:

O primeiro valor para comparar.

param b:

O segundo valor para comparar.

return:

O valor máximo.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/max.xhtml

vec_type clamp(vec_type x, vec_type minVal, vec_type maxVal) 🔗

vec_type clamp(vec_type x, float minVal, float maxVal) 🔗

vec_int_type clamp(vec_int_type x, vec_int_type minVal, vec_int_type maxVal) 🔗

vec_int_type clamp(vec_int_type x, int minVal, int maxVal) 🔗

vec_uint_type clamp(vec_uint_type x, vec_uint_type minVal, vec_uint_type maxVal) 🔗

vec_uint_type clamp(vec_uint_type x, uint minVal, uint maxVal) 🔗

Component-wise Function.

Retorna o valor de x limitado ao intervalo de minVal a maxVal.

O valor retornado é calculado como min(max(x, minVal), maxVal).

param x:

O valor para restringir.

param minVal:

O limite inferior do intervalo no qual limitar x.

param maxVal:

O limite superior do intervalo no qual limitar x.

return:

O valor limitado (clamped).

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/clamp.xhtml

vec_type mix(vec_type a, vec_type b, vec_type c) 🔗

vec_type mix(vec_type a, vec_type b, float c) 🔗

Component-wise Function.

Realiza uma interpolação linear entre a e b usando c para ponderar entre eles.

Calculado como a * (1 - c) + b * c.

Equivalente a lerp() no GDScript.

param a:

O início do intervalo no qual interpolar.

param b:

O fim do intervalo no qual interpolar.

param c:

O valor a ser usado para interpolar entre a e b.

return:

O valor interpolado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/mix.xhtml

vec_type mix(vec_type a, vec_type b, vec_bool_type c) 🔗

Seleciona o valor a ou o valor b com base no valor de c. Para um componente de c que seja falso, o componente correspondente de a é retornado. Para um componente de c que seja verdadeiro, o componente correspondente de b é retornado. Componentes de a e b que não forem selecionados podem ser valores de ponto flutuante inválidos e não terão efeito nos resultados.

If a, b, and c are vector types the operation is performed component-wise. For example, mix(vec2(42, 314), vec2(9.8, 6e23), bvec2(true, false))) will return vec2(9.8, 314).

param a:

Valor retornado quando c é falso.

param b:

Valor retornado quando c é verdadeiro.

param c:

O valor usado para selecionar entre a e b.

return:

O valor interpolado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/mix.xhtml

vec_type fma(vec_type a, vec_type b, vec_type c) 🔗

Component-wise Function.

Realiza, onde possível, uma operação combinada de multiplicação e adição (fused multiply-add), retornando a * b + c. Em casos de uso onde o valor de retorno é eventualmente consumido por uma variável declarada como precisa (precise):

fma() é considerada uma única operação, enquanto a expressão a * b + c consumida por uma variável declarada como precisa é considerada duas operações.

A precisão de fma() pode diferir da precisão da expressão a * b + c.

fma() will be computed with the same precision as any other fma() consumed by a precise variable, giving invariant results for the same input values of a, b, and c.

Caso contrário, na ausência de consumo preciso, não há restrições especiais no número de operações ou diferença de precisão entre fma() e a expressão a * b + c.

param a:

O primeiro valor a ser multiplicado.

param b:

O segundo valor a ser multiplicado.

param c:

O valor a ser adicionado ao resultado.

return:

O valor de a * b + c.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/fma.xhtml

vec_type step(vec_type a, vec_type b) 🔗

vec_type step(float a, vec_type b) 🔗

Component-wise Function.

Generates a step function by comparing b to a.

Equivalent to if (b < a) { return 0.0; } else { return 1.0; }. For element i of the return value, 0.0 is returned if b[i] < a[i], and 1.0 is returned otherwise.

param a:

A localização da borda da função step.

param b:

O valor a ser usado para gerar a função degrau.

return:

0.0 ou 1.0.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/step.xhtml

vec_type smoothstep(vec_type a, vec_type b, vec_type c) 🔗

vec_type smoothstep(float a, float b, vec_type c) 🔗

Component-wise Function.

Realiza uma interpolação suave de Hermite entre 0 e 1 quando a < c < b. Isso é útil em casos onde se deseja uma função de limiar com uma transição suave.

Smoothstep é equivalente a:
vec_type t;
t = clamp((c - a) / (b - a), 0.0, 1.0);
return t * t * (3.0 - 2.0 * t);
Os resultados são indefinidos se a >= b.

param a:

O valor do limite inferior da função de Hermite.

param b:

O valor do limite superior da função de Hermite.

param c:

O valor de origem para a interpolação.

return:

O valor interpolado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/smoothstep.xhtml

vec_bool_type isnan(vec_type x) 🔗

Component-wise Function.

For each element i of the result, returns true if x[i] is a positive or negative floating-point NaN (Not a Number) and false otherwise.

param x:

The value to test for NaN.

return:

true ou false.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/isnan.xhtml

vec_bool_type isinf(vec_type x) 🔗

Component-wise Function.

Para cada elemento i do resultado, retorna true se x[i] for um infinito de ponto flutuante positivo ou negativo, e falso caso contrário.

param x:

O valor a ser testado para o infinito.

return:

true ou false.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/isinf.xhtml

vec_int_type floatBitsToInt(vec_type x) 🔗

Component-wise Function.

Retorna a codificação dos parâmetros de ponto flutuante como int.

A representação a nível de bits do ponto flutuante é preservada.

param x:

O valor cuja codificação em ponto flutuante deve ser retornada.

return:

A codificação em ponto flutuante de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/floatBitsToInt.xhtml

vec_uint_type floatBitsToUint(vec_type x) 🔗

Component-wise Function.

Retorna a codificação dos parâmetros de ponto flutuante como uint.

A representação a nível de bits do ponto flutuante é preservada.

param x:

O valor cuja codificação em ponto flutuante deve ser retornada.

return:

A codificação em ponto flutuante de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/floatBitsToInt.xhtml

vec_type intBitsToFloat(vec_int_type x) 🔗

Component-wise Function.

Converte uma codificação de bits em um valor de ponto flutuante. O oposto de floatBitsToInt<shader_func_floatBitsToInt>

Se a codificação de um NaN for passada em x, ela não gerará sinalização e o valor resultante será indefinido.

Se a codificação de um infinito de ponto flutuante for passada no parâmetro x, o valor de ponto flutuante resultante será o infinito correspondente (positivo ou negativo).

param x:

A codificação de bits a ser retornada como um valor de ponto flutuante.

return:

Um valor de ponto flutuante.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/intBitsToFloat.xhtml

vec_type uintBitsToFloat(vec_uint_type x) 🔗

Component-wise Function.

Converte uma codificação de bits em um valor de ponto flutuante. O oposto de floatBitsToUint<shader_func_floatBitsToUint>

Se a codificação de um NaN for passada em x, ela não gerará sinalização e o valor resultante será indefinido.

Se a codificação de um infinito de ponto flutuante for passada no parâmetro x, o valor de ponto flutuante resultante será o infinito correspondente (positivo ou negativo).

param x:

A codificação de bits a ser retornada como um valor de ponto flutuante.

return:

Um valor de ponto flutuante.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/intBitsToFloat.xhtml

Funções geométricas

float	length(vec_type x)	Comprimento do vetor.
float	distance(vec_type a, vec_type b)	Distância entre vetores, ou seja, `length(a - b)`.
float	dot(vec_type a, vec_type b)	Produto escalar (dot product).
vec3	cross(vec3 a, vec3 b)	Produto vetorial (cross product).
vec_type	normalize(vec_type x)	Normaliza para comprimento unitário.
vec3	reflect(vec3 I, vec3 N)	Refletir (reflect).
vec3	refract(vec3 I, vec3 N, float eta)	Refratar (refract).
vec_type	faceforward(vec_type N, vec_type I, vec_type Nref)	If `dot(Nref, I) < 0`, returns `N`, otherwise `-N`.
mat_type	matrixCompMult(mat_type x, mat_type y)	Multiplicação de componentes de matriz.
mat_type	outerProduct(vec_type column, vec_type row)	Produto externo de matriz.
mat_type	transpose(mat_type m)	Transpor matriz.
float	determinant(mat_type m)	Determinante da matriz.
mat_type	inverse(mat_type m)	Inverter matriz.

Descrições de funções geométricas

float length(vec_type x) 🔗

Returns the length of the vector, i.e., sqrt(x[0] * x[0] + x[1] * x[1] + ... + x[n] * x[n])

param x:

O vetor

return:

O comprimento do vetor.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/length.xhtml

float distance(vec_type a, vec_type b) 🔗

Returns the distance between the two points a and b, i.e., length(b - a);

param a:

O primeiro ponto.

param b:

O segundo ponto.

return:

A distância escalar entre os pontos

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/distance.xhtml

float dot(vec_type a, vec_type b) 🔗

Returns the dot product of two vectors, a and b, i.e., a.x * b.x + a.y * b.y + ...

param a:

O primeiro vetor.

param b:

O segundo vetor.

return:

O produto escalar.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/dot.xhtml

vec3 cross(vec3 a, vec3 b) 🔗

Returns the cross product of two vectors, i.e.:
vec3( a.y * b.z - b.y * a.z,
      a.z * b.x - b.z * a.x,
      a.x * b.y - b.x * a.y)
param a:

O primeiro vetor.

param b:

O segundo vetor.

return:

O produto vetorial de a e b.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/cross.xhtml

vec_type normalize(vec_type x) 🔗

Retorna um vetor com a mesma direção que x, mas com comprimento 1.0.

param x:

O vetor a ser normalizado.

return:

O vetor normalizado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/normalize.xhtml

vec3 reflect(vec3 I, vec3 N) 🔗

Calcula a direção de reflexão para um vetor incidente.

Para um dado vetor incidente I e uma normal de superfície N, reflect retorna a direção de reflexão calculada como I - 2.0 * dot(N, I) * N.

Nota

N deve estar normalizado para obter o resultado desejado.

param I:

O vetor incidente.

param N:

O vetor normal.

return:

O vetor de reflexão.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/reflect.xhtml

vec3 refract(vec3 I, vec3 N, float eta) 🔗

Calcula a direção de refração para um vetor incidente.

Para um dado vetor incidente I, uma normal de superfície N e uma razão de índices de refração, eta, refract retorna o vetor de refração, R.

R é calculado como:
k = 1.0 - eta * eta * (1.0 - dot(N, I) * dot(N, I));
if (k < 0.0)
    R = genType(0.0);       // or genDType(0.0)
else
    R = eta * I - (eta * dot(N, I) + sqrt(k)) * N;
Nota

Os parâmetros de entrada I e N devem estar normalizados para obter o resultado desejado.

param I:

O vetor incidente.

param N:

O vetor normal.

param eta:

A razão dos índices de refração.

return:

O vetor de refração.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/refract.xhtml

vec_type faceforward(vec_type N, vec_type I, vec_type Nref) 🔗

Retorna um vetor apontando na mesma direção que outro.

Orienta um vetor para apontar na direção oposta a uma superfície, conforme definido por sua normal. Se dot(Nref, I) < 0, faceforward retorna N, caso contrário retorna -N.

param N:

O vetor a ser orientado.

param I:

O vetor incidente.

param Nref:

O vetor de referência.

return:

O vetor orientado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/faceforward.xhtml

mat_type matrixCompMult(mat_type x, mat_type y) 🔗

Realiza uma multiplicação componente por componente (component-wise) de duas matrizes.

Realiza uma multiplicação componente por componente de duas matrizes, gerando uma matriz de resultado onde cada componente, result[i][j], é computado como o produto escalar de x[i][j] e y[i][j].

param x:

O primeiro multiplicando da matriz.

param y:

O segundo multiplicando da matriz.

return:

A matriz resultante.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/matrixCompMult.xhtml

mat_type outerProduct(vec_type column, vec_type row) 🔗

Calcula o produto externo de um par de vetores.

Realiza uma multiplicação de matrizes da álgebra linear column * row, gerando uma matriz cujo número de linhas é o número de componentes em column e cujo número de colunas é o número de componentes em row.

param column:

O vetor coluna para multiplicação.

param row:

O vetor linha para multiplicação.

return:

A matriz de produto externo.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/outerProduct.xhtml

mat_type transpose(mat_type m) 🔗

Calcula a transposta de uma matriz.

param m:

A matriz para transpor.

return:

A nova matriz que é a transposta da matriz de entrada m.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/transpose.xhtml

float determinant(mat_type m) 🔗

Calcula o determinante de uma matriz.

param m:

A matriz.

return:

O determinante da matriz de entrada m.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/determinant.xhtml

mat_type inverse(mat_type m) 🔗

Calcula a inversa de uma matriz.

Os valores na matriz retornada são indefinidos se m for singular ou mal condicionada (quase singular).

param m:

A matriz da qual calcular a inversa.

return:

Uma nova matriz que é a inversa da matriz de entrada m.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/inverse.xhtml

Funções de comparação

vec_bool_type	lessThan(vec_type x, vec_type y)	Bool vector > comparison on int/uint/float vectors.
vec_bool_type	greaterThan(vec_type x, vec_type y)	Bool vector < comparison on int/uint/float vectors.
vec_bool_type	lessThanEqual(vec_type x, vec_type y)	Bool vector <= comparison on int/uint/float vectors.
vec_bool_type	greaterThanEqual( vec_type x, vec_type y)	Bool vector >= comparison on int/uint/float vectors.
vec_bool_type	equal(vec_type x, vec_type y)	Bool vector <= comparison on int/uint/float vectors.
vec_bool_type	notEqual(vec_type x, vec_type y)	Bool vector != comparison on int/uint/float vectors.
bool	any(vec_bool_type x)	`true` se qualquer componente for `true`, `false` caso contrário.
bool	all(vec_bool_type x)	`true` se todos os componentes forem `true`, `false` caso contrário.
vec_bool_type	not(vec_bool_type x)	Inverter vetor booleano.

Descrições de funções de comparação

vec_bool_type lessThan(vec_type x, vec_type y) 🔗

Realiza uma comparação menor que componente por componente (component-wise) de dois vetores.

param x:

O primeiro vetor para comparar.

param y:

O segundo vetor para comparar.

return:

Um vetor booleano no qual cada elemento i é computado como x[i] < y[i].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/lessThan.xhtml

vec_bool_type greaterThan(vec_type x, vec_type y) 🔗

Realiza uma comparação maior que componente por componente (component-wise) de dois vetores.

param x:

O primeiro vetor para comparar.

param y:

O segundo vetor para comparar.

return:

Um vetor booleano no qual cada elemento i é computado como x[i] > y[i].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/greaterThan.xhtml

vec_bool_type lessThanEqual(vec_type x, vec_type y) 🔗

Realiza uma comparação menor ou igual componente por componente (component-wise) de dois vetores.

param x:

O primeiro vetor para comparar.

param y:

O segundo vetor para comparar.

return:

Um vetor booleano no qual cada elemento i é computado como x[i] <= y[i].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/lessThanEqual.xhtml

vec_bool_type greaterThanEqual(vec_type x, vec_type y) 🔗

Realiza uma comparação maior ou igual componente por componente (component-wise) de dois vetores.

param x:

O primeiro vetor para comparar.

param y:

O segundo vetor para comparar.

return:

Um vetor booleano no qual cada elemento i é computado como x[i] >= y[i].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/greaterThanEqual.xhtml

vec_bool_type equal(vec_type x, vec_type y) 🔗

Realiza uma comparação de igualdade componente por componente (component-wise) de dois vetores.

param x:

O primeiro vetor para comparar.

param y:

O segundo vetor para comparar.

return:

Um vetor booleano no qual cada elemento i é computado como x[i] == y[i].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/equal.xhtml

vec_bool_type notEqual(vec_type x, vec_type y) 🔗

Realiza uma comparação de diferença componente por componente (component-wise) de dois vetores.

param x:

O primeiro vetor para comparar.

param y:

O segundo vetor para comparar.

return:

Um vetor booleano no qual cada elemento i é computado como x[i] != y[i].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/notEqual.xhtml

bool any(vec_bool_type x) 🔗

Retorna true se qualquer elemento de um vetor booleano for true, caso contrário false.

Funcionalmente equivalente a:
bool any(bvec x) {     // bvec can be bvec2, bvec3 or bvec4
    bool result = false;
    int i;
    for (i = 0; i < x.length(); ++i) {
        result |= x[i];
    }
    return result;
}
param x:

O vetor a ser testado quanto à veracidade.

return:

true if any element of x is true and false otherwise.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/any.xhtml

bool all(vec_bool_type x) 🔗

Retorna true se todos os elementos de um vetor booleano forem true, caso contrário false.

Funcionalmente equivalente a:
bool all(bvec x)       // bvec can be bvec2, bvec3 or bvec4
{
    bool result = true;
    int i;
    for (i = 0; i < x.length(); ++i)
    {
        result &= x[i];
    }
    return result;
}
param x:

O vetor a ser testado quanto à veracidade.

return:

true se todos os elementos de x forem true e false caso contrário.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/all.xhtml

vec_bool_type not(vec_bool_type x) 🔗

Logically inverts a boolean vector.

param x:

O vetor a ser invertido.

return:

A boolean vector in which each element i is computed as !x[i].

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/not.xhtml

Funções de textura

ivec2 ivec2 ivec2 ivec3 ivec3	textureSize(gsampler2D s, int lod) textureSize(samplerCube s, int lod) textureSize(samplerCubeArray s, int lod) textureSize(gsampler2DArray s, int lod) textureSize(gsampler3D s, int lod)	Gets the size of a texture. Por razões de desempenho, esta função deve ser evitada, pois ela sempre realiza uma leitura completa da textura. Quando possível, você deve passar o tamanho da textura como um uniform.
vec2 vec3 vec2 vec2	textureQueryLod(gsampler2D s, vec2 p) textureQueryLod(gsampler2DArray s, vec2 p) textureQueryLod(gsampler3D s, vec3 p) textureQueryLod(samplerCube s, vec3 p)	Computes the level of detail that would be used to sample from a texture.
int int int int	textureQueryLevels(gsampler2D s) textureQueryLevels(gsampler2DArray s) textureQueryLevels(gsampler3D s) textureQueryLevels(samplerCube s)	Gets the number of accessible mipmap levels of a texture.
gvec4_type gvec4_type gvec4_type vec4 vec4 vec4	texture(gsampler2D s, vec2 p [, float bias] ) texture(gsampler2DArray s, vec3 p [, float bias] ) texture(gsampler3D s, vec3 p [, float bias] ) texture(samplerCube s, vec3 p [, float bias] ) texture(samplerCubeArray s, vec4 p [, float bias] ) texture(samplerExternalOES s, vec2 p [, float bias] )	Realiza uma leitura de textura.
gvec4_type gvec4_type gvec4_type	textureProj(gsampler2D s, vec3 p [, float bias] ) textureProj(gsampler2D s, vec4 p [, float bias] ) textureProj(gsampler3D s, vec4 p [, float bias] )	Realiza uma leitura de textura com projeção.
gvec4_type gvec4_type gvec4_type vec4 vec4	textureLod(gsampler2D s, vec2 p, float lod) textureLod(gsampler2DArray s, vec3 p, float lod) textureLod(gsampler3D s, vec3 p, float lod) textureLod(samplerCube s, vec3 p, float lod) textureLod(samplerCubeArray s, vec4 p, float lod)	Realiza uma leitura de textura em um mipmap personalizado.
gvec4_type gvec4_type gvec4_type	textureProjLod(gsampler2D s, vec3 p, float lod) textureProjLod(gsampler2D s, vec4 p, float lod) textureProjLod(gsampler3D s, vec4 p, float lod)	Realiza uma leitura de textura com projeção/LOD.
gvec4_type gvec4_type gvec4_type vec4 vec4	textureGrad(gsampler2D s, vec2 p, vec2 dPdx, vec2 dPdy) textureGrad(gsampler2DArray s, vec3 p, vec2 dPdx, vec2 dPdy) textureGrad(gsampler3D s, vec3 p, vec2 dPdx, vec2 dPdy) textureGrad(samplerCube s, vec3 p, vec3 dPdx, vec3 dPdy) textureGrad(samplerCubeArray s, vec3 p, vec3 dPdx, vec3 dPdy)	Realiza uma leitura de textura com gradientes explícitos.
gvec4_type gvec4_type gvec4_type	textureProjGrad(gsampler2D s, vec3 p, vec2 dPdx, vec2 dPdy) textureProjGrad(gsampler2D s, vec4 p, vec2 dPdx, vec2 dPdy) textureProjGrad(gsampler3D s, vec4 p, vec3 dPdx, vec3 dPdy)	Performs a texture read with projection/LOD and with explicit gradients.
gvec4_type gvec4_type gvec4_type	texelFetch(gsampler2D s, ivec2 p, int lod) texelFetch(gsampler2DArray s, ivec3 p, int lod) texelFetch(gsampler3D s, ivec3 p, int lod)	Busca um único texel usando coordenadas inteiras.
gvec4_type gvec4_type vec4	textureGather(gsampler2D s, vec2 p [, int comps] ) textureGather(gsampler2DArray s, vec3 p [, int comps] ) textureGather(samplerCube s, vec3 p [, int comps] )	Reúne quatro texels de uma textura.
vec_type	dFdx(vec_type p)	Derivada em relação à coordenada de janela `x`, granularidade automática.
vec_type	dFdxCoarse(vec_type p)	Derivada em relação à coordenada de janela `x`, granularidade grossa (coarse). Não disponível ao usar o renderizador de Compatibilidade (Compatibility).
vec_type	dFdxFine(vec_type p)	Derivada em relação à coordenada de janela `x`, granularidade fina (fine). Não disponível ao usar o renderizador de Compatibilidade (Compatibility).
vec_type	dFdy(vec_type p)	Derivada em relação à coordenada de janela `y`, granularidade automática.
vec_type	dFdyCoarse(vec_type p)	Derivada em relação à coordenada de janela `y`, granularidade grossa (coarse). Não disponível ao usar o renderizador de Compatibilidade (Compatibility).
vec_type	dFdyFine(vec_type p)	Derivada em relação à coordenada de janela `y`, granularidade fina (fine). Não disponível ao usar o renderizador de Compatibilidade (Compatibility).
vec_type	fwidth(vec_type p)	Soma das derivadas absolutas em `x` e `y`.
vec_type	fwidthCoarse(vec_type p)	Soma das derivadas absolutas em `x` e `y`. Não disponível ao usar o renderizador de Compatibilidade (Compatibility).
vec_type	fwidthFine(vec_type p)	Soma das derivadas absolutas em `x` e `y`. Não disponível ao usar o renderizador de Compatibilidade (Compatibility).

Descrições das funções de textura

ivec2 textureSize(gsampler2D s, int lod) 🔗

ivec2 textureSize(samplerCube s, int lod) 🔗

ivec2 textureSize(samplerCubeArray s, int lod) 🔗

ivec3 textureSize(gsampler2DArray s, int lod) 🔗

ivec3 textureSize(gsampler3D s, int lod) 🔗

Recupera as dimensões de um nível de uma textura.

Retorna as dimensões do nível lod (se presente) da textura vinculada ao amostrador (sampler).

Os componentes no valor de retorno são preenchidos, em ordem, com a largura, altura e profundidade da textura. Para os formatos de array, o último componente do valor de retorno é o número de camadas no array de texturas.

param s:

O amostrador (sampler) ao qual a textura cujas dimensões serão recuperadas está vinculada.

param lod:

O nível da textura do qual recuperar as dimensões.

return:

As dimensões do nível lod (se presente) da textura vinculada ao amostrador (sampler).

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureSize.xhtml

vec2 textureQueryLod(gsampler2D s, vec2 p) 🔗

vec2 textureQueryLod(gsampler2DArray s, vec2 p) 🔗

vec2 textureQueryLod(gsampler3D s, vec3 p) 🔗

vec2 textureQueryLod(samplerCube s, vec3 p) 🔗

Nota

Disponível apenas no shader de fragmentos.

Calcula o nível de detalhe (level-of-detail) que seria usado para amostrar de uma textura.

O(s) array(s) de mipmap que seriam acessados são retornados no componente x do valor de retorno. O nível de detalhe computado em relação ao nível base é retornado no componente y do valor de retorno.

Se chamada em uma textura incompleta, o resultado da operação é indefinido.

param s:

O amostrador (sampler) ao qual a textura cujo nível de detalhe será consultado está vinculada.

param p:

As coordenadas de textura nas quais o nível de detalhe será consultado.

return:

Veja a descrição.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureQueryLod.xhtml

int textureQueryLevels(gsampler2D s) 🔗

int textureQueryLevels(gsampler2DArray s) 🔗

int textureQueryLevels(gsampler3D s) 🔗

int textureQueryLevels(samplerCube s) 🔗

Calcula o número de níveis de mipmap acessíveis de uma textura.

Se chamada em uma textura incompleta, ou se nenhuma textura estiver associada ao amostrador, 0 é retornado.

param s:

O amostrador (sampler) ao qual a textura cuja contagem de níveis de mipmap será consultada está vinculada.

return:

O número de níveis de mipmap acessíveis na textura, ou 0.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureQueryLevels.xhtml

gvec4_type texture(gsampler2D s, vec2 p [, float bias] ) 🔗

gvec4_type texture(gsampler2DArray s, vec3 p [, float bias] ) 🔗

gvec4_type texture(gsampler3D s, vec3 p [, float bias] ) 🔗

vec4 texture(samplerCube s, vec3 p [, float bias] ) 🔗

vec4 texture(samplerCubeArray s, vec4 p [, float bias] ) 🔗

vec4 texture(samplerExternalOES s, vec2 p [, float bias] ) 🔗

Recupera texels de uma textura.

Amostra texels da textura vinculada a s na coordenada de textura p. Um viés opcional, especificado em bias, é incluído no cálculo do nível de detalhe que é usado para escolher o(s) mipmap(s) do(s) qual(is) amostrar.

Para formas de sombra (shadow forms), o último componente de p é usado como Dsub e a camada do array é especificada no penúltimo componente de p. (O segundo componente de p não é usado para buscas de sombra 1D.)

Para variantes que não são de sombra, a camada do array vem do último componente de P.

param s:

O amostrador (sampler) ao qual a textura da qual os texels serão recuperados está vinculada.

param p:

As coordenadas de textura nas quais a textura será amostrada.

param bias:

Um viés (bias) opcional a ser aplicado durante o cálculo do nível de detalhe.

return:

Um texel.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/texture.xhtml

gvec4_type textureProj(gsampler2D s, vec3 p [, float bias] ) 🔗

gvec4_type textureProj(gsampler2D s, vec4 p [, float bias] ) 🔗

gvec4_type textureProj(gsampler3D s, vec4 p [, float bias] ) 🔗

Performs a texture lookup with projection.

The texture coordinates consumed from p, not including the last component of p, are divided by the last component of p. The resulting 3rd component of p in the shadow forms is used as Dref. After these values are computed, the texture lookup proceeds as in texture.

param s:

O amostrador (sampler) ao qual a textura da qual os texels serão recuperados está vinculada.

param p:

As coordenadas de textura nas quais a textura será amostrada.

param bias:

Viés (bias) opcional a ser aplicado durante o cálculo do nível de detalhe.

return:

Um texel.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureProj.xhtml

gvec4_type textureLod(gsampler2D s, vec2 p, float lod) 🔗

gvec4_type textureLod(gsampler2DArray s, vec3 p, float lod) 🔗

gvec4_type textureLod(gsampler3D s, vec3 p, float lod) 🔗

vec4 textureLod(samplerCube s, vec3 p, float lod) 🔗

vec4 textureLod(samplerCubeArray s, vec4 p, float lod) 🔗

Realiza uma busca de textura na coordenada p a partir da textura vinculada ao amostrador com um nível de detalhe explícito conforme especificado em lod. lod especifica λbase e define as derivadas parciais da seguinte forma:
δu/δx=0, δv/δx=0, δw/δx=0
δu/δy=0, δv/δy=0, δw/δy=0
param s:

O amostrador (sampler) ao qual a textura da qual os texels serão recuperados está vinculada.

param p:

As coordenadas de textura nas quais a textura será amostrada.

param lod:

O nível de detalhe (lod) explícito.

return:

Um texel.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureLod.xhtml

gvec4_type textureProjLod(gsampler2D s, vec3 p, float lod) 🔗

gvec4_type textureProjLod(gsampler2D s, vec4 p, float lod) 🔗

gvec4_type textureProjLod(gsampler3D s, vec4 p, float lod) 🔗

Realiza uma busca de textura com projeção a partir de um nível de detalhe explicitamente especificado.

The texture coordinates consumed from p, not including the last component of p, are divided by the last component of p. The resulting 3rd component of p in the shadow forms is used as Dref. After these values are computed, the texture lookup proceeds as in textureLod, with lod used to specify the level-of-detail from which the texture will be sampled.

param s:

O amostrador (sampler) ao qual a textura da qual os texels serão recuperados está vinculada.

param p:

As coordenadas de textura nas quais a textura será amostrada.

param lod:

O nível de detalhe explícito do qual buscar os texels.

return:

um texel

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureProjLod.xhtml

gvec4_type textureGrad(gsampler2D s, vec2 p, vec2 dPdx, vec2 dPdy) 🔗

gvec4_type textureGrad(gsampler2DArray s, vec3 p, vec2 dPdx, vec2 dPdy) 🔗

gvec4_type textureGrad(gsampler3D s, vec3 p, vec2 dPdx, vec2 dPdy) 🔗

vec4 textureGrad(samplerCube s, vec3 p, vec3 dPdx, vec3 dPdy) 🔗

vec4 textureGrad(samplerCubeArray s, vec3 p, vec3 dPdx, vec3 dPdy) 🔗

Performs a texture lookup at coordinate p from the texture bound to sampler with explicit texture coordinate gradients as specified in dPdx and dPdy. Set:

δs/δx=δp/δx para uma textura 1D, δp.s/δx caso contrário

δs/δy=δp/δy para uma textura 1D, δp.s/δy caso contrário

δt/δx=0.0 para uma textura 1D, δp.t/δx caso contrário

δt/δy=0.0 para uma textura 1D, δp.t/δy caso contrário

δr/δx=0.0 para uma textura 1D ou 2D, δp.p/δx caso contrário

δr/δy=0.0 for a 1D or 2D texture, δp.p/δy otherwise

Para a versão de cubo (cube), assume-se que as derivadas parciais de p estão no sistema de coordenadas usado antes de as coordenadas de textura serem projetadas na face apropriada do cubo.

param s:

O amostrador (sampler) ao qual a textura da qual os texels serão recuperados está vinculada.

param p:

As coordenadas de textura nas quais a textura será amostrada.

param dPdx:

A derivada parcial de P em relação ao x da janela.

param dPdy:

A derivada parcial de P em relação ao y da janela.

return:

Um texel.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureGrad.xhtml

gvec4_type textureProjGrad(gsampler2D s, vec3 p, vec2 dPdx, vec2 dPdy) 🔗

gvec4_type textureProjGrad(gsampler2D s, vec4 p, vec2 dPdx, vec2 dPdy) 🔗

gvec4_type textureProjGrad(gsampler3D s, vec4 p, vec3 dPdx, vec3 dPdy) 🔗

Performs a texture lookup with projection and explicit gradients.

The texture coordinates consumed from p, not including the last component of p, are divided by the last component of p. After these values are computed, the texture lookup proceeds as in textureGrad, passing dPdx and dPdy as gradients.

param s:

O amostrador (sampler) ao qual a textura da qual os texels serão recuperados está vinculada.

param p:

As coordenadas de textura nas quais a textura será amostrada.

param dPdx:

A derivada parcial de p em relação ao x da janela.

param dPdy:

A derivada parcial de p em relação ao y da janela.

return:

Um texel.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureProjGrad.xhtml

gvec4_type texelFetch(gsampler2D s, ivec2 p, int lod) 🔗

gvec4_type texelFetch(gsampler2DArray s, ivec3 p, int lod) 🔗

gvec4_type texelFetch(gsampler3D s, ivec3 p, int lod) 🔗

Realiza a busca de um único texel a partir da coordenada de textura p na textura vinculada ao amostrador (sampler).

param s:

O amostrador (sampler) ao qual a textura da qual os texels serão recuperados está vinculada.

param p:

As coordenadas de textura nas quais a textura será amostrada.

param lod:

Especifica o nível de detalhe (level-of-detail) dentro da textura do qual o texel será buscado.

return:

Um texel.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/texelFetch.xhtml

gvec4_type textureGather(gsampler2D s, vec2 p [, int comps] ) 🔗

gvec4_type textureGather(gsampler2DArray s, vec3 p [, int comps] ) 🔗

vec4 textureGather(samplerCube s, vec3 p [, int comps] ) 🔗

Reúne quatro texels de uma textura.

Retorna o valor:
vec4(Sample_i0_j1(p, base).comps,
     Sample_i1_j1(p, base).comps,
     Sample_i1_j0(p, base).comps,
     Sample_i0_j0(p, base).comps);
param s:

O amostrador (sampler) ao qual a textura da qual os texels serão recuperados está vinculada.

param p:

As coordenadas de textura nas quais a textura será amostrada.

param comps:

opcional o componente da textura de origem (0 -> x, 1 -> y, 2 -> z, 3 -> w) que será usado para gerar o vetor resultante. Zero se não for especificado.

return:

O texel coletado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/textureGather.xhtml

vec_type dFdx(vec_type p) 🔗

Nota

Disponível apenas no shader de fragmentos.

Retorna a derivada parcial de p em relação à coordenada x da janela usando diferenciação local.

Retorna ou dFdxCoarse ou dFdxFine. A implementação pode escolher qual cálculo realizar com base em fatores como desempenho ou o valor do hint da API GL_FRAGMENT_SHADER_DERIVATIVE_HINT.

Aviso

Expressões que implicam derivadas de ordem superior, como dFdx(dFdx(n)), têm resultados indefinidos, assim como derivadas de ordem mista, como dFdx(dFdy(n)).

param p:

A expressão da qual calcular a derivada parcial.

Nota

Assume-se que a expressão p é contínua e, portanto, expressões avaliadas por meio de fluxo de controle não uniforme podem ser indefinidas.

return:

A derivada parcial de p.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/dFdx.xhtml

vec_type dFdxCoarse(vec_type p) 🔗

Nota

Disponível apenas no fragment shader. Não disponível ao usar o renderizador de Compatibilidade (Compatibility).

Retorna a derivada parcial de p em relação à coordenada x da janela.

Calcula derivadas usando diferenciação local com base no valor de p para os vizinhos do fragmento atual, e possivelmente, mas não necessariamente, incluirá o valor para o fragmento atual. Ou seja, sobre uma determinada área, a implementação pode computar derivadas em menos locais únicos do que seria permitido para a função correspondente dFdxFine.

Aviso

Expressões que implicam derivadas de ordem superior, como dFdx(dFdx(n)), têm resultados indefinidos, assim como derivadas de ordem mista, como dFdx(dFdy(n)).

param p:

A expressão da qual calcular a derivada parcial.

Nota

Assume-se que a expressão p é contínua e, portanto, expressões avaliadas por meio de fluxo de controle não uniforme podem ser indefinidas.

return:

A derivada parcial de p.

https://registry.khronos.org/OpenGL-Refpages/gl4/html/dFdx.xhtml

vec_type dFdxFine(vec_type p) 🔗

Nota

Disponível apenas no fragment shader. Não disponível ao usar o renderizador de Compatibilidade (Compatibility).

Retorna a derivada parcial de p em relação à coordenada x da janela.

Calcula derivadas usando diferenciação local com base no valor de p para o fragmento atual e seu(s) vizinho(s) imediato(s).

Aviso

Expressões que implicam derivadas de ordem superior, como dFdx(dFdx(n)), têm resultados indefinidos, assim como derivadas de ordem mista, como dFdx(dFdy(n)).

param p:

A expressão da qual calcular a derivada parcial.

Nota

Assume-se que a expressão p é contínua e, portanto, expressões avaliadas por meio de fluxo de controle não uniforme podem ser indefinidas.

return:

A derivada parcial de p.

https://registry.khronos.org/OpenGL-Refpages/gl4/html/dFdx.xhtml

vec_type dFdy(vec_type p) 🔗

Nota

Disponível apenas no shader de fragmentos.

Retorna a derivada parcial de p em relação à coordenada y da janela usando diferenciação local.

Retorna ou dFdyCoarse ou dFdyFine. A implementação pode escolher qual cálculo realizar com base em fatores como desempenho ou o valor do hint da API GL_FRAGMENT_SHADER_DERIVATIVE_HINT.

Aviso

Expressões que implicam derivadas de ordem superior, como dFdx(dFdx(n)), têm resultados indefinidos, assim como derivadas de ordem mista, como dFdx(dFdy(n)).

param p:

A expressão da qual calcular a derivada parcial.

Nota

Assume-se que a expressão p é contínua e, portanto, expressões avaliadas por meio de fluxo de controle não uniforme podem ser indefinidas.

return:

A derivada parcial de p.

https://registry.khronos.org/OpenGL-Refpages/gl4/html/dFdx.xhtml

vec_type dFdyCoarse(vec_type p) 🔗

Nota

Disponível apenas no fragment shader. Não disponível ao usar o renderizador de Compatibilidade (Compatibility).

Retorna a derivada parcial de p em relação à coordenada y da janela.

Calcula derivadas usando diferenciação local com base no valor de p para os vizinhos do fragmento atual, e possivelmente, mas não necessariamente, incluirá o valor para o fragmento atual. Ou seja, sobre uma determinada área, a implementação pode computar derivadas em menos locais únicos do que seria permitido para as funções correspondentes dFdyFine e dFdyFine.

Aviso

Expressões que implicam derivadas de ordem superior, como dFdx(dFdx(n)), têm resultados indefinidos, assim como derivadas de ordem mista, como dFdx(dFdy(n)).

param p:

A expressão da qual calcular a derivada parcial.

Nota

Assume-se que a expressão p é contínua e, portanto, expressões avaliadas por meio de fluxo de controle não uniforme podem ser indefinidas.

return:

A derivada parcial de p.

https://registry.khronos.org/OpenGL-Refpages/gl4/html/dFdx.xhtml

vec_type dFdyFine(vec_type p) 🔗

Nota

Disponível apenas no fragment shader. Não disponível ao usar o renderizador de Compatibilidade (Compatibility).

Retorna a derivada parcial de p em relação à coordenada y da janela.

Calcula derivadas usando diferenciação local com base no valor de p para o fragmento atual e seu(s) vizinho(s) imediato(s).

Aviso

Expressões que implicam derivadas de ordem superior, como dFdx(dFdx(n)), têm resultados indefinidos, assim como derivadas de ordem mista, como dFdx(dFdy(n)).

param p:

A expressão da qual calcular a derivada parcial.

Nota

Assume-se que a expressão p é contínua e, portanto, expressões avaliadas por meio de fluxo de controle não uniforme podem ser indefinidas.

return:

A derivada parcial de p.

https://registry.khronos.org/OpenGL-Refpages/gl4/html/dFdx.xhtml

vec_type fwidth(vec_type p) 🔗

Retorna a soma do valor absoluto das derivadas em x e y.

Usa diferenciação local para o argumento de entrada p.

Equivalente a abs(dFdx(p)) + abs(dFdy(p)).

param p:

A expressão da qual calcular a derivada parcial.

return:

A derivada parcial.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/fwidth.xhtml

vec_type fwidthCoarse(vec_type p) 🔗

Nota

Disponível apenas no fragment shader. Não disponível ao usar o renderizador de Compatibilidade (Compatibility).

Retorna a soma do valor absoluto das derivadas em x e y.

Usa diferenciação local para o argumento de entrada p.

Equivalent to abs(dFdxCoarse(p)) + abs(dFdyCoarse(p)).

param p:

A expressão da qual calcular a derivada parcial.

return:

A derivada parcial.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/fwidth.xhtml

vec_type fwidthFine(vec_type p) 🔗

Nota

Disponível apenas no fragment shader. Não disponível ao usar o renderizador de Compatibilidade (Compatibility).

Retorna a soma do valor absoluto das derivadas em x e y.

Usa diferenciação local para o argumento de entrada p.

Equivalente a abs(dFdxFine(p)) + abs(dFdyFine(p)).

param p:

A expressão da qual calcular a derivada parcial.

return:

A derivada parcial.

https://registry.khronos.org/OpenGL-Refpages/gl4/html/fwidth.xhtml

Funções de empacotamento e desempacotamento

Essas funções convertem números de ponto flutuante em inteiros de vários tamanhos e, em seguida, empacotam esses inteiros em um único inteiro não sinalizado de 32 bits. As funções 'unpack' realizam a operação oposta, retornando os números de ponto flutuante originais.

uint vec2	packHalf2x16(vec2 v) unpackHalf2x16(uint v)	Converte dois floats de 32 bits para floats de 16 bits e os empacota.
uint vec2	packUnorm2x16(vec2 v) unpackUnorm2x16(uint v)	Converte dois floats de 32 bits normalizados (intervalo 0..1) para inteiros não sinalizados de 16 bits e os empacota.
uint vec2	packSnorm2x16(vec2 v) unpackSnorm2x16(uint v)	Converte dois floats de 32 bits normalizados com sinal (intervalo -1..1) para inteiros sinalizados de 16 bits e os empacota.
uint vec4	packUnorm4x8(vec4 v) unpackUnorm4x8(uint v)	Converte quatro floats de 32 bits normalizados (intervalo 0..1) em inteiros não sinalizados de 8 bits e os empacota.
uint vec4	packSnorm4x8(vec4 v) unpackSnorm4x8(uint v)	Converte quatro floats de 32 bits normalizados com sinal (intervalo -1..1) em inteiros sinalizados de 8 bits e os empacota.

Descrições das funções de empacotamento (packing) e desempacotamento (unpacking)

uint packHalf2x16(vec2 v) 🔗

Converte duas quantidades de ponto flutuante de 32 bits em quantidades de ponto flutuante de 16 bits e as empacota em um único inteiro de 32 bits.

Retorna um inteiro não sinalizado obtido ao converter os componentes de um vetor de ponto flutuante de dois componentes para a representação de ponto flutuante de 16 bits encontrada na Especificação do OpenGL, e então empacotando esses dois inteiros de 16 bits em um inteiro não sinalizado de 32 bits. O primeiro componente do vetor especifica os 16 bits menos significativos do resultado; o segundo componente especifica os 16 bits mais significativos.

param v:

Um vetor de dois valores de ponto flutuante de 32 bits que devem ser convertidos para a representação de 16 bits e empacotados no resultado.

return:

O valor empacotado.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/packHalf2x16.xhtml

vec2 unpackHalf2x16(uint v) 🔗

Inverso de packHalf2x16.

Desempacota um inteiro de 32 bits em dois valores de ponto flutuante de 16 bits, converte-os em valores de ponto flutuante de 32 bits e os coloca em um vetor. O primeiro componente do vetor é obtido a partir dos 16 bits menos significativos de v; o segundo componente é obtido a partir dos 16 bits mais significativos de v.

param v:

Um único inteiro não sinalizado de 32 bits contendo 2 valores de ponto flutuante de 16 bits empacotados.

return:

Dois valores de ponto flutuante descompactados.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/unpackHalf2x16.xhtml

uint packUnorm2x16(vec2 v) 🔗

Empacota valores de ponto flutuante em um inteiro não sinalizado.

Converte cada componente do valor de ponto flutuante normalizado v em valores inteiros de 16 bits e, em seguida, empacota os resultados em um inteiro não sinalizado de 32 bits.

A conversão para o componente c de v para ponto fixo é realizada da seguinte forma:
round(clamp(c, 0.0, 1.0) * 65535.0)
O primeiro componente do vetor será gravado nos bits menos significativos da saída; o último componente será gravado nos bits mais significativos.

param v:

Um vetor de valores a serem empacotados em um inteiro não sinalizado.

return:

Inteiro não sinalizado de 32 bits contendo a codificação empacotada do vetor.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/packUnorm.xhtml

vec2 unpackUnorm2x16(uint v) 🔗

Desempacota valores de ponto flutuante a partir de um inteiro não sinalizado.

Desempacota inteiros não sinalizados de 32 bits individuais em um par de inteiros não sinalizados de 16 bits. Em seguida, cada componente é convertido em um valor de ponto flutuante normalizado para gerar o vetor de dois componentes retornado.

A conversão para o valor de ponto fixo desempacotado f para ponto flutuante é realizada da seguinte forma:

f / 65535.0

O primeiro componente do vetor retornado será extraído dos bits menos significativos da entrada; o último componente será extraído os bits mais significativos.

param v:

Um inteiro não sinalizado contendo valores de ponto flutuante empacotados.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/unpackUnorm.xhtml

uint packSnorm2x16(vec2 v) 🔗

Empacota valores de ponto flutuante em um inteiro não sinalizado.

Converte cada componente do valor de ponto flutuante normalizado v em valores inteiros de 16 bits e, em seguida, empacota os resultados em um inteiro não sinalizado de 32 bits.

A conversão para o componente c de v para ponto fixo é realizada da seguinte forma:
round(clamp(c, -1.0, 1.0) * 32767.0)
O primeiro componente do vetor será gravado nos bits menos significativos da saída; o último componente será gravado nos bits mais significativos.

param v:

Um vetor de valores a serem empacotados em um inteiro não sinalizado.

return:

Inteiro não sinalizado de 32 bits contendo a codificação empacotada do vetor.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/packUnorm.xhtml

vec2 unpackSnorm2x16(uint v) 🔗

Desempacota valores de ponto flutuante a partir de um inteiro não sinalizado.

Desempacota inteiros não sinalizados de 32 bits individuais em um par de inteiros sinalizados de 16 bits. Em seguida, cada componente é convertido em um valor de ponto flutuante normalizado para gerar o vetor de dois componentes retornado.

A conversão para o valor de ponto fixo desempacotado f para ponto flutuante é realizada da seguinte forma:

clamp(f / 32727.0, -1.0, 1.0)

O primeiro componente do vetor retornado será extraído dos bits menos significativos da entrada; o último componente será extraído os bits mais significativos.

param v:

Um inteiro não sinalizado contendo valores de ponto flutuante empacotados.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/unpackUnorm.xhtml

uint packUnorm4x8(vec4 v) 🔗

Empacota valores de ponto flutuante em um inteiro não sinalizado.

Converte cada componente do valor de ponto flutuante normalizado v em valores inteiros de 16 bits e, em seguida, empacota os resultados em um inteiro não sinalizado de 32 bits.

A conversão para o componente c de v para ponto fixo é realizada da seguinte forma:
round(clamp(c, 0.0, 1.0) * 255.0)
O primeiro componente do vetor será gravado nos bits menos significativos da saída; o último componente será gravado nos bits mais significativos.

param v:

Um vetor de valores a serem empacotados em um inteiro não sinalizado.

return:

Inteiro não sinalizado de 32 bits contendo a codificação empacotada do vetor.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/packUnorm.xhtml

vec4 unpackUnorm4x8(uint v) 🔗

Desempacota valores de ponto flutuante a partir de um inteiro não sinalizado.

Desempacota inteiros não sinalizados de 32 bits individuais em quatro inteiros não sinalizados de 8 bits. Em seguida, cada componente é convertido em um valor de ponto flutuante normalizado para gerar o vetor de quatro componentes retornado.

A conversão para o valor de ponto fixo desempacotado f para ponto flutuante é realizada da seguinte forma:

f / 255.0

O primeiro componente do vetor retornado será extraído dos bits menos significativos da entrada; o último componente será extraído os bits mais significativos.

param v:

Um inteiro não sinalizado contendo valores de ponto flutuante empacotados.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/unpackUnorm.xhtml

uint packSnorm4x8(vec4 v) 🔗

Empacota valores de ponto flutuante em um inteiro não sinalizado.

Converte cada componente do valor de ponto flutuante normalizado v em valores inteiros de 16 bits e, em seguida, empacota os resultados em um inteiro não sinalizado de 32 bits.

A conversão para o componente c de v para ponto fixo é realizada da seguinte forma:
round(clamp(c, -1.0, 1.0) * 127.0)
O primeiro componente do vetor será gravado nos bits menos significativos da saída; o último componente será gravado nos bits mais significativos.

param v:

Um vetor de valores a serem empacotados em um inteiro não sinalizado.

return:

Inteiro não sinalizado de 32 bits contendo a codificação empacotada do vetor.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/packUnorm.xhtml

vec4 unpackSnorm4x8(uint v) 🔗

Desempacota valores de ponto flutuante a partir de um inteiro não sinalizado.

Desempacota inteiros não sinalizados de 32 bits individuais em quatro inteiros sinalizados de 8 bits. Em seguida, cada componente é convertido em um valor de ponto flutuante normalizado para gerar o vetor de quatro componentes retornado.

A conversão para o valor de ponto fixo desempacotado f para ponto flutuante é realizada da seguinte forma:

clamp(f / 127.0, -1.0, 1.0)

O primeiro componente do vetor retornado será extraído dos bits menos significativos da entrada; o último componente será extraído os bits mais significativos.

param v:

Um inteiro não sinalizado contendo valores de ponto flutuante empacotados.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/unpackUnorm.xhtml

Funções bitwise (bitwise)

vec_int_type vec_uint_type	bitfieldExtract(vec_int_type value, int offset, int bits) bitfieldExtract(vec_uint_type value, int offset, int bits)	Extrai um intervalo de bits de um inteiro.
vec_int_type vec_uint_type	bitfieldInsert(vec_int_type base, vec_int_type insert, int offset, int bits) bitfieldInsert(vec_uint_type base, vec_uint_type insert, int offset, int bits)	Insere um intervalo de bits em um número inteiro.
vec_int_type vec_uint_type	bitfieldReverse(vec_int_type value) bitfieldReverse(vec_uint_type value)	Inverte a ordem dos bits em um número inteiro.
vec_int_type vec_uint_type	bitCount(vec_int_type value) bitCount(vec_uint_type value)	Conta o número de bits definidos como 1 em um número inteiro.
vec_int_type vec_uint_type	findLSB(vec_int_type value) findLSB(vec_uint_type value)	Encontra o índice do bit menos significativo definido como 1 em um número inteiro.
vec_int_type vec_uint_type	findMSB(vec_int_type value) findMSB(vec_uint_type value)	Encontra o índice do bit mais significativo definido como 1 em um número inteiro.
void void	imulExtended(vec_int_type x, vec_int_type y, out vec_int_type msb, out vec_int_type lsb) umulExtended(vec_uint_type x, vec_uint_type y, out vec_uint_type msb, out vec_uint_type lsb)	Multiplica dois números de 32 bits e produz um resultado de 64 bits.
vec_uint_type	uaddCarry(vec_uint_type x, vec_uint_type y, out vec_uint_type carry)	Adiciona dois números inteiros não sinalizados e gera um carry (transporte).
vec_uint_type	usubBorrow(vec_uint_type x, vec_uint_type y, out vec_uint_type borrow)	Subtrai dois números inteiros não sinalizados e gera um borrow (empréstimo).
vec_type	ldexp(vec_type x, out vec_int_type exp)	Monta um número de ponto flutuante a partir de um valor e de um expoente.
vec_type	frexp(vec_type x, out vec_int_type exp)	Divide um número de ponto flutuante (`x`) em componentes integrais de significando

Descrições das funções bitwise

vec_int_type bitfieldExtract(vec_int_type value, int offset, int bits) 🔗

Extrai um subconjunto dos bits de value e o retorna nos bits menos significativos do resultado. O intervalo de bits extraído é [offset, offset + bits - 1].

Os bits mais significativos do resultado serão definidos como zero.

Nota

Se bits for zero, o resultado será zero.

Aviso

O resultado será indefinido se:

offset ou bits for negativo.

se a soma de offset e bits for maior que o número de bits usado para armazenar o operando.

param value:

O número inteiro do qual extrair os bits.

param offset:

O índice do primeiro bit a ser extraído.

param bits:

O número de bits a extrair.

return:

Número inteiro com os bits solicitados.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/bitfieldExtract.xhtml

vec_uint_type bitfieldExtract(vec_uint_type value, int offset, int bits) 🔗

Component-wise Function.

Extrai um subconjunto dos bits de value e o retorna nos bits menos significativos do resultado. O intervalo de bits extraído é [offset, offset + bits - 1].

Os bits mais significativos serão definidos com o valor de offset + base - 1 (ou seja, ele tem o sinal estendido para a largura do tipo de retorno).

Nota

Se bits for zero, o resultado será zero.

Aviso

O resultado será indefinido se:

offset ou bits for negativo.

se a soma de offset e bits for maior que o número de bits usado para armazenar o operando.

param value:

O número inteiro do qual extrair os bits.

param offset:

O índice do primeiro bit a ser extraído.

param bits:

O número de bits a extrair.

return:

Número inteiro com os bits solicitados.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/bitfieldExtract.xhtml

vec_uint_type bitfieldExtract(vec_uint_type value, int offset, int bits) 🔗

vec_uint_type bitfieldInsert(vec_uint_type base, vec_uint_type insert, int offset, int bits) 🔗

Component-wise Function.

Insere os bits menos significativos de insert em base no deslocamento offset.

O valor retornado terá os bits [offset, offset + bits + 1] obtidos de [0, bits - 1] de insert e todos os outros bits obtidos diretamente dos bits correspondentes de base.

Nota

Se bits for zero, o resultado será o valor original de base.

Aviso

O resultado será indefinido se:

offset ou bits for negativo.

se a soma de offset e bits for maior que o número de bits usado para armazenar o operando.

param base:

O número inteiro no qual inserir insert.

param insert:

O valor de bits a inserir.

param offset:

O índice do primeiro bit a ser inserido.

param bits:

O número de bits a inserir.

return:

base com os bits inseridos.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/bitfieldInsert.xhtml

vec_int_type bitfieldReverse(vec_int_type value) 🔗

vec_uint_type bitfieldReverse(vec_uint_type value) 🔗

Component-wise Function.

Inverte a ordem dos bits em um número inteiro.

O bit numerado como n será obtido do bit (bits - 1) - n de value, onde bits é o número total de bits usado para representar value.

param value:

O valor cujos bits serão invertidos.

return:

value mas com seus bits invertidos.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/bitfieldReverse.xhtml

vec_int_type bitCount(vec_int_type value) 🔗

vec_uint_type bitCount(vec_uint_type value) 🔗

Component-wise Function.

Conta o número de bits definidos como 1 em um número inteiro.

param value:

O valor cujos bits devem ser contados.

return:

O número de bits que estão definidos como 1 na representação binária de value.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/bitCount.xhtml

vec_int_type findLSB(vec_int_type value) 🔗

vec_uint_type findLSB(vec_uint_type value) 🔗

Component-wise Function.

Encontra o índice do bit menos significativo definido como 1.

Nota

Se value for zero, -1 será retornado.

param value:

O valor cujos bits serão varridos.

return:

O número do bit menos significativo que está definido como 1 na representação binária de value.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/findLSB.xhtml

vec_int_type findMSB(vec_int_type value) 🔗

vec_uint_type findMSB(vec_uint_type value) 🔗

Component-wise Function.

Encontra o índice do bit mais significativo definido como 1.

Nota

Para tipos inteiros sinalizados, o bit de sinal é verificado primeiro e depois:

Para inteiros positivos, o resultado será o número do bit mais significativo que está definido como 1.

Para inteiros negativos, o resultado será o número do bit mais significativo definido como 0.

Nota

Para um valor de zero ou 1 negativo, -1 será retornado.

param value:

O valor cujos bits serão varridos.

return:

O número do bit mais significativo que está definido como 1 na representation binária de value.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/findMSB.xhtml

void imulExtended(vec_int_type x, vec_int_type y, out vec_int_type msb, out vec_int_type lsb) 🔗

Component-wise Function.

Realiza multiplicação sinalizada de 32 bits por 32 bits para produzir um resultado de 64 bits.

Os 32 bits menos significativos deste produto são retornados em lsb e os 32 bits mais significativos são retornados em msb.

param x:

O primeiro multiplicando.

param y:

O segundo multiplicando.

param msb:

A variável que receberá a palavra mais significativa do produto.

param lsb:

A variável que receberá a palavra menos significativa do produto.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/umulExtended.xhtml

void umulExtended(vec_uint_type x, vec_uint_type y, out vec_uint_type msb, out vec_uint_type lsb) 🔗

Component-wise Function.

Realiza multiplicação não sinalizada de 32 bits por 32 bits para produzir um resultado de 64 bits.

Os 32 bits menos significativos deste produto são retornados em lsb e os 32 bits mais significativos são retornados em msb.

param x:

O primeiro multiplicando.

param y:

O segundo multiplicando.

param msb:

A variável que receberá a palavra mais significativa do produto.

param lsb:

A variável que receberá a palavra menos significativa do produto.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/umulExtended.xhtml

vec_uint_type uaddCarry(vec_uint_type x, vec_uint_type y, out vec_uint_type carry) 🔗

Component-wise Function.

Adds two 32-bit unsigned integer values (scalars or vectors) and returns a 32-bit unsigned integer, along with a carry output stored in carry.

param x:

O primeiro operando.

param y:

O segundo operando.

param carry:

0 if the sum is less than 2³², otherwise 1.

return:

(x + y) % 2^32.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/uaddCarry.xhtml

vec_uint_type usubBorrow(vec_uint_type x, vec_uint_type y, out vec_uint_type borrow) 🔗

Component-wise Function.

Subtrai inteiros não sinalizados e gera borrow (empréstimo).

param x:

O primeiro operando.

param y:

O segundo operando.

param borrow:

0 se x >= y, caso contrário 1.

return:

A diferença entre x e y se não for negativa, ou 2³² mais essa diferença caso contrário.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/usubBorrow.xhtml

vec_type ldexp(vec_type x, out vec_int_type exp) 🔗

Component-wise Function.

Monta um número de ponto flutuante a partir de um valor e expoente.

Aviso

Se este produto for grande demais para ser representado no tipo de ponto flutuante, o resultado é indefinido.

param x:

O valor a ser usado como fonte do significando.

param exp:

O valor a ser usado como fonte do expoente.

return:

x * 2^exp

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/ldexp.xhtml

vec_type frexp(vec_type x, out vec_int_type exp) 🔗

Component-wise Function.

Extrai x em um significando de ponto flutuante no intervalo [0.5, 1.0) e em um expoente integral de dois, de modo que:
x = significand * 2 ^ exponent
For a floating-point value of 0.0, the significand and exponent are both 0.0.

Aviso

For a floating-point value that is an infinity or a floating-point NaN, the results are undefined.

param x:

O valor do qual o significando e o expoente devem ser extraídos.

param exp:

A variável na qual colocar o expoente de x.

return:

O significando de x.

https://www.khronos.org/registry/OpenGL-Refpages/gl4/html/frexp.xhtml