C++ opengl中的相机不工作

问题是当我面对我的相机向下的z轴，例如和俯仰这工作正常，但在我已经完成了俯仰，并希望在这个新的轴偏航，它开始滚动，因为一些未知的原因=s

    void FrustumCamera::xAxisRotation(float angle)
{
//  angle = angle * (double)degToRad;
    Vector3<float> x = m_orientation.getXAxis();
    Vector3<float> y = m_orientation.getYAxis();
    Vector3<float> z = m_orientation.getZAxis();

    y.rotateAroundAxis(x,angle);
    x = m_orientation.getXAxis();
    z.rotateAroundAxis(x,angle);

    m_orientation.setYAxis(y);
    m_orientation.setZAxis(z);

}
void FrustumCamera::yAxisRotation(float angle)
{
//  angle = angle * (double)degToRad;

    Vector3<float> x = m_orientation.getXAxis();
    Vector3<float> y = m_orientation.getYAxis();
    Vector3<float> z = m_orientation.getZAxis();

    x.rotateAroundAxis(y,angle);
    y = m_orientation.getYAxis();
    z.rotateAroundAxis(y,angle);

    m_orientation.setXAxis(x);
    m_orientation.setZAxis(z);
}
void FrustumCamera::zAxisRotation(float angle)
{
    Vector3<float> x = m_orientation.getXAxis();
    Vector3<float> y = m_orientation.getYAxis();
    Vector3<float> z = m_orientation.getZAxis();

    x.rotateAroundAxis(z,angle);
    z = m_orientation.getYAxis();
    y.rotateAroundAxis(z,angle);

    m_orientation.setXAxis(x);
    m_orientation.setYAxis(y);
}

template <class Type>
void Vector3<Type>::rotateAroundAxis(Vector3<Type> axis, const float angle)
{
    float radians = static_cast<Type>(angle * degToRad);
    Type sinAngle = static_cast<Type>(sin(radians));
    Type cosAngle = 0.0;

    if (angle == 90 || angle == -90)
        cosAngle = 0.0;
    else
        cosAngle = cos(radians); 

    normalise(axis);    // normalise the axis

    Type oneMinusCos = 1 - cosAngle;        // (1 - cos(theta))

    // construct the rotation matrix
    Type tempMatrix[3][3];
    tempMatrix[0][0] = (axis.x * axis.x) * oneMinusCos + cosAngle;
    tempMatrix[0][1] = (axis.x * axis.y) * oneMinusCos + axis.z * sinAngle;
    tempMatrix[0][2] = (axis.x * axis.z) * oneMinusCos - axis.y * sinAngle;
    tempMatrix[1][0] = (axis.x * axis.y) * oneMinusCos - axis.z * sinAngle;
    tempMatrix[1][1] = (axis.y * axis.y) * oneMinusCos + cosAngle;
    tempMatrix[1][2] = (axis.y * axis.z) * oneMinusCos + axis.x * sinAngle;
    tempMatrix[2][0] = (axis.x * axis.z) * oneMinusCos + axis.y * sinAngle;
    tempMatrix[2][1] = (axis.y * axis.z) * oneMinusCos - axis.x * sinAngle;
    tempMatrix[2][2] = (axis.z * axis.z) * oneMinusCos + cosAngle;

    Vector3<Type> temp(*this);
    Vector3<Type> result;

    result.x = (temp.x * tempMatrix[0][0]) + (temp.y * tempMatrix[1][0]) + (temp.z * tempMatrix[2][0]);
    result.y = (temp.x * tempMatrix[0][1]) + (temp.y * tempMatrix[1][1]) + (temp.z * tempMatrix[2][1]);
    result.z = (temp.x * tempMatrix[0][2]) + (temp.y * tempMatrix[1][2]) + (temp.z * tempMatrix[2][2]); 

    *this = result;
}

void OpenGLRenderer::startDraw(unsigned long mask)
{
    //sortBuffer();                                     // sort draw queue
    clearBuffers(mask);                                 // clear buffers
    loadIdentity();
    glTranslatef(-1*m_frustumCamera->getViewMatrix().getTranslationAxis().x,-1*m_frustumCamera->getViewMatrix().getTranslationAxis().y,-1*m_frustumCamera->getViewMatrix().getTranslationAxis().z);
    glMultMatrixf(m_frustumCamera->getViewMatrix().getMatrix());
    glTranslatef(m_frustumCamera->getViewMatrix().getTranslationAxis().x,m_frustumCamera->getViewMatrix().getTranslationAxis().y,m_frustumCamera->getViewMatrix().getTranslationAxis().z);// load identity

    //

    // push matrix stack
    matrixStackPush();                                          
}

