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...
Quaternion
Un quaternione unitario utilizzato per rappresentare le rotazioni in 3D.
Descrizione
The Quaternion built-in Variant type is a 4D data structure that represents rotation in the form of a Hamilton convention quaternion. Compared to the Basis type which can store both rotation and scale, quaternions can only store rotation.
A Quaternion is composed by 4 floating-point components: w, x, y, and z. These components are very compact in memory, and because of this some operations are more efficient and less likely to cause floating-point errors. Methods such as get_angle(), get_axis(), and slerp() are faster than their Basis counterparts.
For a great introduction to quaternions, see this video by 3Blue1Brown. You do not need to know the math behind quaternions, as Godot provides several helper methods that handle it for you. These include slerp() and spherical_cubic_interpolate(), as well as the * operator.
Note: Quaternions must be normalized before being used for rotation (see normalized()).
Note: Similarly to Vector2 and Vector3, the components of a quaternion use 32-bit precision by default, unlike float which is always 64-bit. If double precision is needed, compile the engine with the option precision=double.
Note: In a boolean context, a quaternion will evaluate to false if it's equal to IDENTITY. Otherwise, a quaternion will always evaluate to true.
Nota
Ci sono differenze sostanziali quando si usa questa API con C#. Vedi Differenze dell'API C# rispetto a GDScript per maggiori informazioni.
Tutorial
Proprietà
|
||
|
||
|
||
|
Costruttori
Quaternion(from: Quaternion) |
|
Quaternion(arc_from: Vector3, arc_to: Vector3) |
|
Quaternion(axis: Vector3, angle: float) |
|
Quaternion(from: Basis) |
|
Quaternion(x: float, y: float, z: float, w: float) |
Metodi
angle_to(to: Quaternion) const |
|
dot(with: Quaternion) const |
|
exp() const |
|
from_euler(euler: Vector3) static |
|
get_angle() const |
|
get_axis() const |
|
inverse() const |
|
is_equal_approx(to: Quaternion) const |
|
is_finite() const |
|
is_normalized() const |
|
length() const |
|
length_squared() const |
|
log() const |
|
normalized() const |
|
slerp(to: Quaternion, weight: float) const |
|
slerpni(to: Quaternion, weight: float) const |
|
spherical_cubic_interpolate(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, weight: float) const |
|
spherical_cubic_interpolate_in_time(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const |
Operatori
operator !=(right: Quaternion) |
|
operator *(right: Quaternion) |
|
operator *(right: Vector3) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator +(right: Quaternion) |
|
operator -(right: Quaternion) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator ==(right: Quaternion) |
|
operator [](index: int) |
|
Costanti
IDENTITY = Quaternion(0, 0, 0, 1) 🔗
Il quaternione di identità, che rappresenta nessuna rotazione. Ha la stessa rotazione di Basis.IDENTITY.
Se un Vector3 è ruotato (moltiplicato) da questo quaternione, esso non cambia.
Nota: In GDScript, questa costante è identica alla creazione di un Quaternion senza parametri. Questa costante può essere usata per rendere il codice più chiaro e per coerenza con C#.
Descrizioni delle proprietà
Componente W del quaternione. Questa è la parte "reale".
Nota: I componenti di un quaternione solitamente non dovrebbero essere manipolati direttamente.
Componente X del quaternione. Questo è il valore lungo l'asse "immaginario" i.
Nota: I componenti di un quaternione solitamente non dovrebbero essere manipolati direttamente.
Componente Y del quaternione. Questo è il valore lungo l'asse "immaginario" j.
Nota: I componenti di un quaternione solitamente non dovrebbero essere manipolati direttamente.
Componente Z del quaternione. Questo è il valore lungo l'asse "immaginario" k.
Nota: I componenti di un quaternione solitamente non dovrebbero essere manipolati direttamente.
Descrizioni dei costruttori
Quaternion Quaternion() 🔗
Costruisce un Quaternion identico a IDENTITY.
Nota: In C#, costruisce un Quaternion con tutti i suoi componenti impostati su 0.0.
Quaternion Quaternion(from: Quaternion)
Costruisce un Quaternion come copia del Quaternion specificato.
Quaternion Quaternion(arc_from: Vector3, arc_to: Vector3)
Costruisce un Quaternion che rappresenta l'arco più corto tra arc_from e arc_to. Si possono immaginare come due punti che intersecano la superficie di una sfera, con un raggio di 1.0.
Quaternion Quaternion(axis: Vector3, angle: float)
Costruisce un Quaternion che rappresenta la rotazione attorno all'asse axis per l'angolo angle, in radianti. L'asse deve essere un vettore normalizzato.
Quaternion Quaternion(from: Basis)
Costruisce un Quaternion dalla Basis di rotazione fornita.
Questo costruttore è più veloce di Basis.get_rotation_quaternion(), ma la base fornita deve essere ortonormalizzata (vedi Basis.orthonormalized()). Altrimenti, il costruttore fallisce e restituisce IDENTITY.
Quaternion Quaternion(x: float, y: float, z: float, w: float)
Costruisce un Quaternion definito dai valori forniti.
Nota: Solo i quaternioni normalizzati rappresentano la rotazione; se questi valori non sono normalizzati, il nuovo Quaternion non sarà una rotazione valida.
Descrizioni dei metodi
float angle_to(to: Quaternion) const 🔗
Restituisce l'angolo tra questo quaternione e to. Questa è l'ampiezza dell'angolo di cui dovresti ruotare per passare dall'uno all'altro.
Nota: L'ampiezza dell'errore in virgola mobile per questo metodo è anormalmente alta, quindi metodi come is_zero_approx non funzioneranno in modo affidabile.
float dot(with: Quaternion) const 🔗
Restituisce il prodotto scalare tra questo quaternione e with.
Ciò equivale a (quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w).
Quaternion exp() const 🔗
Restituisce l'esponenziale di questo quaternione. L'asse di rotazione del risultato è l'asse di rotazione normalizzato di questo quaternione, l'angolo del risultato è la lunghezza della parte vettoriale di questo quaternione.
Quaternion from_euler(euler: Vector3) static 🔗
Constructs a new Quaternion from the given Vector3 of Euler angles, in radians. In Godot, Euler angles always use intrinsic order. This method always uses the intrinsic YXZ convention (@GlobalScope.EULER_ORDER_YXZ).
Restituisce l'angolo di rotazione rappresentato da questo quaternione.
Nota: Il quaternione deve essere normalizzato.
Restituisce l'asse di rotazione della rotazione rappresentata da questo quaternione.
Vector3 get_euler(order: int = 2) const 🔗
Returns this quaternion's rotation as a Vector3 of Euler angles, in radians.
The order of each consecutive rotation can be changed with order (see EulerOrder constants). In Godot, Euler angles always use intrinsic order. By default, the intrinsic YXZ convention is used (@GlobalScope.EULER_ORDER_YXZ): since we are decomposing, local Z (roll) is calculated first, then local X (pitch), and lastly local Y (yaw). When using the opposite method from_euler() to compose a rotation, this order is reversed.
Quaternion inverse() const 🔗
Restituisce la versione inversa di questo quaternione, invertendo il segno di ogni componente eccetto w.
bool is_equal_approx(to: Quaternion) const 🔗
Restituisce true se questo quaternione e to sono approssimativamente uguali, chiamando @GlobalScope.is_equal_approx() su ogni componente.
Restituisce true se questo quaternione è finito, chiamando @GlobalScope.is_finite() su ogni componente.
Restituisce true se questo quaternione è normalizzato. Vedi anche normalized().
Restituisce la lunghezza di questo quaternione, detta anche magnitudine.
float length_squared() const 🔗
Restituisce la lunghezza di questo quaternione, al quadrato.
Nota: Questo metodo è più veloce di length(), quindi è preferibile se si desidera solo confrontare le lunghezze dei quaternioni.
Quaternion log() const 🔗
Restituisce il logaritmo di questo quaternione. Moltiplica l'asse di rotazione di questo quaternione per il suo angolo di rotazione e memorizza il risultato nella parte vettoriale del quaternione restituito (x, y e z). La parte reale del quaternione restituito (w) è sempre 0.0.
Quaternion normalized() const 🔗
Restituisce una copia di questo quaternione, normalizzato affinché la sua lunghezza sia 1.0. Vedi anche is_normalized().
Quaternion slerp(to: Quaternion, weight: float) const 🔗
Esegue un'interpolazione sferico-lineare con il quaternione to, specificato un peso (weight) e restituisce il risultato. Sia questo quaternione che to devono essere normalizzati.
Quaternion slerpni(to: Quaternion, weight: float) const 🔗
Esegue un'interpolazione sferico-lineare con il quaternione to, specificato un peso (weight) e restituisce il risultato. A differenza di slerp(), questo metodo non controlla se il percorso di rotazione è inferiore a 90 gradi. Sia questo quaternione che to devono essere normalizzati.
Quaternion spherical_cubic_interpolate(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, weight: float) const 🔗
Esegue un'interpolazione cubica sferica tra quaternioni pre_a, questo vettore, b e post_b, per la quantità specificata da weight.
Quaternion spherical_cubic_interpolate_in_time(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const 🔗
Esegue un'interpolazione cubica sferica tra quaternioni pre_a, questo vettore, b e post_b, per la quantità specificata da weight.
Può eseguire un'interpolazione più fluida rispetto a spherical_cubic_interpolate() in base ai valori temporali.
Descrizioni degli operatori
bool operator !=(right: Quaternion) 🔗
Restituisce true se i componenti di entrambi i quaternioni non sono esattamente uguali.
Note: A causa di errori di precisione per virgola mobile, considera invece utilizzare is_equal_approx(), che è più affidabile.
Quaternion operator *(right: Quaternion) 🔗
Compone (moltiplica) due quaternioni. Questo ruota il quaternione right (il figlio) di questo quaternione (il genitore).
Vector3 operator *(right: Vector3) 🔗
Ruota (moltiplica) il vettore right per questo quaternione, restituendo un Vector3.
Quaternion operator *(right: float) 🔗
Moltiplica ogni componente del Quaternion per il valore float destro.
Questa operazione non è significativa di per sé, ma può essere utilizzata come parte di un'espressione più ampia.
Quaternion operator *(right: int) 🔗
Moltiplica ogni componente del Quaternion per il valore int destro.
Questa operazione non è significativa di per sé, ma può essere utilizzata come parte di un'espressione più ampia.
Quaternion operator +(right: Quaternion) 🔗
Aggiunge ogni componente del Quaternion sinistro al Quaternion destro.
Questa operazione non è significativa di per sé, ma può essere utilizzata come parte di un'espressione più ampia, come l'approssimazione di una rotazione intermedia tra due rotazioni vicine.
Quaternion operator -(right: Quaternion) 🔗
Sottrae ogni componente del Quaternion sinistro dal Quaternion destro.
Questa operazione non è significativa di per sé, ma può essere utilizzata come parte di un'espressione più ampia.
Quaternion operator /(right: float) 🔗
Moltiplica ogni componente del Quaternion per il valore float destro.
Questa operazione non è significativa di per sé, ma può essere utilizzata come parte di un'espressione più ampia.
Quaternion operator /(right: int) 🔗
Moltiplica ogni componente del Quaternion per il valore float destro.
Questa operazione non è significativa di per sé, ma può essere utilizzata come parte di un'espressione più ampia.
bool operator ==(right: Quaternion) 🔗
Restituisce true se i componenti di entrambi i quaternioni sono esattamente uguali.
Note: A causa di errori di precisione per virgola mobile, considera invece utilizzare is_equal_approx(), che è più affidabile.
float operator [](index: int) 🔗
Accede a ogni componente di questo quaternione tramite il suo indice.
L'indice 0 è lo stesso di x, l'indice 1 è lo stesso di y, l'indice 2 è lo stesso di z e l'indice 3 è lo stesso di w.
Quaternion operator unary+() 🔗
Restituisce lo stesso valore come se + non ci fosse. Il + unario non fa nulla, ma a volte può rendere il tuo codice più leggibile.
Quaternion operator unary-() 🔗
Restituisce il valore negativo del Quaternion. Ciò equivale a moltiplicare tutti i componenti per -1. Questa operazione genera un quaternione che rappresenta la stessa rotazione.