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...

Funzioni integrate

Godot supporta un gran numero di funzioni integrate, conformandosi più o meno alle specifiche GLSL ES 3.0.

Nota

I seguenti alias di tipo sono utilizzati solo nella documentazione per ridurre le dichiarazioni ripetitive di funzioni. Ciascuno può riferirsi a diversi tipi effettivi.

alias	Tipi effettivi	Alias nella documentazione glsl
vec_type	float, vec2, vec3, o vec4	genType
vec_int_type	int, ivec2, ivec3 o ivec4	genIType
vec_uint_type	uint, uvec2, uvec3 o uvec4	genUType
vec_bool_type	bool, bvec2, bvec3 o bvec4	genBType
mat_type	mat2, mat3 o mat4	mat
gvec4_type	vec4, ivec4 o uvec4	gvec4
gsampler2D	sampler2D, isampler2D o uSampler2D	gsampler2D
gsampler2DArray	sampler2DArray, isampler2DArray o uSampler2DArray	gsampler2DArray
gsampler3D	sampler3D, isampler3D o uSampler3D	gsampler3D

Se uno di questi viene specificato per più parametri, devono essere tutti dello stesso tipo, salvo diversa indicazione.

Nota

Molte funzioni che accettano uno o più vettori o matrici eseguono la funzione descritta su ciascuna componente del vettore/matrice. Alcuni esempi:

