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...
Vector3
Un vecteur 3D utilisant des coordonnées flottantes.
Description
Une structure de 3 éléments qui peut être utilisée pour représenter des coordonnées 3D ou tout autre triplet de valeurs numériques.
Elle utilise des coordonnées flottantes. Par défaut, ces valeurs flottantes utilisent une précision 32 bits, contrairement à float qui est toujours en 64 bits. Si une précision double est nécessaire, compilez le moteur avec l'option precision=double.
Voir Vector3i pour l'équivalent entier.
Note : Avec des booléens, un Vector3 sera évalué à false s'il est égal à Vector3(0, 0, 0). Sinon, un Vector4 sera toujours évalué à true.
Tutoriels
Propriétés
|
||
|
||
|
Constructeurs
Vector3() |
|
Méthodes
abs() const |
|
bezier_derivative(control_1: Vector3, control_2: Vector3, end: Vector3, t: float) const |
|
bezier_interpolate(control_1: Vector3, control_2: Vector3, end: Vector3, t: float) const |
|
ceil() const |
|
cubic_interpolate(b: Vector3, pre_a: Vector3, post_b: Vector3, weight: float) const |
|
cubic_interpolate_in_time(b: Vector3, pre_a: Vector3, post_b: Vector3, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const |
|
direction_to(to: Vector3) const |
|
distance_squared_to(to: Vector3) const |
|
distance_to(to: Vector3) const |
|
floor() const |
|
inverse() const |
|
is_equal_approx(to: Vector3) 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: Vector3, delta: float) const |
|
normalized() const |
|
octahedron_decode(uv: Vector2) static |
|
octahedron_encode() const |
|
round() const |
|
sign() const |
|
signed_angle_to(to: Vector3, axis: Vector3) const |
|
Opérateurs
operator !=(right: Vector3) |
|
operator *(right: Basis) |
|
operator *(right: Quaternion) |
|
operator *(right: Transform3D) |
|
operator *(right: Vector3) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator +(right: Vector3) |
|
operator -(right: Vector3) |
|
operator /(right: Vector3) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator <(right: Vector3) |
|
operator <=(right: Vector3) |
|
operator ==(right: Vector3) |
|
operator >(right: Vector3) |
|
operator >=(right: Vector3) |
|
operator [](index: int) |
|
Énumérations
enum Axis: 🔗
Axis AXIS_X = 0
La valeur de l'énumération pour l'axe X. Renvoyé par max_axis_index() et min_axis_index().
Axis AXIS_Y = 1
La valeur de l'énumération pour l'axe Y. Retourné par max_axis_index() et min_axis_index().
Axis AXIS_Z = 2
La valeur de l'énumération pour l'axe Z. Renvoyé par max_axis_index() et min_axis_index().
Constantes
ZERO = Vector3(0, 0, 0) 🔗
Le vecteur zéro, un vecteur avec tous ses composants définis 0.
ONE = Vector3(1, 1, 1) 🔗
Le vecteur unitaire, un vecteur avec tous ses composants définis à 1.
INF = Vector3(inf, inf, inf) 🔗
Le vecteur infini, un vecteur avec tous ses composants définit à @GDScript.INF.
LEFT = Vector3(-1, 0, 0) 🔗
Le vecteur unitaire gauche. Représente la direction locale à gauche, et la direction globale vers l'ouest.
RIGHT = Vector3(1, 0, 0) 🔗
Le vecteur unitaire vers la droite. Représente la direction locale à droite, et la direction globale vers l'est.
UP = Vector3(0, 1, 0) 🔗
Vecteur unitaire vers le haut.
DOWN = Vector3(0, -1, 0) 🔗
Vecteur unitaire vers le bas.
FORWARD = Vector3(0, 0, -1) 🔗
Un vecteur avant unité. Représente la direction locale de l'avant et la direction globale du nord. Gardez à l'esprit que la direction vers l'avant pour les lumières, les caméras, etc est différente des ressources 3D comme les personnages, qui se tournent vers la caméra par convention. Utilisez MODEL_FRONT et les constantes similaires quand vous travaillez dans l'espace de ressource 3D.
BACK = Vector3(0, 0, 1) 🔗
Vecteur unitaire vers l'arrière. Représente la direction locale vers l'arrière, et la direction globale vers le sud.
MODEL_LEFT = Vector3(1, 0, 0) 🔗
Vecteur unité pointant vers le côté gauche des ressources 3D importées.
MODEL_RIGHT = Vector3(-1, 0, 0) 🔗
Vecteur unité pointant vers le côté droit des ressources 3D importées.
MODEL_TOP = Vector3(0, 1, 0) 🔗
Vecteur unité pointant vers le haut des ressources 3D importées.
MODEL_BOTTOM = Vector3(0, -1, 0) 🔗
Vecteur unité pointant vers le bas des ressources 3D importées.
MODEL_FRONT = Vector3(0, 0, 1) 🔗
Vecteur unité pointant vers l'avant des ressources 3D importées.
MODEL_REAR = Vector3(0, 0, -1) 🔗
Vecteur unité pointant vers l'arrière des ressources 3D importées.
Descriptions des propriétés
La composante vectorielle X. Également accessible en utilisant le code de position index [0].
La composante vectorielle X. Également accessible en utilisant le code de position index [1].
Le composant vectoriel Z. Également accessible en utilisant l'index [2].
Descriptions des constructeurs
Construit un Vector3 initialisé par défaut, avec toutes ses composantes définies à 0.
Vector3 Vector3(from: Vector3)
Construit un Vector3 comme copie du Vector3 donné.
Vector3 Vector3(from: Vector3i)
Construit un nouveau Vector3 à partir d'un Vector3i.
Vector3 Vector3(x: float, y: float, z: float)
Renvoie un Vector3 avec les coordonnées spécifiées.
Descriptions des méthodes
Renvoie un nouveau vecteur avec tous ses composantes en valeurs absolues (c'est-à-dire toujours positives).
float angle_to(to: Vector3) const 🔗
Renvoie l'angle non signé minimum avec le vecteur donné, en radians.
Vector3 bezier_derivative(control_1: Vector3, control_2: Vector3, end: Vector3, t: float) const 🔗
Renvoie la dérivée au t donné sur la courbe de Bézier définie par ce vecteur et les points control_1, control_2, et end donnés.
Vector3 bezier_interpolate(control_1: Vector3, control_2: Vector3, end: Vector3, t: float) const 🔗
Renvoie le point au t donné sur la courbe de Bézier définie par ce vecteur et les points control_1, control_2, et end donnés.
Vector3 bounce(n: Vector3) const 🔗
Renvoie le vecteur "réfléchi" d'un plan défini par la normale n donnée.
Note: bounce() effectue l'opération que la plupart des moteurs et des frameworks appellent reflect().
Renvoie un nouveau vecteur avec tous les composantes arrondies vers le haut (vers +infini).
Vector3 clamp(min: Vector3, max: Vector3) const 🔗
Renvoie un nouveau vecteur avec toutes les composantes bornées entre les composantes de min et max, en exécutant @GlobalScope.clamp() sur chaque composante.
Vector3 clampf(min: float, max: float) const 🔗
Renvoie un nouveau vecteur avec toutes les composantes bornées entre min et max, en exécutant @GlobalScope.clamp() sur chaque composante.
Vector3 cross(with: Vector3) const 🔗
Renvoie le produit vectoriel de ce vecteur et with.
Cela renvoie un vecteur perpendiculaire à ceci et with, ce qui serait le vecteur normal au plan défini par les deux vecteurs. Comme il y a deux vecteurs possibles, dans des directions opposées, cette méthode renvoie le vecteur défini par un système de coordonnées main droite. Si les deux vecteurs sont parallèles, cette méthode renvoie un vecteur vide, ce qui la rend utile pour tester si deux vecteurs sont parallèles.
Vector3 cubic_interpolate(b: Vector3, pre_a: Vector3, post_b: Vector3, weight: float) const 🔗
Effectue une interpolation cubique entre ce vecteur et b en utilisant pre_a et post_b comme poignées, et renvoie le résultat à la position weight. weight est dans l'intervalle de 0,0 à 1,0, représentant le montant d'interpolation.
Vector3 cubic_interpolate_in_time(b: Vector3, pre_a: Vector3, post_b: Vector3, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const 🔗
Effectue une interpolation cubique entre ce vecteur et b en utilisant pre_a et post_b comme poignées, et renvoie le résultat à la position weight. weight est dans l'intervalle de 0,0 à 1,0, représentant la quantité d'interpolation.
Elle peut effectuer une interpolation plus lisse que cubic_interpolate() pour les valeurs temporelles.
Vector3 direction_to(to: Vector3) const 🔗
Renvoie le vecteur normalisé pointant de ce vecteur en direction de to. Ceci est équivalent à l'utilisation de (b - a).normalized().
float distance_squared_to(to: Vector3) 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: Vector3) const 🔗
Returns the Euclidean distance between this vector and to.
float dot(with: Vector3) const 🔗
Renvoie le produit scalaire de ce vecteur avec with. Ceci peut être utilisé pour comparer l'angle entre deux vecteurs. Par exemple, cela peut être utilisé pour déterminer si un ennemi est face au joueur.
Le produit scalaire sera 0 pour un angle droit (90 degrés), supérieur à 0 pour les angles plus étroits que 90 degrés et inférieur à 0 pour les angles plus larges que 90 degrés.
Lors de l'utilisation de vecteurs unitaires (normalisés), le résultat sera toujours compris entre -1.0 (angle de 180 degrés) lorsque les vecteurs font face à des directions opposées, et 1.0 (angle de 0 degré) lorsque les vecteurs sont alignés.
Note : a.dot(b) est équivalent à b.dot(a).
Renvoie un nouveau vecteur avec tous les composantes arrondies vers le bas (vers -infini).
Renvoie l'inverse du vecteur. Cela est identique à Vector3( 1.0 / v.x, 1.0 / v.y, 1.0 / v.z ).
bool is_equal_approx(to: Vector3) const 🔗
Renvoie true si ce vecteur et to sont approximativement égaux, en exécutant @GlobalScope.is_equal_approx() sur chaque composante.
Renvoie true si ce vecteur est fini, en appelant @GlobalScope.is_finite() sur chaque composante.
Renvoie true si le vecteur est normalisé, c.a.d. sa longueur est environ égale à 1.
Renvoie true si les valeurs de ce vecteur sont approximativement nulles, en exécutant @GlobalScope.is_zero_approx() sur chaque composante.
Cette méthode est plus rapide qu'utiliser is_equal_approx() avec un vecteur nul comme valeur.
Renvoie la longueur (magnitude) de ce vecteur.
float length_squared() const 🔗
Renvoie la longeur (magnitude) au carré de ce vecteur.
Cette méthode est plus rapide que length() donc préférez-le si vous devez comparer des vecteurs ou avoir besoin de la distance carrée pour certaines formules.
Vector3 lerp(to: Vector3, weight: float) const 🔗
Renvoie le résultat de l'interpolation linéaire entre ce vecteur et to par la quantité weight. weight est compris entre 0.0 et 1.0, représentant le montant d'interpolation.
Vector3 limit_length(length: float = 1.0) const 🔗
Renvoie le vecteur avec une longueur maximale en limitant sa longueur à length. Si le vecteur n'est pas fini, le résultat est indéfini.
Vector3 max(with: Vector3) const 🔗
Renvoie le maximum par composante de ceci et with, équivalent à Vector3(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z)).
Renvoie l'axe de la valeur la plus importante du vecteur. Voir les constantesAXIS_*. Si tous les composants sont égaux, cette méthode renvoie AXIS_X.
Vector3 maxf(with: float) const 🔗
Renvoie le maximum par composante de ceci et with, équivalent à Vector3(maxf(x, with), maxf(y, with), maxf(z, with)).
Vector3 min(with: Vector3) const 🔗
Renvoie le minimum par composante de ceci et with, équivalent à Vector3(minf(x, with.x), minf(y, with.y), minf(z, with.z)).
Renvoie l'axe de la valeur la moins importante du vecteur. Voir les constantesAXIS_*. Si tous les composants sont égaux, cette méthode renvoie AXIS_Z.
Vector3 minf(with: float) const 🔗
Renvoie le minimum par composante de ceci et with, équivalent à Vector3(minf(x, with), minf(y, with), minf(z, with)).
Vector3 move_toward(to: Vector3, delta: float) const 🔗
Renvoie un nouveau vecteur déplacé en direction de to par la quantité delta. Ne dépassera pas la valeur finale.
Renvoie le résultat de la mise à l'échelle du vecteur à la longueur unité. Équivalent à v / v.length(). Renvoie (0, 0, 0) si v.length() == 0. Voir aussi is_normalized().
Note : Cette fonction peut renvoyer des valeurs incorrectes si la longueur du vecteur d'entrée est proche de zéro.
Vector3 octahedron_decode(uv: Vector2) static 🔗
Renvoie le Vector3 depuis une forme compressé octaédrique créée en utilisant octahedron_encode() (stocké comme un Vector2).
Vector2 octahedron_encode() const 🔗
Renvoie la forme encodée octaédrique de ce Vector3 en tant que Vector2. Comme un Vector2 occupe 1/3 moins de mémoire comparé à Vector3, cette forme de compression peut être utilisée pour passer de plus grandes quantités de Vector3s normalisés (normalized()) sans augmenter la nécessité de mémoire et de stockage. Voir aussi octahedron_decode().
Note : octahedron_encode() peut seulement être utilisée pour des vecteurs normalisés (normalized()). octahedron_encode() ne vérifie pas si ce Vector3 est normalisé, et va renvoyer une valeur qui ne se décompresse pas en la valeur originale si le Vector3 n'est pas normalisée.
Note : La compression octaédrique a des pertes, même si les différences visuels sont rarement perceptibles dans des scénarios réels.
Basis outer(with: Vector3) const 🔗
Renvoie le produit extérieur avec with.
Vector3 posmod(mod: float) const 🔗
Renvoie un vecteur composé du @GlobalScope.fposmod() des composantes de ce vecteur et mod.
Vector3 posmodv(modv: Vector3) const 🔗
Renvoie un vecteur composé du @GlobalScope.fposmod() des composantes du vecteur et des composantes de modv.
Vector3 project(b: Vector3) const 🔗
Renvoie un nouveau vecteur résultant de la projection de ce vecteur sur le vecteur b donné. Le nouveau vecteur résultant sera parallèle à b. Voir aussi slide().
Note : Si le vecteur b est un vecteur nul, les composantes du nouveau vecteur résultant seront @GDScript.NAN.
Vector3 reflect(n: Vector3) const 🔗
Renvoie le résultat de la réflexion du vecteur à travers un plan défini par le vecteur normal n donné.
Note : reflect() diffère de ce que les autres moteurs et frameworks appellent reflect(). Dans d'autres moteurs, reflect() renvoie le résultat du vecteur réfléchi par le plan donné. La réflexion passe donc par la normale donnée. Tandis que dans Godot, la réflexion passe par le plan et peut être pensé comme rebondissant de la normale. Voir aussi bounce() qui fait ce que la plupart des moteurs appellent reflect().
Vector3 rotated(axis: Vector3, angle: float) const 🔗
Renvoie le résultat de la rotation de ce vecteur autour d'un axe donné, d'un angle donné (en radians). L'axe doit être un vecteur normalisé. Voir aussi @GlobalScope.deg_to_rad().
Renvoie une nouveau vecteur avec tous ses composantes arrondies à l'entier le plus proche, avec les demis arrondis à l'entier supérieur.
Renvoie un nouveau vecteur avec chaque composante définie à 1.0 si elle est positive, -1.0 si elle est négative, et 0.0 si elle est nulle. Le résultat est identique à celui d'appeler @GlobalScope.sign() sur chaque composante.
float signed_angle_to(to: Vector3, axis: Vector3) const 🔗
Renvoie l'angle signé du vecteur donné, en radians. Le signe de l'angle est positif dans le sens inverse des aiguilles d'une montre et négatif dans l'autre direction lorsqu'il est vu du côté spécifié par l'axe axis.
Vector3 slerp(to: Vector3, weight: float) const 🔗
Renvoie le résultat de l'interpolation linéaire sphérique entre ce vecteur et to, par la quantité weight. weight est compris entre 0,0 et 1,0, représentant le montant d'interpolation.
Cette méthode gère également l'interpolation des longueurs si les vecteurs d'entrée ont des longueurs différentes. Pour le cas particulier où un ou deux vecteurs d'entrée ont une longueur nulle, cette méthode se comporte comme lerp().
Vector3 slide(n: Vector3) const 🔗
Returns a new vector resulting from sliding this vector along a plane with normal n. The resulting new vector is perpendicular to n, and is equivalent to this vector minus its projection on n. See also project().
Note: The vector n must be normalized. See also normalized().
Vector3 snapped(step: Vector3) const 🔗
Renvoie un nouveau vecteur avec chaque composante arrondie au multiple le plus proche de la composante correspondante dans step. Cela peut également être utilisé pour arrondir les composantes à un nombre arbitraire de décimales.
Vector3 snappedf(step: float) const 🔗
Renvoie un nouveau vecteur avec chaque composante arrondie au multiple le plus proche de step. Cela peut également être utilisé pour arrondir des composantes à un nombre arbitraire de décimales.
Descriptions des opérateurs
bool operator !=(right: Vector3) 🔗
Renvoie true si les vecteurs ne sont pas égaux.
Note : À cause des erreurs de précision des flottants, envisagez d'utiliser is_equal_approx() à la place, qui est plus fiable.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas comme les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
Vector3 operator *(right: Basis) 🔗
Transforme (multiplie) de manière inverse le Vector3 par la matrice de base Basis donnée, avec la supposition que la base est orthonormée (c.a.d. une rotation/réflexion est OK, une échelle/un cisaillement ne l'est pas).
vector * basis est équivalent à basis.transposed() * vector. Voir Basis.transposed().
Pour transformer par l'inverse d'une base non-orthonormée (par ex. avec une mise à l'échelle), basis.inverse() * vector peut être utilisé à la place. Voir Basis.inverse().
Vector3 operator *(right: Quaternion) 🔗
Transforme (multiplie) de manière inverse le Vector3 par le Quaternion donné.
vector * quaternion est équivalent à quaternion.inverse() * vector. Voir Quaternion.inverse().
Vector3 operator *(right: Transform3D) 🔗
Transforme (multiplie) de manière inverse le Vector3 par la matrice de transformation Transform3D donnée, avec la supposition que la base de la transformation est orthonormée (c.a.d. une rotation/réflexion est OK, une échelle/un cisaillement ne l'est pas).
vector * transform est équivalent à transform.inverse() * vector. Voir Transform3D.inverse().
Pour transformer par l'inverse d'une transformation affine (par ex. avec une mise à l'échelle), transform.affine_inverse() * vector peut être utilisé à la place. Voir Transform3D.affine_inverse().
Vector3 operator *(right: Vector3) 🔗
Multiplie chaque composante du Vector3 par les composantes du Vector3 donné.
print(Vector3(10, 20, 30) * Vector3(3, 4, 5)) # Affiche (30.0, 80.0, 150.0)
Vector3 operator *(right: float) 🔗
Multiplie chaque composante du Vector3 par le flottant float donné.
Vector3 operator *(right: int) 🔗
Multiplie chaque composante du Vector3 par l'entier int donné.
Vector3 operator +(right: Vector3) 🔗
Ajoute chaque composante du Vector3 aux composantes du Vector3 donné.
print(Vector3(10, 20, 30) + Vector3(3, 4, 5)) # Affiche (13.0, 24.0, 35.0)
Vector3 operator -(right: Vector3) 🔗
Soustrait chaque composante du Vector3 par les composantes du Vector3 donné.
print(Vector3(10, 20, 30) - Vector3(3, 4, 5)) # Affiche (7.0, 16.0, 25.0)
Vector3 operator /(right: Vector3) 🔗
Divise chaque composante du Vector3 par les composantes du Vector3 donné.
print(Vector3(10, 20, 30) / Vector3(2, 5, 3)) # Affiche (5.0, 4.0, 10.0)
Vector3 operator /(right: float) 🔗
Divise chaque composante du Vector3 par le flottant float donné.
Vector3 operator /(right: int) 🔗
Divise chaque composante du Vector3 par l'entier int donné.
bool operator <(right: Vector3) 🔗
Compare deux Vector3 en vérifiant en premier si la valeur en X du vecteur de gauche est inférieure à la valeur en X du vecteur right. Si les deux valeurs en X sont exactement égales, alors il répète la vérification sur les valeurs en Y des deux vecteurs, puis sur les valeurs en Z. Cet opérateur est utile pour trier des vecteurs.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas comme les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
bool operator <=(right: Vector3) 🔗
Compare deux Vector3 en vérifiant en premier si la valeur en X du vecteur de gauche est inférieure ou égale à la valeur en X du vecteur right. Si les deux valeurs en X sont exactement égales, alors il répète la vérification sur les valeurs en Y des deux vecteurs, puis sur les valeurs en Z. Cet opérateur est utile pour trier des vecteurs.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas comme les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
bool operator ==(right: Vector3) 🔗
Renvoie true si les vecteurs sont exactement égaux.
Note : À cause des erreurs de précision des flottants, envisagez d'utiliser is_equal_approx() à la place, qui est plus fiable.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas comme les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
bool operator >(right: Vector3) 🔗
Compare deux Vector3 en vérifiant en premier si la valeur en X du vecteur de gauche est supérieure à la valeur en X du vecteur right. Si les deux valeurs en X sont exactement égales, alors il répète la vérification sur les valeurs en Y des deux vecteurs, puis sur les valeurs en Z. Cet opérateur est utile pour trier des vecteurs.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas comme les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
bool operator >=(right: Vector3) 🔗
Compare deux Vector3 en vérifiant en premier si la valeur en X du vecteur de gauche est supérieure ou égale à la valeur en X du vecteur right. Si les deux valeurs en X sont exactement égales, alors il répète la vérification sur les valeurs en Y des deux vecteurs, puis sur les valeurs en Z. Cet opérateur est utile pour trier des vecteurs.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas comme les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être précis quand des NaNs sont présents.
float operator [](index: int) 🔗
Accède aux composantes du vecteur par leur index. v[0] est équivalent à v.x, v[1] est équivalent à v.y, et v[2] est équivalent à v.z.
Renvoie la même valeur comme si + n'était pas là. Le + unaire ne fait rien, mais peut parfois rendre votre code plus lisible.
Renvoie la valeur négative du Vector3. Revient à écrire Vector3(-v.x, -v.y,-v.z). Cette opération retourne la direction du vecteur tout en gardant la même magnitude. Avec des flottants, le nombre zéro peut être positif ou négatif.