Использование кватернионов для вращения OpenGL [дубликат]

На этот вопрос уже есть ответы здесь:

Вращение кватерниона без углов Эйлера(3 ответа)

Закрыто 10 месяцев назад.

Итак, я пишу программу, в которой объекты перемещаются в стиле космосимуляции, чтобы научиться плавно перемещать объекты в трехмерном пространстве. Немного повозившись с углами Эйлера, я понял, что они не очень подходят для трехмерного движения произвольной формы в произвольных направлениях, поэтому я решил перейти к тому, что лучше всего подходит для этой работы — к кватернионам. Я намерен, чтобы объект всегда вращался вокруг своих локальных осей XYZ, а не вокруг глобальных осей XYZ.

Я пытался реализовать систему вращения с помощью кватернионов, но что-то не работает. При вращении объекта по одной оси, если ранее не было вращений, объект нормально вращается по заданной оси.Однако при применении одного поворота после того, как был выполнен другой, второй поворот не всегда происходит вдоль локальной оси, вдоль которой он должен вращаться - например, после поворота примерно на 90° вокруг оси Z поворот вокруг оси Y по-прежнему происходит вокруг глобальной оси Y, а не новой локальной оси Y, которая выровнена с глобальной осью X.

Ха. Итак, давайте пройдемся по этому шаг за шагом. Ошибка должна быть где-то здесь.

ЭТАП 1. Захват входных данных

Я решил, что будет лучше использовать углы Эйлера (или схему Pitch-Yaw-Roll) для захвата входных данных игрока. На данный момент клавиши со стрелками управляют Pitch и Yaw, тогда как Q и E управляют Roll. Я фиксирую ввод игрока таким образом (я использую SFML 1.6):

    ///SPEEDS
    float ForwardSpeed = 0.05;
    float TurnSpeed = 0.5;

    //Rotation
    sf::Vector3 Rotation;
    Rotation.x = 0;
    Rotation.y = 0;
    Rotation.z = 0;
    //PITCH
    if (m_pApp->GetInput().IsKeyDown(sf::Key::Up) == true)
    {
        Rotation.x -= TurnSpeed;
    }
    if (m_pApp->GetInput().IsKeyDown(sf::Key::Down) == true)
    {
        Rotation.x += TurnSpeed;
    }
    //YAW
    if (m_pApp->GetInput().IsKeyDown(sf::Key::Left) == true)
    {
        Rotation.y -= TurnSpeed;
    }
    if (m_pApp->GetInput().IsKeyDown(sf::Key::Right) == true)
    {
        Rotation.y += TurnSpeed;
    }
    //ROLL
    if (m_pApp->GetInput().IsKeyDown(sf::Key::Q) == true)
    {
        Rotation.z -= TurnSpeed;
    }
    if (m_pApp->GetInput().IsKeyDown(sf::Key::E) == true)
    {
        Rotation.z += TurnSpeed;
    }

    //Translation
    sf::Vector3 Translation;
    Translation.x = 0;
    Translation.y = 0;
    Translation.z = 0;

    //Move the entity
    if (Rotation.x != 0 ||
        Rotation.y != 0 ||
        Rotation.z != 0)
    {
        m_Entity->ApplyForce(Translation, Rotation);
    }

m_Entity — это то, что я пытаюсь вращать. Он также содержит матрицы кватерниона и вращения, представляющие вращение объекта.

ШАГ 2 — Обновить кватернион

Я не уверен на 100%, что именно так и должно быть, но это то, что я пытался сделать в Entity::ApplyForce():

//Rotation
m_Rotation.x += Rotation.x;
m_Rotation.y += Rotation.y;
m_Rotation.z += Rotation.z;

//Multiply the new Quaternion by the current one.
m_qRotation = Quaternion(m_Rotation.x, m_Rotation.y, m_Rotation.z);// * m_qRotation;

m_qRotation.RotationMatrix(m_RotationMatrix);

Как видите , я не уверен, лучше ли просто построить новый кватернион из обновленных углов Эйлера, или я должен умножить кватернион, представляющий изменение, на кватернион, представляющий общее текущее вращение, как у меня сложилось впечатление при чтении это руководство. В последнем случае мой код будет выглядеть так:

//Multiply the new Quaternion by the current one.
m_qRotation = Quaternion(Rotation.x, Rotation.y, Rotation.z) * m_qRotation;

m_Rotation — текущее вращение объекта, сохраненное в формате PYR; Ротация — это изменение, требуемое игроком. В любом случае проблема может быть в моей реализации моего класса Quaternion.Вот в чем дело:

Quaternion::Quaternion(float Pitch, float Yaw, float Roll)
{
    float Pi = 4 * atan(1);

    //Set the values, which came in degrees, to radians for C++ trig functions
    float rYaw = Yaw * Pi / 180;
    float rPitch = Pitch * Pi / 180;
    float rRoll = Roll * Pi / 180;

    //Components
    float C1 = cos(rYaw / 2);
    float C2 = cos(rPitch / 2);
    float C3 = cos(rRoll / 2);
    float S1 = sin(rYaw / 2);
    float S2 = sin(rPitch / 2);
    float S3 = sin(rRoll / 2);

    //Create the final values
    a = ((C1 * C2 * C3) - (S1 * S2 * S3));
    x = (S1 * S2 * C3) + (C1 * C2 * S3);
    y = (S1 * C2 * C3) + (C1 * S2 * S3);
    z = (C1 * S2 * C3) - (S1 * C2 * S3);
}

