[Análisis detallado del motor de juego Overload] Fórmula de Quaternion para codificar

Fórmula del cuaternión

Este artículo solo registra las fórmulas relacionadas con los cuaterniones y no habla de sus principios matemáticos porque yo tampoco los entiendo. Introduzca estas fórmulas matemáticas únicamente en Sobrecarga al código.

1. Definición de cuaternión

William Hamilton inventó los cuaterniones en 1843 como un método que permitía multiplicar, dividir, rotar y estirar vectores. Un cuaternión es un número complejo que consta de cuatro números, un escalar y un vector. [w,v], w es un escalar, v es un vector 3D, después de la expansión es——[w, (x,y,z)]: q = w + x ∗ i + y ∗ j + z ∗
$$q=w+X\ast i+y\ast j+z\ast k$$
en:
$i^2=j^2=k^2=-1$，$yo=-ji=k$，$a=-yo=j$，$jk=-kj=yo$ ,

Para cualquier cuaternión dado, se puede representar una rotación en el espacio 3D. En el espacio 3D, cualquier rotación se puede expresar como un ángulo de rotación alrededor de un eje. Como sugiere el nombre, el ángulo del eje es un eje A (ax, ay, az) más un ángulo de rotación. Convierte cuaterniones en ángulos de eje. Entonces, cualquier cuaternión dado puede representar una rotación en el espacio 3D.
Eche un vistazo a la definición de cuaterniones en Overload: simplemente encapsula 4 números y define muchas funciones.

struct FQuaternion
{
    
    
public:
	float x; // 矢量部分
	float y;
	float z;
	float w; // 标量部分
}

2. Cálculos comunes de cuaterniones.

1. 相加
$$q+\hat{r}=(q_{},q_{})+(r_{},r_{})=(q_{}+r_{},q_{}+r_{})$$
código de sobrecarga correspondiente:

OvMaths::FQuaternion OvMaths::FQuaternion::operator+(const FQuaternion& p_otherQuat) const
{
    
    
    return FQuaternion(x + p_otherQuat.x, y + p_otherQuat.x,
z + p_otherQuat.z, w + p_otherQuat.w);
  }

