22

我正在实现一个用于空间可视化的 3D 引擎,并且正在编写一个具有以下导航功能的相机:

  • 旋转相机(即,类似于旋转头部)
  • 围绕任意 3D 点(空间中的一个点,可能不在屏幕中心)旋转;相机需要围绕这个点旋转,保持相同的相对观察方向,即观察方向也会改变。这不直接看选择的旋转点)
  • 在相机的平面中平移(因此在与相机的观察矢量正交的平面中向上/向下或向左/向右移动)

相机不应该滚动——也就是说,“向上”仍然是向上的。因此,我用一个位置和两个角度表示相机,围绕 X 和 Y 轴旋转(Z 将是滚动的。)然后使用相机位置和这两个角度重新计算视图矩阵。这适用于平移和旋转眼睛,但不适用于围绕任意点旋转。相反,我得到以下行为:

  • 眼睛本身明显地向上或向下移动比它应该移动的更远
  • m_dRotationX当为 0 或 pi时,眼睛根本不会向上或向下移动。(云台锁?如何避免?)
  • m_dRotationX当在 pi 和 2pi 之间时,眼睛的旋转被反转(改变旋转使它在应该往下看的时候往上看,当它应该往上看时往下看) 。

(a) 是什么导致了这种旋转“漂移”?

这可能是万向节锁。如果是这样,对此的标准答案是“使用四元数表示旋转”,在 SO 上多次说过(例如123),但不幸的是没有具体细节例如。这是我找到的最佳答案到目前为止;它很少见。)我一直在努力使用结合上述两种旋转类型的四元数来实现相机。事实上,我正在使用两个旋转构建一个四元数,但下面的评论者说没有理由 - 立即构建矩阵很好。

当围绕一个点旋转时更改 X 和 Y 旋转(表示相机的观察方向)时会发生这种情况,但不会仅在直接更改旋转时发生,即围绕自身旋转相机。对我来说,这没有意义。这是相同的价值观。

(b) 不同的方法(例如四元数)是否更适合这台相机?如果是这样,我如何实现上述所有三个相机导航功能?

如果另一种方法会更好,那么请考虑提供该方法的具体实施示例。(我正在使用 DirectX9 和 C++,以及 SDK 提供的 D3DX* 库。)在第二种情况下,我将在几天内添加并奖励赏金,届时我可以在问题中添加一个。这听起来像是我在抢先一步,但我的时间很短,需要快速实施或解决这个问题(这是一个截止日期很紧的商业项目。)详细的答案也将改进 SO 档案,因为大多数到目前为止,我读过的相机答案对代码很简单。

谢谢你的帮助 :)


一些说明

感谢您到目前为止的评论和回答!我将尝试澄清有关该问题的一些事项:

  • 每当其中之一发生变化时,都会根据相机位置和两个角度重新计算视图矩阵。矩阵本身永远不会累积(即更新) - 它会重新计算。但是,相机位置和两个角度变量是累加的(例如,每当鼠标移动时,一个或两个角度都会有少量添加或减去,具体取决于鼠标上下移动的像素数和/或在屏幕上左右显示。)

  • 评论者 JCooper说我遇到了万向节锁定问题,我需要:

在应用变换之前,在变换上添加另一个旋转,将 eyePos 旋转到完全位于 yz 平面中,然后再进行另一个旋转,然后将其移回。在应用 yaw-pitch-roll 矩阵之前和之后立即围绕 y 轴旋转以下角度(其中一个角度需要取反;尝试是确定哪个角度的最快方法)。 double fixAngle = atan2(oEyeTranslated.z,oEyeTranslated.x);

不幸的是,当按照描述执行此操作时,由于其中一个旋转,我的眼睛以非常快的速度从场景上方射出。我确信我的代码只是这个描述的一个糟糕的实现,但我仍然需要更具体的东西。一般来说,我发现算法的非特定文本描述不如注释的、解释的实现有用。 我正在为一个与下面的代码集成的具体工作示例添加赏金(即也与其他导航方法)。这是因为我想了解解决方案,并且有一些可行的方法,并且因为我由于我的最后期限很紧,因此需要实施一些快速有效的东西。