Operazione	Operazione scalare 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))`

La Specifica del linguaggio GLSL afferma nella sezione 5.10 Operazioni su vettori e matrici:

Salvo poche eccezioni, le operazioni sono eseguite componente per componente. Di solito, quando un operatore opera su un vettore o una matrice, opera indipendentemente su ciascuna componente del vettore o della matrice, in modo componente per componente. [...] Le eccezioni sono matrice moltiplicata per vettore, vettore moltiplicato per matrice e matrice moltiplicata per matrice. Queste operazioni non operano componente per componente, ma eseguono la corretta moltiplicazione algebrica lineare.

Queste descrizioni delle funzioni sono adattate e modificate dalla documentazione ufficiale di OpenGL originariamente pubblicata da Khronos Group con licenza Open Publication License. Ogni descrizione di una funzione rimanda alla corrispondente documentazione ufficiale di OpenGL. La cronologia delle modifiche di questa pagina è disponibile su GitHub.

funzioni trigonometriche

Tipo restituito	Funzione	Descrizione / valore restituito
vec_type	radians(vec_type gradi)	Converte da gradi a radianti.
vec_type	degrees(vec_type radianti)	Converte da radianti a gradi.
vec_type	sin(vec_type x)	Seno.
vec_type	cos(vec_type x)	Coseno.
vec_type	tan(vec_type x)	Tangente.
vec_type	asin(vec_type x)	Arcoseno.
vec_type	acos(vec_type x)	Arcocoseno.
vec_type vec_type	atan(vec_type y_over_x) atan(vec_type y, vec_type x)	Arcotangente.
vec_type	sinh(vec_type x)	Seno iperbolico.
vec_type	cosh(vec_type x)	Coseno iperbolico.
vec_type	tanh(vec_type x)	Tangente iperbolica.
vec_type	asinh(vec_type x)	Arcoseno iperbolico.
vec_type	acosh(vec_type x)	Arcocoseno iperbolico.
vec_type	atanh(vec_type x)	Arcotangente iperbolica.

Descrizioni delle funzioni trigonometriche

vec_type radians(vec_type degrees) 🔗

Component-wise Function.

Converte una quantità specificata in gradi in radianti, con la formula gradi * (PI / 180).

param degrees:

La quantità, in gradi, da convertire in radianti.

return:

Il valore di degrees convertito in radianti.

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

vec_type degrees(vec_type radians) 🔗

Component-wise Function.

Converte una quantità specificata in radianti in gradi, con la formula radianti * (180 / PI )

param radians:

La quantità, in radianti, da convertire in gradi.

return:

Il valore di radians convertito in gradi.

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

vec_type sin(vec_type angle) 🔗

Component-wise Function.

Restituisce il seno trigonometrico di angle.

param angle:

La quantità, in radianti, di cui restituire il seno.

return:

Il seno di angle.

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

vec_type cos(vec_type angle) 🔗

Component-wise Function.

Restituisce il coseno trigonometrico di angle.

param angle:

La quantità, in radianti, di cui restituire il coseno.

return:

Il coseno di angle.

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

vec_type tan(vec_type angle) 🔗

Component-wise Function.

Restituisce la tangente trigonometrica di angle.

param angle:

La quantità, in radianti, di cui restituire la tangente.

return:

La tangente di angle.

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

vec_type asin(vec_type x) 🔗

Component-wise Function.

Arcoseno, o seno inverso. Calcola l'angolo il cui seno è x e compreso nell'intervallo [-PI/2, PI/2]. Il risultato è indefinito se x < -1 o x > 1.

param x:

Il valore di cui restituire l'arcoseno.

return:

L'angolo il cui seno trigonometrico è x.

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

vec_type acos(vec_type x) 🔗

Component-wise Function.

Arcocoseno, o inverso del coseno. Calcola l'angolo il cui coseno è x e rientra nell'intervallo [0, PI].

Il risultato è indefinito se x < -1 o x > 1.

param x:

Il valore di cui restituire l'arcocoseno.

return:

L'angolo il cui coseno trigonometrico è x.

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

vec_type atan(vec_type y_over_x) 🔗

Component-wise Function.

Calcola l'arcotangente, specificato un valore di tangente di y/x.

Nota

A causa dell'ambiguità del segno, la funzione non può determinare con certezza in quale quadrante ricade l'angolo solo per il valore della sua tangente. Se è necessario conoscere il quadrante, usare atan(vec_type y, vec_type x).

param y_over_x:

La frazione di cui restituire l'arco tangente.

return:

L'arcotangente trigonometrico di y_over_x ed è compreso nell'intervallo [-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.

Calcola l'arcotangente, specificati numeratore e denominatore. I segni di y e x vengono utilizzati per determinare il quadrante in cui si trova l'angolo. Il risultato è indefinito se x == 0.

Equivalente a atan2() in GDScript.

param y:

Il numeratore della frazione di cui restituire l'arco tangente.

param x:

Il denominatore della frazione di cui restituire l'arco tangente.

return:

L'arcotangente trigonometrico di y/x ed è compreso nell'intervallo [-PI, PI].

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

vec_type sinh(vec_type x) 🔗

Component-wise Function.

Calcola il seno iperbolico attraverso (e^x - e^-x)/2.

param x:

Il valore di cui restituire il seno iperbolico.

return:

Il seno iperbolico di x.

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

vec_type cosh(vec_type x) 🔗

Component-wise Function.

Calcola il coseno iperbolico attraverso (e^x + e^-x)/2.

param x:

Il valore di cui restituire il coseno iperbolico.

return:

Il coseno iperbolico di x.

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

vec_type tanh(vec_type x) 🔗

Component-wise Function.

Calcola la tangente iperbolica attraverso sinh(x)/cosh(x).

param x:

Il valore di cui restituire la tangente iperbolica.

return:

La tangente iperbolica di x.

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

vec_type asinh(vec_type x) 🔗

Component-wise Function.

Calcola il seno iperbolico dell'arco di x, o l'inverso di sinh.

param x:

Il valore di cui restituire L'arcoseno iperbolico.

return:

L'arcoseno iperbolico di x.

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

vec_type acosh(vec_type x) 🔗

Component-wise Function.

Calcola l'arcocoseno iperbolico di x, o l'inverso non negativo di cosh. Il risultato è indefinito se x < 1.

param x:

Il valore di cui restituire L'arcocoseno iperbolico.

return:

L'arcocoseno iperbolico di x.

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

vec_type atanh(vec_type x) 🔗

Component-wise Function.

Calcola l'arcotangente iperbolica di x, o l'inverso di tanh. Il risultato è indefinito se abs(x) > 1.

param x:

Il valore di cui restituire l'arcotangente iperbolica.

return:

L'arcotangente iperbolica di x.

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

Funzioni matematiche e esponenziali

Tipo restituito	Funzione	Descrizione / valore restituito
vec_type	pow(vec_type x, vec_type y)	Potenza (indefinita se `x < 0` o se `x == 0` e `y <= 0`).
vec_type	exp(vec_type x)	Esponenziale in base e.
vec_type	exp2(vec_type x)	Esponenziale in base 2.
vec_type	log(vec_type x)	Logaritmo naturale (in base e).
vec_type	log2(vec_type x)	Logaritmo in base 2.
vec_type	sqrt(vec_type x)	Radice quadrata.
vec_type	inversesqrt(vec_type x)	Radice quadrata inversa.
vec_type vec_int_type	abs(vec_type x) abs(vec_int_type x)	Valore assoluto (restituisce un valore positivo se negativo).
vec_type	sign(vec_type x)	Restituisce `1.0` se positivo, `-1.0` se negativo, `0.0` altrimenti.
vec_int_type	sign(vec_int_type x)	Restituisce `1` se positivo, `-1` se negativo, `0` altrimenti.
vec_type	floor(vec_type x)	Arrotonda al numero intero inferiore.
vec_type	round(vec_type x)	Arrotonda al numero intero più vicino.
vec_type	roundEven(vec_type x)	Arrotonda al numero intero pari più vicino.
vec_type	trunc(vec_type x)	Troncamento.
vec_type	ceil(vec_type x)	Arrotonda al numero intero superiore.
vec_type	fract(vec_type x)	Frazionario (restituisce `x - floor(x)`).
vec_type vec_type	mod(vec_type x, vec_type y) mod(vec_type x, float y)	Modulo (resto della divisione).
vec_type	modf(vec_type x, out vec_type i)	Frazionario di `x`, con `i` come parte intera.
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)	Valore più piccolo tra `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)	Valore più grande tra `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` tra `min` e `max` (incluso).
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 linearmente tra `a` e `b` per `c`.
vec_type	fma(vec_type a, vec_type b, vec_type c)	Operazione di moltiplicazione-addizione fusa: `(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 con formula di Hermite tra `a` e `b` tramite `c`.
vec_bool_type	isnan(vec_type x)	Restituisce `true` se lo scalare o la componente di un vettore è `NaN`.
vec_bool_type	isinf(vec_type x)	Restituisce `true` se lo scalare o la componente di un vettore è `INF`.
vec_int_type	floatBitsToInt(vec_type x)	Copia dei bit da `float` a `int`, senza conversione.
vec_uint_type	floatBitsToUint(vec_type x)	Copia dei bit da `float` a `uint`, senza conversione.
vec_type	intBitsToFloat(vec_int_type x)	Copia dei bit da `int` a `float`, senza conversione.
vec_type	uintBitsToFloat(vec_uint_type x)	Copia dei bit da `uint` a `float`, senza conversione.

Descrizioni delle funzioni esponenziali e matematiche

vec_type pow(vec_type x, vec_type y) 🔗

Component-wise Function.

Eleva x alla potenza di y.

Il risultato è indefinito se x < 0 o se x == 0 e y <= 0.

param x:

Il valore da elevare alla potenza y.

param y:

La potenza a cui verrà elevato x.

return:

Il valore di x elevato alla potenza y.

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

vec_type exp(vec_type x) 🔗

Component-wise Function.

Eleva e alla potenza di x, ovvero l'esponenziale naturale.

Equivalente a pow(e, x).

param x:

Il valore da elevare a potenza.

return:

L'esponenziale naturale di x.

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

vec_type exp2(vec_type x) 🔗

Component-wise Function.

Eleva 2 alla potenza di x.

Equivalente a pow(2.0, x).

param x:

Il valore della potenza a cui verrà elevato 2.

return:

2 elevato alla potenza di x.

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

vec_type log(vec_type x) 🔗

Component-wise Function.

Restituisce il logaritmo naturale di x, ovvero il valore y che soddisfa x == pow(e, y). Il risultato è indefinito se x <= 0.

param x:

Il valore di cui calcolare il logaritmo naturale.

return:

Il logaritmo naturale di x.

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

vec_type log2(vec_type x) 🔗

Component-wise Function.

Restituisce il logaritmo in base 2 di x, ovvero il valore y che soddisfa x == pow(2, y). Il risultato è indefinito se x <= 0.

param x:

Il valore di cui calcolare il logaritmo in base 2.

return:

Il logaritmo in base 2 di x.

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

vec_type sqrt(vec_type x) 🔗

Component-wise Function.

Restituisce la radice quadrata di x. Il risultato è indefinito se x < 0.

param x:

Il valore di cui calcolare la radice quadrata.

return:

La radice quadrata di x.

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

vec_type inversesqrt(vec_type x) 🔗

Component-wise Function.

Restituisce l'inverso della radice quadrata di x, ovvero 1,0 / sqrt(x). Il risultato è indefinito se x <= 0.

param x:

Il valore di cui calcolare l'inverso della radice quadrata.

return:

L'inverso della radice quadrata di 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.

Restituisce il valore assoluto di x. Restituisce x se x è positivo, altrimenti restituisce -1 * x.

param x:

Il valore di cui restituire l'assoluto.

return:

Il valore assoluto di 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.

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

param x:

Il valore da cui estrarre il segno.

return:

Il segno di x.

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

vec_type floor(vec_type x) 🔗

Component-wise Function.

Restituisce un valore uguale al numero intero più vicino che sia minore o uguale a x.

param x:

Il valore da arrotondare per difetto al numero intero più vicino.

return:

L'intero più vicino che è minore o uguale a x.

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

vec_type round(vec_type x) 🔗

Component-wise Function.

Arrotonda x al numero intero più vicino.

Nota

L'arrotondamento dei valori con una parte frazionaria di 0.5 dipende dall'implementazione. Ciò include la possibilità che round(x) restituisca lo stesso valore di roundEven(x) per tutti i valori di x.

param x:

Il valore da arrotondare.

return:

Il valore arrotondato.

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

vec_type roundEven(vec_type x) 🔗

Component-wise Function.

Arrotonda x all'intero più vicino. Un valore con una parte frazionaria di 0.5 verrà sempre arrotondato all'intero pari più vicino. Ad esempio, sia 3.5 sia 4.5 verranno arrotondati a 4.0.

param x:

Il valore da arrotondare.

return:

Il valore arrotondato.

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

vec_type trunc(vec_type x) 🔗

Component-wise Function.

Tronca x. Restituisce un valore uguale all'intero più vicino a x il cui valore assoluto non sia maggiore del valore assoluto di x.

param x:

Il valore da valutare.

return:

Il valore troncato.

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

vec_type ceil(vec_type x) 🔗

Component-wise Function.

Restituisce un valore uguale al numero intero più vicino che è maggiore o uguale a x.

param x:

Il valore da valutare.

return:

Il valore arrotondato per eccesso al numero intero più vicino.

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

vec_type fract(vec_type x) 🔗

Component-wise Function.

Restituisce la parte frazionaria di x.

Questo viene calcolato come x - floor(x).

param x:

Il valore da valutare.

return:

La parte frazionaria di 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.

Restituisce il valore di x modulo y. Questo viene anche chiamato resto.

Questo viene calcolato come x - y * floor(x/y).

param x:

Il valore da valutare.

return:

Il valore di 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 un valore in virgola mobile x nelle sue parti intera e frazionaria.

La parte frazionaria del numero viene restituita dalla funzione. La parte intera (come quantità in virgola mobile) viene restituita nel parametro di output i.

param x:

Il valore da separare.

param out i:

Una variabile che riceve la parte intera di x.

return:

La parte frazionaria del numero.

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.

Restituisce il minimo di due valori a e b.

Restituisce b se b < a, altrimenti restituisce a.

param a:

Il primo valore da confrontare.

param b:

Il secondo valore da confrontare.

return:

Il valore minimo.

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.

Restituisce il massimo di due valori a e b.

Restituisce b se b > a, altrimenti restituisce a.

param a:

Il primo valore da confrontare.

param b:

Il secondo valore da confrontare.

return:

Il valore massimo.

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.

Restituisce il valore di x limitato all'intervallo minVal e maxVal.

Il valore restituito viene calcolato come min(max(x, minVal), maxVal).

param x:

Il valore da limitare.

param minVal:

L'estremità inferiore dell'intervallo in cui limitare x.

param maxVal:

L'estremità superiore dell'intervallo in cui limitare x.

return:

Il valore limitato.

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.

Effettua un'interpolazione lineare tra a e b utilizzando c per pesare tra di loro.

Calcolata come a * (1 - c) + b * c.

Equivalente a lerp() in GDScript.

param a:

L'inizio dell'intervallo in cui effettuare l'interpolazione.

param b:

La fine dell'intervallo in cui effettuare l'interpolazione.

param c:

Il valore da utilizzare per interpolare tra a e b.

return:

Il valore interpolato.

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

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

Seleziona il valore a o il valore b in base al valore di c. Per una componente di c che è falsa, viene restituita la componente corrispondente di a. Per una componente di c che è vera, viene restituita la componente corrispondente di b. È possibile che le componenti non selezionate di a e b siano valori in virgola mobile non validi, e ciò non avranno alcun effetto sui risultati.

Se a, b e c sono tipi vettoriali, l'operazione viene eseguita componente per componente. Ad esempio, mix(vec2(42, 314), vec2(9.8, 6e23), bvec2(true, false))) restituirà vec2(9.8, 314).

param a:

Valore restituito quando c è falso.

param b:

Valore restituito quando c è vero.

param c:

Il valore utilizzato per selezionare tra a e b.

return:

Il valore interpolato.

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.

Esegue, ove possibile, un'operazione di moltiplicazione-addizione fusa, restituendo a * b + c. Nei casi d'uso in cui il valore restituito viene infine utilizzata da una variabile dichiarata come precisa:

fma() è considerata una singola operazione, mentre l'espressione a * b + c utilizzata da una variabile dichiarata come precisa è considerata due operazioni.

La precisione di fma() può differire dalla precisione dell'espressione a * b + c.

fma() verrà calcolato con la stessa precisione di qualsiasi altro fma() utilizzato da una variabile precisa, fornendo risultati invarianti per gli stessi valori di input di a, b e c.

Altrimenti, in assenza di un utilizzo preciso, non ci sono vincoli particolari sul numero di operazioni o sulla differenza di precisione tra fma() e l'espressione a * b + c.

param a:

Il primo valore da moltiplicare.

param b:

Il secondo valore da moltiplicare.

param c:

Il valore da sommare al risultato.

return:

Il valore di 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.

Genera una funzione a gradini confrontando b con a.

Equivalente a if (b < a) { return 0.0; } else { return 1.0; }. Per l'elemento i del valore restituito, viene restituito 0.0 se b[i] < a[i], altrimenti 1.0.

param a:

La posizione del bordo della funzione gradino.

param b:

Il valore da usare per generare la funzione gradino.

return:

0.0 o 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.

Effettua un'interpolazione uniforme con la formula di Hermite tra 0 e 1 quando a < c < b. Questa è utile nei casi in cui si desidera una funzione soglia con una transizione uniforme.

Smoothstep è equivalente a:
vec_type t;
t = clamp((c - a) / (b - a), 0.0, 1.0);
return t * t * (3.0 - 2.0 * t);
I risultati sono indefiniti se a >= b.

param a:

Il valore del limite inferiore della funzione di Hermite.

param b:

Il valore del limite superiore della funzione di Hermite.

param c:

Il valore sorgente per l'interpolazione.

return:

Il valore interpolato.

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

vec_bool_type isnan(vec_type x) 🔗

Component-wise Function.

Per ogni elemento i del risultato, restituisce true se x[i] è un NaN (Not a Number) in virgola mobile positivo o negativo e false in caso contrario.

param x:

Il valore da testare per NaN.

return:

true o false.

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

vec_bool_type isinf(vec_type x) 🔗

Component-wise Function.

Per ogni elemento i del risultato, restituisce true se x[i] è un infinito in virgola mobile positivo o negativo e false in caso contrario.

param x:

Il valore da testare per infinito.

return:

true o false.

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

vec_int_type floatBitsToInt(vec_type x) 🔗

Component-wise Function.

Restituisce la codifica dei parametri in virgola mobile come int.

La rappresentazione a livello di bit in virgola mobile viene preservata.

param x:

Il valore di cui restituire la codifica in virgola mobile.

return:

La codifica in virgola mobile di x.

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

vec_uint_type floatBitsToUint(vec_type x) 🔗

Component-wise Function.

Restituisce la codifica dei parametri in virgola mobile come uint.

La rappresentazione a livello di bit in virgola mobile viene preservata.

param x:

Il valore di cui restituire la codifica in virgola mobile.

return:

La codifica in virgola mobile di x.

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

vec_type intBitsToFloat(vec_int_type x) 🔗

Component-wise Function.

Converte una codifica in bit in un valore in virgola mobile. Opposto di floatBitsToInt<shader_func_floatBitsToInt>

Se la codifica di un NaN viene passata in x, non verrà segnalato e il valore risultante sarà indefinito.

Se la codifica di un infinito in virgola mobile viene passata nel parametro x, il valore in virgola mobile risultante è l'infinito in virgola mobile corrispondente (positivo o negativo).

param x:

La codifica in bit da restituire come valore in virgola mobile.

return:

Un valore in virgola mobile.

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

vec_type uintBitsToFloat(vec_uint_type x) 🔗

Component-wise Function.

Converte una codifica in bit in un valore in virgola mobile. Opposto di floatBitsToUint<shader_func_floatBitsToUint>

Se la codifica di un NaN viene passata in x, non verrà segnalato e il valore risultante sarà indefinito.

Se la codifica di un infinito in virgola mobile viene passata nel parametro x, il valore in virgola mobile risultante è l'infinito in virgola mobile corrispondente (positivo o negativo).

param x:

La codifica in bit da restituire come valore in virgola mobile.

return:

Un valore in virgola mobile.

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

Funzioni geometriche

float	length(vec_type x)	Lunghezza del vettore.
float	distance(vec_type a, vec_type b)	Distanza tra i vettori, ovvero `length(a - b)`.
float	dot(vec_type a, vec_type b)	Prodotto scalare.
vec3	cross(vec3 a, vec3 b)	Prodotto vettoriale.
vec_type	normalize(vec_type x)	Normalizza alla lunghezza unitaria.
vec3	reflect(vec3 I, vec3 N)	Riflessione.
vec3	refract(vec3 I, vec3 N, float eta)	Rifrazione.
vec_type	faceforward(vec_type N, vec_type I, vec_type Nref)	Se `dot(Nref, I)` < 0, restituisce `N`, altrimenti `-N`.
mat_type	matrixCompMult(mat_type x, mat_type y)	Moltiplicazione di componenti di matrice.
mat_type	outerProduct(vec_type column, vec_type row)	Prodotto diadico (esterno) di matrice.
mat_type	transpose(mat_type m)	Trasposizione di matrice.
float	determinant(mat_type m)	Determinante della matrice.
mat_type	inverse(mat_type m)	Inversione di matrice.

Descrizioni delle funzioni geometriche

float length(vec_type x) 🔗

Restituisce la lunghezza del vettore, ovvero sqrt(x[0] * x[0] + x[1] * x[1] + ... + x[n] * x[n])

param x:

Il vettore

return:

La lunghezza del vettore.

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

float distance(vec_type a, vec_type b) 🔗

Restituisce la distanza tra i due punti a e b.

ovvero, length(b - a);

param a:

Il primo punto.

param b:

Il secondo punto.

return:

La distanza scalare tra i punti

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

float dot(vec_type a, vec_type b) 🔗

Restituisce il prodotto scalare di due vettori, a e b, ovvero a.x * b.x + a.y * b.y + ...

param a:

Il primo vettore.

param b:

Il secondo vettore.

return:

Il prodotto scalare.

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

vec3 cross(vec3 a, vec3 b) 🔗

Restituisce il prodotto vettoriale di due vettori. Ovvero:
vec2( a.y * b.z - b.y * a.z,
      a.z * b.x - b.z * a.x,
      a.x * b.z - b.x * a.y)
param a:

Il primo vettore.

param b:

Il secondo vettore.

return:

Il prodotto vettoriale di a e b.

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

vec_type normalize(vec_type x) 🔗

Restituisce un vettore con la stessa direzione di x ma con lunghezza 1.0.

param x:

Il vettore da normalizzare.

return:

Il vettore normalizzato.

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

vec3 reflect(vec3 I, vec3 N) 🔗

Calcola la direzione di riflessione di un vettore incidente.

Per un determinato vettore incidente I e una normale alla superfice N, restituisce la direzione della riflessione calcolata come I - 2,0 * dot(N, I) * N.

Nota

Per ottenere il risultato desiderato N deve essere normalizzato.

param I:

Il vettore incidente.

param N:

Il vettore normale.

return:

Il vettore di riflessione.

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

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

Calcola la direzione della rifrazione per un vettore incidente.

Per un determinato vettore incidente I, normale alla superficie N e rapporto degli indici di rifrazione, eta, restituisce il vettore di rifrazione, R.

R è calcolato come:
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

Per ottenere il risultato desiderato, i parametri di input I e N devono essere normalizzati.

param I:

Il vettore incidente.

param N:

Il vettore normale.

param eta:

Il rapporto tra indici di rifrazione.

return:

Il vettore di refrazione.

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

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

Restituisce un vettore che punta nella stessa direzione di un altro.

Orienta un vettore in modo che punti lontano da una superficie, come definito dalla sua normale. Se dot(Nref, I) < 0 restituisce N, altrimenti restituisce -N.

param N:

Il vettore da orientare.

param I:

Il vettore incidente.

param Nref:

Il vettore di riferimento.

return:

Il vettore orientato.

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

mat_type matrixCompMult(mat_type x, mat_type y) 🔗

Esegue una moltiplicazione componente per componente di due matrici.

Esegue una moltiplicazione componente per componente di due matrici, producendo una matrice risultante in cui ogni componente, result[i][j], viene calcolato come prodotto scalare di x[i][j] e y[i][j].

param x:

Il primo moltiplicando di matrice.

param y:

Il secondo moltiplicando di matrice.

return:

La matrice risultante.

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

mat_type outerProduct(vec_type column, vec_type row) 🔗

Calcola il prodotto esterno di una coppia di vettori.

Esegue la moltiplicazione di matrici algebriche lineari column * row, restituendo una matrice il cui numero di righe è il numero di componenti in column e il cui numero di colonne è il numero di componenti in row.

param column:

Il vettore colonna per la moltiplicazione.

param row:

Il vettore riga per la moltiplicazione.

return:

La matrice del prodotto diadico.

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

mat_type transpose(mat_type m) 🔗

Calcola la trasposizione di una matrice.

param m:

La matrice da trasporre.

return:

Una nuova matrice che è la trasposta della matrice di input m.

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

float determinant(mat_type m) 🔗

Calcola il determinante di una matrice.

param m:

La matrice.

return:

Il determinante della matrice di input m.

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

mat_type inverse(mat_type m) 🔗

Calcola l'inversa di una matrice.

I valori nella matrice restituita sono indefiniti se m è singolare o mal condizionato (quasi singolare).

param m:

La matrice di cui calcolare l'inversa.

return:

Una nuova matrice che è l'inversa della matrice di input m.

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

Funzioni di confronto

vec_bool_type	lessThan(vec_type x, vec_type y)	Confronto del vettore bool < sui vettori int/uint/float.
vec_bool_type	greaterThan(vec_type x, vec_type y)	Confronto del vettore bool > sui vettori int/uint/float.
vec_bool_type	lessThanEqual(vec_type x, vec_type y)	Confronto del vettore bool <= sui vettori int/uint/float.
vec_bool_type	greaterThanEqual( vec_type x, vec_type y)	Confronto del vettore bool >= sui vettori int/uint/float.
vec_bool_type	equal(vec_type x, vec_type y)	Confronto del vettore bool == sui vettori int/uint/float.
vec_bool_type	notEqual(vec_type x, vec_type y)	Confronto del vettore bool != sui vettori int/uint/float.
bool	any(vec_bool_type x)	`true` se una componente è `true`, `false` altrimenti.
bool	all(vec_bool_type x)	`true` se tutte le componenti sono `true`, `false` altrimenti.
vec_bool_type	not(vec_bool_type x)	Inverte un vettore booleano.

Descrizioni delle funzioni di confronto

vec_bool_type lessThan(vec_type x, vec_type y) 🔗

Esegue un confronto minore componente per componente di due vettori.

param x:

Il primo vettore da confrontare.

param y:

Il secondo vettore da confrontare.

return:

Un vettore booleano in cui ogni elemento i è calcolato come 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) 🔗

Esegue un confronto maggiore componente per componente di due vettori.

param x:

Il primo vettore da confrontare.

param y:

Il secondo vettore da confrontare.

return:

Un vettore booleano in cui ogni elemento i è calcolato come 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) 🔗

Esegue un confronto minore o uguale componente per componente di due vettori.

param x:

Il primo vettore da confrontare.

param y:

Il secondo vettore da confrontare.

return:

Un vettore booleano in cui ogni elemento i è calcolato come 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) 🔗

Esegue un confronto maggiore o uguale componente per componente di due vettori.

param x:

Il primo vettore da confrontare.

param y:

Il secondo vettore da confrontare.

return:

Un vettore booleano in cui ogni elemento i è calcolato come 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) 🔗

Esegue un confronto di uguaglianza componente per componente di due vettori.

param x:

Il primo vettore da confrontare.

param y:

Il secondo vettore da confrontare.

return:

Un vettore booleano in cui ogni elemento i è calcolato come 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) 🔗

Esegue un confronto di ineguaglianza componente per componente di due vettori.

param x:

Il primo vettore per il confronto.

param y:

Il secondo vettore per il confronto.

return:

Un vettore booleano in cui ogni elemento i è calcolato come x[i] != y[i].

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

bool any(vec_bool_type x) 🔗

Restituisce true se un qualsiasi elemento di un vettore booleano è true, altrimenti false.

Funzionalmente 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:

Il vettore da testare per verità.

return:

Vero se un qualsiasi elemento di x è vero e falso altrimenti.

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

bool all(vec_bool_type x) 🔗

Restituisce true se tutti gli elementi di un vettore booleano sono true, altrimenti false.

Funzionalmente 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:

Il vettore da testare per verità.

return:

true se tutti gli elementi di x sono true e false altrimenti.

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

vec_bool_type not(vec_bool_type x) 🔗

Invertire logicamente un vettore booleano.

param x:

Il vettore da invertire.

return:

Un nuovo vettore booleano per cui ciascun elemento i è calcolato come !x[i].

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

Funzioni di texture

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)	Ottiene le dimensioni di una texture. Per motivi di prestazioni, si dovrebbe evitare questa funzione poiché esegue sempre una lettura completa della texture. Quando possibile, è preferibile passare le dimensioni della texture come uniforme.
vec2 vec3 vec2 vec2	textureQueryLod(gsampler2D s, vec2 p) textureQueryLod(gsampler2DArray s, vec2 p) textureQueryLod(gsampler3D s, vec3 p) textureQueryLod(samplerCube s, vec3 p)	Calcola il livello di dettaglio che sarebbe utilizzato per campionare da una texture.
int int int int	textureQueryLevels(gsampler2D s) textureQueryLevels(gsampler2DArray s) textureQueryLevels(gsampler3D s) textureQueryLevels(samplerCube s)	Ottiene il numero di livelli di mipmap accessibili di una 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] )	Esegue una lettura di una texture.
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] )	Esegue una lettura di una texture con proiezione.
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)	Esegue una lettura di una texture su una mipmap personalizzata.
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)	Esegue una lettura di una texture con proiezione/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)	Esegue una lettura di una texture con gradienti espliciti.
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)	Esegue una lettura di una texture con proiezione/LOD e gradienti espliciti
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)	Recupera un singolo texel usando coordinate intere.
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] )	Raccoglie quattro texel da una texture.
vec_type	dFdx(vec_type p)	Derivata rispetto alla coordinata di finestra `x`, granularità automatica.
vec_type	dFdxCoarse(vec_type p)	Derivata rispetto alla coordinata di finestra `x`, granularità ruvida. Non disponibile quando si utilizza il renderer Compatibilità.
vec_type	dFdxFine(vec_type p)	Derivata rispetto alla coordinata di finestra `x`, granularità fine. Non disponibile quando si utilizza il renderer Compatibilità.
vec_type	dFdy(vec_type p)	Derivata rispetto alla coordinata della finestra `y`, granularità automatica.
vec_type	dFdyCoarse(vec_type p)	Derivata rispetto alla coordinata della finestra `y`, granularità ruvida. Non disponibile quando si utilizza il renderer Compatibilità.
vec_type	dFdyFine(vec_type p)	Derivata rispetto alla coordinata della finestra `y`, granularità fine. Non disponibile quando si utilizza il renderer Compatibilità.
vec_type	fwidth(vec_type p)	Somma della derivata assoluta in `x` e `y`.
vec_type	fwidthCoarse(vec_type p)	Somma della derivata assoluta in `x` e `y`. Non disponibile quando si utilizza il renderer Compatibilità.
vec_type	fwidthFine(vec_type p)	Somma della derivata assoluta in `x` e `y`. Non disponibile quando si utilizza il renderer Compatibilità.

Descrizioni delle funzioni di texture

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 le dimensioni di un livello di una texture.

Restituisce le dimensioni del livello lod (se presente) della texture associata al campionatore.

Le componenti del valore restituito vengono riempite, in ordine, con la larghezza, l'altezza e la profondità della texture. Per i formati array, l'ultima componente del valore restituito è il numero di livelli nell'array di texture.

param s:

Il campionatore a cui è associata la texture di cui si vogliono recuperare le dimensioni.

param lod:

Il livello della texture di cui recuperare le dimensioni.

return:

Le dimensioni del livello lod (se presente) della texture associata al campionatore.

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

Disponibile solo nello shader frammento.

Calcola il livello di dettaglio che sarebbe utilizzato per campionare da una texture.

Gli array di mipmap accessibili vengono restituiti nella componente x del valore restituito. Il livello di dettaglio calcolato rispetto al livello base viene restituito nella componente y del valore restituito.

Se chiamata su una texture incompleta, il risultato dell'operazione è indefinito.

param s:

Il campionatore a cui è associata la texture di cui verrà richiesto il livello di dettaglio.

param p:

Le coordinate della texture in base alle quali verrà richiesto il livello di dettaglio.

return:

Vedi la descrizione.

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) 🔗

Calcola il numero di livelli di mipmap accessibili di una texture.

Se chiamata una texture incompleta o se al campionatore non è associata alcuna texture, viene restituito 0.

param s:

Il campionatore a cui è associata la texture di cui verrà richiesto il numero di livelli di mipmap.

return:

Il numero di livelli di mipmap accessibili nella texture, o 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 i texel da una texture.

Campiona i texel dalla texture associata a s alle coordinate p. Un bias facoltativo, specificato in bias, è incluso nel calcolo del livello di dettaglio utilizzato per scegliere le mipmap da cui campionare.

Per i formati d'ombra, l'ultima componente di p è utilizzata come Dsub e il livello di array è specificato nella penultima componente di p. (La seconda componente di p non è utilizzata per le ricerche di ombre 1D.)

Per le varianti non di ombra, Il livello di array deriva dall'ultima componente di P.

param s:

Il campionatore a cui è associata la texture da cui verranno recuperati i texel.

param p:

Le coordinate di texture in cui verrà campionata la texture.

param bias:

Un bias facoltativo da applicare durante il calcolo del livello di dettaglio.

return:

Un 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] ) 🔗

Esegue una ricerca di texture con proiezione.

Le coordinate della texture ricavate da p, esclusa l'ultima componente di p, vengono divise per l'ultima componente di p. La terza componente risultante di p nei formati di ombra viene utilizzata come Dref. Dopo aver calcolato questi valori, la ricerca di texture procede come in texture.

param s:

Il campionatore a cui è associata la texture da cui verranno recuperati i texel.

param p:

Le coordinate di texture in cui verrà campionata la texture.

param bias:

Bias facoltativo da applicare durante il calcolo del livello di dettaglio.

return:

Un 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) 🔗

Esegue una ricerca di texture alle coordinate p dalla texture associata al campionatore con un livello di dettaglio esplicito come specificato in lod. lod specifica λbase e imposta le derivate parziali come segue:
δu/δx=0, δv/δx=0, δw/δx=0
δu/δy=0, δv/δy=0, δw/δy=0
param s:

Il campionatore a cui è associata la texture da cui verranno recuperati i texel.

param p:

Le coordinate di texture in cui verrà campionata la texture.

param lod:

Il livello di dettaglio esplicito.

return:

Un 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) 🔗

Esegue una ricerca di texture con proiezione da un livello di dettaglio specificato esplicitamente.

Le coordinate della texture ricavate da P, esclusa l'ultima componente di p, vengono divise per l'ultima componente di p. La terza componente di p risultante nei formati di ombra viene utilizzata come Dref. Dopo aver calcolato questi valori, la ricerca della texture procede come in textureLod<shader_func_textureLod>`, con ``lod utilizzato per specificare il livello di dettaglio da cui verrà campionata la texture.

