Неправильно вправо, вверх и вперед после поворота

Question

Я работаю над добавлением обработчика матрицы в свою игру, используя OpenGL, и пока что большинство из них работает, но я, кажется, не понимаю, как правильно извлечь векторы вправо, вверх и вперед из матрицы вращения. У меня есть следующий код:

glm::mat4 clsMatrixHandler::SetRotation( float a_Pitch, float a_Yaw, float a_Roll )
{
    glm::mat4 l_Rotx;
    glm::mat4 l_Roty;
    glm::mat4 l_Rotz;
    PitchYawRollToXYZMatrices( a_Pitch, a_Yaw, a_Roll, l_Rotx, l_Roty, l_Rotz );
    m_PitchYawRolls.clear( );
    m_PitchYawRolls.push_back( glm::vec3( a_Pitch, a_Yaw, a_Roll ) );
    m_RotationMatrix = l_Rotx * l_Roty * l_Rotz;
    m_Right = glm::vec3( m_RotationMatrix[ 0 ][ 0 ], m_RotationMatrix[ 1 ][ 0 ], m_RotationMatrix[ 2 ][ 0 ] );
    m_Up = glm::vec3( m_RotationMatrix[ 0 ][ 1 ], m_RotationMatrix[ 1 ][ 1 ], m_RotationMatrix[ 2 ][ 1 ] );
    m_Forward = glm::vec3( m_RotationMatrix[ 0 ][ 2 ], m_RotationMatrix[ 1 ][ 2 ], m_RotationMatrix[ 2 ][ 2 ] );
    return m_RotationMatrix;
}

void clsMatrixHandler::PitchYawRollToXYZMatrices( float a_Pitch, float a_Yaw, float a_Roll, glm::mat4& a_rX, glm::mat4& a_rY, glm::mat4& a_rZ )
{
    float l_cPitch = glm::cos( glm::radians( a_Pitch ) );
    float l_sPitch = glm::sin( glm::radians( a_Pitch ) );
    float l_cYaw = glm::cos( glm::radians( a_Yaw ) );
    float l_sYaw = glm::sin( glm::radians( a_Yaw ) );
    float l_cRoll = glm::cos( glm::radians( a_Roll ) );
    float l_sRoll = glm::sin( glm::radians( a_Roll ) );
    a_rX = {
        l_cPitch, -l_sPitch, 0.0f, 0.0f,
        l_sPitch,  l_cPitch, 0.0f, 0.0f,
        0.0f,      0.0f,     1.0f, 0.0f,
        0.0f,      0.0f,     0.0f, 1.0f
    };
    a_rY = {
        l_cYaw, 0.0f, -l_sYaw, 0.0f,
        0.0f,   1.0f,  0.0f,   0.0f,
        l_sYaw, 0.0f,  l_cYaw, 0.0f,
        0.0f,   0.0f,  0.0f,   1.0f
    };
    a_rZ = {
        1.0f, 0.0f,     0.0f,    0.0f,
        0.0f, l_cRoll, -l_sRoll, 0.0f,
        0.0f, l_sRoll,  l_cRoll, 0.0f,
        0.0f, 0.0f,     0.0f,    1.0f
    };
}

void clsMatrixHandler::Test()
{
    float l_Pitch = -90.0f;
    float l_Yaw = 0.0f;
    float l_Roll = 0.0f;
    glm::mat4 l_RotationMatrix = m_MatrixHandler.SetRotation( l_Pitch, l_Yaw, l_Roll );

    std::vector<glm::vec3> l_PYRs = m_MatrixHandler.GetPitchYawRolls( );
    OutputDebugStringA( ( "Pitch: " + std::to_string( l_PYRs[ l_PYRs.size( ) - 1 ].x ) + "\n" +
                          "Yaw: " + std::to_string( l_PYRs[ l_PYRs.size( ) - 1 ].y ) + "\n" +
                          "Roll: " + std::to_string( l_PYRs[ l_PYRs.size( ) - 1 ].z ) + "\n" ).c_str( ) );

    glm::vec4 l_Point = glm::vec4( 10, 0, 0, 0 );
    glm::vec4 l_PointInLocalSpace = l_RotationMatrix * glm::vec4( l_Point.x, l_Point.y, l_Point.z, 0 );

    OutputDebugStringA( ( "New Transformation Matrix: \n" +
                          std::to_string( l_RotationMatrix[ 0 ][ 0 ] ) + ", " + std::to_string( l_RotationMatrix[ 1 ][ 0 ] ) + ", " + std::to_string( l_RotationMatrix[ 2 ][ 0 ] ) + "\n" +
                          std::to_string( l_RotationMatrix[ 0 ][ 1 ] ) + ", " + std::to_string( l_RotationMatrix[ 1 ][ 1 ] ) + ", " + std::to_string( l_RotationMatrix[ 2 ][ 1 ] ) + "\n" +
                          std::to_string( l_RotationMatrix[ 0 ][ 2 ] ) + ", " + std::to_string( l_RotationMatrix[ 1 ][ 2 ] ) + ", " + std::to_string( l_RotationMatrix[ 2 ][ 2 ] ) + "\n"
                          ).c_str( ) );

    OutputDebugStringA( ( "New Point Position: \n" + std::to_string( l_PointInLocalSpace.x ) + ", " + std::to_string( l_PointInLocalSpace.y ) + ", " + std::to_string( l_PointInLocalSpace.z ) + "\n" ).c_str( ) );
}

Выход:

Pitch: -90.000000
Yaw: 0.000000
Roll: 0.000000
New Transformation Matrix: 
-0.000000, -1.000000, 0.000000
1.000000, -0.000000, 0.000000
0.000000, 0.000000, 1.000000
New Point Position: 
-0.000000, 10.000000, 0.000000

Насколько я знаю, первая, вторая и третья строки в матрице расположены справа, вверх и вперед, поэтому:

Right: 0.0, -1.0, 0.0
Up: 1.0, 0.0, 0.0
Forward: 0.0, 0.0, 1.0

Кроме того, шаг -90 должен указывать вперед (0,0, 1,0, 0,0) сейчас.

1. Как это возможно, я просто катился, а не разбил?
2. Почему умножение матрицы на точку дает мне правильный результат?

Answer 1

В вашем коде a_rX вычисляет вращение вокруг оси z и a_rZ вращение вокруг оси х.

Чтобы решить вашу проблему, шаг должен быть:

a_rX = {
    1.0f, 0.0f,      0.0f,     0.0f,
    0.0f, l_cPitch, -l_sPitch, 0.0f,
    0.0f, l_sPitch,  l_cPitch, 0.0f,      
    0.0f, 0.0f,      0.0f,     1.0f
};

и рулон должен быть:

a_rZ = {
    l_cRoll, -l_sRoll, 0.0f, 0.0f,
    l_sRoll,  l_cRoll, 0.0f, 0.0f,
    0.0f,     0.0f,    1.0f, 0.0f,
    0.0f,     0.0f,    0.0f, 1.0f
};