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...
Vector4
Un vecteur 4D utilisant des coordonnés flottantes.
Description
Une structure de 4 éléments qui peut être utilisée pour représenter des coordonnées 4D ou tout autre quadruplet 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 Vector4i pour l'équivalent entier.
Note : Avec des booléens, un Vector4 sera évalué à false s'il est égal à Vector4(0, 0, 0,0). Sinon, un Vector4 sera toujours évalué à true.
Propriétés
|
||
|
||
|
||
|
Constructeurs
Vector4() |
|
Méthodes
abs() const |
|
ceil() const |
|
cubic_interpolate(b: Vector4, pre_a: Vector4, post_b: Vector4, weight: float) const |
|
cubic_interpolate_in_time(b: Vector4, pre_a: Vector4, post_b: Vector4, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const |
|
direction_to(to: Vector4) const |
|
distance_squared_to(to: Vector4) const |
|
distance_to(to: Vector4) const |
|
floor() const |
|
inverse() const |
|
is_equal_approx(to: Vector4) const |
|
is_finite() const |
|
is_normalized() const |
|
is_zero_approx() const |
|
length() const |
|
length_squared() const |
|
max_axis_index() const |
|
min_axis_index() const |
|
normalized() const |
|
round() const |
|
sign() const |
|
Opérateurs
operator !=(right: Vector4) |
|
operator *(right: Projection) |
|
operator *(right: Vector4) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator +(right: Vector4) |
|
operator -(right: Vector4) |
|
operator /(right: Vector4) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator <(right: Vector4) |
|
operator <=(right: Vector4) |
|
operator ==(right: Vector4) |
|
operator >(right: Vector4) |
|
operator >=(right: Vector4) |
|
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().
Axis AXIS_W = 3
La valeur de l'énumération pour l'axe W. Renvoyé par max_axis_index() et min_axis_index().
Constantes
ZERO = Vector4(0, 0, 0, 0) 🔗
Le vecteur zéro, un vecteur avec tous ses composants définis 0.
ONE = Vector4(1, 1, 1, 1) 🔗
Le vecteur unitaire, un vecteur avec tous ses composants définis à 1.
INF = Vector4(inf, inf, inf, inf) 🔗
Le vecteur infini, un vecteur avec tous ses composants définit à @GDScript.INF.
Descriptions des propriétés
La composante W du vecteur. Aussi accessible en utilisant la position d'index [3].
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 Vector4 initialisé par défaut, avec toutes ses composantes définies à 0.
Vector4 Vector4(from: Vector4)
Construit un Vector4i comme copie du Vector4i donné.
Vector4 Vector4(from: Vector4i)
Construit un nouveau Vector4 à partir d'un Vector4i.
Vector4 Vector4(x: float, y: float, z: float, w: float)
Renvoie un Vector4 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).
Renvoie un nouveau vecteur avec tous les composantes arrondies vers le haut (vers +infini).
Vector4 clamp(min: Vector4, max: Vector4) 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.
Vector4 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.
Vector4 cubic_interpolate(b: Vector4, pre_a: Vector4, post_b: Vector4, 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.
Vector4 cubic_interpolate_in_time(b: Vector4, pre_a: Vector4, post_b: Vector4, 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.
Vector4 direction_to(to: Vector4) 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: Vector4) 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: Vector4) const 🔗
Returns the Euclidean distance between this vector and to.
float dot(with: Vector4) const 🔗
Renvoie le produit scalaire de ce vecteur avec with.
Renvoie un nouveau vecteur avec tous les composantes arrondies vers le bas (vers -infini).
Renvoie l'inverse du vecteur. Cela est identique à Vector4( 1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w ).
bool is_equal_approx(to: Vector4) 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.
Vector4 lerp(to: Vector4, 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.
Vector4 max(with: Vector4) const 🔗
Renvoie le maximum par composante de ceci et with, équivalent à Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w,with)).
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.
Vector4 maxf(with: float) const 🔗
Renvoie le minimum par composante de ceci et with, équivalent à Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w,with)).
Vector4 min(with: Vector4) const 🔗
Renvoie le minimum par composante de ceci et with, équivalent à Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z),minf(w,with.w)).
Renvoie l'axe de la valeur la moins importante du vecteur. Voir les constantes AXIS_*. Si tous les composantes sont égales, cette méthode renvoie AXIS_W.
Vector4 minf(with: float) const 🔗
Renvoie le minimum par composante de ceci et with, équivalent à Vector4(minf(x, with), minf(y, with), minf(z, with),minf(w,with)).
Renvoie le résultat de la mise à l'échelle du vecteur à la longueur unité. Équivalent à v / v.length(). Renvoie (0, 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.
Vector4 posmod(mod: float) const 🔗
Renvoie un vecteur composé du @GlobalScope.fposmod() des composantes de ce vecteur et mod.
Vector4 posmodv(modv: Vector4) const 🔗
Renvoie un vecteur composé du @GlobalScope.fposmod() des composantes du vecteur et des composantes de modv.
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.
Vector4 snapped(step: Vector4) 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.
Vector4 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: Vector4) 🔗
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.
Vector4 operator *(right: Projection) 🔗
Transforme (multiplie) le Vector4 par la transposée de la matrice de Projection donnée.
Pour transformer par l'inverse d'une projection, projection.inverse() * vector peut être utilisée à la place. Voir Projection.inverse().
Vector4 operator *(right: Vector4) 🔗
Multiplie chaque composante du Vector4 par les composantes du Vector4 donné.
print(Vector4(10, 20, 30, 40) * Vector4(3, 4, 5, 6)) # Affiche (30.0, 80.0, 150.0, 240.0)
Vector4 operator *(right: float) 🔗
Multiplie chaque composante du Vector4 par le flottant float donné.
print(Vector4(10, 20, 30, 40) * 2) # Affiche (20.0, 40.0, 60.0, 80.0)
Vector4 operator *(right: int) 🔗
Multiplie chaque composante du Vector4 par l'entier int donné.
Vector4 operator +(right: Vector4) 🔗
Ajoute chaque composante du Vector4 aux composantes du Vector4 donné.
print(Vector4(10, 20, 30, 40) + Vector4(3, 4, 5, 6)) # Affiche (13.0, 24.0, 35.0, 46.0)
Vector4 operator -(right: Vector4) 🔗
Sosutrait chaque composante du Vector4 par les composantes du Vector4 donné.
print(Vector4(10, 20, 30, 40) - Vector4(3, 4, 5, 6)) # Affiche (7.0, 16.0, 25.0, 34.0)
Vector4 operator /(right: Vector4) 🔗
Divise chaque composante du Vector4 par les composantes du Vector4 donné.
print(Vector4(10, 20, 30, 40) / Vector4(2, 5, 3, 4)) # Affiche (5.0, 4.0, 10.0, 10.0)
Vector4 operator /(right: float) 🔗
Divise chaque composante du Vector4 par le flottant float donné.
print(Vector4(10, 20, 30, 40) / 2) # Affiche (5.0, 10.0, 15.0, 20.0)
Vector4 operator /(right: int) 🔗
Divise chaque composante du Vector4 par l'entier int donné.
bool operator <(right: Vector4) 🔗
Compare deux Vector4 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, sur les valeurs en Z des deux vecteurs, puis sur les valeurs en W. 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: Vector4) 🔗
Compare deux Vector4 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, sur les valeurs en Z des deux vecteurs, puis sur les valeurs en W. 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: Vector4) 🔗
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: Vector4) 🔗
Compare deux Vector4 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, sur les valeurs en Z des deux vecteurs, puis sur les valeurs en W. 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: Vector4) 🔗
Compare deux Vector4 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, sur les valeurs en Z des deux vecteurs, puis sur les valeurs en W. 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, v[2] est équivalent à v.z, et v[3] est équivalent à v.w.
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 Vector4. Revient à écrire Vector4(-v.x, -v.y,-v.z,-v.w). 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.