Vector2
Un vector 2D que utiliza coordenadas de punto flotante.
Descripción
Estructura de 2 elementos que se puede usar para representar coordenadas 2D o cualquier otro par 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 una precisión doble, compila el motor con la opción precision=double.
Véase Vector2i para su contraparte entera.
Nota: En un contexto booleano, un Vector2 se evaluará como false si es igual a Vector2(0, 0). De lo contrario, un Vector2 siempre se evaluará como true.
Tutoriales
Propiedades
|
||
|
Constructores
Vector2() |
|
Métodos
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 |
|
Operadores
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) |
|
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().
Constantes
ZERO = Vector2(0, 0) 🔗
Vector cero, un vector con todos los componentes ajustados a 0.
ONE = Vector2(1, 1) 🔗
Un vector, un vector con todos los componentes ajustados a 1.
INF = Vector2(inf, inf) 🔗
Vector infinito, un vector con todos los componentes ajustados a @GDScript.INF.
LEFT = Vector2(-1, 0) 🔗
Vector de la unidad izquierda. Representa la dirección de la izquierda.
RIGHT = Vector2(1, 0) 🔗
Vector de la unidad derecha. Representa la dirección de la derecha.
UP = Vector2(0, -1) 🔗
Vector de la unidad superior. Y está abajo en 2D, por lo que este vector apunta -Y.
DOWN = Vector2(0, 1) 🔗
Vector de la unidad de descenso. Y está abajo en 2D, así que este vector apunta a +Y.
Descripciones de Propiedades
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].
Descripciones de Constructores
Construye un Vector2 inicializado por defecto con todos sus componentes a 0.
Vector2 Vector2(from: Vector2)
Construye un Vector2 como una copia del Vector2 dado.
Vector2 Vector2(from: Vector2i)
Construye un nuevo Vector2 a partir de Vector2i.
Vector2 Vector2(x: float, y: float)
Construye un nuevo Vector2 a partir de los x y y dados.
Descripciones de Métodos
Devuelve un nuevo vector con todos los componentes en valores absolutos (es decir, positivos).
Devuelve el ángulo de este vector con respecto al eje X positivo, o vector (1, 0), en radianes.
Por ejemplo, Vector2.RIGHT.angle() devolverá cero, Vector2.DOWN.angle() devolverá PI / 2 (un cuarto de vuelta, o 90 grados), y Vector2(1, -1).angle() devolverá -PI / 4 (un octavo de vuelta negativo, o -45 grados).
Ilustración del ángulo devuelto.
Equivalente al resultado de @GlobalScope.atan2() cuando se llama con el y e x del vector como parámetros: atan2(y, x).
float angle_to(to: Vector2) const 🔗
Devuelve el ángulo con signo al vector dado, en radianes.
Ilustración del ángulo devuelto.
float angle_to_point(to: Vector2) const 🔗
Devuelve el ángulo entre la línea que conecta los dos puntos y el eje X, en radianes.
a.angle_to_point(b) es equivalente a hacer (b - a).angle().
Ilustración del ángulo devuelto.
Devuelve la relación de aspecto de este vector, la relación de x a y.
Vector2 bezier_derivative(control_1: Vector2, control_2: Vector2, end: Vector2, t: float) const 🔗
Devuelve la derivada en el t dado en la curva de Bézier definida por este vector y los puntos control_1, control_2 y end dados.
Vector2 bezier_interpolate(control_1: Vector2, control_2: Vector2, end: Vector2, t: float) const 🔗
Devuelve el punto en el t dado en la curva de Bézier definida por este vector y los puntos control_1, control_2 y end dados.
Vector2 bounce(n: Vector2) const 🔗
Devuelve el vector "rebotado" de una línea definida por la normal n dada perpendicular a la línea.
Nota: bounce() realiza la operación que la mayoría de los motores y frameworks llaman reflect().
Devuelve un nuevo vector con todos los componentes redondeados hacia arriba (hacia el infinito positivo).
Vector2 clamp(min: Vector2, max: Vector2) const 🔗
Devuelve un nuevo vector con todos los componentes limitados entre los componentes de min y max, ejecutando @GlobalScope.clamp() en cada componente.
Vector2 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.
float cross(with: Vector2) const 🔗
Devuelve el análogo 2D del producto cruz para este vector y with.
Esta es el área con signo del paralelogramo formado por los dos vectores. Si el segundo vector está en el sentido de las agujas del reloj desde el primer vector, entonces el producto cruz es el área positiva. Si es en sentido contrario a las agujas del reloj, el producto cruz es el área negativa. Si los dos vectores son paralelos, esto devuelve cero, lo que lo hace útil para probar si dos vectores son paralelos.
Nota: El producto cruz no se define en 2D matemáticamente. Este método incrusta los vectores 2D en el plano XY del espacio 3D y utiliza el componente Z de su producto cruz como análogo.
Vector2 cubic_interpolate(b: Vector2, pre_a: Vector2, post_b: Vector2, 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.
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 🔗
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.
Vector2 direction_to(to: Vector2) 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: Vector2) const 🔗
Devuelve la distancia al cuadrado entre este vector y to.
Este método se ejecuta más rápido que distance_to(), así que es preferible si necesitas comparar vectores o necesitas la distancia al cuadrado para alguna fórmula.
float distance_to(to: Vector2) const 🔗
Devuelve la distancia entre este vector y to.
float dot(with: Vector2) const 🔗
Devuelve el producto escalar de este vector y with. Esto puede ser usado para comparar el ángulo entre dos vectores. Por ejemplo, esto puede ser usado para determinar si un enemigo está de cara al jugador.
El producto escalar será 0 para un ángulo recto (90 grados), mayor que 0 para ángulos más estrechos que 90 grados y menor que 0 para ángulos más anchos que 90 grados.
Cuando se utilizan vectores unitarios (normalizados), el resultado siempre estará entre -1.0 (ángulo de 180 grados) cuando los vectores estén orientados en direcciones opuestas, y 1.0 (ángulo de 0 grados) cuando los vectores estén alineados.
Nota: a.dot(b) es equivalente a b.dot(a).
Devuelve un nuevo vector con todos los componentes redondeados hacia abajo (hacia el infinito negativo).
Vector2 from_angle(angle: float) static 🔗
Crea un Vector2 rotado al angle dado en radianes. Esto es equivalente a hacer Vector2(cos(angle), sin(angle)) o Vector2.RIGHT.rotated(angle).
print(Vector2.from_angle(0)) # Imprime (1.0, 0.0)
print(Vector2(1, 0).angle()) # Imprime 0.0, que es el ángulo usado arriba.
print(Vector2.from_angle(PI / 2)) # Imprime (0.0, 1.0)
Nota: La longitud del Vector2 devuelto es aproximadamente 1.0, pero no se garantiza que sea exactamente 1.0 debido a problemas de precisión de punto flotante. Llama a normalized() en el Vector2 devuelto si requieres un vector unitario.
bool is_equal_approx(to: Vector2) 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.
Vector2 lerp(to: Vector2, 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.
Vector2 limit_length(length: float = 1.0) const 🔗
Devuelve el vector con una longitud máxima limitando su longitud a length. Si el vector no es finito, el resultado no está definido.
Vector2 max(with: Vector2) const 🔗
Devuelve el máximo componente a componente de este y with, equivalente a Vector2(maxf(x, with.x), maxf(y, with.y)).
Devuelve el eje del valor más alto del vector. Consulta las constantes AXIS_*. Si todos los componentes son iguales, este método devuelve AXIS_X.
Vector2 maxf(with: float) const 🔗
Devuelve el máximo componente a componente de este y with, equivalente a Vector2(maxf(x, with), maxf(y, with)).
Vector2 min(with: Vector2) const 🔗
Devuelve el mínimo componente a componente de este y with, equivalente a Vector2(minf(x, with.x), minf(y, with.y)).
Devuelve el eje del valor más bajo del vector. Consulta las constantes AXIS_*. Si todos los componentes son iguales, este método devuelve AXIS_Y.
Vector2 minf(with: float) const 🔗
Devuelve el mínimo componente a componente de este y with, equivalente a Vector2(minf(x, with), minf(y, with)).
Vector2 move_toward(to: Vector2, delta: float) const 🔗
Devuelve un nuevo vector movido hacia to por la cantidad fija de delta. No pasará del valor final.
Devuelve el resultado de escalar el vector a la longitud de la unidad. Equivalente a v / v.length(). Devuelve (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.
Devuelve un vector perpendicular girado 90 grados en sentido contrario a las agujas del reloj en comparación con el original, con la misma longitud.
Vector2 posmod(mod: float) const 🔗
Devuelve un vector compuesto por el @GlobalScope.fposmod() de los componentes de este vector y mod.
Vector2 posmodv(modv: Vector2) const 🔗
Devuelve un vector compuesto por el @GlobalScope.fposmod() de los componentes de este vector y los componentes de modv.
Vector2 project(b: Vector2) const 🔗
Devuelve un nuevo vector resultante de proyectar este vector sobre el vector b dado. El nuevo vector resultante es paralelo a b. Ver también slide().
Nota: Si el vector b es un vector cero, los componentes del nuevo vector resultante serán @GDScript.NAN.
Vector2 reflect(line: Vector2) const 🔗
Devuelve el resultado de reflejar el vector desde una línea definida por el vector de dirección line dado.
Nota: reflect() difiere de lo que otros motores y frameworks llaman reflect(). En otros motores, reflect() toma una dirección normal que es una dirección perpendicular a la línea. En Godot, se especifica la dirección de la línea directamente. Véase también bounce() que hace lo que la mayoría de los motores llaman reflect().
Vector2 rotated(angle: float) const 🔗
Devuelve el resultado de rotar este vector por angle (en radianes). Véase también @GlobalScope.deg_to_rad().
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.
Vector2 slerp(to: Vector2, weight: float) const 🔗
Devuelve el resultado de la interpolación lineal esférica 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.
Este método también gestiona la interpolación de las longitudes si los vectores de entrada tienen longitudes diferentes. Para el caso especial de que uno o ambos vectores de entrada tengan longitud cero, este método se comporta como lerp().
Vector2 slide(n: Vector2) const 🔗
Devuelve un nuevo vector resultante de deslizar este vector a lo largo de una línea con la normal n. El nuevo vector resultante es perpendicular a n, y es equivalente a este vector menos su proyección sobre n. Véase también project().
Nota: El vector n debe ser normalizado. Véase también normalized().
Vector2 snapped(step: Vector2) 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.
Vector2 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: Vector2) 🔗
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.
Vector2 operator *(right: Transform2D) 🔗
Transforma inversamente (multiplica) el Vector2 por la matriz de transformación Transform2D dada, bajo el supuesto de que la base de la transformación es ortonormal (es decir, la rotación/reflexión está bien, el escalado/sesgo no lo está).
vector * transform es equivalente a transform.inverse() * vector. Véase Transform2D.inverse().
Para transformar por la inversa de una transformación afín (por ejemplo, con escalado) se puede usar transform.affine_inverse() * vector en su lugar. Véase Transform2D.affine_inverse().
Vector2 operator *(right: Vector2) 🔗
Multiplica cada componente del Vector2 por los componentes del Vector2 dado.
print(Vector2(10, 20) * Vector2(3, 4)) # Imprime (30.0, 80.0)
Vector2 operator *(right: float) 🔗
Multiplica cada componente del Vector2 por el float dado.
Vector2 operator *(right: int) 🔗
Multiplica cada componente del Vector2 por el int dado.
Vector2 operator +(right: Vector2) 🔗
Suma cada componente de Vector2 con los componentes del Vector2 dado.
print(Vector2(10, 20) + Vector2(3, 4)) # Imprime (13.0, 24.0)
Vector2 operator -(right: Vector2) 🔗
Resta cada componente de Vector2 por los componentes del Vector2 dado.
print(Vector2(10, 20) - Vector2(3, 4)) # Imprime (7.0, 16.0)
Vector2 operator /(right: Vector2) 🔗
Divide cada componente de Vector2 entre los componentes del Vector2 dado.
print(Vector2(10, 20) / Vector2(2, 5)) # Imprime (5.0, 4.0)
Vector2 operator /(right: float) 🔗
Divide cada componente del Vector2 por el float dado.
Vector2 operator /(right: int) 🔗
Divide cada componente del Vector2 por el int dado.
bool operator <(right: Vector2) 🔗
Compara dos vectores Vector2 comprobando primero si el valor X del vector de la izquierda 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. 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 NaN.
bool operator <=(right: Vector2) 🔗
Compara dos vectores Vector2 comprobando primero si el valor X del vector de la izquierda 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. 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 NaN.
bool operator ==(right: Vector2) 🔗
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: Vector2) 🔗
Compara dos vectores Vector2 comprobando primero si el valor X del vector de la izquierda 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. 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 NaN.
bool operator >=(right: Vector2) 🔗
Compara dos vectores Vector2 comprobando primero si el valor X del vector de la izquierda 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. 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 NaN.
float operator [](index: int) 🔗
Accede a los componentes del vector utilizando su index. v[0] es equivalente a v.x, y v[1] es equivalente a v.y.
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 Vector2. Esto es lo mismo que escribir Vector2(-v.x, -v.y). Esta operación invierte la dirección del vector manteniendo la misma magnitud. Con los floats, el número cero puede ser positivo o negativo.