param s:

Il campionatore a cui è associata la texture da cui verranno recuperati i texel.

param p:

Le coordinate di texture in cui verrà campionata la texture.

param lod:

Il livello di dettaglio esplicito da cui recuperare i texel.

return:

un 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) 🔗

Esegue una ricerca di texture alle coordinate p dalla texture associata al campionatore con gradienti di coordinate della texture espliciti come specificato in dPdx e dPdy. Impostare:

δs/δx=δp/δx per una texture 1D, δp.s/δx altrimenti

δs/δy=δp/δy per una texture 1D, δp.s/δy altrimenti

δt/δx=0.0 per una texture 1D, δp.t/δx altrimenti

δt/δy=0.0 per una texture 1D, δp.t/δy altrimenti

δr/δx=0.0 per una texture 1D o 2D, δp.p/δx altrimenti

δr/δy=0.0 per una texture 1D o 2D, δp.p/δy altrimenti

Per la versione cubica, si presume che le derivate parziali di p siano nel sistema di coordinate utilizzato prima che le coordinate di texture siano proiettate sulla faccia appropriata del cubo.

param s:

Il campionatore a cui è associata la texture da cui verranno recuperati i texel.

param p:

Le coordinate di texture in cui verrà campionata la texture.

param dPdx:

La derivata parziale di P rispetto alla x di finestra.

