如何在现代OpenGL中正确实现四元数相机？

Question

我正在尝试在OpenGL中创建一个基于四元数的UVN相机，使用了下面列出的各种教程，并阅读了关于四元数和轴角旋转的相关知识。但是我遇到了一个奇怪的错误，无法解决。

基本上，相机似乎一直正常工作，直到相机从+z旋转约45度为止，在这一点上，向上或向下倾斜相机似乎会围绕其目标轴倾斜相机，转动上向量。

当相机面对-z时，向上或向下倾斜会产生相反的错觉，向上倾斜会使相机向下倾斜，向下倾斜会使相机向上倾斜。

我已经看到其他实现建议使用非UVN系统，其中四元数累积成一个描述当前方向与某个任意起始角度之间差异的四元数。这听起来很棒，但是我似乎无法确定如何实现它，特别是从此转换为视图矩阵。

在SO的其他地方，我读到将旋转分成两个分别表示偏航和俯仰的四元数的方法，但我并不认为这是问题的原因，因为在这种情况下，如果我理解正确，应用这两个旋转的顺序并不重要。

相关源代码片段：

四元数操作

Quaternion<TValue> conjugate() const{
            return Quaternion({ { -m_values[X], -m_values[Y], -m_values[Z], m_values[W] } });
};

Quaternion<TValue>& operator*=(const Quaternion<TValue>& rhs) {
        TValue x, y, z, w;
            w = rhs[W] * m_values[W] - rhs[X] * m_values[X] - rhs[Y] * m_values[Y] - rhs[Z] * m_values[Z];
            x = rhs[W] * m_values[X] + rhs[X] * m_values[W] - rhs[Y] * m_values[Z] + rhs[Z] * m_values[Y];
            y = rhs[W] * m_values[Y] + rhs[X] * m_values[Z] + rhs[Y] * m_values[W] - rhs[Z] * m_values[X];
            z = rhs[W] * m_values[Z] - rhs[X] * m_values[Y] + rhs[Y] * m_values[X] + rhs[Z] * m_values[W];          

            m_values[X] = x;
            m_values[Y] = y;
            m_values[Z] = z;
            m_values[W] = w;
            return *this;
};
static Quaternion<TValue> rotation(Vector<3, TValue> axis, TValue angle){
        float x, y, z, w;
        TValue halfTheta = angle / 2.0f;
        TValue sinHalfTheta = sin(halfTheta);
        return Quaternion<TValue>({ { axis[X] * sinHalfTheta, axis[Y] * sinHalfTheta, axis[Z] * sinHalfTheta, cos(halfTheta) } });
};

向量旋转操作

Vector<dimensions, TValue> rotate(const Vector<3, TValue> axis, float angle){
        Quaternion<TValue> R = Quaternion<TValue>::rotation(axis, angle);
        Quaternion<TValue> V = (*this);
        Vector<dimensions, TValue> result = R * V * R.conjugate();
        return result;
}

相机方法

Camera::Camera(Vector<2, int> windowSize, float fov, float near, float far):
m_uvn(Matrix<4, float>::identity()),
m_translation(Matrix<4, float>::identity()),
m_ar(windowSize[Dimensions::X] / (float)windowSize[Dimensions::Y]),
m_fov(fov),
m_near(near),
m_far(far),
m_position(),
m_forward({ { 0, 0, 1 } }),
m_up({ { 0, 1, 0 } })
{
    setViewMatrix(Matrix<4, float>::identity());
    setProjectionMatrix(Matrix<4, float>::perspective(m_ar, m_near, m_far, m_fov));
};

Matrix<4, float> Camera::getVPMatrix() const{
    return m_vp;
};

const Vector<3, float> Camera::globalY = Vector<3, float>({ { 0, 1, 0 } });

void Camera::setProjectionMatrix(const Matrix<4, float> p){
    m_projection = p;
    m_vp = m_projection * m_view;
};

void Camera::setViewMatrix(const Matrix<4, float> v){
    m_view = v;
    m_vp = m_projection * m_view;
};

void Camera::setTranslationMatrix(const Matrix<4, float> t){
    m_translation = t;
    setViewMatrix(m_uvn * m_translation);
}

void Camera::setPosition(Vector<3, float> position){
    if (position != m_position){
        m_position = position;
        setTranslationMatrix(Matrix<4, float>::translation(-position));
    }
};

