1

我有一个simd_float4x4矩阵，它是相机的变换矩阵。

在该矩阵中，我们有tx,即平移向量和ty, , , , , , ,和,即旋转矩阵。tz0x0y0z1x1y1z2x2y2z

┌                  ┐
|  0x  1x  2x  tx  |
|  0y  1y  2y  ty  |
|  0z  1z  2z  tz  |
|  0   0   0   1   |
└                  ┘

当我在 3D 应用程序上测试旋转矩阵时，我看到沿 X 轴和 Y 轴的旋转是反转的，而沿 Z 轴的旋转是正确的。

因此，在 X 轴和 Y 轴上，真实相机顺时针旋转的任何旋转都显示为逆时针旋转。

我需要反转这些旋转。

忍受我，因为我的矩阵代数生锈了。

因此，如this SO answer的下一张图片所述，轴的旋转矩阵是

在此处输入图像描述

如果我在正确的道路上，我需要将我的旋转矩阵乘以Rxand Ry，对吗？

如果我想反转 and 中的旋转X，Y我的RxandRy将等于：

     ┌             ┐
     |  1   0   0  |
Rx = |  0  -1   0  |
     |  0   0  -1  |
     └             ┘

     ┌             ┐
     |  -1  0   0  |
Ry = |   0  1   0  |
     |   0  0  -1  |
     └             ┘

我可以相乘Rx并Ry获得我必须使用的最终矩阵：

    ┌              ┐
    |  -1   0   0  |
R = |   0  -1   0  |
    |   0   0   1  |
    └              ┘

所以，我所要做的就是将我的旋转矩阵乘以R得到旋转X和Y反转，对吧？

不，最终结果是一样的……唯一发生的事情是相机似乎在 Y 轴上旋转了。

我正在使用此代码

import simd

extension simd_float4x4 {

  var rotatedXY: simd_float4x4 {

    let c0 = SIMD3<Float>(-1.0, 0.0, 0.0)
    let c1 = SIMD3<Float>(0.0, -1.0, 0.0)
    let c2 = SIMD3<Float>(0.0,  0.0, 1.0)
    let inverse = simd_float3x3(c0,c1,c2)

    let cx0 = SIMD3<Float>(columns.0.x, columns.0.y, columns.0.z)
    let cx1 = SIMD3<Float>(columns.1.x, columns.1.y, columns.1.z)
    let cx2 = SIMD3<Float>(columns.2.x, columns.2.y, columns.2.z)
    let matrix = simd_float3x3(cx0,cx1,cx2)

    let multiplication = matrix * inverse

    var resultado = self

    resultado.columns.0.x = multiplication.columns.0.x
    resultado.columns.0.y = multiplication.columns.0.y
    resultado.columns.0.z = multiplication.columns.0.z

    resultado.columns.1.x = multiplication.columns.1.x
    resultado.columns.1.y = multiplication.columns.1.y
    resultado.columns.1.z = multiplication.columns.1.z

    resultado.columns.2.x = multiplication.columns.2.x
    resultado.columns.2.y = multiplication.columns.2.y
    resultado.columns.2.z = multiplication.columns.2.z

    return resultado
  }
}

我错过了什么？

4

1 回答 1

1

我意识到我把这条线倒过来了。

let multiplication = matrix * inverse

正确的是

let multiplication = inverse * matrix
于 2020-06-15T02:39:06.833 回答