//Overload the multiplier operator
Quaternion Quaternion::operator* (Quaternion OtherQuat)
{
    float A = (OtherQuat.a * a) - (OtherQuat.x * x) - (OtherQuat.y * y) - (OtherQuat.z * z);
    float X = (OtherQuat.a * x) + (OtherQuat.x * a) + (OtherQuat.y * z) - (OtherQuat.z * y);
    float Y = (OtherQuat.a * y) - (OtherQuat.x * z) - (OtherQuat.y * a) - (OtherQuat.z * x);
    float Z = (OtherQuat.a * z) - (OtherQuat.x * y) - (OtherQuat.y * x) - (OtherQuat.z * a);
    Quaternion NewQuat = Quaternion(0, 0, 0);
    NewQuat.a = A;
    NewQuat.x = X;
    NewQuat.y = Y;
    NewQuat.z = Z;
    return NewQuat;
}

//Calculates a rotation matrix and fills Matrix with it
void Quaternion::RotationMatrix(GLfloat* Matrix)
{
    //Column 1
    Matrix[0] = (a*a) + (x*x) - (y*y) - (z*z);
    Matrix[1] = (2*x*y) + (2*a*z);
    Matrix[2] = (2*x*z) - (2*a*y);
    Matrix[3] = 0;
    //Column 2
    Matrix[4] = (2*x*y) - (2*a*z);
    Matrix[5] = (a*a) - (x*x) + (y*y) - (z*z);
    Matrix[6] = (2*y*z) + (2*a*x);
    Matrix[7] = 0;
    //Column 3
    Matrix[8] = (2*x*z) + (2*a*y);
    Matrix[9] = (2*y*z) - (2*a*x);
    Matrix[10] = (a*a) - (x*x) - (y*y) + (z*z);
    Matrix[11] = 0;
    //Column 4
    Matrix[12] = 0;
    Matrix[13] = 0;
    Matrix[14] = 0;
    Matrix[15] = 1;
}

Там, наверное, есть что-то такое, от чего кто-нибудь поумнее меня содрогнется, но я этого не вижу. Для преобразования углов Эйлера в кватернион я использовал «первый метод» согласно этому источнику, который также, по-видимому, предполагает, что уравнение автоматически создает единичный кватернион («явно нормализованный»). Для умножения кватернионов я снова использовал это руководство по C++.

ШАГ 3. Получение матрицы вращения из кватерниона

Как только это будет сделано, согласно ответу Р. Мартиньо Фернандеса на этот вопрос, я пытаюсь построить матрицу вращения из кватерниона и используйте это, чтобы обновить вращение моего объекта, используя приведенный выше код Quaternion::RotationMatrix() в следующей строке:

m_qRotation.RotationMatrix(m_RotationMatrix);

Я должен отметить, что m_RotationMatrix — это GLfloat m_RotationMatrix[16], согласно обязательные параметры glMultMatrix, которые, я считаю, я должен использовать позже при отображении объекта. Он инициализируется как:

m_RotationMatrix = {1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1};

Который, как я считаю, является «нейтральной» матрицей вращения OpenGL (каждые 4 значения вместе представляют столбец, верно? Опять же, я получил это из страницы glMultMatrix).

ШАГ 4 - Отображение!

Наконец, мы получаем функцию, запускающую каждый цикл для объекта, который должен его отображать.

glPushMatrix();

glTranslatef(m_Position.x, m_Position.y, m_Position.z);
glMultMatrixf(m_RotationMatrix);

//glRotatef(m_Rotation.y, 0.0, 1.0, 0.0);
//glRotatef(m_Rotation.z, 0.0, 0.0, 1.0);
//glRotatef(m_Rotation.x, 1.0, 0.0, 0.0);

//glRotatef(m_qRotation.a, m_qRotation.x, m_qRotation.y, m_qRotation.z);

//[...] various code displaying the object's VBO

glPopMatrix();

Я оставил там свои предыдущие неудачные попытки, закомментировал.

Заключение - Грустная панда

Это завершение жизненного цикла ввода данных игроком, от колыбели до могилы, управляемой OpenGL.

Очевидно, я чего-то не понял, так как поведение, которое я получаю, не является тем поведением, которое я хочу или ожидаю.Но я не особенно разбираюсь в матричной математике или кватернионах, поэтому у меня нет достаточного понимания, чтобы увидеть ошибку на моем пути.

Кто-нибудь может мне помочь?

задан Community 23 May 2017 в 11:46

0 ответов

Другие вопросы по тегам:

3d quaternions sfml c++ opengl

Использование кватернионов для вращения OpenGL [дубликат]

0 ответов

Похожие вопросы: