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...
Vector2
Un vecteur 2D utilisant des coordonnées flottantes.
Description
Une structure de 2 éléments qui peut être utilisée pour représenter les coordonnées 2D ou toute autre paire de valeurs numériques.
Il utilise des coordonnées flottantes. Par défaut, ces valeurs flottantes utilisent une précision de 32 bits, contrairement à float qui est toujours de 64 bits. Si une double précision est nécessaire, compilez le moteur avec l'option précision=double.
Voir Vector2i pour son homologue entier.
Note : Dans un contexte booléen, un Vector2 évaluera false s'il est égal à Vector2(0, 0). Sinon, un Vector2 évaluera toujours true.
Tutoriels
Propriétés
|
||
|
Constructeurs
Vector2() |
|
Méthodes
abs() const |
|
angle() const |
|
angle_to_point(to: Vector2) const |
|
aspect() const |
|
bezier_derivative(control_1: Vector2, control_2: Vector2, end: Vector2, t: float) const |
|
bezier_interpolate(control_1: Vector2, control_2: Vector2, end: Vector2, t: float) const |
|
ceil() const |
|
cubic_interpolate(b: Vector2, pre_a: Vector2, post_b: Vector2, weight: float) const |
|
cubic_interpolate_in_time(b: Vector2, pre_a: Vector2, post_b: Vector2, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const |
|
direction_to(to: Vector2) const |
|
distance_squared_to(to: Vector2) const |
|
distance_to(to: Vector2) const |
|
floor() const |
|
from_angle(angle: float) static |
|
is_equal_approx(to: Vector2) 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: Vector2, delta: float) const |
|
normalized() const |
|
orthogonal() const |
|
round() const |
|
sign() const |
|
Opérateurs
operator !=(right: Vector2) |
|
operator *(right: Transform2D) |
|
operator *(right: Vector2) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator +(right: Vector2) |
|
operator -(right: Vector2) |
|
operator /(right: Vector2) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator <(right: Vector2) |
|
operator <=(right: Vector2) |
|
operator ==(right: Vector2) |
|
operator >(right: Vector2) |
|
operator >=(right: Vector2) |
|
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().
Constantes
ZERO = Vector2(0, 0) 🔗
Le vecteur zéro, un vecteur avec tous ses composants définis 0.
ONE = Vector2(1, 1) 🔗
Le vecteur unitaire, un vecteur avec tous ses composants définis à 1.
INF = Vector2(inf, inf) 🔗
Le vecteur infini, un vecteur avec tous ses composants définit à @GDScript.INF.
LEFT = Vector2(-1, 0) 🔗
Le vecteur unitaire gauche. Représente la direction vers la gauche.
RIGHT = Vector2(1, 0) 🔗
Le vecteur unitaire droit. Représente la direction vers la droite.
UP = Vector2(0, -1) 🔗
Le vecteur unitaire vers le haut. Y représente le bas en 2D, donc ce vecteur pointe vers -Y.
DOWN = Vector2(0, 1) 🔗
Le vecteur unitaire vers le bas. Y représente le bas en 2D, donc ce vecteur pointe vers +Y.
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].
Descriptions des constructeurs
Construit un Vector2 initialisé par défaut avec toutes les composantes définies à 0.
Vector2 Vector2(from: Vector2)
Construit un Vector2 comme copie du Vector2 donné.
Vector2 Vector2(from: Vector2i)
Construit un nouveau Vector2 depuis un Vector2i.
Vector2 Vector2(x: float, y: float)
Construit un nouveau Vector2 depuis les x et y donnés.
Descriptions des méthodes
Renvoie un nouveau vecteur avec tous ses composantes en valeurs absolues (c'est-à-dire toujours positives).
Renvoie l'angle de ce vecteur par rapport à l'axe X positif, ou aussi le vecteur (1,0), en radians.
Par exemple, Vector2.RIGHT.angle() va renvoyer zéro, Vector2.DOWN.angle() va renvoyer PI / 2 (un quart de tour, ou 90 degrés), et Vector2(1,-1).angle() va renvoyer -PI / 4 (un huitième de tour négatif, ou -45 degrés).
Équivalent au résultat de @GlobalScope.atan2() lorsqu'appelé avec y et x.
Illustration de l'angle renvoyé.
float angle_to(to: Vector2) const 🔗
Returns the signed angle to the given vector, in radians. The result ranges from -PI to PI (inclusive).
Illustration of the returned angle.
float angle_to_point(to: Vector2) const 🔗
Returns the signed angle between the X axis and the line from this vector to point to, in radians. The result ranges from -PI to PI (inclusive).
a.angle_to_point(b) is equivalent to (b - a).angle(). See also angle().
Illustration of the returned angle.
Returns this vector's aspect ratio, which is x divided by y.
Vector2 bezier_derivative(control_1: Vector2, control_2: Vector2, end: Vector2, 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.
Vector2 bezier_interpolate(control_1: Vector2, control_2: Vector2, end: Vector2, 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.
Vector2 bounce(n: Vector2) const 🔗
Renvoie le vecteur "réfléchi" d'une ligne définie par la normale n donnée perpendiculaire à la ligne.
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).
Vector2 clamp(min: Vector2, max: Vector2) 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.
Vector2 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.
float cross(with: Vector2) const 🔗
Renvoie l'analogue 2D produit vectoriel de ce vecteur et with.
C'est l'aire signée du parallélogramme formé par les deux vecteurs. Si le second vecteur est dans le sens des aiguilles d'une montre depuis le premier vecteur, le produit vectoriel est l'aire positive. S'il est dans le sens inverse, le produit vectoriel est l'aire négative. Si les deux vecteurs sont parallèle, ceci renvoie zéro, ce qui la rend utile pour tester si deux vecteurs sont parallèles.
Note : Le produit vectoriel n'est pas défini en 2D mathématiquement. Cette méthode intègre les vecteurs 2D dans le plan XY de l'espace 3D et utilise la composante Z du produit vectoriel comme l'analogue.
Vector2 cubic_interpolate(b: Vector2, pre_a: Vector2, post_b: Vector2, 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.
Vector2 cubic_interpolate_in_time(b: Vector2, pre_a: Vector2, post_b: Vector2, 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.
Vector2 direction_to(to: Vector2) const 🔗
Returns the normalized vector pointing from this vector to to.
a.direction_to(b) is equivalent to (b - a).normalized(). See also normalized().
float distance_squared_to(to: Vector2) 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: Vector2) const 🔗
Returns the Euclidean distance between this vector and to.
float dot(with: Vector2) 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).
Vector2 from_angle(angle: float) static 🔗
Crée un Vector2 unitaire tourné de l'angle donné en radians. Ceci équivaut à faire Vector2(cos(angle), sin(angle)) ou Vector2.RIGHT.rotated(angle).
print(Vector2.from_angle(0)) # Affiche (1.0, 0.0)
print(Vector2(1, 0).angle()) # Affiche 0.0, qui est l'angle utilisé ci-dessus.
print(Vector2.from_angle(PI / 2)) # Affiche (0.0, 1.0)
Note : La longueur du Vector2 renvoyé est approximativement 1.0, mais elle n'est pas garantie d'être exactement 1.0 en raison de problèmes de précision flottants. Appelez normalized() sur le Vector2 renvoyé si vous avez besoin d'un vecteur unitaire.
bool is_equal_approx(to: Vector2) 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.
Vector2 lerp(to: Vector2, 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.
Vector2 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.
Vector2 max(with: Vector2) const 🔗
Renvoie le maximum par composante de ceci et with, équivalent à Vector2(maxf(x, with.x), maxf(y, with.y)).
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.
Vector2 maxf(with: float) const 🔗
Renvoie le maximum par composante de ceci et with, équivalent à Vector2(maxf(x, with), maxf(y, with)).
Vector2 min(with: Vector2) const 🔗
Renvoie le minimum par composante de ceci et with, équivalent à Vector2(minf(x, with.x), minf(y, with.y)).
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_Y.
Vector2 minf(with: float) const 🔗
Renvoie le minimum par composante de ceci et with, équivalent à Vector2(minf(x, with), minf(y, with)).
Vector2 move_toward(to: Vector2, 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) 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.
Renvoie un vecteur perpendiculaire, pivoté de 90 degrés dans le sens anti-horaire comparé à l'original, avec la même longueur.
Vector2 posmod(mod: float) const 🔗
Renvoie un vecteur composé du @GlobalScope.fposmod() des composantes de ce vecteur et mod.
Vector2 posmodv(modv: Vector2) const 🔗
Renvoie un vecteur composé du @GlobalScope.fposmod() des composantes du vecteur et des composantes de modv.
Vector2 project(b: Vector2) 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.
Vector2 reflect(line: Vector2) const 🔗
Renvoie le résultat de la réflexion du vecteur par rapport à une ligne définie par le vecteur de direction line donné.
Note : reflect() diffère de ce que les autres moteurs et frameworks appellent reflect(). Dans d'autres moteurs reflect() prends une direction normale qui est une direction perpendiculaire à la ligne. Dans Godot, vous spécifiez la direction de la ligne directement. Voir aussi bounce() qui fait ce que la plupart des moteurs appellent reflect().
Vector2 rotated(angle: float) const 🔗
Renvoie le résultat de la rotation de ce vecteur par angle (en radians). 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.
Vector2 slerp(to: Vector2, 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().
Vector2 slide(n: Vector2) const 🔗
Returns a new vector resulting from sliding this vector along a line 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().
Vector2 snapped(step: Vector2) 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.
Vector2 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: Vector2) 🔗
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.
Vector2 operator *(right: Transform2D) 🔗
Transforme (multiplie) de manière inverse le Vector2 par la matrice de transformation Transform2D 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 Transform2D.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 Transform2D.affine_inverse().
Vector2 operator *(right: Vector2) 🔗
Multiplie chaque composante du Vector2 par les composantes du Vector2 donné.
print(Vector2(10, 20) * Vector2(3, 4)) # Affiche (30.0, 80.0)
Vector2 operator *(right: float) 🔗
Multiplie chaque composante du Vector2 par le flottant float donné.
Vector2 operator *(right: int) 🔗
Multiplie chaque composante du Vector2 par l'entier int donné.
Vector2 operator +(right: Vector2) 🔗
Ajoute chaque composante du Vector2 aux composantes du Vector2 donné.
print(Vector2(10, 20) + Vector2(3, 4)) # Affiche (13.0, 24.0)
Vector2 operator -(right: Vector2) 🔗
Soustrait chaque composante du Vector2 par les composantes du Vector2 donné.
print(Vector2(10, 20) - Vector2(3, 4)) # Affiche (7.0, 16.0)
Vector2 operator /(right: Vector2) 🔗
Divise chaque composante du Vector2 par les composantes du Vector2 donné.
print(Vector2(10, 20) / Vector2(2, 5)) # Affiche (5.0, 4.0)
Vector2 operator /(right: float) 🔗
Divise chaque composante du Vector2 par le flottant float donné.
Vector2 operator /(right: int) 🔗
Divise chaque composante du Vector2 par l'entier int donné.
bool operator <(right: Vector2) 🔗
Compare deux Vector2 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. Cet opérateur est utile pour trier des vecteurs.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas de la même façon que les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être exacts si des NaN sont inclus.
bool operator <=(right: Vector2) 🔗
Compare deux Vector2i 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. Cet opérateur est utile pour trier des vecteurs.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas de la même façon que les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être exacts si des NaN sont inclus.
bool operator ==(right: Vector2) 🔗
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: Vector2) 🔗
Compare deux Vector2 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. Cet opérateur est utile pour trier des vecteurs.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas de la même façon que les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être exacts si des NaN sont inclus.
bool operator >=(right: Vector2) 🔗
Compare deux Vector2 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. Cet opérateur est utile pour trier des vecteurs.
Note : Les vecteurs avec des éléments @GDScript.NAN ne se comportent pas de la même façon que les autres vecteurs. Ainsi, les résultats de cet opérateur peuvent ne pas être exacts si des NaN sont inclus.
float operator [](index: int) 🔗
Accède aux composantes du vecteur par leur index. v[0] est équivalent à v.x et v[1] est équivalent à v.y.
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 Vector2. Revient à écrire Vector2(-v.x, -v.y). 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.