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 vector 4D que utiliza coordenadas de punto flotante.
Descripción
Una estructura de 4 elementos que se puede usar para representar coordenadas 4D o cualquier otro cuarteto de valores numéricos.
Utiliza coordenadas de punto flotante. De forma predeterminada, estos valores de punto flotante utilizan una precisión de 32 bits, a diferencia de float, que siempre tiene 64 bits. Si se necesita precisión doble, compila el motor con la opción precision=double.
Véase Vector4i para su contraparte entera.
Nota: En un contexto booleano, un Vector4 se evaluará como false si es igual a Vector4(0, 0, 0, 0). De lo contrario, un Vector4 siempre se evaluará como true.
Propiedades
|
||
|
||
|
||
|
Constructores
Vector4() |
|
Métodos
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 |
|
Operadores
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) |
|
Enumeraciones
enum Axis: 🔗
Axis AXIS_X = 0
Valor enumerado para el eje X. Devuelto por max_axis_index() y min_axis_index().
Axis AXIS_Y = 1
Valor enumerado para el eje Y. Devuelto por max_axis_index() y min_axis_index().
Axis AXIS_Z = 2
Valor enumerado para el eje Z. Devuelto por max_axis_index() y min_axis_index().
Axis AXIS_W = 3
Valor enumerado para el eje W. Devuelto por max_axis_index() y min_axis_index().
Constantes
ZERO = Vector4(0, 0, 0, 0) 🔗
Vector cero, un vector con todos los componentes ajustados a 0.
ONE = Vector4(1, 1, 1, 1) 🔗
Un vector, un vector con todos los componentes ajustados a 1.
INF = Vector4(inf, inf, inf, inf) 🔗
Vector infinito, un vector con todos los componentes ajustados a @GDScript.INF.
Descripciones de Propiedades
El componente W del vector. También se puede acceder utilizando la posición del índice [3].
El componente X del vector. También se puede acceder utilizando la posición del índice [0].
El componente Y del vector. También se puede acceder usando la posición del índice [1].
El componente Z del vector. También se puede acceder usando la posición del índice [2].
Descripciones de Constructores
Construye un Vector4 inicializado por defecto con todos los componentes establecidos a 0.
Vector4 Vector4(from: Vector4)
Construye un Vector4 como copia del Vector4 dado.
Vector4 Vector4(from: Vector4i)
Construye un nuevo Vector4 a partir del Vector4i dado.
Vector4 Vector4(x: float, y: float, z: float, w: float)
Devuelve un Vector4 con los componentes dados.
Descripciones de Métodos
Devuelve un nuevo vector con todos los componentes en valores absolutos (es decir, positivos).
Devuelve un nuevo vector con todos los componentes redondeados hacia arriba (hacia el infinito positivo).
Vector4 clamp(min: Vector4, max: Vector4) const 🔗
Devuelve un nuevo vector con todos los componentes limitados entre los componentes de min y max, ejecutando @GlobalScope.clamp() en cada componente.
Vector4 clampf(min: float, max: float) const 🔗
Devuelve un nuevo vector con todos los componentes restringidos entre min y max, ejecutando @GlobalScope.clamp() en cada componente.
Vector4 cubic_interpolate(b: Vector4, pre_a: Vector4, post_b: Vector4, weight: float) const 🔗
Realiza una interpolación cúbica entre este vector y b usando pre_a y post_b como manejadores, y devuelve el resultado en la posición weight. weight está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
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 🔗
Realiza una interpolación cúbica entre este vector y b usando pre_a y post_b como manejadores, y devuelve el resultado en la posición weight. weight está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
Puede realizar una interpolación más suave que cubic_interpolate() por los valores de tiempo.
Vector4 direction_to(to: Vector4) const 🔗
Devuelve el vector normalizado que apunta desde este vector a to. Esto es equivalente a usar (to - self).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 🔗
Devuelve la distancia euclidiana entre este vector y to.
float dot(with: Vector4) const 🔗
Devuelve el producto escalar de este vector y with.
Devuelve un nuevo vector con todos los componentes redondeados hacia abajo (hacia el infinito negativo).
Devuelve el inverso del vector. Esto es lo mismo que Vector4(1.0 / v.x, 1.0 / v.y, 1.0 / v.z, 1.0 / v.w).
bool is_equal_approx(to: Vector4) const 🔗
Devuelve true si este vector y to son aproximadamente iguales, ejecutando @GlobalScope.is_equal_approx() en cada componente.
Devuelve true si este vector es finito, llamando a @GlobalScope.is_finite() en cada componente.
Devuelve true si el vector está normalizado, es decir, si su longitud es aproximadamente igual a 1.
Devuelve true si los valores de este vector son aproximadamente cero, ejecutando @GlobalScope.is_zero_approx() en cada componente.
Este método es más rápido que usar is_equal_approx() con un valor como un vector cero.
Devuelve la longitud (magnitud) de este vector.
float length_squared() const 🔗
Devuelve la longitud cuadrada (magnitud cuadrada) de este vector.
Este método funciona más rápido que el length(), por lo que es preferible si necesitas comparar vectores o necesitas la distancia al cuadrado para alguna fórmula.
Vector4 lerp(to: Vector4, weight: float) const 🔗
Devuelve el resultado de la interpolación lineal entre este vector y to por la cantidad weight. weight está en el rango de 0.0 a 1.0, representando la cantidad de interpolación.
Vector4 max(with: Vector4) const 🔗
Devuelve el máximo componente a componente de este y with, equivalente a Vector4(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z), maxf(w, with.w)).
Devuelve el eje del valor más alto del vector. Véanse las constantes AXIS_*. Si todos los componentes son iguales, este método devuelve AXIS_X.
Vector4 maxf(with: float) const 🔗
Devuelve el máximo componente a componente de este y with, equivalente a Vector4(maxf(x, with), maxf(y, with), maxf(z, with), maxf(w, with)).
Vector4 min(with: Vector4) const 🔗
Devuelve el mínimo componente a componente de este y with, equivalente a Vector4(minf(x, with.x), minf(y, with.y), minf(z, with.z), minf(w, with.w)).
Devuelve el eje del valor más bajo del vector. Ver las constantes AXIS_*. Si todos los componentes son iguales, este método devuelve AXIS_W.
Vector4 minf(with: float) const 🔗
Devuelve el mínimo componente a componente de este y with, equivalente a Vector4(minf(x, with), minf(y, with), minf(z, with), minf(w, with)).
Devuelve el resultado de escalar el vector a longitud unitaria. Equivalente a v / v.length(). Devuelve (0, 0, 0, 0) si v.length() == 0. Véase también is_normalized().
Nota: Esta función puede devolver valores incorrectos si la longitud del vector de entrada es cercana a cero.
Vector4 posmod(mod: float) const 🔗
Devuelve un vector compuesto por el @GlobalScope.fposmod() de los componentes de este vector y mod.
Vector4 posmodv(modv: Vector4) const 🔗
Devuelve un vector compuesto por el @GlobalScope.fposmod() de los componentes de este vector y los componentes de modv.
Devuelve un nuevo vector con todos los componentes redondeados al entero más cercano, con los casos intermedios redondeados desde cero.
Devuelve un nuevo vector con cada componente establecido a 1.0 si es positivo, -1.0 si es negativo y 0.0 si es cero. El resultado es idéntico a llamar a @GlobalScope.sign() en cada componente.
Vector4 snapped(step: Vector4) const 🔗
Devuelve un nuevo vector con cada componente ajustado al múltiplo más cercano del componente correspondiente en step. Esto también se puede usar para redondear los componentes a un número arbitrario de decimales.
Vector4 snappedf(step: float) const 🔗
Devuelve un nuevo vector con cada componente ajustado al múltiplo más cercano de step. Esto también se puede usar para redondear los componentes a un número arbitrario de decimales.
Descripciones de Operadores
bool operator !=(right: Vector4) 🔗
Devuelve true si los vectores no son iguales.
Nota: Debido a errores de precisión en punto flotante, considera usar is_equal_approx() en su lugar, ya que es más fiable.
Nota: Los vectores con elementos @GDScript.NAN no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador podrían no ser precisos si se incluyen NaN.
Vector4 operator *(right: Projection) 🔗
Transforma (multiplica) el Vector4 por la transpuesta de la matriz Projection dada.
Para transformar por la inversa de una proyección, se puede usar en su lugar projection.inverse() * vector. Véase Projection.inverse().
Vector4 operator *(right: Vector4) 🔗
Multiplica cada componente del Vector4 por los componentes del Vector4 dado.
print(Vector4(10, 20, 30, 40) * Vector4(3, 4, 5, 6)) # Imprime (30.0, 80.0, 150.0, 240.0)
Vector4 operator *(right: float) 🔗
Multiplica cada componente del Vector4 por el float dado.
print(Vector4(10, 20, 30, 40) * 2) # Imprime (20.0, 40.0, 60.0, 80.0)
Vector4 operator *(right: int) 🔗
Multiplica cada componente del Vector4 por el int dado.
Vector4 operator +(right: Vector4) 🔗
Suma cada componente del Vector4 con los componentes del Vector4 dado.
print(Vector4(10, 20, 30, 40) + Vector4(3, 4, 5, 6)) # Imprime (13.0, 24.0, 35.0, 46.0)
Vector4 operator -(right: Vector4) 🔗
Resta cada componente del Vector4 por los componentes del Vector4 dado.
print(Vector4(10, 20, 30, 40) - Vector4(3, 4, 5, 6)) # Imprime (7.0, 16.0, 25.0, 34.0)
Vector4 operator /(right: Vector4) 🔗
Divide cada componente del Vector4 por los componentes del Vector4 dado.
print(Vector4(10, 20, 30, 40) / Vector4(2, 5, 3, 4)) # Imprime (5.0, 4.0, 10.0, 10.0)
Vector4 operator /(right: float) 🔗
Divide cada componente del Vector4 por el float dado.
print(Vector4(10, 20, 30, 40) / 2) # Imprime (5.0, 10.0, 15.0, 20.0)
Vector4 operator /(right: int) 🔗
Divide cada componente del Vector4 por el int dado.
bool operator <(right: Vector4) 🔗
Compara dos vectores Vector4 comprobando primero si el valor X del vector izquierdo es menor que el valor X del vector right. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores, los valores Z de los dos vectores, y luego con los valores W. Este operador es útil para ordenar vectores.
Nota: Los vectores con elementos @GDScript.NAN no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaNs.
bool operator <=(right: Vector4) 🔗
Compara dos vectores Vector4 comprobando primero si el valor X del vector izquierdo es menor o igual que el valor X del vector right. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores, los valores Z de los dos vectores, y luego con los valores W. Este operador es útil para ordenar vectores.
Nota: Los vectores con elementos @GDScript.NAN no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaNs.
bool operator ==(right: Vector4) 🔗
Devuelve true si los vectores son exactamente iguales.
Nota: Debido a errores de precisión en punto flotante, considera usar is_equal_approx() en su lugar, ya que es más fiable.
Nota: Los vectores con elementos @GDScript.NAN no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador podrían no ser precisos si se incluyen NaN.
bool operator >(right: Vector4) 🔗
Compara dos vectores Vector4 comprobando primero si el valor X del vector izquierdo es mayor que el valor X del vector right. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores, los valores Z de los dos vectores, y luego con los valores W. Este operador es útil para ordenar vectores.
Nota: Los vectores con elementos @GDScript.NAN no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaNs.
bool operator >=(right: Vector4) 🔗
Compara dos vectores Vector4 comprobando primero si el valor X del vector izquierdo es mayor o igual que el valor X del vector right. Si los valores X son exactamente iguales, entonces repite esta comprobación con los valores Y de los dos vectores, los valores Z de los dos vectores, y luego con los valores W. Este operador es útil para ordenar vectores.
Nota: Los vectores con elementos @GDScript.NAN no se comportan igual que otros vectores. Por lo tanto, los resultados de este operador pueden no ser precisos si se incluyen NaNs.
float operator [](index: int) 🔗
Accede a los componentes del vector usando su index. v[0] es equivalente a v.x, v[1] es equivalente a v.y, v[2] es equivalente a v.z, y v[3] es equivalente a v.w.
Devuelve el mismo valor como si el + no estuviera ahí. El + unario no hace nada, pero a veces puede hacer que tu código sea más legible.
Devuelve el valor negativo del Vector4. Esto es lo mismo que escribir Vector4(-v.x, -v.y, -v.z, -v.w). Esta operación invierte la dirección del vector manteniendo la misma magnitud. Con los floats, el número cero puede ser tanto positivo como negativo.