Внедрение комплексной камеры, основанной на поворотах

Ответ 1

Мне кажется, что "Roll" не может быть возможным, учитывая то, как вы формируете свою матрицу представлений. Независимо от всего остального кода (некоторые из которых выглядят немного забавно), вызов D3DXMatrixLookAtLH(&m_oViewMatrix, &oEyePos, &oTarget, &oUpVector); должен создать матрицу без рулона, если задан [0,1,0] как вектор "Вверх", если oTarget-oEyePos не будет параллельным вектор. Это не похоже на то, что вы ограничиваете m_dRotationY в пределах (-.49pi,+. 49pi).

Возможно, вы можете уточнить, как вы знаете, что происходит "roll". У вас есть наземная плоскость, а линия горизонта этой плоскости земли отходит от горизонтали?

В стороне, в UpdateView, D3DXQuaternionRotationYawPitchRoll кажется совершенно ненужным, так как вы сразу же поворачиваетесь и меняете его на матрицу. Просто используйте D3DXMatrixRotationYawPitchRoll, как это было в событии мыши. Кватернионы используются в камерах, потому что они являются удобным способом накопления поворотов, происходящих в координатах глаз. Поскольку вы используете только две оси вращения в строгом порядке, ваш способ накопления углов должен быть прекрасным. Векторное преобразование (0,0,1) также не является необходимым. oRotationMatrix должен иметь эти значения в записях (_31,_32,_33).

Обновление

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

Ваш код отлично работает для локального тона и рыскания, поскольку они выполняются в координатах камеры.

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

Если оси камеры не совпадают с мировыми, странные вещи произойдут. В крайнем случае камера не будет двигаться вообще, потому что вы пытаетесь ее перевернуть.

Выше было то, что обычно происходит, но поскольку вы управляете ориентацией камеры отдельно, камера фактически не катится.

Вместо этого он остается вертикально, но вы получаете странный перевод.

Один из способов управления этим состоял в том, чтобы (1) всегда помещал камеру в каноническое положение и ориентацию относительно контрольной точки, (2) делал поворот, а затем (3) возвращал его, когда вы закончите (например, аналогично тому, как вы переводите контрольную точку в начало координат, примените поворот Yaw-Pitch, а затем переведите назад). Однако, думая больше об этом, это, вероятно, не самый лучший способ пойти.

Обновление 2

Я думаю, что ответ Generic Human, вероятно, лучший. Остается вопрос, как много тона должно применяться, если вращение вне оси, но пока мы это проигнорируем. Возможно, это даст вам приемлемые результаты.

Суть ответа такова: перед движением мыши ваша камера находится на c ₁= m_oEyePos и ориентирована на M ₁= D3DXMatrixRotationYawPitchRoll(&M_1,m_dRotationX,m_dRotationY,0). Рассмотрим опорную точку a= m_oRotateAroundPos. С точки зрения камеры эта точка a '= M ₁ (a-c ₁).

Вы хотите изменить ориентацию камеры на M ₂= D3DXMatrixRotationYawPitchRoll(&M_2,m_dRotationX+dX,m_dRotationY+dY,0). [Важно: поскольку вы не позволяете m_dRotationY выйти за пределы определенного диапазона, вы должны убедиться, что dY не нарушает это ограничение.] Когда камера меняет ориентацию, вы также хотите, чтобы ее положение вращалось вокруг a в новую точку c ₂. Это означает, что a не изменится с точки зрения камеры. Т.е. M ₁ (ac ₁) == M ₂ (ac ₂).

Итак, мы решаем для c ₂ (помните, что транспонирование матрицы вращения такая же, как и обратная):

M <суб > 2суб > ^T M <суб > 1суб > (ас <суб > 1суб > ) == (ас <суб > 2) = >

-M <суб > 2суб > ^TМ <суб > 1суб > (а-с <суб > 1суб > ) + а == с <суб > 2суб >

Теперь, если мы рассмотрим это как преобразование, применяемое к c ₁, мы можем видеть, что он сначала отрицается, а затем переводится a, затем поверните на M ₁, затем поверните на M ₂ ^T, снова отменили, а затем снова перевели a. Это преобразования, которые хорошо подходят графическим библиотекам, и все они могут быть зажаты в одну матрицу преобразования.

@Generic Human заслуживает доверия за ответ, но вот код для него. Конечно, вам нужно реализовать функцию для проверки изменения высоты тона до ее применения, но это просто. Этот код, вероятно, имеет пару опечаток, поскольку я не пытался скомпилировать:

