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
Une matrice 2×3 représentant une transformation 2D.
Description
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.
Note
Il y a des différences notables dans l'utilisation de cette API en C#. Voir Différences de l'API C# par rapport à GDScript pour plus d'informations.
Tutoriels
Propriétés
|
||
|
||
|
Constructeurs
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) |
Méthodes
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 |
Opérateurs
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) |
Constantes
IDENTITY = Transform2D(1, 0, 0, 1, 0, 0) 🔗
La Transform2D identité. Il s'agit d'une transformation sans translation, sans rotation, et d'une échelle de Vector2.ONE. Cela signifie également que :
Le x pointe vers la droite (Vector2.RIGHT);
Le y pointe vers le bas (Vector2.DOWN);
var transformation = Transform2D.IDENTITY
print("| X | Y | Origin")
print("| %.f | %.f | %.f" % [transformation.x.x, transformation.y.x, transformation.origin.x])
print("| %.f | %.f | %.f" % [transformation.x.y, transformation.y.y, transformation.origin.y])
# Affiche :
# | X | Y | Origine
# | 1 | 0 | 0
# | 0 | 1 | 0
Si un Vector2, un Rect2, un PackedVector2Array, ou une autre Transform2D est transformé (multiplié) par cette constante, aucune transformation ne se produit.
Note : En GDScript, cette constante est équivalente à la création d'une Transform2D sans aucun argument. Elle peut être utilisée pour rendre votre code plus clair, et pour la cohérence avec le C#.
FLIP_X = Transform2D(-1, 0, 0, 1, 0, 0) 🔗
Lorsqu'une transformation est multipliée par FLIP_X, cela inverse le signe toutes les composantes de l'axe x (la colonne X).
Lorsque FLIP_X est multiplié par n'importe quelle base, cela inverse le signe de la composante Vector2.x de tous les axes (la ligne X).
FLIP_Y = Transform2D(1, 0, 0, -1, 0, 0) 🔗
Lorsqu'une transformation est multipliée par FLIP_Y, cela inverse le signe toutes les composantes de l'axe y (la colonne Y).
Lorsque FLIP_Y est multiplié par n'importe quelle base, cela inverse le signe de la composante Vector2.y de tous les axes (la ligne Y).
Descriptions des propriétés
Vector2 origin = Vector2(0, 0) 🔗
Le décalage de translation de cette transformation, et la colonne 2 de la matrice. Dans l'espace 2D, cela peut être considéré comme la position.
L'axe X de la base de la transformation et la colonne 0 de la matrice. Combiné à y, cela représente la rotation, l'échelle et le cisaillement de la transformation.
Sur la transformation identité, ce vecteur pointe vers la droite (Vector2.RIGHT).
L'axe Y de la base de la transformation et la colonne 1 de la matrice. Combiné à x, cela représente la rotation, l'échelle et le cisaillement de la transformation.
Sur la transformation identité, ce vecteur pointe vers le bas (Vector2.DOWN).
Descriptions des constructeurs
Transform2D Transform2D() 🔗
Construit une Transform2D identique à IDENTITY.
Note : En C#, cela construit une Transform2D avec tous ses composantes définies à Vector2.ZERO.
Transform2D Transform2D(from: Transform2D)
Construit une Transform2D comme copie de la Transform2D donnée.
Transform2D Transform2D(rotation: float, position: Vector2)
Construit une Transform2D à partir d’un angle (en radians) et d’une position donnés.
Transform2D Transform2D(rotation: float, scale: Vector2, skew: float, position: Vector2)
Construit une Transform2D à partir d’un angle (en radians), d’une échelle, d’un cisaillement (en radians) et d’une position donnés.
Transform2D Transform2D(x_axis: Vector2, y_axis: Vector2, origin: Vector2)
Construit une Transform2D avec 3 valeurs de Vector2 représentant x, y et l'origine origin (les trois colonnes de la matrice).
Descriptions des méthodes
Transform2D affine_inverse() const 🔗
Renvoie la version inversée de cette transformation. Contrairement à inverse(), cette méthode fonctionne avec presque n'importe quelle base, y compris les non-uniformes, mais est plus lent.
Note : Pour que cette méthode puisse se finir correctement, la base de la transformation doit avoir un déterminant qui ne vaut pas exactement 0.0 (voir determinant()).
Vector2 basis_xform(v: Vector2) const 🔗
Renvoie une copie du vecteur v, transformé (multiplié) par la matrice de la base de la transformation. Contrairement à l'opérateur de multiplication (*), cette méthode ignore l'origine origin.
Vector2 basis_xform_inv(v: Vector2) const 🔗
Renvoie une copie du vecteur v, transformé (multiplié) par la matrice de la base de la transformation inverse. Cette méthode ignore l'origine origin.
Note : Cette méthode suppose que la base de cette transformation est orthonormée (voir orthonormalized()). Si la base n'est pas orthonormée, transformation.affine_inverse().basis_xform(vecteur) devrait être utilisé à la place (voir affine_inverse()).
Renvoie le determinant de la matrice de la base de cette transformation. Pour les mathématiques avancées, ce nombre peut être utilisé pour déterminer quelques attributs :
Si le déterminant vaut exactement
0.0, la base n'est pas inversible (voir inverse()).Si le déterminant est un nombre négatif, la base représente une échelle négative.
Note : Si l'échelle de la base est la même pour chaque axe, son déterminant vaut toujours cette échelle à la puissance 2.
Renvoie la translation de cette transformation. Équivalent à origin.
Renvoie la rotation de cette transformation (en radians). Cela est équivalent à l’angle de x (voir Vector2.angle()).
Renvoie la longueur de x et y, en tant que Vector2. Si la base de cette transformation n'est pas cisaillée, cette valeur est le facteur d'échelle. Il n'est pas affecté par la rotation.
var ma_transformation = Transform2D(
Vector2(2, 0),
Vector2(0, 4),
Vector2(0, 0)
)
# Tourner la Transform2D de n'importe quelle manière conserve son échelle.
ma_transformation = ma_transformation.rotated(TAU / 2)
print(ma_transformation.get_scale()) # Affiche (2.0, 4.0)
var maTransformation = new Transform2D(
Vector3(2.0f, 0.0f),
Vector3(0.0f, 4.0f),
Vector3(0.0f, 0.0f)
);
// Tourner la Transform2D de n'importe quelle manière conserve son échelle.
maTransformation = maTransformation.Rotated(Mathf.Tau / 2.0f);
GD.Print(maTransformation.GetScale()); // Affiche (2, 4)
Note : Si la valeur renvoyée par determinant() est négative, l'échelle est aussi négative.
Renvoie le cisaillement de cette transformation (en radians).
Transform2D interpolate_with(xform: Transform2D, weight: float) const 🔗
Renvoie le résultat de l'interpolation linéaire entre cette transformation et xform selon le poids weight donné.
Le poids weight devrait être compris entre 0.0 et 1.0 (inclusifs). Les valeurs en dehors de cette plage sont permises et peuvent être utilisées pour effectuer à la place une extrapolation.
Transform2D inverse() const 🔗
Renvoie la version inversée de cette transformation.
Note : Pour que cette méthode puisse se finir correctement, la base de la transformation doit être orthonormée (voir orthonormalized()). Cela signifie que la base ne devrait représenter qu'une rotation. Si ce n'est pas le cas, utilisez plutôt affine_inverse().
Renvoie true si cette base de cette transformation est conforme. Une base conforme est à la fois orthogonale (les axes sont perpendiculaires les uns aux autres) et uniforme (les axes partagent la même longueur). Cette méthode peut être particulièrement utile lors des calculs de physique.
bool is_equal_approx(xform: Transform2D) const 🔗
Renvoie true si cette transformation et xform sont approximativement égales, en utilisant @GlobalScope.is_equal_approx() sur chaque composante.
Renvoie true si cette transformation est finie, en appelant @GlobalScope.is_finite() sur chaque composante.
Transform2D looking_at(target: Vector2 = Vector2(0, 0)) const 🔗
Renvoie une copie de la transformation tournée de telle sorte que l'axe X tourné pointe vers la position cible target, dans l'espace global.
Transform2D orthonormalized() const 🔗
Renvoie une copie de cette transformation avec sa base orthonormalisée. Une base orthonormale est à la fois orthogonale (les axes sont perpendiculaires les uns aux autres) et normalisée (les axes ont une longueur de 1.0), ce qui signifie également qu'elle ne peut représenter qu'une rotation.
Transform2D rotated(angle: float) const 🔗
Renvoie une copie de cette transformation tournée d'un angle angle donné (en radians).
Si angle est positif, la transformation est tournée dans le sens horaire..
Cette méthode est une version optimisée de la multiplication de la transformation X donnée avec une transformation de rotation R correspondante sur la gauche, c'est-à-dire R * X.
Cela peut être considéré comme une transformation par rapport au repère global/parent.
Transform2D rotated_local(angle: float) const 🔗
Renvoie une copie de cette transformation tournée d'un angle angle donné (en radians).
Cette méthode est une version optimisée de la multiplication de la transformation X donnée avec une transformation de rotation R correspondante sur la droite, c'est-à-dire X * R.
Cela peut être considéré comme une transformation par rapport au repère local.
Transform2D scaled(scale: Vector2) const 🔗
Renvoie une copie de cette transformation redimensionnée d'un facteur scale donné.
Cette méthode est une version optimisée de la multiplication de la transformation X donnée avec une transformation d'échelle S correspondante sur la gauche, c'est-à-dire S * X.
Cela peut être considéré comme une transformation par rapport au repère global/parent.
Transform2D scaled_local(scale: Vector2) const 🔗
Renvoie une copie de cette transformation redimensionnée d'un facteur scale donné.
Cette méthode est une version optimisée de la multiplication de la transformation X donnée avec une transformation d'échelle S correspondante sur la droite, c'est-à-dire X * S.
Cela peut être considéré comme une transformation par rapport au repère local.
Transform2D translated(offset: Vector2) const 🔗
Renvoie une copie de cette transformation translatée d'un décalage offset donné.
Cette méthode est une version optimisée de la multiplication de la transformation X donnée avec une transformation de translation T correspondante sur la gauche, c'est-à-dire T * X.
Cela peut être considéré comme une transformation par rapport au repère global/parent.
Transform2D translated_local(offset: Vector2) const 🔗
Renvoie une copie de cette transformation translatée d'un décalage offset donné.
Cette méthode est une version optimisée de la multiplication de la transformation X donnée avec une transformation de translation T correspondante sur la droite, c'est-à-dire X* T.
Cela peut être considéré comme une transformation par rapport au repère local.
Descriptions des opérateurs
bool operator !=(right: Transform2D) 🔗
Renvoie true si les composantes des deux transformations ne sont pas égales.
Note : En raison des erreurs de précision des flottants, envisagez d'utiliser is_equal_approx() qui est plus fiable.
PackedVector2Array operator *(right: PackedVector2Array) 🔗
Transforme (multiplie) chaque élément Vector2 du PackedVector2Array donné par cette matrice de transformation.
Sur de plus grands tableaux, cette opération est beaucoup plus rapide que de transformer chaque Vector2 individuellement.
Rect2 operator *(right: Rect2) 🔗
Transforme (multiplie) ce Rect2 par cette matrice de transformation.
Transform2D operator *(right: Transform2D) 🔗
Transforme (multiplie) cette transformation par la transformation right.
C'est l'opération effectuée entre les nœuds CanvasItem parent et enfant.
Note : Si vous devez seulement modifier un attribut de cette transformation, envisagez d'utiliser l'une des méthodes suivantes, à la place :
Pour la translation, voir translated() ou translated_local().
Pour la rotation, voir rotated() ou rotated_local().
Pour l'échelle, voir scaled() ou scaled_local().
Vector2 operator *(right: Vector2) 🔗
Transforme (multiplie) le Vector2 par cette matrice de transformation.
Transform2D operator *(right: float) 🔗
Multiplie toutes les composantes de la Transform2D par le flottant float donné, y compris l'origine origin. Cela affecte uniformément l'échelle de la transformation.
Transform2D operator *(right: int) 🔗
Multiplie toutes les composantes de la Transform2D par l'entier int donné, y compris l'origine origin. Cela affecte uniformément l'échelle de la transformation.
Transform2D operator /(right: float) 🔗
Divise toutes les composantes de la Transform2D par le flottant float donné, y compris l'origine origin. Cela affecte uniformément l'échelle de la transformation.
Transform2D operator /(right: int) 🔗
Divise toutes les composantes de la Transform2D par l'entier int donné, y compris l'origine origin. Cela affecte uniformément l'échelle de la transformation.
bool operator ==(right: Transform2D) 🔗
Renvoie true si les composantes des deux transformations sont exactement égales.
Note : En raison des erreurs de précision des flottants, envisagez d'utiliser is_equal_approx() qui est plus fiable.
Vector2 operator [](index: int) 🔗
Accède à chaque axe (colonne) de cette transformation par son index. L'index 0 est identique à x, l'index 1 est identique à y, et l'index 2 est identique à origin.