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...
Vector2
Un vettore 2D che utilizza coordinate in virgola mobile.
Descrizione
Una struttura a 2 elementi che può essere utilizzata per rappresentare coordinate 2D o qualsiasi altra coppia di 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 Vector2i per la sua controparte con numeri interi.
Nota: In un contesto booleano, un Vector2 sarà valutato come false se è uguale a Vector2(0, 0). Altrimenti, un Vector2 sarà sempre valutato come true.
Tutorial
Proprietà
|
||
|
Costruttori
Vector2() |
|
Metodi
abs() const |
|
angle() const |
|
angle_to_point(to: Vector2) const |
|
aspect() const |
|
bezier_derivative(control_1: Vector2, control_2: Vector2, end: Vector2, t: float) const |
|
bezier_interpolate(control_1: Vector2, control_2: Vector2, end: Vector2, t: float) const |
|
ceil() const |
|
cubic_interpolate(b: Vector2, pre_a: Vector2, post_b: Vector2, weight: float) const |
|
cubic_interpolate_in_time(b: Vector2, pre_a: Vector2, post_b: Vector2, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const |
|
direction_to(to: Vector2) const |
|
distance_squared_to(to: Vector2) const |
|
distance_to(to: Vector2) const |
|
floor() const |
|
from_angle(angle: float) static |
|
is_equal_approx(to: Vector2) const |
|
is_finite() const |
|
is_normalized() const |
|
is_zero_approx() const |
|
length() const |
|
length_squared() const |
|
limit_length(length: float = 1.0) const |
|
max_axis_index() const |
|
min_axis_index() const |
|
move_toward(to: Vector2, delta: float) const |
|
normalized() const |
|
orthogonal() const |
|
round() const |
|
sign() const |
|
Operatori
operator !=(right: Vector2) |
|
operator *(right: Transform2D) |
|
operator *(right: Vector2) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator +(right: Vector2) |
|
operator -(right: Vector2) |
|
operator /(right: Vector2) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator <(right: Vector2) |
|
operator <=(right: Vector2) |
|
operator ==(right: Vector2) |
|
operator >(right: Vector2) |
|
operator >=(right: Vector2) |
|
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().
Costanti
ZERO = Vector2(0, 0) 🔗
Il vettore zero, un vettore con tutti i suoi componenti impostati su 0.
ONE = Vector2(1, 1) 🔗
Il vettore unitario, un vettore con tutti i suoi componenti impostati su 1.
INF = Vector2(inf, inf) 🔗
Il vettore infinito, un vettore con tutti i suoi componenti impostati su @GDScript.INF.
LEFT = Vector2(-1, 0) 🔗
Il vettore unitario sinistro. Rappresenta la direzione a sinistra.
RIGHT = Vector2(1, 0) 🔗
Il vettore unitario destro. Rappresenta la direzione a destra.
UP = Vector2(0, -1) 🔗
Il vettore unitario verso l'alto. Y è verso il basso in 2D, quindi questo vettore punta verso -Y.
DOWN = Vector2(0, 1) 🔗
Il vettore unitario verso il basso. Y è verso il basso in 2D, quindi questo vettore punta verso +Y.
Descrizioni delle proprietà
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].
Descrizioni dei costruttori
Costruisce un Vector2 predefinito con tutti i componenti impostati su 0.
Vector2 Vector2(from: Vector2)
Costruisce un Vector2 come copia del Vector2 specificato.
Vector2 Vector2(from: Vector2i)
Costruisce un nuovo Vector2 da Vector2i.
Vector2 Vector2(x: float, y: float)
Costruisce un nuovo Vector2 dai parametri x e y forniti.
Descrizioni dei metodi
Restituisce un nuovo vettore con tutti i componenti in valori assoluti (ovvero positivi).
Returns this vector's angle with respect to the positive X axis, or (1, 0) vector, in radians.
For example, Vector2.RIGHT.angle() will return zero, Vector2.DOWN.angle() will return PI / 2 (a quarter turn, or 90 degrees), and Vector2(1, -1).angle() will return -PI / 4 (a negative eighth turn, or -45 degrees).
This is equivalent to calling @GlobalScope.atan2() with y and x.
Illustration of the returned angle.
float angle_to(to: Vector2) const 🔗
Returns the signed angle to the given vector, in radians. The result ranges from -PI to PI (inclusive).
Illustration of the returned angle.
float angle_to_point(to: Vector2) const 🔗
Returns the signed angle between the X axis and the line from this vector to point to, in radians. The result ranges from -PI to PI (inclusive).
a.angle_to_point(b) is equivalent to (b - a).angle(). See also angle().
Illustration of the returned angle.
Returns this vector's aspect ratio, which is x divided by y.
Vector2 bezier_derivative(control_1: Vector2, control_2: Vector2, end: Vector2, t: float) const 🔗
Restituisce la derivata in t sulla curva di Bézier definita da questo vettore e dai punti control_1, control_2 e end specificati.
Vector2 bezier_interpolate(control_1: Vector2, control_2: Vector2, end: Vector2, t: float) const 🔗
Restituisce il in t sulla curva di Bézier definita da questo vettore e dai punti control_1, control_2 e end specificati.
Vector2 bounce(n: Vector2) const 🔗
Restituisce il vettore "rimbalzato" da una linea definita dalla normale n perpendicolare alla linea.
Nota: bounce() esegue l'operazione che la maggior parte dei motori e framework chiama reflect().
Restituisce un nuovo vettore con tutti i componenti arrotondati per eccesso (verso l'infinito positivo).
Vector2 clamp(min: Vector2, max: Vector2) const 🔗
Restituisce un nuovo vettore con tutti i suoi componenti limitati tra i componenti di min e max, eseguendo @GlobalScope.clamp() su ciascun componente.
Vector2 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.
float cross(with: Vector2) const 🔗
Restituisce l'analogo 2D del prodotto vettoriale per questo vettore e with.
Questa è l'area (con segno) del parallelogramma formato dai due vettori. Se il secondo vettore è in senso orario rispetto al primo vettore, il prodotto vettoriale è l'area positiva. Se è in senso antiorario, il prodotto vettoriale è l'area negativa. Se i due vettori sono paralleli, restituisce zero, il che lo rende utile per verificare se due vettori sono paralleli.
Nota: Il prodotto vettoriale non è definito matematicamente in 2D. Questo metodo incorpora i vettori 2D nel piano XY dello spazio 3D e utilizza il componente Z del loro prodotto vettoriale come analogo.
Vector2 cubic_interpolate(b: Vector2, pre_a: Vector2, post_b: Vector2, 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.
Vector2 cubic_interpolate_in_time(b: Vector2, pre_a: Vector2, post_b: Vector2, 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.
Vector2 direction_to(to: Vector2) const 🔗
Returns the normalized vector pointing from this vector to to.
a.direction_to(b) is equivalent to (b - a).normalized(). See also normalized().
float distance_squared_to(to: Vector2) 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: Vector2) const 🔗
Returns the Euclidean distance between this vector and to.
float dot(with: Vector2) const 🔗
Restituisce il prodotto scalare di questo vettore e with. Può essere utilizzato per confrontare l'angolo tra due vettori. Ad esempio, può essere utilizzato per determinare se un nemico è rivolto verso il giocatore.
Il prodotto scalare sarà 0 per un angolo retto (90 gradi), maggiore di 0 per angoli più stretti di 90 gradi e minore di 0 per angoli più larghi di 90 gradi.
Quando si utilizzano vettori unitari (normalizzati), il risultato sarà sempre compreso tra -1.0 (angolo di 180 gradi) quando i vettori sono rivolti in direzioni opposte e 1.0 (angolo di 0 gradi) quando i vettori sono allineati.
Nota: a.dot(b) è equivalente a b.dot(a).
Restituisce un nuovo vettore con tutti i componenti arrotondati per difetto (verso l'infinito negativo).
Vector2 from_angle(angle: float) static 🔗
Crea un Vector2 unitario ruotato all'angolo angle, in radianti. Ciò equivale a fare Vector2(cos(angle), sin(angle)) o Vector2.RIGHT.rotated(angle).
print(Vector2.from_angle(0)) # Stampa (1.0, 0.0)
print(Vector2(1, 0).angle()) # Stampa 0.0, che è l'angolo usato in precedenza.
print(Vector2.from_angle(PI / 2)) # Stampa (0.0, 1.0)
Nota: La lunghezza del Vector2 restituito è circa 1.0, ma non è garantito che sia esattamente 1.0 a causa di problemi di precisione in virgola mobile. Chiamare normalized() sul Vector2 restituito se si necessita di un vettore unitario.
bool is_equal_approx(to: Vector2) 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.
Vector2 lerp(to: Vector2, 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.
Vector2 limit_length(length: float = 1.0) const 🔗
Restituisce il vettore con una lunghezza massima limitandone la lunghezza a length. Se il vettore non è finito, il risultato è indefinito.
Vector2 max(with: Vector2) const 🔗
Restituisce il massimo, componente per componente, di questo vettore e with, equivalente a Vector2(maxf(x, with.x), maxf(y, with.y)).
Restituisce l'asse del valore più alto del vettore. Vedi le costanti AXIS_*. Se tutti i componenti sono uguali, questo metodo restituisce AXIS_X.
Vector2 maxf(with: float) const 🔗
Restituisce il massimo, componente per componente, di questo vettore e with, equivalente a Vector2(maxf(x, with), maxf(y, with)).
Vector2 min(with: Vector2) const 🔗
Restituisce il minimo, componente per componente, di questo vettore e with, equivalente a Vector2(minf(x, with.x), minf(y, with.y)).
Restituisce l'asse del valore più basso del vettore. Vedi le costanti AXIS_*. Se tutti i componenti sono uguali, questo metodo restituisce AXIS_Y.
Vector2 minf(with: float) const 🔗
Restituisce il minimo, componente per componente, di questo vettore e with, equivalente a Vector2(minf(x, with), minf(y, with)).
Vector2 move_toward(to: Vector2, delta: float) const 🔗
Restituisce un nuovo vettore spostato verso to per la quantità delta. Non andrà oltre il valore finale.
Restituisce il risultato della scalatura del vettore a lunghezza unitaria. Equivalente a v / v.length(). Restituisce (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.
Restituisce un vettore perpendicolare ruotato di 90 gradi in senso antiorario rispetto all'originale, con la stessa lunghezza.
Vector2 posmod(mod: float) const 🔗
Restituisce un vettore composto dal risultato di @GlobalScope.fposmod() dai componenti di questo vettore e mod.
Vector2 posmodv(modv: Vector2) const 🔗
Restituisce un vettore composto dal risultato di @GlobalScope.fposmod() dai componenti di questo vettore e i componenti di modv.
Vector2 project(b: Vector2) const 🔗
Restituisce un nuovo vettore risultante dalla proiezione di questo vettore sul vettore b. Il nuovo vettore risultante è parallelo a b. Vedi anche slide().
Nota: Se il vettore b è un vettore zero, i componenti del nuovo vettore risultante saranno @GDScript.NAN.
Vector2 reflect(line: Vector2) const 🔗
Restituisce il risultato della riflessione del vettore da una linea definita dal vettore di direzione line.
Nota: reflect() differisce da ciò che altri motori e framework chiamano reflect(). In altri motori, reflect() assume una direzione normale che è una direzione perpendicolare alla linea. In Godot, specifichi direttamente la direzione della linea. Vedi anche bounce() che fa ciò che la maggior parte dei motori chiama reflect().
Vector2 rotated(angle: float) const 🔗
Restituisce il risultato della rotazione di questo vettore di angle (in radianti). Vedi anche @GlobalScope.deg_to_rad().
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.
Vector2 slerp(to: Vector2, weight: float) const 🔗
Restituisce il risultato dell'interpolazione lineare sferica tra questo vettore e to, per la quantità weight. weight è compreso tra 0,0 e 1,0, e rappresenta la quantità di interpolazione.
Questo metodo gestisce anche l'interpolazione delle lunghezze se i vettori passati hanno lunghezze diverse. Per il caso speciale di uno o entrambi i vettori passati con lunghezza zero, questo metodo si comporta come lerp().
Vector2 slide(n: Vector2) const 🔗
Restituisce un nuovo vettore risultante dallo scorrimento di questo vettore lungo una linea con la normale n. Il nuovo vettore risultante è perpendicolare a n ed è equivalente a questo vettore meno la sua proiezione su n. Vedi anche project().
Nota: Il vettore n deve essere normalizzato. Vedi anche normalized().
Vector2 snapped(step: Vector2) 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.
Vector2 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: Vector2) 🔗
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.
Vector2 operator *(right: Transform2D) 🔗
Trasforma inversamente (moltiplica) il Vector2 per la matrice di trasformazione Transform2D fornita, presupponendo che la base di trasformazione sia ortonormale (ovvero rotazione/riflessione vanno bene, ma scala/inclinazione no).
vector * transform è equivalente a transform.inverse() * vector. VediTransform2D.inverse().
Per trasformare per inverso una trasformazione affine (ad esempio con scala) può essere utilizzato transform.affine_inverse() * vector. Vedi Transform2D.affine_inverse().
Vector2 operator *(right: Vector2) 🔗
Moltiplica ogni componente del Vector2 per i componenti del Vector2 fornito.
print(Vector2(10, 20) * Vector2(3, 4)) # Stampa (30.0, 80.0)
Vector2 operator *(right: float) 🔗
Moltiplica ogni componente del Vector2i per il float fornito.
Vector2 operator *(right: int) 🔗
Moltiplica ogni componente del Vector2 per l'int fornito.
Vector2 operator +(right: Vector2) 🔗
Aggiunge ogni componente del Vector2 con i componenti del Vector2 fornito.
print(Vector2(10, 20) + Vector2(3, 4)) # Stampa (13.0, 24.0)
Vector2 operator -(right: Vector2) 🔗
Sottrae ogni componente del Vector2 dai componenti del Vector2 fornito.
print(Vector2(10, 20) - Vector2(3, 4)) # Stampa (7.0, 16.0)
Vector2 operator /(right: Vector2) 🔗
Divide ogni componente del Vector2 per i componenti del Vector2 fornito.
print(Vector2(10, 20) / Vector2(2, 5)) # Stampa (5.0, 4.0)
Vector2 operator /(right: float) 🔗
Divide ogni componente del Vector2 per il float fornito.
Vector2 operator /(right: int) 🔗
Divide ogni componente del Vector2 per l'int fornito.
bool operator <(right: Vector2) 🔗
Confronta due vettori Vector2 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. 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: Vector2) 🔗
Confronta due vettori Vector2 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. 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: Vector2) 🔗
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: Vector2) 🔗
Confronta due vettori Vector2 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. 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: Vector2) 🔗
Confronta due vettori Vector2 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. 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, mentre v[1] è equivalente a v.y.
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 Vector2. Equivale a scrivere Vector2(-v.x, -v.y). Questa operazione inverte la direzione del vettore mantenendo la stessa magnitudine. Con i float, il numero zero può essere sia positivo sia negativo.