param dPdy:

La derivata parziale di P rispetto alla y di finestra.

return:

Un 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) 🔗

Esegue una ricerca di texture con proiezione e gradienti espliciti.

Le coordinate della texture ricavate da p, esclusa l'ultima componente di p, vengono divise per l'ultima componente di p. Dopo aver calcolato questi valori, la ricerca di texture procede come in textureGrad<shader_func_textureGrad>, passando dPdx e dPdy come gradienti.

param s:

Il campionatore a cui è associata la texture da cui verranno recuperati i texel.

param p:

Le coordinate di texture in cui verrà campionata la texture.

param dPdx:

La derivata parziale di p rispetto alla x di finestra.

param dPdy:

La derivata parziale di p rispetto alla y di finestra.

return:

Un 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) 🔗

Esegue una ricerca di un singolo texel dalla coordinata p di texture nella texture associata al campionatore.

param s:

Il campionatore a cui è associata la texture da cui verranno recuperati i texel.

param p:

Le coordinate di texture in cui verrà campionata la texture.

param lod:

Specifica il livello di dettaglio all'interno della texture da cui verrà recuperato il texel.

return:

Un 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] ) 🔗

Raccoglie quattro texel da una texture.

Restituisce il valore:
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:

Il campionatore a cui è associata la texture da cui verranno recuperati i texel.

