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...
Vector4
Un vettore 4D che utilizza coordinate in virgola mobile.
Descrizione
Una struttura a 4 elementi che può essere utilizzata per rappresentare coordinate 4D o qualsiasi altro insieme di 4 valori numerici.
Utilizza coordinate in virgola mobile. Per impostazione predefinita, questi valori in virgola mobile usano una precisione a 32 bit, a differenza di float che è sempre a 64 bit. Se è necessaria una precisione doppia, compila il motore con l'opzione precision=double.
Vedi Vector3i per la sua controparte con numeri interi.
Nota: In un contesto booleano, un Vector4 sarà valutato come false se è uguale a Vector4(0, 0, 0, 0). Altrimenti, un Vector4 sarà sempre valutato come true.
Proprietà
|
||
|
||
|
||
|
Costruttori
Vector4() |
|
Metodi
abs() const |
|
ceil() const |
|
cubic_interpolate(b: Vector4, pre_a: Vector4, post_b: Vector4, weight: float) const |
|
cubic_interpolate_in_time(b: Vector4, pre_a: Vector4, post_b: Vector4, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const |
|
direction_to(to: Vector4) const |
|
distance_squared_to(to: Vector4) const |
|
distance_to(to: Vector4) const |
|
floor() const |
|
inverse() const |
|
is_equal_approx(to: Vector4) const |
|
is_finite() const |
|
is_normalized() const |
|
is_zero_approx() const |
|
length() const |
|
length_squared() const |
|
max_axis_index() const |
|
min_axis_index() const |
|
normalized() const |
|
round() const |
|
sign() const |
|
Operatori
operator !=(right: Vector4) |
|
operator *(right: Projection) |
|
operator *(right: Vector4) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator +(right: Vector4) |
|
operator -(right: Vector4) |
|
operator /(right: Vector4) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator <(right: Vector4) |
|
operator <=(right: Vector4) |
|
operator ==(right: Vector4) |
|
operator >(right: Vector4) |
|
operator >=(right: Vector4) |
|
operator [](index: int) |
|
Enumerazioni
enum Axis: 🔗
Axis AXIS_X = 0
Valore enumerato per l'asse X. Restituito da max_axis_index() e min_axis_index().
Axis AXIS_Y = 1
Valore enumerato per l'asse Y. Restituito da max_axis_index() e min_axis_index().
Axis AXIS_Z = 2
Valore enumerato per l'asse Z. Restituito da max_axis_index() e min_axis_index().
Axis AXIS_W = 3
Valore enumerato per l'asse W. Restituito da max_axis_index() e min_axis_index().
Costanti
ZERO = Vector4(0, 0, 0, 0) 🔗
Il vettore zero, un vettore con tutti i suoi componenti impostati su 0.
ONE = Vector4(1, 1, 1, 1) 🔗
Il vettore unitario, un vettore con tutti i suoi componenti impostati su 1.
INF = Vector4(inf, inf, inf, inf) 🔗
Il vettore infinito, un vettore con tutti i suoi componenti impostati su @GDScript.INF.
Descrizioni delle proprietà
Il componente W del vettore. Accessibile anche tramite la posizione di indice [3].
Il componente X del vettore. Accessibile anche tramite la posizione di indice [0].
Il componente Y del vettore. Accessibile anche tramite la posizione di indice [1].
Il componente Z del vettore. Accessibile anche tramite la posizione di indice [2].
Descrizioni dei costruttori
Costruisce un Vector4 predefinito con tutti i componenti impostati su 0.
Vector4 Vector4(from: Vector4)
Costruisce un Vector4 come copia del Vector4 specificato.
Vector4 Vector4(from: Vector4i)
Costruisce un nuovo Vector4 dal Vector4i fornito.
Vector4 Vector4(x: float, y: float, z: float, w: float)
Restituisce un Vector4 con i componenti forniti.
Descrizioni dei metodi
Restituisce un nuovo vettore con tutti i componenti in valori assoluti (ovvero positivi).
Restituisce un nuovo vettore con tutti i componenti arrotondati per eccesso (verso l'infinito positivo).
Vector4 clamp(min: Vector4, max: Vector4) const 🔗
Restituisce un nuovo vettore con tutti i suoi componenti limitati tra i componenti di min e max, eseguendo @GlobalScope.clamp() su ciascun componente.
Vector4 clampf(min: float, max: float) const 🔗
Restituisce un nuovo vettore con tutti i suoi componenti limitati tra min e max, eseguendo @GlobalScope.clamp() su ciascun componente.
Vector4 cubic_interpolate(b: Vector4, pre_a: Vector4, post_b: Vector4, weight: float) const 🔗
Esegue un'interpolazione cubica tra questo vettore e b usando pre_a e post_b come manopole e restituisce il risultato nella posizione weight. weight è compreso tra 0,0 e 1,0, e rappresenta la quantità di interpolazione.
Vector4 cubic_interpolate_in_time(b: Vector4, pre_a: Vector4, post_b: Vector4, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const 🔗
Esegue un'interpolazione cubica tra questo vettore e b usando pre_a e post_b come manopole e restituisce il risultato nella posizione weight. weight è compreso tra 0,0 e 1,0, e rappresenta la quantità di interpolazione.
Può eseguire un'interpolazione più fluida rispetto al cubic_interpolate() in base ai valori temporali.
Vector4 direction_to(to: Vector4) const 🔗
Restituisce il vettore normalizzato che punta da questo vettore a to. Ciò equivale a usare (b - a).normalized().
float distance_squared_to(to: Vector4) const 🔗
Returns the squared Euclidean distance between this vector and to.
This method runs faster than distance_to(), so prefer it if you need to compare vectors or need the squared distance for some formula.
float distance_to(to: Vector4) const 🔗
Restituisce la distanza euclidea tra questo vettore e to.
float dot(with: Vector4) const 🔗
Restituisce il prodotto scalare di questo vettore e il vettore with.
Restituisce un nuovo vettore con tutti i componenti arrotondati per difetto (verso l'infinito negativo).
Restituisce l'inverso del vettore. È lo stesso di Vector2(1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w).
bool is_equal_approx(to: Vector4) const 🔗
Restituisce true se questo vettore e to sono approssimativamente uguali, eseguendo @GlobalScope.is_equal_approx() su ciascun componente.
Restituisce true se questo vettore è finito, eseguendo @GlobalScope.is_finite() su ciascun componente.
Restituisce true se il vettore è normalizzato, ovvero la sua lunghezza è approssimativamente uguale a 1.
Restituisce true se i valori di questo vettore sono approssimativamente zero, eseguendo @GlobalScope.is_zero_approx() su ciascun componente.
Questo metodo è più veloce di is_equal_approx() con un valore come vettore zero.
Restituisce la lunghezza (magnitudine) di questo vettore.
float length_squared() const 🔗
Restituisce la lunghezza (magnitudine) al quadrato di questo vettore.
Questo metodo è più veloce di length(), quindi è preferibile se è necessario confrontare vettori o se è necessaria la distanza al quadrato per una formula.
Vector4 lerp(to: Vector4, weight: float) const 🔗
Restituisce il risultato dell'interpolazione lineare tra questo vettore e to per la quantità weight. weight è compreso tra 0.0 e 1.0, che rappresenta la quantità di interpolazione.
Vector4 max(with: Vector4) const 🔗
Restituisce il massimo, componente per componente, di questo vettore e with, equivalente a Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w)).
Restituisce l'asse del valore più alto del vettore. Vedi le costanti AXIS_*. Se tutti i componenti sono uguali, questo metodo restituisce AXIS_X.
Vector4 maxf(with: float) const 🔗
Restituisce il massimo, componente per componente, di questo vettore e with, equivalente a Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with)).
Vector4 min(with: Vector4) const 🔗
Restituisce il minimo, componente per componente, di questo vettore e with, equivalente a Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w)).
Restituisce l'asse del valore più basso del vettore. Vedi le costanti AXIS_*. Se tutti i componenti sono uguali, questo metodo restituisce AXIS_W.
Vector4 minf(with: float) const 🔗
Restituisce il minimo, componente per componente, di questo vettore e with, equivalente a Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with)).
Restituisce il risultato della scalatura del vettore a lunghezza unitaria. Equivalente a v / v.length(). Restituisce (0, 0, 0, 0) se v.length() == 0. Vedi anche is_normalized().
Nota: Questa funzione potrebbe restituire valori non corretti se la lunghezza del vettore passato è vicina a zero.
Vector4 posmod(mod: float) const 🔗
Restituisce un vettore composto dal risultato di @GlobalScope.fposmod() dai componenti di questo vettore e mod.
Vector4 posmodv(modv: Vector4) const 🔗
Restituisce un vettore composto dal risultato di @GlobalScope.fposmod() dai componenti di questo vettore e i componenti di modv.
Restituisce un nuovo vettore con tutti i componenti arrotondati all'intero più vicino, con i casi a metà arrotondati lontani da zero.
Restituisce un nuovo vettore con ogni componente impostato su 1.0 se è positivo, -1.0 se è negativo e 0.0 se è zero. Il risultato è identico alla chiamata di @GlobalScope.sign() su ciascun componente.
Vector4 snapped(step: Vector4) const 🔗
Restituisce un nuovo vettore con ciascun componente arrotondato al multiplo più vicino del componente corrispondente in step. Può anche essere utilizzato per arrotondare i componenti a un numero arbitrario di decimali.
Vector4 snappedf(step: float) const 🔗
Restituisce un nuovo vettore con ogni componente arrotondato al multiplo più vicino di step. Può anche essere utilizzato per arrotondare i componenti a un numero arbitrario di decimali.
Descrizioni degli operatori
bool operator !=(right: Vector4) 🔗
Restituisce true se i vettori non sono uguali.
Nota: A causa di errori di precisione per virgola mobile, considera invece utilizzare is_equal_approx(), che è più affidabile.
Nota: I vettori con componenti @GDScript.NAN non si comportano allo stesso modo di altri vettori. Perciò, i risultati di questa operazione potrebbero non essere accurati se valori NaN sono inclusi.
Vector4 operator *(right: Projection) 🔗
Trasforma (moltiplica) il Vector4 per la trasposta della matrice Projection fornita.
Per trasformare per inverso di una proiezione può essere usato projection.inverse() * vector. Vedi Projection.inverse().
Vector4 operator *(right: Vector4) 🔗
Moltiplica ogni componente del Vector4 per i componenti del Vector4 fornito.
print(Vector3i(10, 20, 30) * Vector3i(3, 4, 5)) # Stampa (30.0, 80.0, 150.0, 240.0)
Vector4 operator *(right: float) 🔗
Moltiplica ogni componente del Vector3i per il float fornito.
print(Vector4(10, 20, 30, 40) * 2) # Stampa (20.0, 40.0, 60.0, 80.0)
Vector4 operator *(right: int) 🔗
Moltiplica ogni componente del Vector4 per l'int fornito.
Vector4 operator +(right: Vector4) 🔗
Aggiunge ogni componente del Vector4 con i componenti del Vector4 fornito.
print(Vector4(10, 20, 30, 40) + Vector4(3, 4, 5, 6)) # Stampa (13.0, 24.0, 35.0, 46.0)
Vector4 operator -(right: Vector4) 🔗
Sottrae ogni componente del Vector4 dai componenti del Vector4 fornito.
print(Vector4(10, 20, 30, 40) - Vector4(3, 4, 5, 6)) # Stampa (7.0, 16.0, 25.0, 34.0)
Vector4 operator /(right: Vector4) 🔗
Divide ogni componente del Vector4 per i componenti del Vector4 fornito.
print(Vector4(10, 20, 30, 40) / Vector4(2, 5, 3, 4)) # Stampa (5.0, 4.0, 10.0, 10.0)
Vector4 operator /(right: float) 🔗
Divide ogni componente del Vector4 per il float fornito.
print(Vector4(10, 20, 30, 40) / 2 # Stampa (5.0, 10.0, 15.0, 20.0)
Vector4 operator /(right: int) 🔗
Divide ogni componente del Vector4 per l'int fornito.
bool operator <(right: Vector4) 🔗
Confronta due vettori Vector4 verificando prima se il valore X del vettore di sinistra è minore del valore X del vettore right. Se i valori X sono esattamente uguali, ripete questa verifica con i valori Y dei due vettori, i valori Z dei due vettori e poi con i valori W. Questo operatore è utile per ordinare i vettori.
Nota: I vettori con componenti @GDScript.NAN non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
bool operator <=(right: Vector4) 🔗
Confronta due vettori Vector4 verificando prima se il valore X del vettore di sinistra è minore o uguale al valore X del vettore right. Se i valori X sono esattamente uguali, ripete questa verifica con i valori Y dei due vettori, i valori Z dei due vettori e poi con i valori W. Questo operatore è utile per ordinare i vettori.
Nota: I vettori con componenti @GDScript.NAN non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
bool operator ==(right: Vector4) 🔗
Restituisce true se i vettori sono esattamente uguali.
Nota: A causa di errori di precisione per virgola mobile, considera invece utilizzare is_equal_approx(), che è più affidabile.
Nota: I vettori con componenti @GDScript.NAN non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
bool operator >(right: Vector4) 🔗
Confronta due vettori Vector4 verificando prima se il valore X del vettore di sinistra è maggiore del valore X del vettore right. Se i valori X sono esattamente uguali, ripete questa verifica con i valori Y dei due vettori, i valori Z dei due vettori e poi con i valori W. Questo operatore è utile per ordinare i vettori.
Nota: I vettori con componenti @GDScript.NAN non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
bool operator >=(right: Vector4) 🔗
Confronta due vettori Vector4 verificando prima se il valore X del vettore di sinistra è maggiore o uguale al valore X del vettore right. Se i valori X sono esattamente uguali, ripete questa verifica con i valori Y dei due vettori, i valori Z dei due vettori e poi con i valori W. Questo operatore è utile per ordinare i vettori.
Nota: I vettori con componenti @GDScript.NAN non si comportano come altri vettori. Pertanto, i risultati di questo operatore potrebbero non essere accurati se valori NAN sono inclusi.
float operator [](index: int) 🔗
Accede ai componenti del vettore attraverso il loro indice (index). v[0] è equivalente a v.x, v[1] è equivalente a v.y, v[2] è equivalente a v.z, v[3] è equivalente a v.w.
Restituisce lo stesso valore come se + non ci fosse. Il + unario non fa nulla, ma a volte può rendere il tuo codice più leggibile.
Restituisce il valore negativo del Vector4. Equivale a scrivere Vector4(-v.x, -v.y, -v.z, -v.w). Questa operazione inverte la direzione del vettore mantenendo la stessa magnitudine. Con i float, il numero zero può essere sia positivo sia negativo.