How to rotate a vector by a given direction

Rotating a Vector by a Given Direction: A Comprehensive Guide

Learn the fundamental concepts and practical implementations for rotating a 3D vector using quaternions and rotation matrices, with examples in GLM.

Rotating vectors is a cornerstone operation in 3D graphics, physics simulations, and robotics. Whether you're orienting objects, calculating trajectories, or transforming coordinate systems, understanding how to correctly rotate a vector by a given direction is crucial. This article will delve into the mathematical principles behind vector rotation, focusing on two primary methods: rotation matrices and quaternions. We'll explore their advantages, disadvantages, and provide practical code examples using the popular GLM (OpenGL Mathematics) library.

Understanding Rotation: Axes, Angles, and Directions

Before diving into the mechanics of rotation, it's essential to grasp the core concepts. A rotation is defined by an axis of rotation and an angle around that axis. When we talk about rotating a vector by a 'given direction,' we often imply that this direction defines the axis of rotation. The magnitude of rotation is then specified by an angle. For example, rotating a vector around the Y-axis by 90 degrees. In more complex scenarios, a 'direction' might implicitly define a transformation that aligns one vector with another, which involves finding the appropriate rotation.

graph TD
    A[Start] --> B{Define Rotation Axis (Direction)}
    B --> C{Define Rotation Angle}
    C --> D{Choose Rotation Method}
    D --> E1[Rotation Matrix]
    D --> E2[Quaternion]
    E1 --> F[Apply Matrix to Vector]
    E2 --> G[Apply Quaternion to Vector]
    F --> H[Resultant Rotated Vector]
    G --> H

Conceptual flow for rotating a vector by a given direction.

Method 1: Rotation Matrices

Rotation matrices are 3x3 matrices that, when multiplied by a 3D vector, transform that vector by rotating it around a specified axis. Each column of a rotation matrix represents the new orientation of the basis vectors (X, Y, Z) after rotation. They are intuitive for understanding coordinate system transformations and are widely used. However, a potential drawback is that they can accumulate floating-point errors over successive rotations, leading to 'gimbal lock' or non-orthonormal matrices, which can cause scaling or shearing.

#include <glm/glm.hpp>
#include <glm/gtc/matrix_transform.hpp>
#include <iostream>

int main() {
    // Original vector
    glm::vec3 originalVector = glm::vec3(1.0f, 0.0f, 0.0f);

    // Rotation axis (normalized direction vector)
    glm::vec3 rotationAxis = glm::normalize(glm::vec3(0.0f, 1.0f, 0.0f)); // Y-axis

    // Rotation angle in radians (e.g., 90 degrees)
    float angle = glm::radians(90.0f);

    // Create a rotation matrix
    glm::mat4 rotationMatrix = glm::rotate(glm::mat4(1.0f), angle, rotationAxis);

    // Rotate the vector
    glm::vec3 rotatedVector = glm::vec3(rotationMatrix * glm::vec4(originalVector, 1.0f));

    std::cout << "Original Vector: (" << originalVector.x << ", " << originalVector.y << ", " << originalVector.z << ")\n";
    std::cout << "Rotated Vector: (" << rotatedVector.x << ", " << rotatedVector.y << ", " << rotatedVector.z << ")\n";

    return 0;
}

C++ example using GLM to rotate a vector with a rotation matrix.

Method 2: Quaternions

Quaternions are a more advanced mathematical construct often preferred in 3D applications for representing rotations. They consist of a scalar part and a 3D vector part. Quaternions offer several advantages over rotation matrices: they are more compact (4 numbers vs. 9), computationally more efficient for concatenating rotations, and inherently avoid issues like gimbal lock and normalization errors. While their mathematical intuition can be less direct, libraries like GLM make them straightforward to use.

#include <glm/glm.hpp>
#include <glm/gtc/quaternion.hpp>
#include <glm/gtx/quaternion.hpp>
#include <iostream>

int main() {
    // Original vector
    glm::vec3 originalVector = glm::vec3(1.0f, 0.0f, 0.0f);

    // Rotation axis (normalized direction vector)
    glm::vec3 rotationAxis = glm::normalize(glm::vec3(0.0f, 1.0f, 0.0f)); // Y-axis

    // Rotation angle in radians (e.g., 90 degrees)
    float angle = glm::radians(90.0f);

    // Create a quaternion from axis and angle
    glm::quat rotationQuat = glm::angleAxis(angle, rotationAxis);

    // Rotate the vector using the quaternion
    glm::vec3 rotatedVector = rotationQuat * originalVector;

    std::cout << "Original Vector: (" << originalVector.x << ", " << originalVector.y << ", " << originalVector.z << ")\n";
    std::cout << "Rotated Vector: (" << rotatedVector.x << ", " << rotatedVector.y << ", " << rotatedVector.z << ")\n";

    return 0;
}

C++ example using GLM to rotate a vector with a quaternion.

Choosing Between Matrices and Quaternions

The choice between rotation matrices and quaternions often depends on the specific application and performance requirements.

• Rotation Matrices are generally easier to understand visually and for simple, single rotations. They integrate well with other matrix transformations (translation, scaling) into a single glm::mat4 for model-view-projection pipelines. However, they are prone to numerical instability over many concatenated rotations.

• Quaternions are superior for interpolating rotations (e.g., for smooth animations) and for accumulating multiple rotations without introducing errors like gimbal lock. They are more computationally efficient for these tasks. Many modern game engines and 3D applications primarily use quaternions for object orientation and then convert them to matrices for rendering when needed.

Comparison of Rotation Matrices vs. Quaternions

1. Define the Original Vector

Start by defining the 3D vector you wish to rotate. This is typically a glm::vec3.

2. Specify Rotation Axis and Angle

Determine the axis around which the vector will rotate (a normalized glm::vec3 direction) and the angle of rotation (in radians).

3. Choose Rotation Method

Decide whether to use a rotation matrix (glm::mat4) or a quaternion (glm::quat) based on your application's needs.

4. Construct Rotation Object

Use glm::rotate for matrices or glm::angleAxis for quaternions to create the rotation transformation.

5. Apply Rotation

Multiply your original vector by the rotation matrix or quaternion to obtain the new, rotated vector.