Quaternion
Un cuaternión unitario utilizado para representar rotaciones 3D.
Descripción
The Quaternion built-in Variant type is a 4D data structure that represents rotation in the form of a Hamilton convention quaternion. Compared to the Basis type which can store both rotation and scale, quaternions can only store rotation.
A Quaternion is composed by 4 floating-point components: w, x, y, and z. These components are very compact in memory, and because of this some operations are more efficient and less likely to cause floating-point errors. Methods such as get_angle(), get_axis(), and slerp() are faster than their Basis counterparts.
For a great introduction to quaternions, see this video by 3Blue1Brown. You do not need to know the math behind quaternions, as Godot provides several helper methods that handle it for you. These include slerp() and spherical_cubic_interpolate(), as well as the * operator.
Note: Quaternions must be normalized before being used for rotation (see normalized()).
Note: Similarly to Vector2 and Vector3, the components of a quaternion use 32-bit precision by default, unlike float which is always 64-bit. If double precision is needed, compile the engine with the option precision=double.
Nota
Hay diferencias notables cuando usa esta API con C#. Véase Diferencias de la API de C# con GDScript para más información.
Tutoriales
Propiedades
|
||
|
||
|
||
|
Constructores
Quaternion(from: Quaternion) |
|
Quaternion(arc_from: Vector3, arc_to: Vector3) |
|
Quaternion(axis: Vector3, angle: float) |
|
Quaternion(from: Basis) |
|
Quaternion(x: float, y: float, z: float, w: float) |
Métodos
angle_to(to: Quaternion) const |
|
dot(with: Quaternion) const |
|
exp() const |
|
from_euler(euler: Vector3) static |
|
get_angle() const |
|
get_axis() const |
|
inverse() const |
|
is_equal_approx(to: Quaternion) const |
|
is_finite() const |
|
is_normalized() const |
|
length() const |
|
length_squared() const |
|
log() const |
|
normalized() const |
|
slerp(to: Quaternion, weight: float) const |
|
slerpni(to: Quaternion, weight: float) const |
|
spherical_cubic_interpolate(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, weight: float) const |
|
spherical_cubic_interpolate_in_time(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const |
Operadores
operator !=(right: Quaternion) |
|
operator *(right: Quaternion) |
|
operator *(right: Vector3) |
|
operator *(right: float) |
|
operator *(right: int) |
|
operator +(right: Quaternion) |
|
operator -(right: Quaternion) |
|
operator /(right: float) |
|
operator /(right: int) |
|
operator ==(right: Quaternion) |
|
operator [](index: int) |
|
Constantes
IDENTITY = Quaternion(0, 0, 0, 1) 🔗
El cuaternión identidad, que no representa rotación. Tiene la misma rotación que Basis.IDENTITY.
Si un Vector3 se rota (multiplica) por este cuaternión, no cambia.
Nota: En GDScript, esta constante es equivalente a crear un Quaternion sin argumentos. Puede usarse para hacer tu código más claro y por consistencia con C#.
Descripciones de Propiedades
Componente W del cuaternión. Esta es la parte "real".
Nota: Los componentes de un cuaternión normalmente no deben ser manipulados directamente.
Componente X del cuaternión. Este es el valor a lo largo del eje "imaginario" i.
Nota: Los componentes de un cuaternión normalmente no deben ser manipulados directamente.
Componente Y del cuaternión. Este es el valor a lo largo del eje "imaginario" j.
Nota: Los componentes de un cuaternión normalmente no deben ser manipulados directamente.
Componente Z del cuaternión. Este es el valor a lo largo del eje "imaginario" k.
Nota: Los componentes de un cuaternión normalmente no deben ser manipulados directamente.
Descripciones de Constructores
Quaternion Quaternion() 🔗
Construye un Quaternion idéntico a IDENTITY.
Nota: En C#, esto construye un Quaternion con todos sus componentes establecidos en 0.0.
Quaternion Quaternion(from: Quaternion)
Construye un Quaternion como copia del Quaternion dado.
Quaternion Quaternion(arc_from: Vector3, arc_to: Vector3)
Construye un Quaternion que representa el arco más corto entre arc_from y arc_to. Estos pueden imaginarse como dos puntos que se intersecan en la superficie de una esfera, con un radio de 1.0.
Quaternion Quaternion(axis: Vector3, angle: float)
Construye un Quaternion que representa la rotación alrededor del axis por el angle dado, en radianes. El eje debe ser un vector normalizado.
Quaternion Quaternion(from: Basis)
Construye un Quaternion a partir de la Basis de rotación dada.
Este constructor es más rápido que Basis.get_rotation_quaternion(), pero la base dada debe ser ortonormalizada (véase Basis.orthonormalized()). De lo contrario, el constructor falla y devuelve IDENTITY.
Quaternion Quaternion(x: float, y: float, z: float, w: float)
Construye un Quaternion definido por los valores dados.
Nota: Solo los cuaterniones normalizados representan una rotación; si estos valores no están normalizados, el nuevo Quaternion no será una rotación válida.
Descripciones de Métodos
float angle_to(to: Quaternion) const 🔗
Devuelve el ángulo entre este cuaternión y to. Esta es la magnitud del ángulo que necesitarías rotar para ir de uno al otro.
Nota: La magnitud del error de punto flotante para este método es anormalmente alta, por lo que métodos como is_zero_approx no funcionarán de forma fiable.
float dot(with: Quaternion) const 🔗
Devuelve el producto escalar entre este cuaternión y with.
Esto es equivalente a (quat.x * with.x) + (quat.y * with.y) + (quat.z * with.z) + (quat.w * with.w).
Quaternion exp() const 🔗
Devuelve el exponencial de este cuaternión. El eje de rotación del resultado es el eje de rotación normalizado de este cuaternión, el ángulo del resultado es la longitud de la parte vectorial de este cuaternión.
Quaternion from_euler(euler: Vector3) static 🔗
Construye un nuevo Quaternion a partir del Vector3 de ángulos de Euler dado, en radianes. Este método siempre usa la convención YXZ (@GlobalScope.EULER_ORDER_YXZ).
Devuelve el ángulo de la rotación representada por este cuaternión.
Nota: El cuaternión debe estar normalizado.
Devuelve el eje de rotación de la rotación representada por este cuaternión.
Vector3 get_euler(order: int = 2) const 🔗
Returns this quaternion's rotation as a Vector3 of Euler angles, in radians.
The order of each consecutive rotation can be changed with order (see EulerOrder constants). By default, the YXZ convention is used (@GlobalScope.EULER_ORDER_YXZ): Z (roll) is calculated first, then X (pitch), and lastly Y (yaw). When using the opposite method from_euler(), this order is reversed.
Quaternion inverse() const 🔗
Devuelve la versión inversa de este cuaternión, invirtiendo el signo de cada componente excepto w.
bool is_equal_approx(to: Quaternion) const 🔗
Devuelve true si este cuaternión y to son aproximadamente iguales, llamando a @GlobalScope.is_equal_approx() en cada componente.
Devuelve true si este cuaternión es finito, llamando a @GlobalScope.is_finite() en cada componente.
Devuelve true si este cuaternión está normalizado. Véase también normalized().
Devuelve la longitud de este cuaternión, también llamada magnitud.
float length_squared() const 🔗
Devuelve la longitud al cuadrado de este cuaternión.
Nota: Este método es más rápido que length(), así que prefiérelo si solo necesitas comparar las longitudes de los cuaterniones.
Quaternion log() const 🔗
Devuelve el logaritmo de este cuaternión. Multiplica el eje de rotación de este cuaternión por su ángulo de rotación, y almacena el resultado en la parte vectorial del cuaternión devuelto (x, y, y z). La parte real del cuaternión devuelto (w) es siempre 0.0.
Quaternion normalized() const 🔗
Devuelve una copia de este cuaternión, normalizada para que su longitud sea 1.0. Véase también is_normalized().
Quaternion slerp(to: Quaternion, weight: float) const 🔗
Realiza una interpolación lineal esférica con el cuaternión to, dado un weight y devuelve el resultado. Tanto este cuaternión como to deben estar normalizados.
Quaternion slerpni(to: Quaternion, weight: float) const 🔗
Realiza una interpolación esférica-lineal con el cuaternión to, dado un weight, y devuelve el resultado. A diferencia de slerp(), este método no comprueba si la ruta de rotación es inferior a 90 grados. Tanto este cuaternión como to deben estar normalizados.
Quaternion spherical_cubic_interpolate(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, weight: float) const 🔗
Realiza una interpolación esférica cúbica entre los cuaterniones pre_a, este cuaternión, b y post_b, por la cantidad dada weight.
Quaternion spherical_cubic_interpolate_in_time(b: Quaternion, pre_a: Quaternion, post_b: Quaternion, weight: float, b_t: float, pre_a_t: float, post_b_t: float) const 🔗
Performs a spherical cubic interpolation between quaternions pre_a, this vector, b, and post_b, by the given amount weight.
It can perform smoother interpolation than spherical_cubic_interpolate() by the time values.
Descripciones de Operadores
bool operator !=(right: Quaternion) 🔗
Devuelve true si los componentes de ambos cuaterniones no son exactamente iguales.
Nota: Debido a errores de precisión de punto flotante, considera usar is_equal_approx() en su lugar, que es más fiable.
Quaternion operator *(right: Quaternion) 🔗
Compone (multiplica) dos cuaterniones. Esto rota el cuaternión right (el hijo) por este cuaternión (el padre).
Vector3 operator *(right: Vector3) 🔗
Rota (multiplica) el vector right por este cuaternión, devolviendo un Vector3.
Quaternion operator *(right: float) 🔗
Multiplica cada componente del Quaternion por el valor float de la derecha.
Esta operación no es significativa por sí sola, pero puede usarse como parte de una expresión más grande.
Quaternion operator *(right: int) 🔗
Multiplica cada componente del Quaternion por el valor int de la derecha.
Esta operación no es significativa por sí sola, pero puede usarse como parte de una expresión más grande.
Quaternion operator +(right: Quaternion) 🔗
Suma cada componente del Quaternion de la izquierda al Quaternion de la derecha.
Esta operación no es significativa por sí sola, pero puede usarse como parte de una expresión más grande, como la aproximación de una rotación intermedia entre dos rotaciones cercanas.
Quaternion operator -(right: Quaternion) 🔗
Resta cada componente del Quaternion de la izquierda por el Quaternion de la derecha.
Esta operación no es significativa por sí sola, pero puede ser usada como parte de una expresión más grande.
Quaternion operator /(right: float) 🔗
Divide cada componente del Quaternion por el valor float de la derecha.
Esta operación no es significativa por sí sola, pero puede ser usada como parte de una expresión más grande.
Quaternion operator /(right: int) 🔗
Divide cada componente del Quaternion por el valor int de la derecha.
Esta operación no es significativa por sí sola, pero puede ser usada como parte de una expresión más grande.
bool operator ==(right: Quaternion) 🔗
Devuelve true si los componentes de ambos cuaterniones son exactamente iguales.
Nota: Debido a errores de precisión de punto flotante, considera usar is_equal_approx() en su lugar, que es más fiable.
float operator [](index: int) 🔗
Accede a cada componente de este cuaternión por su índice.
El índice 0 es el mismo que x, el índice 1 es el mismo que y, el índice 2 es el mismo que z, y el índice 3 es el mismo que w.
Quaternion operator unary+() 🔗
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.
Quaternion operator unary-() 🔗
Devuelve el valor negativo del Quaternion. Esto es lo mismo que multiplicar todos los componentes por -1. Esta operación da como resultado un cuaternión que representa la misma rotación.