param p:

Le coordinate di texture in cui verrà campionata la texture.

param comps:

facoltativo la componente della texture sorgente (0 -> x, 1 -> y, 2 -> z, 3 -> w) che verrà utilizzata per generare il vettore risultante. Zero se non specificato.

return:

Il texel recuperato.

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

vec_type dFdx(vec_type p) 🔗

Nota

Disponibile solo nello shader frammento.

Restituisce la derivata parziale di p rispetto alla coordinata x di finestra utilizzando la differenziazione locale.

Restituisce dFdxCoarse o dFdxFine. L'implementazione può scegliere quale calcolo eseguire in base a fattori come le prestazioni o il valore del suggerimento GL_FRAGMENT_SHADER_DERIVATIVE_HINT dell'API.

Avvertimento

Le espressioni che implicano derivate di ordine superiore come dFdx(dFdx(n)) hanno risultati indefiniti, così come le derivate di ordine misto come dFdx(dFdy(n)).

param p:

L'espressione di cui calcolare la derivata parziale.

Nota

Si suppone che l'espressione p sia continua e pertanto le espressioni valutate tramite un flusso di controllo non uniforme potrebbero essere indefinite.

return:

La derivata parziale di p.

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

vec_type dFdxCoarse(vec_type p) 🔗

Nota

