Los cuaterniones son una forma alternativa de representar la parte de rotación de una transformación, y pueden ser más fáciles de manipular que las matrices. Como con una matriz, usted puede codificar transformaciones geométricas en una, concatenar varias de ellas para mezclar múltiples transformaciones, y aplicarlas a un vector, pero sólo pueden almacenar rotaciones puras. La gran ventaja es que puede interpolar precisamente entre dos cuaterniones para obtener una rotación parcial, evitando los enormes problemas de la interpolación más convencional con ángulos eulerianos.
Los cuaterniones sólo poseen versiones de punto flotante, sin ningún sufijo "_f". Por otro lado, la mayoría de las funciones de cueterniones se corresponden con una función matricial que realiza una operación similar.
Cuaternión significa 'de cuatro partes', y es exactamente eso. Aquí está la estructura:
typedef struct QUAT
{
float w, x, y, z;
}
extern QUAT identity_quat;
Variable global que contiene el cuaternión identidad 'que no hace nada'.
Multiplicar por el cuaternión identidad no tiene efecto alguno.
void get_x_rotate_quat(QUAT *q, float r);
void get_y_rotate_quat(QUAT *q, float r);
void get_z_rotate_quat(QUAT *q, float r);
Construye cuaterniones de ejes de rotación, almacenándolos en q. Cuando
sean aplicados a un punto, éstos cuaterniones lo rotarán sobre el eje
relevante el ángulo especificado (dado en binario, 256 grados forman un
círculo).
void get_rotation_quat(QUAT *q, float x, float y, float z);
Construye un cuaternión que rotará puntos alrededor de los tres ejes las
cantidades especificadas (dadas en binario, 256 grados forman un círculo).
void get_vector_rotation_quat(QUAT *q, float x, y, z, float a);
Construye un cuaternión que rotará puntos alrededor del vector x,y,z el
ángulo especificado (dado en binario, 256 grados forman un círculo).
void quat_to_matrix(const QUAT *q, MATRIX_f *m);
Construye una matriz de rotación a partir de un cuaternión.
void matrix_to_quat(const MATRIX_f *m, QUAT *q);
Construye un cuaternión a partir de una matriz de rotación. La translación
es descartada durante la conversión. Use get_align_matrix_f() si la matriz
no está ortonormalizada, porque de otra forma podrían pasar cosas
extrañas.
void quat_mul(const QUAT *p, const QUAT *q, QUAT *out);
Multiplica dos cuaterniones, almacenando el resultado en out. El
cuaternión resultante tendrá el mismo efecto que la combinación de p y q,
es decir, cuando es aplicado a un punto, (punto * out) = ((punto * p) *
q). Cualquier cantidad de rotaciones pueden ser concatenadas de ésta
manera. Note que la multiplicación del cuaternión no es conmutativa, es
decir que quat_mul(p, q) != quat_mul(q, p).
void apply_quat(const QUAT *q, float x, y, z, *xout, *yout, *zout);
Multiplica el punto (x, y, z) por el cuaternión q, almacenando el
resultado en (*xout, *yout, *zout). Esto es un poquito más lento que
apply_matrix_f(), así que úselo para trasladar unos pocos puntos. Si usted
tiene muchos puntos, es mucho más eficiente llamar a quat_to_matrix() y
entonces usar apply_matrix_f().
void quat_interpolate(const QUAT *from, QUAT *to, float t, QUAT *out);
Construye un cuaternión que representa una rotación entre from y to. El
argumento t puede ser cualquiera entre 0 y 1, y representa dónde estará
el resultado entre from y to. 0 devuelve from, 1 devuelve to, y 0.5
devolverá una rotación exactamente en la mitad. El resultado es copiado a
out. Esta función creará una rotación corta (menos de 180 grados) entre
from y to.
void quat_slerp(const QUAT *from, QUAT *to, float t, QUAT *out, int how);
Igual que quat_interpolate(), pero permite más control sobre cómo es hecha
la rotación. El parámetro how puede ser alguno de estos valores:
QUAT_SHORT - como quat_interpolate(), usa el camino más corto
QUAT_LONG - la rotación será mayor que 180 grados
QUAT_CW - rotación horaria vista desde arriba
QUAT_CCW - rotación antihoraria vista desde arriba
QUAT_USER - los cuaterniones son interpolados exactamente como
son dados.