void Camera::moveForward(float ammount){
    setPosition(m_position + (m_forward * ammount));
}

void Camera::moveRight(float ammount){
    setPosition(m_position + (getRight() * ammount));
}

void Camera::moveUp(float ammount){
    setPosition(m_position + (m_up * ammount));
}

void Camera::setLookAt(Vector<3, float> target, Vector<3, float> up){
    Vector<3, float> newUp = up.normalize();
    Vector<3, float> newForward = target.normalize();
    if (newUp != m_up || newForward != m_forward){
        m_up = newUp;
        m_forward = newForward;

        Vector<3, float> newLeft = getLeft();
        m_up = newLeft * m_forward;

        m_uvn = generateUVN();
        setViewMatrix(m_uvn * m_translation);
    }
};

void Camera::rotateX(float angle){
    Vector<3, float> hAxis = (globalY * m_forward).normalize();
    m_forward = m_forward.rotate(hAxis, angle).normalize();
    m_up = (m_forward * hAxis).normalize();

    m_uvn = generateUVN();
    setViewMatrix(m_translation * m_uvn);
}

void Camera::rotateY(float angle){
    Vector<3, float> hAxis = (globalY * m_forward).normalize();
    m_forward = m_forward.rotate(globalY, angle).normalize();
    m_up = (m_forward * hAxis).normalize();

    m_uvn = generateUVN();
    setViewMatrix(m_translation * m_uvn);
}

Vector<3, float> Camera::getRight(){
    return (m_forward * m_up).normalize();
}

Vector <3, float> Camera::getLeft(){
    return (m_up * m_forward).normalize();
}

};

我猜问题要么出在我的四元数实现上，要么出在我使用它的方式上，但由于系统的复杂性，我似乎无法进一步确定问题。由于经历了奇怪的错误，我不确定我尝试实现相机的方式是否有问题？

教程

• https://www.youtube.com/watch?v=1Aw1PDu33PI
• http://www.gamedev.net/page/resources/_/technical/math-and-physics/a-simple-quaternion-based-camera-r1997

四元数/向量数学

• http://mathworld.wolfram.com/Quaternion.html
• https://en.wikipedia.org/wiki/Cross_product
• http://ogldev.atspace.co.uk/www/tutorial13/tutorial13.html
• http://www.euclideanspace.com/maths/algebra/realNormedAlgebra/quaternions/index.htm

- Edward J Brown

---

我认为最好的做法是将您的函数过程分解 - 尝试编写数学过程与代码之间的1:1映射，并将文档与数学进行比较。 - CinchBlue

这个问题需要非常长的答案（据我所见 - 我因为所有代码而无法确定）。 您应该提供一个 http://stackoverflow.com/help/mcve 而不是整个实现。 尝试定位错误，然后在此寻求帮助。 - WorldSEnder

将您的实现输出与Eigen或GLM进行比较。 - genpfault

Answer 1

虽然这是一个老问题，但仍然是一个相关的话题，所以我会给出一些指针。要记住的是四元数是一个三维映射。单位四元数和次纯四元数提供了一种一致的方式来表示这个旋转是这个值。相对于欧拉角的好处在于它们试图从某个轴周围的旋转重建方向，而四元数直接对应于方向并且可以避免万向锁。

特别地，对于四元数相机，让Q{1,0,0,0}，其中w=1，这个四元数对应的矩阵是单位矩阵。因此，任何有效的单位四元数分解成一个3x3矩阵，给出了（通常）相机的世界空间旋转。然而，你甚至不需要那个，因为你可以定义你的相机空间，比如说X{1,0,0} Y{0,1,0} Z{0,0,-1}，然后将这些单位轴乘以你的相机方向四元数，得到的向量就是变换后的单位向量。这些向量创建了你的右、上和前向量，可以用来构建视图变换的3x3旋转。

移动相机应该相对简单。线性运动向量可以轻松重构并应用于相机位置，而角度运动可以通过将相机四元数乘以方向来实现，该方向是旋转发生的相应平面的法线。例如，向左和向右转是在XZ平面上发生的旋转，因此Y向量（作为单位四元数而不是纯四元数）将与相机四元数相乘，产生所需的旋转效果。

- Daniel Rollins