Disponibile solo nello shader di frammenti. Non disponibile quando si utilizza il renderer Compatibilità.

Restituisce la derivata parziale di p rispetto alla coordinata x di finestra.

Calcola le derivate utilizzando la differenziazione locale in base al valore di p per i vicini del frammento attuale e includerà eventualmente, ma non necessariamente, il valore del frammento attuale. In altre parole, su una determinata area, l'implementazione può calcolare le derivate in meno posizioni univoche rispetto a quelle consentite dalla corrispondente funzione dFdxFine.

Avvertimento

Le espressioni che implicano derivate di ordine superiore come dFdx(dFdx(n)) hanno risultati indefiniti, così come le derivate di ordine misto come dFdx(dFdy(n)).

param p:

L'espressione di cui calcolare la derivata parziale.

Nota

Si suppone che l'espressione p sia continua e pertanto le espressioni valutate tramite un flusso di controllo non uniforme potrebbero essere indefinite.

return:

La derivata parziale di p.

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

vec_type dFdxFine(vec_type p) 🔗

Nota

Disponibile solo nello shader di frammenti. Non disponibile quando si utilizza il renderer Compatibilità.

Restituisce la derivata parziale di p rispetto alla coordinata x di finestra.

Calcola le derivate utilizzando la differenziazione locale in base al valore di p per il frammento attuale e i suoi vicini immediati.

Avvertimento

Le espressioni che implicano derivate di ordine superiore come dFdx(dFdx(n)) hanno risultati indefiniti, così come le derivate di ordine misto come dFdx(dFdy(n)).

param p:

L'espressione di cui calcolare la derivata parziale.

Nota

Si suppone che l'espressione p sia continua e pertanto le espressioni valutate tramite un flusso di controllo non uniforme potrebbero essere indefinite.

return:

La derivata parziale di p.

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

vec_type dFdy(vec_type p) 🔗

Nota

Disponibile solo nello shader frammento.

Restituisce la derivata parziale di p rispetto alla coordinata y di finestra utilizzando la differenziazione locale.

Restituisce dFdyCoarse o dFdyFine. L'implementazione può scegliere quale calcolo eseguire in base a fattori come le prestazioni o il valore del suggerimento GL_FRAGMENT_SHADER_DERIVATIVE_HINT dell'API.

Avvertimento

Le espressioni che implicano derivate di ordine superiore come dFdx(dFdx(n)) hanno risultati indefiniti, così come le derivate di ordine misto come dFdx(dFdy(n)).

param p:

L'espressione di cui calcolare la derivata parziale.

Nota

Si suppone che l'espressione p sia continua e pertanto le espressioni valutate tramite un flusso di controllo non uniforme potrebbero essere indefinite.

return:

La derivata parziale di p.

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

vec_type dFdyCoarse(vec_type p) 🔗

Nota

Disponibile solo nello shader di frammenti. Non disponibile quando si utilizza il renderer Compatibilità.

Restituisce la derivata parziale di p rispetto alla coordinata y di finestra.

Calcola le derivate utilizzando la differenziazione locale in base al valore di p per i vicini del frammento attuale e includerà eventualmente, ma non necessariamente, il valore del frammento attuale. In altre parole, su una determinata area, l'implementazione può calcolare le derivate in meno posizioni univoche rispetto a quelle consentite dalle corrispondenti funzioni dFdyFine e dFdyFine.

Avvertimento

Le espressioni che implicano derivate di ordine superiore come dFdx(dFdx(n)) hanno risultati indefiniti, così come le derivate di ordine misto come dFdx(dFdy(n)).

param p:

L'espressione di cui calcolare la derivata parziale.

Nota

Si suppone che l'espressione p sia continua e pertanto le espressioni valutate tramite un flusso di controllo non uniforme potrebbero essere indefinite.

return:

La derivata parziale di p.

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

vec_type dFdyFine(vec_type p) 🔗

Nota

Disponibile solo nello shader di frammenti. Non disponibile quando si utilizza il renderer Compatibilità.

Restituisce la derivata parziale di p rispetto alla coordinata y di finestra.

Calcola le derivate utilizzando la differenziazione locale in base al valore di p per il frammento attuale e i suoi vicini immediati.

Avvertimento

Le espressioni che implicano derivate di ordine superiore come dFdx(dFdx(n)) hanno risultati indefiniti, così come le derivate di ordine misto come dFdx(dFdy(n)).

param p:

L'espressione di cui calcolare la derivata parziale.

Nota

Si suppone che l'espressione p sia continua e pertanto le espressioni valutate tramite un flusso di controllo non uniforme potrebbero essere indefinite.

return:

La derivata parziale di p.

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

vec_type fwidth(vec_type p) 🔗

Restituisce la somma del valore assoluto delle derivate in x e y.

Utilizza la differenziazione locale per l'argomento di input p.

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

param p:

L'espressione di cui calcolare la derivata parziale.

return:

La derivata parziale.

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

vec_type fwidthCoarse(vec_type p) 🔗

Nota

Disponibile solo nello shader di frammenti. Non disponibile quando si utilizza il renderer Compatibilità.

Restituisce la somma del valore assoluto delle derivate in x e y.

Utilizza la differenziazione locale per l'argomento di input p.

Equivalente a abs(dFdxCoarse(p)) + abs(dFdyCoarse(p)).

param p:

L'espressione di cui calcolare la derivata parziale.

return:

La derivata parziale.

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

vec_type fwidthFine(vec_type p) 🔗

Nota

Disponibile solo nello shader di frammenti. Non disponibile quando si utilizza il renderer Compatibilità.

Restituisce la somma del valore assoluto delle derivate in x e y.

Utilizza la differenziazione locale per l'argomento di input p.

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

param p:

L'espressione di cui calcolare la derivata parziale.

return:

La derivata parziale.

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

Funzioni di compressione e decompressione

