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...
Transform2D
Una matrice 2×3 che rappresenta una trasformazione 2D.
Descrizione
The Transform2D built-in Variant type is a 2×3 matrix representing a transformation in 2D space. It contains three Vector2 values: x, y, and origin. Together, they can represent translation, rotation, scale, and skew.
The x and y axes form a 2×2 matrix, known as the transform's basis. The length of each axis (Vector2.length()) influences the transform's scale, while the direction of all axes influence the rotation. Usually, both axes are perpendicular to one another. However, when you rotate one axis individually, the transform becomes skewed. Applying a skewed transform to a 2D sprite will make the sprite appear distorted.
For a general introduction, see the Matrices and transforms tutorial.
Note: Unlike Transform3D, there is no 2D equivalent to the Basis type. All mentions of "basis" refer to the x and y components of Transform2D.
Note: In a boolean context, a Transform2D will evaluate to false if it's equal to IDENTITY. Otherwise, a Transform2D 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
Transform2D(from: Transform2D) |
|
Transform2D(rotation: float, position: Vector2) |
|
Transform2D(rotation: float, scale: Vector2, skew: float, position: Vector2) |
|
Transform2D(x_axis: Vector2, y_axis: Vector2, origin: Vector2) |
Metodi
affine_inverse() const |
|
basis_xform(v: Vector2) const |
|
basis_xform_inv(v: Vector2) const |
|
determinant() const |
|
get_origin() const |
|
get_rotation() const |
|
get_scale() const |
|
get_skew() const |
|
interpolate_with(xform: Transform2D, weight: float) const |
|
inverse() const |
|
is_conformal() const |
|
is_equal_approx(xform: Transform2D) const |
|
is_finite() const |
|
looking_at(target: Vector2 = Vector2(0, 0)) const |
|
orthonormalized() const |
|
rotated_local(angle: float) const |
|
scaled_local(scale: Vector2) const |
|
translated(offset: Vector2) const |
|
translated_local(offset: Vector2) const |
Operatori
operator !=(right: Transform2D) |
|
operator *(right: PackedVector2Array) |
|
operator *(right: Rect2) |
|
operator *(right: Transform2D) |
|
operator *(right: Vector2) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator ==(right: Transform2D) |
|
operator [](index: int) |
Costanti
IDENTITY = Transform2D(1, 0, 0, 1, 0, 0) 🔗
Il Transform2D di identità. Una trasformazione senza traslazione, senza rotazione e con una scala pari a Vector2.ONE. Ciò significa anche che:
La x punta a destra (Vector2.RIGHT);
La y punta in basso (Vector2.DOWN).
var transform = Transform2D.IDENTITY
print("| X | Y | Origin")
print("| %.f | %.f | %.f" % [transform.x.x, transform.y.x, transform.origin.x])
print("| %.f | %.f | %.f" % [transform.x.y, transform.y.y, transform.origin.y])
# Stampa:
# | X | Y | Origin
# | 1 | 0 | 0
# | 0 | 1 | 0
Se un Vector2, un Rect2, un PackedVector2Array o un altro Transform2D viene trasformato (moltiplicato) per questa costante, non si verifica alcuna trasformazione.
Nota: In GDScript, questa costante è identica alla creazione di un Transform2D senza alcun argomento. Questa costante può essere usata per rendere il codice più chiaro e per coerenza con C#.
FLIP_X = Transform2D(-1, 0, 0, 1, 0, 0) 🔗
Quando una qualsiasi trasformazione è moltiplicata per FLIP_X, nega tutti i componenti dell'asse x (la colonna X).
Quando FLIP_X è moltiplicata per qualsiasi trasformazione, nega il componente Vector2.x di tutti gli assi (la riga X).
FLIP_Y = Transform2D(1, 0, 0, -1, 0, 0) 🔗
Quando una qualsiasi trasformazione è moltiplicata per FLIP_Y, nega tutti i componenti dell'asse y (la colonna Y).
Quando FLIP_Y è moltiplicata per qualsiasi trasformazione, nega il componente Vector2.y di tutti gli assi (la riga Y).
Descrizioni delle proprietà
Vector2 origin = Vector2(0, 0) 🔗
L'offset di traslazione di questa trasformazione e la colonna 2 della matrice. Nello spazio 2D, questo può essere visto come la posizione.
L'asse X della base di trasformazione e la colonna 0 della matrice. Combinato con y, questo rappresenta la rotazione, la scala e l'inclinazione della trasformazione.
Sulla trasformazione di identità, questo vettore punta a destra (Vector2.RIGHT).
L'asse Y della base di trasformazione e la colonna 1 della matrice. Combinato con x, questo rappresenta la rotazione, la scala e l'inclinazione della trasformazione.
Sulla trasformazione di identità, questo vettore punta in basso (Vector2.DOWN).
Descrizioni dei costruttori
Transform2D Transform2D() 🔗
Costruisce un Transform2D identico a IDENTITY.
Nota: In C#, costruisce un Transform2D con tutti i suoi componenti impostati su Vector2.ZERO.
Transform2D Transform2D(from: Transform2D)
Costruisce un Transform2D come copia del Transform2D specificato.
Transform2D Transform2D(rotation: float, position: Vector2)
Costruisce un Transform2D da un determinato angolo (in radianti) e posizione.
Transform2D Transform2D(rotation: float, scale: Vector2, skew: float, position: Vector2)
Costruisce un Transform2D da un determinato angolo (in radianti), scala, inclinazione (in radianti) e posizione.
Transform2D Transform2D(x_axis: Vector2, y_axis: Vector2, origin: Vector2)
Costruisce un Transform2D da 3 valori Vector2 che rappresentano x, y e origin (le tre colonne della matrice).
Descrizioni dei metodi
Transform2D affine_inverse() const 🔗
Restituisce la versione invertita di questa trasformazione. A differenza di inverse(), questo metodo funziona con quasi ogni base, comprese quelle non uniformi, ma è più lento.
Nota: Affinché questo metodo restituisca correttamente, la base della trasformazione deve avere un determinante che non sia esattamente 0.0 (vedi determinant()).
Vector2 basis_xform(v: Vector2) const 🔗
Restituisce una copia del vettore v, trasformato (moltiplicato) per la matrice della base di trasformazione. A differenza dell'operatore di moltiplicazione (*), questo metodo ignora l'origin.
Vector2 basis_xform_inv(v: Vector2) const 🔗
Restituisce una copia del vettore v, trasformato (moltiplicato) per la matrice della base di trasformazione inversa (vedi inverse()). Questo metodo ignora l'origin.
Nota: Questo metodo presuppone che la base di questa trasformazione sia ortonormale (vedi orthonormalized()). Se la base non è ortonormale, dovrebbe essere usato transform.affine_inverse().basis_xform(vector) (vedi affine_inverse()).
Restituisce il determinante della matrice di questa base di trasformazione. Per la matematica avanzata, questo numero può essere utilizzato per determinare alcuni attributi:
Se il determinante è esattamente
0.0, la base non è invertibile (vedi inverse()).Se il determinante è un numero negativo, la base rappresenta una scala negativa.
Nota: Se la scala della base è la stessa per ogni asse, il suo determinante è sempre quella scala alla potenza di 2.
Restituisce la traslazione di questa trasformazione. Equivale a origin.
Restituisce la rotazione di questa trasformazione (in radianti). Ciò equivale all'angolo di x (vedi Vector2.angle()).
Restituisce la lunghezza di x e y, come Vector2. Se la base di questa trasformazione non è distorta, questo valore è il fattore di scala. Non è influenzato dalla rotazione.
var my_transform = Transform2D(
Vector2(2, 0),
Vector2(0, 4),
Vector2(0, 0)
)
# Ruotare il Transform2D in qualsiasi modo ne preserva la scala.
my_transform = my_transform.rotated(TAU / 2)
print(my_transform.get_scale()) # Stampa (2.0, 4.0).
var myTransform = new Transform2D(
Vector3(2.0f, 0.0f),
Vector3(0.0f, 4.0f),
Vector3(0.0f, 0.0f)
);
// Ruotare il Transform2D in qualsiasi modo ne preserva la scala.
myTransform = myTransform.Rotated(Mathf.Tau / 2.0f);
GD.Print(myTransform.GetScale()); // Stampa (2, 4).
Nota: Se il valore restituito da determinant() è negativo, anche la scala è negativa.
Restituisce l'inclinazione di questa trasformazione (in radianti).
Transform2D interpolate_with(xform: Transform2D, weight: float) const 🔗
Restituisce il risultato dell'interpolazione lineare tra questa trasformazione e xform per il peso weight.
weight dovrebbe essere compreso tra 0.0 e 1.0 (inclusi). I valori al di fuori di questo intervallo sono consentiti e possono essere utilizzati per eseguire un'estrapolazione.
Transform2D inverse() const 🔗
Restituisce la versione invertita di questa trasformazione.
Nota: Affinché questo metodo restituisca correttamente, la base della trasformazione deve essere ortonormale (vedi orthonormalized()). Ciò significa che la base dovrebbe rappresentare solo una rotazione. In caso contrario, usa invece affine_inverse().
Restituisce true se la base di questa trasformazione è conforme. Una base conforme è sia ortogonale (gli assi sono perpendicolari tra loro) sia uniforme (gli assi condividono la stessa lunghezza). Questo metodo può essere particolarmente utile durante i calcoli di fisica.
bool is_equal_approx(xform: Transform2D) const 🔗
Restituisce true se questa trasformazione e xform sono approssimativamente uguali, chiamando @GlobalScope.is_equal_approx() su ogni componente.
Restituisce true se questa trasformazione è finita, chiamando @GlobalScope.is_finite() su ogni componente.
Transform2D looking_at(target: Vector2 = Vector2(0, 0)) const 🔗
Restituisce una copia della trasformazione ruotata in modo che l'asse X ruotato punti verso la posizione target, nello spazio globale.
Transform2D orthonormalized() const 🔗
Restituisce una copia di questa trasformazione con la sua base ortonormalizzata. Una base ortonormale è sia ortogonale (gli assi sono perpendicolari tra loro) sia normalizzata (gli assi hanno una lunghezza di 1.0), il che significa anche che può rappresentare solo una rotazione.
Transform2D rotated(angle: float) const 🔗
Restituisce una copia di questa trasformazione ruotata dell'angolo angle (in radianti).
Se angle è positivo, la trasformazione viene ruotata in senso orario.
Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita X con una corrispondente trasformazione di rotazione R da sinistra, ovvero R * X.
Ciò può essere visto come una trasformazione rispetto alla struttura globale/padre.
Transform2D rotated_local(angle: float) const 🔗
Restituisce una copia della trasformazione ruotata dell'angolo angle (in radianti).
Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita X con una corrispondente trasformazione di rotazione R da destra, ovvero X * R.
Questo può essere visto come una trasformazione rispetto al frame locale.
Transform2D scaled(scale: Vector2) const 🔗
Restituisce una copia della trasformazione scalata dal fattore scale specificato.
Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita X con una trasformazione di scala corrispondente S da sinistra, ovvero S * X.
Questo può essere visto come una trasformazione rispetto al frame globale/padre.
Transform2D scaled_local(scale: Vector2) const 🔗
Restituisce una copia della trasformazione scalata dal fattore scale specificato.
Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita X con una trasformazione di scala corrispondente S da destra, ovvero X * S.
Questo può essere visto come una trasformazione rispetto al frame locale.
Transform2D translated(offset: Vector2) const 🔗
Restituisce una copia della trasformazione traslata dal valore di offset.
Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita X con una corrispondente trasformazione di traslazione T da sinistra, ovvero T * X.
Questo può essere visto come una trasformazione rispetto al frame globale/padre.
Transform2D translated_local(offset: Vector2) const 🔗
Restituisce una copia della trasformazione traslata dal valore di offset.
Questo metodo è una versione ottimizzata della moltiplicazione della trasformazione fornita X con una corrispondente trasformazione di traslazione T da destra, ovvero X * T.
Questo può essere visto come una trasformazione rispetto al frame locale.
Descrizioni degli operatori
bool operator !=(right: Transform2D) 🔗
Restituisce true se i componenti di entrambe le trasformazioni non sono uguali, rispettivamente.
Note: A causa di errori di precisione per virgola mobile, considera invece utilizzare is_equal_approx(), che è più affidabile.
PackedVector2Array operator *(right: PackedVector2Array) 🔗
Trasforma (moltiplica) ogni elemento Vector2 del PackedVector2Array specificato per questa matrice di trasformazione.
Su array più grandi, questa operazione è molto più veloce della trasformazione di ogni singolo Vector2.
Rect2 operator *(right: Rect2) 🔗
Trasforma (moltiplica) il Rect2 per questa matrice di trasformazione.
Transform2D operator *(right: Transform2D) 🔗
Trasforma (moltiplica) questa trasformazione per la trasformazione right.
Questa è l'operazione eseguita tra i nodi CanvasItem genitore e figlio.
Nota: Se devi modificare solo un attributo di questa trasformazione, considera di usare uno dei seguenti metodi:
Per la traduzione, vedi translated() o translated_local().
Per la rotazione, vedi rotated() o rotated_local().
Per la scala, vedi scaled() o scaled_local().
Vector2 operator *(right: Vector2) 🔗
Trasforma (moltiplica) il Vector2 per questa matrice di trasformazione.
Transform2D operator *(right: float) 🔗
Moltiplica tutti i componenti del Transform2D per il float indicato, incluso l'origin. Ciò influenza la scala della trasformazione in modo uniforme.
Transform2D operator *(right: int) 🔗
Moltiplica tutti i componenti del Transform2D per l'int indicato, incluso l'origin. Ciò influenza la scala della trasformazione in modo uniforme.
Transform2D operator /(right: float) 🔗
Divide tutti i componenti del Transform2D per il float indicato, incluso l'origin. Ciò influenza la scala della trasformazione in modo uniforme.
Transform2D operator /(right: int) 🔗
Divide tutti i componenti del Transform2D per l'int indicato, incluso l'origin. Ciò influenza la scala della trasformazione in modo uniforme.
bool operator ==(right: Transform2D) 🔗
Restituisce true se i componenti di entrambe le trasformazioni non sono esattamente uguali.
Note: A causa di errori di precisione per virgola mobile, considera invece utilizzare is_equal_approx(), che è più affidabile.
Vector2 operator [](index: int) 🔗
Accede a ciascun asse (colonna) di questa trasformazione tramite il loro indice. L'indice 0 è lo stesso di x, l'indice 1 è lo stesso di y e l'indice 2 è lo stesso di origin.