Windows Development Documentation

Introduction

Quaternions are a mathematical concept used extensively in computer graphics, robotics, and physics simulations for representing rotations in 3D space. They offer a robust and efficient alternative to other rotation representations, particularly Euler angles.

What Are Quaternions?

A quaternion is a number system that extends complex numbers. It consists of four components: one real component and three imaginary components. In the context of 3D rotations, a quaternion can represent a rotation around an arbitrary axis by a specific angle.

They were first described by Irish mathematician William Rowan Hamilton in 1843.

Mathematical Representation

A quaternion q can be represented as:

q = w + xi + yj + zk

where:

• w is the real part.
• x, y, and z are the imaginary parts.
• i, j, and k are the basis vectors with the following properties:
  • i² = j² = k² = ijk = -1
  • ij = k, ji = -k
  • jk = i, kj = -i
  • ki = j, ik = -j

For representing rotations, a unit quaternion (where the magnitude is 1) is typically used. A unit quaternion can be expressed in terms of an angle θ and an axis vector v = (x, y, z):

q = cos(θ/2) + (x*i + y*j + z*k)*sin(θ/2)

Here, w = cos(θ/2) and the vector part (x, y, z) represents the normalized axis of rotation.

Advantages Over Euler Angles

• Avoids Gimbal Lock: Euler angles suffer from gimbal lock, a phenomenon where two of the three rotational degrees of freedom become aligned, leading to a loss of one degree of freedom and unpredictable behavior. Quaternions do not suffer from this issue.
• Efficient Composition: Combining rotations using quaternions is achieved through quaternion multiplication, which is generally more efficient and numerically stable than applying sequential rotations with Euler angles.
• Smoother Interpolation: Spherical linear interpolation (Slerp) with quaternions provides smooth and natural interpolation between orientations, crucial for animations and camera movements.

Common Operations

Key operations performed with quaternions include:

• Conjugation: For q = w + xi + yj + zk, the conjugate is q* = w - xi - yj - zk.
• Magnitude: |q| = sqrt(w² + x² + y² + z²). For unit quaternions, |q| = 1.
• Inverse: For a unit quaternion, the inverse is its conjugate: q⁻¹ = q*.
• Multiplication: The product of two quaternions p and q is another quaternion. This operation corresponds to composing the rotations they represent.
• Rotation of a Vector: A vector v = (vx, vy, vz) can be represented as a pure quaternion v_q = 0 + vxi + vyj + vzk. To rotate v by a quaternion q, the operation is v_rotated = q * v_q * q⁻¹.
• Normalization: Ensuring a quaternion has a magnitude of 1, which is essential for it to represent a pure rotation.
• Slerp (Spherical Linear Interpolation): Used to find intermediate quaternions between two given quaternions, resulting in smooth transitions.

DirectXMath Implementation

The DirectXMath library provides a comprehensive set of functions for working with quaternions, primarily using the DirectX::XMVECTOR type, which can represent a 4D vector or a quaternion. A quaternion is typically stored as (x, y, z, w).

Key Structures and Types:

• DirectX::XMVECTOR: Can be used to represent quaternions.
• DirectX::XMQuaternionRotationAxis: Creates a quaternion from an axis and angle.
• DirectX::XMQuaternionRotationMatrix: Creates a quaternion from a rotation matrix.
• DirectX::XMQuaternionRotationRollPitchYaw: Creates a quaternion from Euler angles (use with caution due to potential gimbal lock).
• DirectX::XMQuaternionMultiply: Multiplies two quaternions.
• DirectX::XMVector3Transform: Rotates a 3D vector using a quaternion.
• DirectX::XMQuaternionSlerp: Performs spherical linear interpolation.
• DirectX::XMQuaternionNormalize: Normalizes a quaternion.

Example: Creating a Quaternion for a 90-degree rotation around the Y-axis:

#include <DirectXMath.h>

// Define the rotation axis (Y-axis) and angle (90 degrees)
DirectX::XMVECTOR rotationAxis = DirectX::XMVectorSet(0.0f, 1.0f, 0.0f, 0.0f); // (x, y, z, w)
float angleInRadians = DirectX::XM_PIDIV2; // 90 degrees in radians

// Create the quaternion
DirectX::XMVECTOR quaternion = DirectX::XMQuaternionRotationAxis(rotationAxis, angleInRadians);

// The 'quaternion' XMVECTOR now holds the (x, y, z, w) components of the rotation.
// For example, you can extract components:
// float x = DirectX::XMVectorGetX(quaternion);
// float y = DirectX::XMVectorGetY(quaternion);
// float z = DirectX::XMVectorGetZ(quaternion);
// float w = DirectX::XMVectorGetW(quaternion);
                

Practical Examples

// Assuming 'modelQuaternion' represents the desired orientation
DirectX::XMMATRIX rotationMatrix = DirectX::XMMatrixRotationQuaternion(modelQuaternion);

// Apply this matrix to your model's vertices
// For each vertex v: v_rotated = v * rotationMatrix;
                

// Assume:
// DirectX::XMVECTOR startQuaternion;
// DirectX::XMVECTOR endQuaternion;
// float interpolationFactor; // A value between 0.0 and 1.0

DirectX::XMVECTOR interpolatedQuaternion = DirectX::XMQuaternionSlerp(startQuaternion, endQuaternion, interpolationFactor);