How do I get the 3D rotation from one orthogonal basis to another (quaternion or matrix)

by

Summary

The problem at hand involves finding the 3D rotation between two orthogonal bases, each defined by right, up, and forward normalized vectors. This is crucial for calculating the rotation of a car after acceleration in a 3D graphics application using raylib. The goal is to obtain a quaternion or matrix representation of this rotation.

Root Cause

The root cause of the issue lies in the construction of the rotation matrix and the choice of coordinate system. Specifically:

  • The pitch axis is not properly localized, leading to unexpected rotations.
  • The world forward direction is defined as -z, which may not align with the conventional +z forward direction in other graphics libraries.

Why This Happens in Real Systems

This issue arises in real systems due to:

  • Insufficient consideration of coordinate system conventions: Different libraries and applications may use different conventions for axis orientations and rotations.
  • Incorrect construction of rotation matrices: Manual construction of rotation matrices can lead to errors if the axis orientations and rotations are not properly accounted for.
  • Lack of understanding of quaternion representations: Quaternions provide a more intuitive and efficient way to represent 3D rotations, but require a good understanding of their mathematical properties.

Real-World Impact

The real-world impact of this issue includes:

  • Inaccurate car rotations: The car’s rotation will not be correctly calculated, leading to unrealistic visuals and potentially affecting gameplay or simulation accuracy.
  • Increased development time: Debugging and resolving this issue can consume significant development time, delaying project completion.
  • Poor user experience: Inaccurate rotations can lead to a poor user experience, particularly in applications where realistic graphics and physics are crucial.

Example or Code

// Example code in C using raylib
#include "raylib.h"

int main() {
    // Define the two orthogonal bases
    Vector3 basis1Right = {1, 0, 0};
    Vector3 basis1Up = {0, 1, 0};
    Vector3 basis1Forward = {0, 0, -1};

    Vector3 basis2Right = {0, 1, 0};
    Vector3 basis2Up = {0, 0, 1};
    Vector3 basis2Forward = {1, 0, 0};

    // Calculate the rotation matrix between the two bases
    Matrix rotationMatrix = {
        basis2Right.x, basis2Right.y, basis2Right.z, 0,
        basis2Up.x, basis2Up.y, basis2Up.z, 0,
        basis2Forward.x, basis2Forward.y, basis2Forward.z, 0,
        0, 0, 0, 1
    };

    // Convert the rotation matrix to a quaternion
    Quaternion rotationQuaternion = {
        sqrt(1 + rotationMatrix.m0 + rotationMatrix.m4 + rotationMatrix.m8) / 2,
        (rotationMatrix.m7 - rotationMatrix.m5) / (4 * sqrt(1 + rotationMatrix.m0 + rotationMatrix.m4 + rotationMatrix.m8)),
        (rotationMatrix.m2 - rotationMatrix.m6) / (4 * sqrt(1 + rotationMatrix.m0 + rotationMatrix.m4 + rotationMatrix.m8)),
        (rotationMatrix.m3 - rotationMatrix.m1) / (4 * sqrt(1 + rotationMatrix.m0 + rotationMatrix.m4 + rotationMatrix.m8))
    };

    return 0;
}

How Senior Engineers Fix It

Senior engineers fix this issue by:

  • Carefully considering the coordinate system conventions used in the application and library.
  • Using established libraries and functions for constructing rotation matrices and quaternions.
  • Verifying the correctness of the rotation through thorough testing and debugging.
  • Applying mathematical principles to ensure accurate calculations and transformations.

Why Juniors Miss It

Juniors may miss this issue due to:

  • Lack of experience with 3D graphics and rotations.
  • Insufficient understanding of coordinate system conventions and quaternion representations.
  • Inadequate testing and debugging practices.
  • Overreliance on manual calculations instead of using established libraries and functions.