2. 相乘
$$\begin{array}{rl}q\times \hat{r}& =(yo{q}_{}+j{q}_{}+k{q}_{}+q_{})(y{r}_{}+jr{\_}_{}+k{r}_{}+r_{})\\ & =q_{}{r}_{}-q_{}{r}_{}-q_{}{r}_{}-q_{}{r}_{}\\ & +yo(q_{}{r}_{}-q_{}{r}_{}+r_{}{q}_{}+q_{}{r}_{})\\ & +j(q_{}{r}_{}-q_{}{r}_{}+r_{}{q}_{}+q_{}{r}_{})\\ & +k(q_{}{r}_{}-q_{}{r}_{}+r_{}{q}_{}+q_{}{r}_{}\end{array}$$
Código de sobrecarga correspondiente:

OvMaths::FQuaternion OvMaths::FQuaternion::operator*(const FQuaternion& p_otherQuat) const
{
    
    
	return FQuaternion
	(
		x * p_otherQuat.w + y * p_otherQuat.z - z * p_otherQuat.y + w * p_otherQuat.x,
		-x * p_otherQuat.z + y * p_otherQuat.w + z * p_otherQuat.x + w * p_otherQuat.y,
		x * p_otherQuat.y - y * p_otherQuat.x + z * p_otherQuat.w + w * p_otherQuat.z,
		-x * p_otherQuat.x - y * p_otherQuat.y - z * p_otherQuat.z + w * p_otherQuat.w
	);
}

3. Invierta la parte del vector conjugado e ingrese directamente el código:

OvMaths::FQuaternion OvMaths::FQuaternion::Conjugate(const FQuaternion & p_target)
{
    
    
	return {
    
     -p_target.x, -p_target.y, -p_target.z, p_target.w };
}

4. Determina
$$q=q/\sqrt{w^2+X^2+y^2+z^2}$$

5. 点积
$$q\cdot \hat{r}=q_{}\ast r_{}+q_{}\ast r_{}+q_{}\ast r_{}+q_{}\ast r_{}$$
Código:

float OvMaths::FQuaternion::DotProduct(const FQuaternion & p_left, const FQuaternion & p_right)
{
    
    
	return 
		p_left.x * p_right.x +
		p_left.y * p_right.y +
		p_left.z * p_right.z +
		p_left.w * p_right.w;
}

6. Interpolación
La interpolación de dos cuaterniones q y r se puede utilizar para animar el proceso de rotación.
El cálculo de interpolación debe calcular primero la mitad del ángulo entre q y r $\theta$ , qfrecuencia$cos\left(\theta \right)$ y luego use la función acos para encontrar$\theta$
$$i=porque(\_q\cdot \hat{r})$$
da la cantidad de interpolación t, 0<t<1.0, la cantidad de interpolación se puede obtener:
$$q_{}=\frac{q\ast sen((1-t)\ast yo)+\hat{r}sen(t\ast yo}{sen\left(yo\right)}$$

Código de sobrecarga correspondiente:

OvMaths::FQuaternion OvMaths::FQuaternion::Slerp(const FQuaternion& p_start, const FQuaternion& p_end, float p_alpha)
{
    
    
	FQuaternion from = p_start; // 第一个四元数
	FQuaternion to = p_end; // 第二个四元数

	p_alpha = std::clamp(p_alpha, 0.f, 1.f); // 插值量t
	float cosAngle = FQuaternion::DotProduct(from, to); // 计算四元数的点积

	if (cosAngle < 0.f) // 小于0说明两个四元数角度大于180度，to为什么要翻转呢？
	{
    
    
		cosAngle = -cosAngle;
		to = FQuaternion(-to.x, -to.y, -to.z, -to.w);
	}

	if (cosAngle < 0.95f) // 两个四元数角度较大时
	{
    
    
		float angle = std::acos(cosAngle); // 计算角度theta
		float sinAngle = std::sin(angle); // 计算sin(theta)
		float invSinAngle = 1.f / sinAngle;
		float t1 = std::sin((1 - p_alpha) * angle) * invSinAngle;
		float t2 = std::sin(p_alpha * angle) * invSinAngle;
		return FQuaternion(from.x * t1 + to.x * t2, from.y * t1 + to.y * t2, from.z * t1 + to.z * t2, from.w * t1 + to.w * t2);
	}
	else
	{
    
    
	    // 两个四元数角度较小时
		return FQuaternion::Lerp(from, to, p_alpha);
	}
}

Cuando el ángulo entre los dos cuaterniones es pequeño, $sen\left(\theta \right)$ tiene un problema de división por 0, por lo que se realiza un tratamiento especial.

3. Ángulo del eje al cuaternión

Entrada: eje de rotación A (ax, ay, az), ángulo de rotación ángulo
Salida:
qx = ax * sin(angle/2)
qy = ay * sin(angle/2)
qz = az * sin(angle/2)
qw = porque(ángulo/2)

Entre ellos:
el eje de rotación es un vector unitario, entonces: ax ax + ay ay + az*az = 1
El cuaternión calculado también está unitario, entonces:
$$cos(ánguloe/2)\_{}^2+unax\ast unax\ast sen(ánguloe/2)\_{}^2+yy\ast yy\ast sen(ánguloe/2)\_{}^2+laz\ast laz\ast sen(ánguloe/2)\_{}^2=1$$

4. Ángulo del eje del cuaternión

$$X=qx/sqrt(1-qw\ast qw)$$
$$y=qy/sqrt(1-qw\ast qw)$$
$$z=qz/sqrt(1-qw\ast qw)$$
$$ángulo\_\_\_=2\ast aporque\left(qw\right)$$

• El cálculo del eje de singularidad
  es un valor con singularidad. Cuando el ángulo = 0, hay un problema de división por 0.
            q = cos(ángulo/2) + i ( x * sin(ángulo/2)) + j (y * sin(ángulo/2)) + k ( z * sin(ángulo/2)) cuando el ángulo es 0 grados
  Cuando , el cuaternión es q = 1 + i 0 + j 0 + k 0, entonces al calcular el eje,
  ángulo = 2 * acos(qw) = 0
  x = qx / sqrt(1-qw qw) = dividir por cero = infinito
  y = qy / sqrt(1-qw qw) = dividir por cero = infinito
  z = qz / sqrt(1-qw*qw) = dividir por cero = infinito
  pero girar 0 grados equivale a no girar, por lo que el eje dado puede ser cualquier valor.

El código correspondiente en Sobrecarga:

OvMaths::FVector3 OvMaths::FQuaternion::GetRotationAxis(const FQuaternion & p_target)
{
    
    
	const float S = sqrt(std::max(1.f - (p_target.w * p_target.w), 0.f));

	if (S >= 0.0001f)
	{
    
    
		return FVector3(p_target.x / S, p_target.y / S, p_target.z / S);
	}

	return FVector3(1.f, 0.f, 0.f);
}

5. Convertir cuaternión en matriz

Los cuaterniones se utilizan principalmente para representar rotaciones en gráficos. Para el cuaternión qw + i qx + j qy + k qz, las matrices de rotación correspondientes de 3x3 y 4x4 son las siguientes:
$$R_{3,}=\left[\begin{array}{ccc}1-2(y^2+z^2)& 2(xy-zw)\_& 2(xz+law)\\ 2(xy+zw)\_& 1-2(x^2+z^2)& 2(yz-xw)\_\\ 2(xz-law& 2(yz+xw)& 1-2(x^2+y^2\end{array}\right]$$

$$R_{4,}=\left[\begin{array}{cccc}1-2(y^2+z^2)& 2(xy-zw)\_& 2(xz+law)& 0\\ 2(xy+zw)\_& 1-2(x^2+z^2)& 2(yz-xw)\_& 0\\ 2(xz-law)& 2(yz+xw)\_& 1-2(x^2+y^2)& 0\\ & & & \end{array}\right]$$

4. Girar alrededor de un punto.

Los cuaterniones representan rotación alrededor del origen del sistema de coordenadas. La rotación alrededor de un punto, como su nombre lo indica, es una rotación alrededor de un punto específico. Es esencialmente un movimiento compuesto de traslación + rotación.
Supongamos que tenemos una matriz [R] que define una rotación alrededor del origen y ahora queremos hacer la misma rotación alrededor de cualquier punto P.
Podemos ver que su orientación es la misma que la rotación alrededor del origen, pero se ha trasladado a una posición diferente.

Su equivalente cinemático es:

1. Traducir el objeto al origen (menos P, traducir usando los vectores -Px, -Py, -Pz)
2. Girar alrededor del origen
3. Traducir el objeto nuevamente (agregue P, use +Px, +Py, +Pz para traducir)

[Resultado de la transformación] = [+Px,+Py,+Pz] * [Girar alrededor del origen] * [-Px,-Py,-Pz]

En forma matricial:
$$\left[R\right]=[T{]}^{-1}\ast [R]\ast [T]$$

Entre ellos:
[R] = matriz de rotación, que puede ser un cuaternión
$$[T{]}^{-1}=\left[\begin{array}{cccc}1& 0& 0& {PAG}_{}\\ 0& 1& 0& {PAG}_{}\\ 0& 0& 1& {PAG}_{}\\ & & & \end{array}\right]$$

$$\left[T\right]=\left[\begin{array}{cccc}1& 0& 0& -{PAG}_{}\\ 0& 1& 0& -{PAG}_{}\\ 0& 0& 1& -{PAG}_{}\\ & & & \end{array}\right]$$

Determine lo siguiente:
$$\left[\begin{array}{cccc}{r}_{}& r_{}& r_{}& {PAG}_{}-r_{}\ast {PAG}_{}-r_{}\ast {PAG}_{}-r_{}\ast {PAG}_{}\\ r_{}& r_{}& r_{}& {PAG}_{}-r_{}\ast {PAG}_{}-r_{}\ast {PAG}_{}-r_{}\ast {PAG}_{}\\ r_{}& r_{}& r_{}& {PAG}_{}-r_{}\ast {PAG}_{}-r_{}\ast {PAG}_{}-r_{}\ast {PAG}_{}\\ & & & \end{array}\right]$$
Se puede comparar con alrededor del origen, el componente de rotación de la matriz es el mismo, solo se agrega el componente de traducción.

La fórmula del punto de bobinado en Sobrecarga es la siguiente:

// 点p_point绕原点旋转的坐标
OvMaths::FVector3 OvMaths::FQuaternion::RotatePoint(const FVector3& p_point, const FQuaternion& p_quaternion)
{
    
    
	FVector3 Q(p_quaternion.x, p_quaternion.y, p_quaternion.z);
	FVector3 T = FVector3::Cross(Q, p_point) * 2.0f;

	return p_point + (T * p_quaternion.w) + FVector3::Cross(Q, T);
}

// 点p_point绕p_pivot旋转后的坐标（这个地方我理解可能有误，转动之后不应该再加回来吗？）
OvMaths::FVector3 OvMaths::FQuaternion::RotatePoint(const FVector3 & p_point, const FQuaternion & p_quaternion, const FVector3 & p_pivot)
{
    
    
	FVector3 toRotate = p_point - p_pivot;
	return RotatePoint(toRotate, p_quaternion);
}

Utiliza otra fórmula. No he encontrado la fuente de esta fórmula. Debería ser equivalente a la fórmula anterior. No he realizado ninguna derivación ni verificación. No entiendo muy bien esta función. Espero que puedan dejarme un mensaje y darme algún consejo. ¡Gracias!