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...
Transform3D
Une matrice 3×4 représentant une transformation 3D.
Description
The Transform3D built-in Variant type is a 3×4 matrix representing a transformation in 3D space. It contains a Basis, which on its own can represent rotation, scale, and shear. Additionally, combined with its own origin, the transform can also represent a translation.
For a general introduction, see the Matrices and transforms tutorial.
Note: Godot uses a right-handed coordinate system, which is a common standard. For directions, the convention for built-in types like Camera3D is for -Z to point forward (+X is right, +Y is up, and +Z is back). Other objects may use different direction conventions. For more information, see the 3D asset direction conventions tutorial.
Note: In a boolean context, a Transform3D will evaluate to false if it's equal to IDENTITY. Otherwise, a Transform3D 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
Transform3D(from: Transform3D) |
|
Transform3D(basis: Basis, origin: Vector3) |
|
Transform3D(from: Projection) |
|
Transform3D(x_axis: Vector3, y_axis: Vector3, z_axis: Vector3, origin: Vector3) |
Méthodes
affine_inverse() const |
|
interpolate_with(xform: Transform3D, weight: float) const |
|
inverse() const |
|
is_equal_approx(xform: Transform3D) const |
|
is_finite() const |
|
looking_at(target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false) const |
|
orthonormalized() const |
|
rotated_local(axis: Vector3, angle: float) const |
|
scaled_local(scale: Vector3) const |
|
translated(offset: Vector3) const |
|
translated_local(offset: Vector3) const |
Opérateurs
operator !=(right: Transform3D) |
|
operator *(right: AABB) |
|
operator *(right: PackedVector3Array) |
|
operator *(right: Plane) |
|
operator *(right: Transform3D) |
|
operator *(right: Vector3) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator ==(right: Transform3D) |
Constantes
IDENTITY = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0) 🔗
La Transform3D identité. Il s'agit d'une transformation sans translation, sans rotation, et une échelle de Vector3.ONE. Sa basis est égale à Basis.IDENTITY. Cela signifie également que :
Son Basis.x pointe vers la droite (Vector3.RIGHT);
Son Basis.y pointe vers le haut (Vector3.UP);
Son Basis.z pointe vers l'arrière(Vector3.BACK).
var transformation = Transform3D.IDENTITY
var base = transformation.basis
print("| X | Y | Z | Origine")
print("| %.f | %.f | %.f | %.f" % [base.x.x, base.y.x, base.z.x, transform.origin.x])
print("| %.f | %.f | %.f | %.f" % [base.x.y, base.y.y, base.z.y, transform.origin.y])
print("| %.f | %.f | %.f | %.f" % [base.x.z, base.y.z, base.z.z, transform.origin.z])
# Affiche :
# | X | Y | Z | Origin
# | 1 | 0 | 0 | 0
# | 0 | 1 | 0 | 0
# | 0 | 0 | 1 | 0
Si un Vector3, un AABB, un Plane, un PackedVector3Array, ou une autre Transform3D est transformé (multiplié) par cette constante, aucune transformation ne se produit.
Note : En GDScript, cette constante est équivalente à la création d'une Transform3D sans aucun argument. Elle peut être utilisée pour rendre votre code plus clair, et pour la cohérence avec le C#.
FLIP_X = Transform3D(-1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0) 🔗
Transform3D avec effet miroir appliqué perpendiculairement au plan YZ. Sa base basis est égale à Basis.FLIP_X.
FLIP_Y = Transform3D(1, 0, 0, 0, -1, 0, 0, 0, 1, 0, 0, 0) 🔗
Transform3D avec effet miroir appliqué perpendiculairement au plan XZ. Sa base basis est égale à Basis.FLIP_Y.
FLIP_Z = Transform3D(1, 0, 0, 0, 1, 0, 0, 0, -1, 0, 0, 0) 🔗
Transform3D avec effet miroir appliqué perpendiculairement au plan XY. Sa base basis est égale à Basis.FLIP_Z.
Descriptions des propriétés
Basis basis = Basis(1, 0, 0, 0, 1, 0, 0, 0, 1) 🔗
La Basis de cette transformation. Elle est composée de 3 axes (Basis.x, Basis.y, et Basis.z). Ensemble, ils représentent la rotation, l'échelle et le cisaillement de la transformation.
Vector3 origin = Vector3(0, 0, 0) 🔗
Le décalage de translation de la transformation. Dans l'espace 3D, cela peut être vu comme la position.
Descriptions des constructeurs
Transform3D Transform3D() 🔗
Construit une Transform3D identique à IDENTITY.
Note : En C#, cela construit une Transform3D avec son origin et les composantes de sa basis définis à Vector3.ZERO.
Transform3D Transform3D(from: Transform3D)
Construit une Transform3D à partir de la Transform3D donnée.
Transform3D Transform3D(basis: Basis, origin: Vector3)
Construit une Transform3D à partir de la Basis et du Vector3 (la position) donnés.
Transform3D Transform3D(from: Projection)
Construit une Transform3D depuis une Projection. Comme Transform3D est une matrice 3×4 et Projection est une matrice 4×4, cette opération coupe la dernière ligne de la matrice de projection (from.x.w, from.y.w, from.z.w, et from.w.w ne sont pas inclus dans la nouvelle transformation).
Transform3D Transform3D(x_axis: Vector3, y_axis: Vector3, z_axis: Vector3, origin: Vector3)
Construit une Transform3D à partir de quatre valeurs Vector3 (également appelées colonnes de la matrice).
Les trois premiers arguments sont les axes de basis (Basis.x, Basis.y et Basis.z).
Descriptions des méthodes
Transform3D 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. Voir aussi Basis.inverse().
Note : Pour que cette méthode puisse se finir correctement, la basis de la transformation doit avoir un déterminant qui ne vaut pas exactement 0.0 (voir Basis.determinant()).
Transform3D interpolate_with(xform: Transform3D, 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.
Transform3D inverse() const 🔗
Renvoie la version inversée de cette transformation. Voir aussi Basis.inverse().
Note : Pour que cette méthode puisse se finir correctement, la basis 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().
bool is_equal_approx(xform: Transform3D) 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.
Transform3D looking_at(target: Vector3, up: Vector3 = Vector3(0, 1, 0), use_model_front: bool = false) const 🔗
Renvoie une copie de cette transformation tournée de sorte que l'axe avant (-Z) pointe vers la position cible target.
L'axe vers le haut (+Y) pointe aussi près du vecteur up que possible tout en restant perpendiculaire à l'axe avant. La transformation résultante est orthonormalisée. L'information existante de rotation, d'échelle et de cisaillement de la transformation originale est supprimée. Les vecteurs target et up ne peuvent être nuls, ne peuvent être parallèles entre eux, et sont définis dans l'espace global/parent.
Si use_model_front vaut true, l'axe +Z (axe avant des ressources) est traité comme l'avant (implique que +X est la gauche) et pointe vers la position cible target. Par défaut, l'axe -Z (avant de la caméra) est traité comme l'avant (implique que +X est la droite).
Transform3D orthonormalized() const 🔗
Renvoie une copie de cette transformation avec sa basis 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. Voir aussi Basis.orthonormalized().
Transform3D rotated(axis: Vector3, angle: float) const 🔗
Renvoie une copie de cette transformation tournée autour de l'axe axis donné d'un angle angle donné (en radians).
L'axe axis doit être un vecteur normalisé (voir Vector3.normalized()). Si angle est positif, la base est tournée dans le sens antihoraire autour de l'axe.
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.
Transform3D rotated_local(axis: Vector3, angle: float) const 🔗
Renvoie une copie de cette transformation tournée autour de l'axe axis donné de l'angle angle donné (en radians).
L'axe axis doit être un vecteur normalisé dans le système de coordonnées local de la transformation. Par exemple, pour tourner autour de l'axe X local, utilisez Vector3.RIGHT.
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.
Transform3D scaled(scale: Vector3) 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.
Transform3D scaled_local(scale: Vector3) 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.
Transform3D translated(offset: Vector3) 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.
Transform3D translated_local(offset: Vector3) 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: Transform3D) 🔗
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.
AABB operator *(right: AABB) 🔗
Transforme (multiplie) cette AABB par cette matrice de transformation.
PackedVector3Array operator *(right: PackedVector3Array) 🔗
Transforme (multiplie) chaque élément Vector3 du PackedVector3Array donné par cette matrice de transformation.
Sur de plus grands tableaux, cette opération est beaucoup plus rapide que de transformer chaque Vector3 individuellement.
Plane operator *(right: Plane) 🔗
Transforme (multiplie) ce Plane par cette matrice de transformation.
Transform3D operator *(right: Transform3D) 🔗
Transforme (multiplie) cette transformation par la transformation right.
C'est l'opération effectuée entre les Node3Ds parent et enfant.
Note : Si vous devez seulement modifier un attribut de cette transformation, envisagez à la place d'utiliser l'une des méthodes suivantes :
- Pour la translation, voir :ref:`translated()<class_Transform3D_method_translated>` ou :ref:`translated_local()<class_Transform3D_method_translated_local>`.
Pour la rotation, voir rotated() ou rotated_local().
Pour l'échelle, voir scaled() ou scaled_local().
Vector3 operator *(right: Vector3) 🔗
Transforme (multiplie) ce Vector3 par cette matrice de transformation.
Transform3D operator *(right: float) 🔗
Multiplie tous les composantes de la Transform3D par le float donné, y compris l'origine origin. Cela affecte uniformément l'échelle de la transformation, en redimensionnant la basis.
Transform3D operator *(right: int) 🔗
Multiplie tous les composantes de la Transform3D par l'int donné, y compris l'origine origin. Cela affecte uniformément l'échelle de la transformation, en redimensionnant la basis.
Transform3D operator /(right: float) 🔗
Divise tous les composantes de la Transform3D par le float donné, y compris l'origine origin. Cela affecte uniformément l'échelle de la transformation, en redimensionnant la basis.
Transform3D operator /(right: int) 🔗
Divise tous les composantes de la Transform3D par le int donné, y compris l'origine origin. Cela affecte uniformément l'échelle de la transformation, en redimensionnant la basis.
bool operator ==(right: Transform3D) 🔗
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.