请,如果您回答算法的文本描述,请确保它足够详细以实现(“围绕 Y 旋转,然后变换,然后旋转回来”可能对您有意义,但缺乏了解您的意思的细节。 好答案很清楚,有路标,即使有不同的基础,也能让其他人理解,是“坚固的防风雨信息板”。

反过来,我试图清楚地描述问题,如果我能更清楚地告诉我。


我当前的代码

要实现上述三个导航功能,在鼠标移动事件中根据光标移动的像素移动:

// Adjust this to change rotation speed when dragging (units are radians per pixel mouse moves)
// This is both rotating the eye, and rotating around a point
static const double dRotatePixelScale = 0.001;
// Adjust this to change pan speed (units are meters per pixel mouse moves)
static const double dPanPixelScale = 0.15;

switch (m_eCurrentNavigation) {
    case ENavigation::eRotatePoint: {
        // Rotating around m_oRotateAroundPos
        const double dX = (double)(m_oLastMousePos.x - roMousePos.x) * dRotatePixelScale * D3DX_PI;
        const double dY = (double)(m_oLastMousePos.y - roMousePos.y) * dRotatePixelScale * D3DX_PI;

        // To rotate around the point, translate so the point is at (0,0,0) (this makes the point
        // the origin so the eye rotates around the origin), rotate, translate back
        // However, the camera is represented as an eye plus two (X and Y) rotation angles
        // This needs to keep the same relative rotation.

        // Rotate the eye around the point
        const D3DXVECTOR3 oEyeTranslated = m_oEyePos - m_oRotateAroundPos;
        D3DXMATRIX oRotationMatrix;
        D3DXMatrixRotationYawPitchRoll(&oRotationMatrix, dX, dY, 0.0);
        D3DXVECTOR4 oEyeRotated;
        D3DXVec3Transform(&oEyeRotated, &oEyeTranslated, &oRotationMatrix);
        m_oEyePos = D3DXVECTOR3(oEyeRotated.x, oEyeRotated.y, oEyeRotated.z) + m_oRotateAroundPos;

        // Increment rotation to keep the same relative look angles
        RotateXAxis(dX);
        RotateYAxis(dY);
        break;
    }
    case ENavigation::ePanPlane: {
        const double dX = (double)(m_oLastMousePos.x - roMousePos.x) * dPanPixelScale;
        const double dY = (double)(m_oLastMousePos.y - roMousePos.y) * dPanPixelScale;
        m_oEyePos += GetXAxis() * dX; // GetX/YAxis reads from the view matrix, so increments correctly
        m_oEyePos += GetYAxis() * -dY; // Inverted compared to screen coords
        break;
    }
    case ENavigation::eRotateEye: {
        // Rotate in radians around local (camera not scene space) X and Y axes
        const double dX = (double)(m_oLastMousePos.x - roMousePos.x) * dRotatePixelScale * D3DX_PI;
        const double dY = (double)(m_oLastMousePos.y - roMousePos.y) * dRotatePixelScale * D3DX_PI;
        RotateXAxis(dX);
        RotateYAxis(dY);
        break;
    }

和方法非常简单RotateXAxisRotateYAxis

void Camera::RotateXAxis(const double dRadians) {
    m_dRotationX += dRadians;
    m_dRotationX = fmod(m_dRotationX, 2 * D3DX_PI); // Keep in valid circular range
}

void Camera::RotateYAxis(const double dRadians) {
    m_dRotationY += dRadians;

    // Limit it so you don't rotate around when looking up and down
    m_dRotationY = std::min(m_dRotationY, D3DX_PI * 0.49); // Almost fully up
    m_dRotationY = std::max(m_dRotationY, D3DX_PI * -0.49); // Almost fully down
}

并由此生成视图矩阵:

void Camera::UpdateView() const {
    const D3DXVECTOR3 oEyePos(GetEyePos());
    const D3DXVECTOR3 oUpVector(0.0f, 1.0f, 0.0f); // Keep up "up", always.

    // Generate a rotation matrix via a quaternion
    D3DXQUATERNION oRotationQuat;
    D3DXQuaternionRotationYawPitchRoll(&oRotationQuat, m_dRotationX, m_dRotationY, 0.0);
    D3DXMATRIX oRotationMatrix;
    D3DXMatrixRotationQuaternion(&oRotationMatrix, &oRotationQuat);

    // Generate view matrix by looking at a point 1 unit ahead of the eye (transformed by the above
    // rotation)
    D3DXVECTOR3 oForward(0.0, 0.0, 1.0);
    D3DXVECTOR4 oForward4;
    D3DXVec3Transform(&oForward4, &oForward, &oRotationMatrix);
    D3DXVECTOR3 oTarget = oEyePos + D3DXVECTOR3(oForward4.x, oForward4.y, oForward4.z); // eye pos + look vector = look target position
    D3DXMatrixLookAtLH(&m_oViewMatrix, &oEyePos, &oTarget, &oUpVector);
}
4

4 回答 4

8

在我看来,考虑到您形成视图矩阵的方式,“滚动”是不可能的。不管所有其他代码(其中一些看起来确实有点滑稽),调用D3DXMatrixLookAtLH(&m_oViewMatrix, &oEyePos, &oTarget, &oUpVector);应该创建一个没有滚动的矩阵,当[0,1,0]作为“向上”向量给出时,除非oTarget-oEyePos碰巧与向上向量平行。情况似乎并非如此,因为您限制m_dRotationY在 (-.49pi,+.49pi) 范围内。

也许你可以澄清你是如何知道“滚动”正在发生的。您是否有地平面并且该地平面的水平线偏离水平线?

顺便说一句,在 中UpdateViewD3DXQuaternionRotationYawPitchRoll似乎完全没有必要,因为您立即转身将其更改为矩阵。就像D3DXMatrixRotationYawPitchRoll在鼠标事件中一样使用。四元数用于相机,因为它们是一种方便的方式来累积眼睛坐标中发生的旋转。由于您仅以严格的顺序使用两个旋转轴,因此累积角度的方式应该没问题。(0,0,1) 的向量变换也不是必需的。oRotationMatrix应该已经在条目中有这些值(_31,_32,_33)


更新

鉴于它不是滚动,这就是问题所在:您创建一个旋转矩阵以在世界坐标中移动眼睛,但您希望俯仰发生在相机坐标中。由于不允许滚动并且最后执行偏航,因此在世界和相机参考系中偏航始终相同。考虑下面的图像:

局部旋转

您的代码适用于本地俯仰和偏航,因为它们是在相机坐标中完成的。

围绕一个点的正常间距

但是当您围绕参考点旋转时,您正在创建一个位于世界坐标中的旋转矩阵,并使用它来旋转相机中心。如果相机的坐标系恰好与世界坐标系对齐,这可以正常工作。但是,如果您在旋转摄像机位置之前不检查是否达到了俯仰限制,那么当您达到该限制时,您会出现疯狂的行为。相机会突然开始在世界上滑行——仍然围绕参考点“旋转”,但不再改变方向。

围绕一个点锁定间距

如果相机的轴与世界的轴不一致,就会发生奇怪的事情。在极端情况下,相机根本不会移动,因为您正试图让它滚动。

离轴俯仰会导致滚动

以上是通常会发生的情况,但由于您单独处理相机方向,相机实际上并没有滚动。

相机方向与平移分开处理

相反,它保持直立,但你会得到奇怪的翻译。

处理此问题的一种方法是(1)始终将相机置于相对于参考点的规范位置和方向,(2)进行旋转,然后(3)完成后将其放回原处(例如,类似于将参考点平移到原点的方式,应用 Yaw-Pitch 旋转,然后平移回来)。然而,仔细想想,这可能不是最好的方法。


更新 2

我认为通用人类的答案可能是最好的。如果旋转是离轴的,问题仍然是应该应用多少俯仰,但现在,我们将忽略它。也许它会给你可接受的结果。

答案的本质是:在鼠标移动之前,您的相机位于c 1 =m_oEyePos并且由M 1 =定向D3DXMatrixRotationYawPitchRoll(&M_1,m_dRotationX,m_dRotationY,0)。考虑参考点a = m_oRotateAroundPos。从相机的角度来看,这个点是a'=M 1 (ac 1 )

您想将相机的方向更改为M 2 = D3DXMatrixRotationYawPitchRoll(&M_2,m_dRotationX+dX,m_dRotationY+dY,0)。[重要提示:由于您不允许m_dRotationY超出特定范围,因此应确保 dY 不违反该约束。] 随着相机改变方向,您还希望其位置围绕a旋转到新点2 . _ 这意味着从相机的角度来看, a不会改变。即,M 1 (ac 1 )==M 2 (ac 2 )

所以我们求解c 2(记住旋转矩阵的转置与逆矩阵相同):

M 2 T M 1 (ac 1 )==(ac 2 ) =>

-M 2 T M 1 (ac 1 )+a==c 2

现在,如果我们将其视为应用于c 1的变换,那么我们可以看到它首先被取反,然后被a平移,然后被M 1旋转,然后被M 2 T旋转,再次被取反,然后被平移再次。这些是图形库擅长的变换,它们都可以压缩成一个单一的变换矩阵。

@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;
}
于 2012-07-16T20:53:17.020 回答
5

我认为有一个更简单的解决方案可以让您回避所有轮换问题。

符号:A是我们要旋转的点,C是原始相机位置,M是将全局坐标映射到相机本地视口的原始相机旋转矩阵。

  1. 记下A的局部坐标,它等于A' = M × ( A - C )。
  2. 像在正常的“眼睛旋转”模式下一样旋转相机。更新视图矩阵M使其修改为M 2并且C保持不变。
  3. 现在我们想找到C 2使得A' = M 2 × ( A - C 2 )。
    这很容易通过等式C 2 = A - M 2 -1 × A'完成。
  4. 瞧,相机已经旋转,因为A的局部坐标没有改变,所以A保持在相同的位置、相同的比例和距离。

作为额外的奖励,“眼睛旋转”和“点旋转”模式之间的旋转行为现在是一致的。

于 2012-07-27T08:26:25.487 回答
4

您通过重复应用小的旋转矩阵来围绕该点旋转,这可能会导致漂移(小的精度误差加起来),我敢打赌,一段时间后您不会真正做一个完美的圆圈。由于视图的角度使用简单的一维双精度,因此它们的漂移要小得多。

一个可能的解决方法是在您进入该视图模式时存储一个专用的偏航/俯仰和相对位置,并使用这些来进行数学计算。这需要更多的簿记,因为您需要在移动相机时更新它们。请注意,如果点移动,它也会使相机移动,我认为这是一种改进。

于 2012-07-13T14:15:03.080 回答
2

如果我理解正确,您对最终矩阵中的旋转分量感到满意(除了问题#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 是相当奇怪的(这是偏航,不是俯仰,对吧?)并且可能与上述有关。

于 2012-07-31T13:19:43.850 回答