Vector3
Un vector 3D que utiliza coordenadas de punto flotante.
Descripción
Estructura de 3 elementos que puede ser usada para representar coordenadas 3D o cualquier otro trío 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 es de 64 bits. Si se necesita una precisión doble, compila el motor con la opción precision=double.
Véase Vector3i para su contraparte entera.
Nota: En un contexto booleano, un Vector3 se evaluará como false si es igual a Vector3(0, 0, 0). De lo contrario, un Vector3 siempre se evaluará como true.
Tutoriales
Propiedades
|
||
|
||
|
Constructores
Vector3() |
|
Métodos
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 |
|
Operadores
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) |
|
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().
Constantes
ZERO = Vector3(0, 0, 0) 🔗
Vector cero, un vector con todos los componentes ajustados a 0.
ONE = Vector3(1, 1, 1) 🔗
Un vector, un vector con todos los componentes ajustados a 1.
INF = Vector3(inf, inf, inf) 🔗
Vector infinito, un vector con todos los componentes ajustados a @GDScript.INF.
LEFT = Vector3(-1, 0, 0) 🔗
Vector de la unidad izquierda. Representa la dirección local de la izquierda y la dirección global del oeste.
RIGHT = Vector3(1, 0, 0) 🔗
Vector de la unidad derecha. Representa la dirección local de la derecha, y la dirección global del este.
UP = Vector3(0, 1, 0) 🔗
Vector de la unidad superior.
DOWN = Vector3(0, -1, 0) 🔗
Vector de la unidad inferior.
FORWARD = Vector3(0, 0, -1) 🔗
Vector unitario hacia adelante. Representa la dirección local de avance y la dirección global del norte. Ten en cuenta que la dirección de avance para las luces, las cámaras, etc. es diferente de los activos 3D como los personajes, que miran hacia la cámara por convención. Utiliza MODEL_FRONT y constantes similares cuando trabaje en el espacio de activos 3D.
BACK = Vector3(0, 0, 1) 🔗
Vector de la unidad trasera. Representa la dirección local de la espalda, y la dirección global del sur.
MODEL_LEFT = Vector3(1, 0, 0) 🔗
Vector unitario que apunta hacia el lado izquierdo de los activos 3D importados.
MODEL_RIGHT = Vector3(-1, 0, 0) 🔗
Vector unitario que apunta hacia el lado derecho de los activos 3D importados.
MODEL_TOP = Vector3(0, 1, 0) 🔗
Vector unitario que apunta hacia el lado superior (arriba) de los activos 3D importados.
MODEL_BOTTOM = Vector3(0, -1, 0) 🔗
Vector unitario que apunta hacia el lado inferior (abajo) de los activos 3D importados.
MODEL_FRONT = Vector3(0, 0, 1) 🔗
Vector unitario que apunta hacia el lado frontal (mirando hacia adelante) de los activos 3D importados.
MODEL_REAR = Vector3(0, 0, -1) 🔗
Vector unitario que apunta hacia el lado trasero (parte posterior) de los activos 3D importados.
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].
El componente Z del vector. También se puede acceder usando la posición del índice [2].
Descripciones de Constructores
Construye un Vector3 inicializado por defecto con todos los componentes establecidos en 0.
Vector3 Vector3(from: Vector3)
Construye un Vector3 como una copia del Vector3 dado.
Vector3 Vector3(from: Vector3i)
Construye un nuevo Vector3 a partir de un Vector3i.
Vector3 Vector3(x: float, y: float, z: float)
Devuelve un Vector3 con los componentes dados.
Descripciones de Métodos
Devuelve un nuevo vector con todos los componentes en valores absolutos (es decir, positivos).
float angle_to(to: Vector3) const 🔗
Devuelve el ángulo mínimo sin signo del vector dado, en radianes.
Vector3 bezier_derivative(control_1: Vector3, control_2: Vector3, end: Vector3, 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.
Vector3 bezier_interpolate(control_1: Vector3, control_2: Vector3, end: Vector3, 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.
Vector3 bounce(n: Vector3) const 🔗
Devuelve el vector "rebotado" de un plano definido por la normal dada n.
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).
Vector3 clamp(min: Vector3, max: Vector3) const 🔗
Devuelve un nuevo vector con todos los componentes limitados entre los componentes de min y max, ejecutando @GlobalScope.clamp() en cada componente.
Vector3 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.
Vector3 cross(with: Vector3) const 🔗
Devuelve el producto vectorial de este vector y with.
Esto devuelve un vector perpendicular tanto a este como a with, que sería el vector normal del plano definido por los dos vectores. Como hay dos de estos vectores, en direcciones opuestas, este método devuelve el vector definido por un sistema de coordenadas a derechas. Si los dos vectores son paralelos, esto devuelve un vector vacío, lo que lo hace útil para probar si dos vectores son paralelos.
Vector3 cubic_interpolate(b: Vector3, pre_a: Vector3, post_b: Vector3, 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.
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 🔗
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.
Vector3 direction_to(to: Vector3) 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: Vector3) 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: Vector3) const 🔗
Devuelve la distancia entre este vector y to.
float dot(with: Vector3) 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).
Devuelve la inversa del vector. Es lo mismo que Vector3(1.0 / v.x, 1.0 / v.y, 1.0 / v.z).
bool is_equal_approx(to: Vector3) 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.
Vector3 lerp(to: Vector3, 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.
Vector3 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.
Vector3 max(with: Vector3) const 🔗
Devuelve el máximo componente a componente de este y with, equivalente a Vector3(maxf(x, with.x), maxf(y, with.y), maxf(z, with.z)).
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.
Vector3 maxf(with: float) const 🔗
Devuelve el máximo componente a componente de este y with, equivalente a Vector3(maxf(x, with), maxf(y, with), maxf(z, with)).
Vector3 min(with: Vector3) const 🔗
Devuelve el mínimo componente a componente de este y with, equivalente a Vector3(minf(x, with.x), minf(y, with.y), minf(z, with.z)).
Devuelve el eje del valor más bajo del vector. Consulta las constantes AXIS_*. Si todos los componentes son iguales, este método devuelve la constante AXIS_Z.
Vector3 minf(with: float) const 🔗
Devuelve el mínimo componente a componente de este y with, equivalente a Vector3(minf(x, with), minf(y, with), minf(z, with)).
Vector3 move_toward(to: Vector3, 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 unitaria. Equivalente a v / v.length(). Devuelve (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.
Vector3 octahedron_decode(uv: Vector2) static 🔗
Devuelve el Vector3 de una forma comprimida octaédrica creada usando octahedron_encode() (almacenado como un Vector2).
Vector2 octahedron_encode() const 🔗
Devuelve la forma codificada en octaedro (oct32) de este Vector3 como un Vector2. Dado que un Vector2 ocupa 1/3 menos de memoria en comparación con Vector3, esta forma de compresión se puede utilizar para pasar mayores cantidades de normalized() Vector3s sin aumentar los requisitos de almacenamiento o memoria. Véase también octahedron_decode().
Nota: octahedron_encode() sólo se puede utilizar para vectores normalized(). octahedron_encode() no comprueba si este Vector3 está normalizado y devolverá un valor que no se descomprime al valor original si el Vector3 no está normalizado.
Nota: La compresión octaédrica es pérdida, aunque las diferencias visuales rara vez son perceptibles en escenarios del mundo real.
Basis outer(with: Vector3) const 🔗
Devuelve el producto exterior con with.
Vector3 posmod(mod: float) const 🔗
Devuelve un vector compuesto por el @GlobalScope.fposmod() de los componentes de este vector y mod.
Vector3 posmodv(modv: Vector3) const 🔗
Devuelve un vector compuesto por el @GlobalScope.fposmod() de los componentes de este vector y los componentes de modv.
Vector3 project(b: Vector3) 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.
Vector3 reflect(n: Vector3) const 🔗
Devuelve el resultado de reflejar el vector a través de un plano definido por el vector normal dado n.
Nota: reflect() difiere de lo que otros motores y frameworks llaman reflect(). En otros motores, reflect() devuelve el resultado del vector reflejado por el plano dado. La reflexión, por tanto, pasa a través de la normal dada. Mientras que en Godot la reflexión pasa a través del plano y se puede pensar como un rebote en la normal. Véase también bounce() que hace lo que la mayoría de los motores llaman reflect().
Vector3 rotated(axis: Vector3, angle: float) const 🔗
Devuelve el resultado de rotar este vector alrededor de un eje dado por angle (en radianes). El eje debe ser un vector normalizado. 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.
float signed_angle_to(to: Vector3, axis: Vector3) const 🔗
Devuelve el ángulo con signo al vector dado, en radianes. El signo del ángulo es positivo en el sentido contrario a las agujas del reloj y negativo en el sentido de las agujas del reloj cuando se ve desde el lado especificado por el axis.
Vector3 slerp(to: Vector3, 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().
Vector3 slide(n: Vector3) const 🔗
Devuelve un nuevo vector resultante de deslizar este vector a lo largo de un plano con 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().
Vector3 snapped(step: Vector3) 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.
Vector3 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: Vector3) 🔗
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.
Vector3 operator *(right: Basis) 🔗
Transforma inversamente (multiplica) el Vector3 por la matriz Basis dada, bajo el supuesto de que la base es ortonormal (es decir, la rotación/reflexión está bien, la escala/sesgo no lo está).
vector * basis es equivalente a basis.transposed() * vector. Véase Basis.transposed().
Para transformar por la inversa de una base no ortonormal (por ejemplo, con escalado) se puede utilizar basis.inverse() * vector en su lugar. Véase Basis.inverse().
Vector3 operator *(right: Quaternion) 🔗
Transforma inversamente (multiplica) el Vector3 por el Quaternion dado.
vector * quaternion es equivalente a quaternion.inverse() * vector. Véase Quaternion.inverse().
Vector3 operator *(right: Transform3D) 🔗
Transforma inversamente (multiplica) el Vector3 por la matriz de transformación Transform3D dada, bajo el supuesto de que la base de transformación es ortonormal (es decir, la rotación/reflexión está bien, la escala/sesgo no lo está).
vector * transform es equivalente a transform.inverse() * vector. Véase Transform3D.inverse().
Para transformar por la inversa de una transformación afín (por ejemplo, con escalado) se puede utilizar transform.affine_inverse() * vector en su lugar. Véase Transform3D.affine_inverse().
Vector3 operator *(right: Vector3) 🔗
Multiplica cada componente de Vector3 por los componentes del Vector3 dado.
print(Vector3(10, 20, 30) * Vector3(3, 4, 5)) # Imprime (30.0, 80.0, 150.0)
Vector3 operator *(right: float) 🔗
Multiplica cada componente del Vector3 por el float dado.
Vector3 operator *(right: int) 🔗
Multiplica cada componente del Vector3 por el int dado.
Vector3 operator +(right: Vector3) 🔗
Suma cada componente de Vector3 con los componentes del Vector3 dado.
print(Vector3(10, 20, 30) + Vector3(3, 4, 5)) # Imprime (13.0, 24.0, 35.0)
Vector3 operator -(right: Vector3) 🔗
Resta cada componente de Vector3 por los componentes del Vector3 dado.
print(Vector3(10, 20, 30) - Vector3(3, 4, 5)) # Imprime (7.0, 16.0, 25.0)
Vector3 operator /(right: Vector3) 🔗
Divide cada componente de Vector3 entre los componentes del Vector3 dado.
print(Vector3(10, 20, 30) / Vector3(2, 5, 3)) # Imprime (5.0, 4.0, 10.0)
Vector3 operator /(right: float) 🔗
Divide cada componente del Vector3 por el float dado.
Vector3 operator /(right: int) 🔗
Divide cada componente del Vector3 por el int dado.
bool operator <(right: Vector3) 🔗
Compara dos vectores Vector3 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, y luego con los valores Z. 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: Vector3) 🔗
Compara dos vectores Vector3 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, y luego con los valores Z. 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: Vector3) 🔗
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: Vector3) 🔗
Compara dos vectores Vector3 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, y luego con los valores Z. 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: Vector3) 🔗
Compara dos vectores Vector3 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, y luego con los valores Z. 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, v[1] es equivalente a v.y, y v[2] es equivalente a v.z.
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 Vector3. Esto es lo mismo que escribir Vector3(-v.x, -v.y, -v.z). Esta operación invierte la dirección del vector manteniendo la misma magnitud. Con floats, el número cero puede ser positivo o negativo.