Queste funzioni convertono i numeri in virgola mobile in interi di varie dimensioni e poi impacchettano tali interi in un singolo intero senza segno a 32 bit. Le funzioni "unpack" eseguono l'operazione opposta, restituendo i numeri in virgola mobile originali.

uint vec2	packHalf2x16(vec2 v) unpackHalf2x16(uint v)	Converti due numeri in virgola mobile a 32 bit in numeri in virgola mobile a 16 bit e li comprime.
uint vec2	packUnorm2x16(vec2 v) unpackUnorm2x16(uint v)	Converte due numeri in virgola mobile normalizzati (intervallo 0..1) a 32 bit in numeri interi senza segno a 16 bit e li comprime.
uint vec2	packSnorm2x16(vec2 v) unpackSnorm2x16(uint v)	Converte due numeri in virgola mobile normalizzati con segno (intervallo -1..1) a 16 bit in numeri interi con segno a 16 bit e li comprime.
uint vec4	packUnorm4x8(vec4 v) unpackUnorm4x8(uint v)	Converte quattro numeri in virgola mobile a 32 bit normalizzati (intervallo 0..1) in numeri interi senza segno a 8 bit e li comprime.
uint vec4	packSnorm4x8(vec4 v) unpackSnorm4x8(uint v)	Converti quattro numeri in virgola mobile normalizzati con segno (intervallo -1..1) a 32 bit in numeri interi con segno a 8 bit e li comprime.

Descrizioni delle funzioni di compressione e decompressione

uint packHalf2x16(vec2 v) 🔗

Converte due quantità in virgola mobile a 32 bit in quantità in virgola mobile a 16 bit e le comprime in un singolo intero a 32 bit.

Restituisce un intero senza segno ottenuto convertendo le componenti di un vettore a virgola mobile a due componenti nella rappresentazione a virgola mobile a 16 bit presente nelle specifiche OpenGL, e successivamente comprimendo questi due interi a 16 bit in un intero senza segno a 32 bit. La prima componente del vettore specifica i 16 bit meno significativi del risultato; la seconda componente specifica i 16 bit più significativi.

param v:

Un vettore di due valori in virgola mobile a 32 bit che devono essere convertiti in una rappresentazione a 16 bit e inseriti nel risultato.

return:

Il valore compresso.

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

vec2 unpackHalf2x16(uint v) 🔗

Inverso di packHalf2x16.

Estrae un intero a 32 bit in due valori a virgola mobile a 16 bit, li converte in valori a virgola mobile a 32 bit e li inserisce in un vettore. La prima componente del vettore è ottenuta dai 16 bit meno significativi di v; la seconda componente è ottenuta dai 16 bit più significativi di v.

param v:

Un singolo intero senza segno a 32 bit contenente 2 valori impacchettati in virgola mobile a 16 bit.

return:

Due valori scompattati in virgola mobile.

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

uint packUnorm2x16(vec2 v) 🔗

Impacchetta valori in virgola mobile in un intero senza segno.

Converte ogni componente del valore in virgola mobile normalizzato v in valori interi a 16 bit e poi comprime i risultati in un intero senza segno a 32 bit.

La conversione della componente c di v in virgola fissa viene eseguita come segue:
round(clamp(c, 0.0, 1.0) * 65535.0)
La prima componente del vettore verrà scritta nei bit meno significativi dell'output; l'ultima componente verrà scritto nei bit più significativi.

param v:

Un vettore di valori da impacchettare in un intero senza segno.

return:

Intero senza segno a 32 bit contenente la codifica compressa del vettore.

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

vec2 unpackUnorm2x16(uint v) 🔗

Estrae valori in virgola mobile da un intero senza segno.

Estrae singoli interi senza segno a 32 bit in una coppia di interi senza segno a 16 bit. Successivamente, ogni componente viene convertita in un valore a virgola mobile normalizzato per generare il vettore a due componenti restituito.

La conversione del valore estratto in virgola mobile f viene eseguita come segue:

f / 65535.0

La prima componente del vettore restituito verrà estratta dai bit meno significativi dell'input; l'ultima componente verrà estratta dai bit più significativi.

param v:

Un numero intero senza segno contenente valori impacchettati in virgola mobile.

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

uint packSnorm2x16(vec2 v) 🔗

Impacchetta i valori in virgola mobile in un numero intero senza segno.

Converti ogni componente del valore in virgola mobile normalizzato v in valori interi a 16 bit e poi impacchetta i risultati in un intero senza segno a 32 bit.

La conversione della componente c di v in virgola fissa viene eseguita come segue:
round(clamp(c, -1.0, 1.0) * 32767.0)
La prima componente del vettore verrà scritta nei bit meno significativi dell'output; l'ultima componente verrà scritto nei bit più significativi.

param v:

Un vettore di valori da impacchettare in un intero senza segno.

return:

Intero senza segno a 32 bit contenente la codifica compressa del vettore.

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

vec2 unpackSnorm2x16(uint v) 🔗

Estrae i valori in virgola mobile da un intero senza segno.

Estrae singoli interi senza segno a 32 bit in una coppia di interi con segno a 16 bit. Successivamente, ogni componente viene convertita in un valore a virgola mobile normalizzato per generare il vettore a due componenti restituito.

La conversione del valore estratto in virgola mobile f viene eseguita come segue:

clamp(f / 32727.0, -1.0, 1.0)

La prima componente del vettore restituito verrà estratta dai bit meno significativi dell'input; l'ultima componente verrà estratta dai bit più significativi.

param v:

Un numero intero senza segno contenente valori impacchettati in virgola mobile.

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

uint packUnorm4x8(vec4 v) 🔗

Impacchetta i valori in virgola mobile in un numero intero senza segno.

Converte ogni componente del valore in virgola mobile normalizzato v in valori interi a 16 bit e poi comprime i risultati all'interno di un intero senza segno a 32 bit.

La conversione della componente c di v in virgola fissa viene eseguita come segue:
round(clamp(c, 0.0, 1.0) * 255.0)
La prima componente del vettore verrà scritta nei bit meno significativi dell'output; l'ultima componente verrà scritto nei bit più significativi.

param v:

Un vettore di valori da impacchettare in un intero senza segno.

return:

Intero senza segno a 32 bit contenente la codifica compressa del vettore.

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

vec4 unpackUnorm4x8(uint v) 🔗

Estrae i valori in virgola mobile da un intero senza segno.

Estrae singoli interi senza segno a 32 bit in quattro interi senza segno a 8 bit. Successivamente, ogni componente viene convertita in un valore a virgola mobile normalizzato per generare il vettore a quattro componenti restituito.

La conversione del valore estratto in virgola mobile f viene eseguita come segue:

f / 255.0

La prima componente del vettore restituito verrà estratta dai bit meno significativi dell'input; l'ultima componente verrà estratta dai bit più significativi.

param v:

Un numero intero senza segno contenente valori impacchettati in virgola mobile.

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

uint packSnorm4x8(vec4 v) 🔗

Impacchetta i valori in virgola mobile in un numero intero senza segno.

Converti ogni componente del valore in virgola mobile normalizzato v in valori interi a 16 bit e poi impacchetta i risultati in un intero senza segno a 32 bit.

La conversione della componente c di v in virgola fissa viene eseguita come segue:
round(clamp(c, -1.0, 1.0) * 127.0)
La prima componente del vettore verrà scritta nei bit meno significativi dell'output; l'ultima componente verrà scritto nei bit più significativi.

param v:

Un vettore di valori da impacchettare in un intero senza segno.

return:

Intero senza segno a 32 bit contenente la codifica compressa del vettore.

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

vec4 unpackSnorm4x8(uint v) 🔗

Estrae valori in virgola mobile da un intero senza segno.

Estrae singoli interi senza segno a 32 bit in quattro interi con segno a 8 bit. Successivamente, ogni componente viene convertita in un valore in virgola mobile normalizzato per generare il vettore a quattro componenti restituito.