case ENavigation::eRotatePoint: {
    const double dX = (double)(m_oLastMousePos.x - roMousePos.x) * dRotatePixelScale * D3DX_PI;
    double dY = (double)(m_oLastMousePos.y - roMousePos.y) * dRotatePixelScale * D3DX_PI;
    dY = validatePitch(dY); // dY needs to be kept within bounds so that m_dRotationY is within bounds

    D3DXMATRIX oRotationMatrix1; // The camera orientation before mouse-change
    D3DXMatrixRotationYawPitchRoll(&oRotationMatrix1, m_dRotationX, m_dRotationY, 0.0);

    D3DXMATRIX oRotationMatrix2; // The camera orientation after mouse-change
    D3DXMatrixRotationYawPitchRoll(&oRotationMatrix2, m_dRotationX + dX, m_dRotationY + dY, 0.0);

    D3DXMATRIX oRotationMatrix2Inv; // The inverse of the orientation
    D3DXMatrixTranspose(&oRotationMatrix2Inv,&oRotationMatrix2); // Transpose is the same in this case

    D3DXMATRIX oScaleMatrix; // Negative scaling matrix for negating the translation
    D3DXMatrixScaling(&oScaleMatrix,-1,-1,-1);

    D3DXMATRIX oTranslationMatrix; // Translation by the reference point
    D3DXMatrixTranslation(&oTranslationMatrix,
         m_oRotateAroundPos.x,m_oRotateAroundPos.y,m_oRotateAroundPos.z);

    D3DXMATRIX oTransformMatrix; // The full transform for the eyePos.
    // We assume the matrix multiply protects against variable aliasing
    D3DXMatrixMultiply(&oTransformMatrix,&oScaleMatrix,&oTranslationMatrix);
    D3DXMatrixMultiply(&oTransformMatrix,&oTransformMatrix,&oRotationMatrix1);
    D3DXMatrixMultiply(&oTransformMatrix,&oTransformMatrix,&oRotationMatrix2Inv);
    D3DXMatrixMultiply(&oTransformMatrix,&oTransformMatrix,&oScaleMatrix);
    D3DXMatrixMultiply(&oTransformMatrix,&oTransformMatrix,&oTranslationMatrix);

    D3DXVECTOR4 oEyeFinal;
    D3DXVec3Transform(&oEyeFinal, &m_oEyePos, &oTransformMatrix);

    m_oEyePos = D3DXVECTOR3(oEyeFinal.x, oEyeFinal.y, oEyeFinal.z) 

    // Increment rotation to keep the same relative look angles
    RotateXAxis(dX);
    RotateYAxis(dY);
    break;
}

Ответ 2

Вы вращаетесь вокруг точки, многократно применяя малые матрицы вращения, это, вероятно, вызывает дрейф (небольшие ошибки точности складываются), и я уверен, вы не сделаете идеальный круг через некоторое время. Так как углы для представления используют простой одномерный двойной, они имеют гораздо меньший дрейф.

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

Ответ 3

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

Обозначение: A - это точка, которую мы хотим повернуть вокруг, C - исходное местоположение камеры, M - исходная матрица вращения камеры, которая отображает глобальные координаты в локальное окно просмотра камеры.

• Запишите локальные координаты A, которые равны A '= M × (A - C).
• Поверните камеру, как в обычном режиме "поворота глаз". Обновите матрицу представлений M так, чтобы она была изменена на M ₂, а C не изменился.
• Теперь мы хотели бы найти C ₂, что A '= M ₂ × (A - C ₂).
  Это легко сделать с помощью уравнения C ₂= A - M ₂ ^-1 × A '.
• Voilà, камера была повернута и из-за того, что локальные координаты A не изменились, A остается в том же месте и в том же масштабе и расстоянии.

В качестве дополнительного бонуса поведение вращения теперь согласовано между режимом "поворот глаз" и "поворот точки".

Ответ 4

Если я правильно понимаю, вы удовлетворены компонентом вращения в финальной матрице (за исключением элементов управления с инвертированным вращением в задаче № 3), но не с частью перевода, так это?

Проблема, похоже, связана с тем, что вы относитесь к ним по-другому: вы каждый раз пересчитываете часть вращения с нуля, но накапливаете часть перевода (m_oEyePos). В других комментариях упоминаются проблемы с точностью, но на самом деле они более значительны, чем просто точность FP: накопление вращений с небольшими значениями рыскания/шага просто не совпадает - математически --- как одно большое вращение от накопленного рыскания/высоты. Следовательно, расхождение поворота/сдвига. Чтобы исправить это, попробуйте пересчитать положение глаз с нуля одновременно с частью вращения, аналогично тому, как вы находите "oTarget = oEyePos +...":

oEyePos = m_oRotateAroundPos - dist * D3DXVECTOR3(oForward4.x, oForward4.y, oForward4.z)

dist можно фиксировать или вычислять из положения старого глаза. Это будет поддерживать точку поворота в центре экрана; в более общем случае (который вас интересует), -dist * oForward здесь следует заменить старым/начальным m_oEyePos - m_oRotateAroundPos, умноженным на старое/начальное вращение камеры, чтобы привести его в пространство камеры (поиск постоянного вектора смещения в система координат камеры), затем умножается на инвертированное вращение новой камеры, чтобы получить новое направление в мире.

Это, конечно же, будет зависеть от карданного замка, когда шаг будет прямо вверх или вниз. Вам нужно будет точно определить, какое поведение вы ожидаете в этих случаях, чтобы решить эту часть. С другой стороны, блокировка в m_dRotationX = 0 или = pi довольно странная (это рыскание, а не шаг, справа?) И может быть связано с выше.