空心平截头体A:：xAxisRotation（浮动角度）
{
//角度=角度*（双）除气器；
vector3x=m_方向。getXAxis（）；
vector3y=m_方向。getYAxis（）；
向量3 z=m_方向。getZAxis（）；
y、 旋转圆周轴（x，角度）；
x=m_方向。getXAxis（）；
z、 旋转圆周轴（x，角度）；
m_方向。setYAxis（y）；
m_方向。setZAxis（z）；
}
空心平截头体：Y轴旋转（浮动角度）
{
//角度=角度*（双）除气器；
vector3x=m_方向。getXAxis（）；
vector3y=m_方向。getYAxis（）；
向量3 z=m_方向。getZAxis（）；
x、 旋转圆周轴（y，角度）；
y=m_方向。getYAxis（）；
z、 旋转圆周轴（y，角度）；
m_方向。setXAxis（x）；
m_方向。setZAxis（z）；
}
空心平截头体：Z轴旋转（浮动角度）
{
vector3x=m_方向。getXAxis（）；
vector3y=m_方向。getYAxis（）；
向量3 z=m_方向。getZAxis（）；
x、 旋转圆周轴（z，角度）；
z=m_方向。getYAxis（）；
y、 旋转圆周轴（z，角度）；
m_方向。setXAxis（x）；
m_方向。setYAxis（y）；
}
模板
void Vector3:：rotateAroundAxis（Vector3轴，常量浮动角度）
{
浮动弧度=静态投影（角度*degToRad）；
类型sinAngle=静态_铸造（sin（弧度））；
类型cosAngle=0.0；
如果（角度==90 | |角度==-90）
余角=0.0；
其他的
余弦角=余弦（弧度）；
使（轴）正常化；//使轴正常化
类型oneMinusCos=1-余角；//（1-余角（θ））
//构造旋转矩阵
类型tempMatrix[3][3]；
tempMatrix[0][0]=（轴x*轴x）*oneMinusCos+cosAngle；
tempMatrix[0][1]=（x轴*y轴）*oneMinusCos+z轴*正弦角；
tempMatrix[0][2]=（x轴*z轴）*oneMinusCos-y轴*正弦角；
tempMatrix[1][0]=（x轴*y轴）*oneMinusCos-z轴*正弦角；
tempMatrix[1][1]=（y轴*y轴）*oneMinusCos+cosAngle；
tempMatrix[1][2]=（y轴*z轴）*oneMinusCos+x轴*正弦角；
tempMatrix[2][0]=（x轴*z轴）*oneMinusCos+y轴*正弦角；
tempMatrix[2][1]=（y轴*z轴）*oneMinusCos-x轴*正弦角；
tempMatrix[2][2]=（z轴*z轴）*oneMinusCos+余角；
矢量3温度（*此温度）；
矢量3结果；
结果x=（临时x*临时矩阵[0][0]）+（临时y*临时矩阵[1][0]）+（临时z*临时矩阵[2][0]）；
结果y=（临时x*临时矩阵[0][1]）+（临时y*临时矩阵[1][1]）+（临时z*临时矩阵[2][1]）；
结果z=（临时x*临时矩阵[0][2]）+（临时y*临时矩阵[1][2]）+（临时z*临时矩阵[2][2]）；
*这=结果；
}
void OpenGLRenderer:：startDraw（无符号长掩码）
{
//sortBuffer（）；//排序绘制队列
clearBuffers（掩码）；//清除缓冲区
loadIdentity（）；
GLTRANSTAREF（-1*m_视锥棱镜->getViewMatrix（）.getTranslationAxis（）.x，-1*m_视锥棱镜->getViewMatrix（）.getTranslationAxis（）.y，-1*m_视锥棱镜->getViewMatrix（）.getTranslationAxis（）.z）；
glMultMatrixf（m_-frustumCamera->getViewMatrix（）.getMatrix（））；
glTranslatef（m_-frustumCamera->getViewMatrix（）.getTranslationAxis（）.x，m_-frustumCamera->getViewMatrix（）.getTranslationAxis（）.getTranslationAxis（）.y，m_-frustumCamera->getViewMatrix（）.getTranslationAxis（）.z）；//加载标识
//
//推矩阵堆栈
matrixStackPush（）；
}

您可能正在经历；如果你一直向上或向下俯仰，使你的视线向量与你的上方向向量平行，这种情况下，偏航将与滚动相同

这可能是通过欧拉角逐段构造旋转的缺点。您可能需要研究四元数。（请注意，您不能使用欧拉角旋转；它们只是旋转的表示形式（您需要将其转换为矩阵或四元数），但您处理它的方式在很大程度上是一种“欧拉角”思维方式）

矩阵乘法的优点在于，任何多重旋转序列都可以表示（并连接）为单个旋转矩阵。你需要做的事情是这样的：

void Transformable::yaw(float angle)
{
    float4x4 rot; // temp rotation matrix
    float3 translate(&_transform._41); // save our translation
    float3 up(&_transform._21); // y axis

    // build the rotation matrix for rotation around y
    MatrixRotationAxis(&rot, &up, angle);

    // multiply our transform by the rotation matrix
    // note that order of multiplication matters and depends on
    // if your matrices are column-major or row-major
    MatrixMultiply(&_transform, &_transform, &rot);

    // write back our original translation
    memcpy(&_transform._41, &translate, sizeof(float3));

    // might want to reorthogonalise every now and then
    // to make sure basis vectors are orthonormal
    // or you will probably get matrix creep after a few operations
}

---

而不是一次旋转一个基向量。在这种情况下，变换将是表示变换矩阵的4x4同质矩阵。（旋转和平移）。左上角的3x3子矩阵只是方向空间的基向量。

矩阵不是避免了万向节锁吗？我非常专注，因为我正在传递我的新矩阵轴来旋转？你能给我一个更好的解释我将如何去修理它吗？'x.rotateAroundAxis（z，angle）；'是欧拉角旋转，而不是通过矩阵旋转。您需要将矩阵乘以旋转矩阵以避免万向节锁定。非常感谢这解决了我现在要尝试解决的另一个问题：(