La conversione del valore estratto in virgola mobile f viene eseguita come segue:

clamp(f / 127.0, -1.0, 1.0)

La prima componente del vettore restituito verrà estratta dai bit meno significativi dell'input; l'ultima componente verrà estratta dai bit più significativi.

param v:

Un numero intero senza segno contenente valori impacchettati in virgola mobile.

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

Funzioni bit a bit

vec_int_type vec_uint_type	bitfieldExtract(vec_int_type value, int offset, int bits) bitfieldExtract(vec_uint_type value, int offset, int bits)	Estrae un intervallo di bit da un intero.
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)	Inserisce un intervallo di bit da un intero.
vec_int_type vec_uint_type	bitfieldReverse(vec_int_type value) bitfieldReverse(vec_uint_type value)	Inverte l'ordine dei bit in un intero.
vec_int_type vec_uint_type	bitCount(vec_int_type value) bitCount(vec_uint_type value)	Conta il numero di bit 1 in un intero.
vec_int_type vec_uint_type	findLSB(vec_int_type value) findLSB(vec_uint_type value)	Trova l'indice del bit meno significativo impostato su 1 in un intero.
vec_int_type vec_uint_type	findMSB(vec_int_type value) findMSB(vec_uint_type value)	Trova l'indice del bit più significativo impostato su 1 in un intero.
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)	Moltiplica due numeri a 32 bit e produce un risultato a 64 bit.
vec_uint_type	uaddCarry(vec_uint_type x, vec_uint_type y, out vec_uint_type carry)	Aggiunge due interi senza segno e ne genera il riporto.
vec_uint_type	usubBorrow(vec_uint_type x, vec_uint_type y, out vec_uint_type borrow)	Sottrae due interi senza segno e ne genera il prestito.
vec_type	ldexp(vec_type x, out vec_int_type exp)	Assembla un numero in virgola mobile da un valore e da un esponente.
vec_type	frexp(vec_type x, out vec_int_type exp)	Divide un numero in virgola mobile (`x`) in componenti significativa e integrale

Descrizioni delle funzioni bit a bit

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

Estrae un sottoinsieme dei bit di value e lo restituisce nei bit meno significativi del risultato. L'intervallo di bit estratti è [offset, offset + bit - 1].

I bit più significativi del risultato verranno impostati su zero.

Nota

Se bit è zero, il risultato sarà zero.

Avvertimento

Il risultato sarà indefinito se:

l'offset o i bit sono negativi.

se la somma di offset e bit è maggiore del numero di bit utilizzati per memorizzare l'operando.

param value:

L'intero da cui estrarre i bit.

param offset:

L'indice del primo bit da estrarre.

param bits:

Il numero di bit da estrarre.

return:

Intero con i bit richiesti.

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.

Estrae un sottoinsieme dei bit di value e lo restituisce nei bit meno significativi del risultato. L'intervallo di bit estratti è [offset, offset + bit - 1].

I bit più significativi verranno impostati sul valore di offset + base - 1 (ovvero, il segno verrà esteso alla larghezza del tipo restituito).

Nota

Se bit è zero, il risultato sarà zero.

Avvertimento

Il risultato sarà indefinito se:

l'offset o i bit sono negativi.

se la somma di offset e bit è maggiore del numero di bit utilizzati per memorizzare l'operando.

param value:

L'intero da cui estrarre i bit.

param offset:

L'indice del primo bit da estrarre.

param bits:

Il numero di bit da estrarre.

return:

Intero con i bit richiesti.

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.

Inserisce i bits bit meno significativi di insert in base all'offset offset.

Il valore restituito avrà i bit [offset, offset + bit + 1] presi da [0, bit - 1] di insert e tutti gli altri bit presi direttamente dai bit corrispondenti di base.

Nota

Se bit è zero, il risultato sarà il valore originale della base.

Avvertimento

Il risultato sarà indefinito se:

l'offset o i bit sono negativi.

se la somma di offset e bit è maggiore del numero di bit utilizzati per memorizzare l'operando.

param base:

L'intero in cui inserire insert.

param insert:

Il valore dei bit da inserire.

param offset:

L'indice del primo bit da inserire.

param bits:

Il numero di bit da inserire.

return:

base con bit inseriti.

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 l'ordine dei bit in un intero.

Il bit numerato n verrà preso dal bit (bits - 1) - n di valore, dove bits è il numero totale di bit utilizzati per rappresentare valore.

param value:

Il valore di cui invertire i bit.

return:

value ma con i suoi bit invertiti.

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 il numero di bit 1 in un intero.

param value:

Il valore di cui contare i bit.

return:

Il numero di bit impostati a 1 nella rappresentazione binaria di valore.

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.

Trova l'indice del bit meno significativo impostato su 1.

Nota

Se value è zero, verrà restituito -1.

param value:

Il valore di cui analizzare i bit.

return:

Il numero di bit del bit meno significativo che è impostato su 1 nella rappresentazione binaria del valore.

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.

Trova l'indice del bit più significativo impostato su 1.

Nota

Per i tipi interi con segno, il bit del segno viene controllato prima e poi:

Per i numeri interi positivi, il risultato sarà il numero di bit del bit più significativo impostato su 1.

Per i numeri interi negativi, il risultato sarà il numero di bit del bit più significativo impostato su 0.

Nota

Per un valore pari a zero o 1 negativo, verrà restituito -1.

param value:

Il valore di cui analizzare i bit.

return:

Il numero di bit del bit più significativo impostato su 1 nella rappresentazione binaria del valore.

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.

Esegue una moltiplicazione con segno a 32 bit per 32 bit per produrre un risultato a 64 bit.

I 32 bit meno significativi di questo prodotto vengono restituiti in lsb e i 32 bit più significativi vengono restituiti in msb.

param x:

Il primo moltiplicando.

param y:

Il secondo moltiplicando.

param msb:

La variabile che riceve la word più significativa del prodotto.

param lsb:

La variabile che riceve la word meno significativa del prodotto.

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.

Esegue una moltiplicazione senza segno a 32 bit per 32 bit per produrre un risultato a 64 bit.

I 32 bit meno significativi di questo prodotto vengono restituiti in lsb e i 32 bit più significativi vengono restituiti in msb.

param x:

Il primo moltiplicando.

param y:

Il secondo moltiplicando.

param msb:

La variabile che riceve la word più significativa del prodotto.

param lsb:

La variabile che riceve la word meno significativa del prodotto.

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.

Somma interi senza segno e ne genera il riporto.

Somma due variabili intere (scalari o vettori) senza segno a 32 bit e genera un risultato intero senza segno a 32 bit, insieme a un riporto in output. Il valore riporto è .

param x:

Il primo operando.

param y:

Il secondo operando.

param carry:

0 se la somma è minore di 2³², altrimenti 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.

Sottrai interi senza segno e ne genera il prestito.

param x:

Il primo operando.

param y:

Il secondo operando.

param borrow:

0 se x >= y, altrimenti 1.

return:

La differenza tra x e y se non negativa, altrimenti 2³² più tale differenza.

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.

Assembla un numero in virgola mobile da un valore e da un esponente.

Avvertimento

Se questo prodotto è troppo grande per essere rappresentato nel tipo a virgola mobile, il risultato è indefinito.

param x:

Il valore da utilizzare come sorgente della mantissa.

param exp:

Il valore da utilizzare come sorgente dell'esponente.

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.

Estrae x in una mantissa in virgola mobile compresa nell'intervallo [0.5, 1.0) e con esponente integrale di due, in modo che:
x = significand * 2 ^ exponent
Per un valore in virgola mobile pari a zero, entrambi la mantissa e l'esponente siano zero.

Avvertimento

Per un valore in virgola mobile che è infinito o un valore in virgola mobile NaN, i risultati sono indefiniti.

param x:

Il valore da cui estrarre la mantissa ed esponente.

param exp:

La variabile in cui inserire l'esponente di x.

return:

La mantissa di x.

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