来自模型视图矩阵的openGL位置和方向 [英] openGL position and orientation from modelview matrix

问题描述

我的问题如下:

我在opengl场景中嵌套了对象，我只知道它们的相对位置和方向.

I have nested object in my opengl scene, and i only know their relative position and orientation.

如何获得内部对象的绝对位置和方向?我正在考虑计算内部对象的模型视图矩阵，然后获得当前矩阵，但是如何将其转换为位置和方向?换句话说，要两个浮点向量，所以我可以调用以下代码:

How do I get the absolute position and orientation of the inner object? I' thinking of calculating the modelview matrix of the inner object, and after that i have the current matrix, but how do i convert it to position and orientation? In other words, to two float vector, so I can call the following code:

glTranslatef(position.x,position.y,position.z);

glRotatef(alignment.x,1.0f,0.0f,0.0f);
glRotatef(alignment.y,0.0f,1.0f,0.0f);
glRotatef(alignment.z,0.0f,0.0f,1.0f);

提前谢谢！

推荐答案

如果您拥有对象的模型视图矩阵，则可以使用以下代码提取位置:

If you have the modelview matrix of the object you can extract the position with the following code:

// ... Some rotations/translations has been applied
GLfloat matrix[16]; 
glGetFloatv (GL_MODELVIEW_MATRIX, matrix);
const float position_x = matrix[12];
const float position_y = matrix[13];
const float position_z = matrix[14];

旋转稍微复杂一点，请看:欧拉角.我们想要的旋转矩阵是zyx-one =>

The rotation is a little bit more complex, look at: euler angles. The rotation matrix we want is the transpose of the zyx-one =>

//c1 = cos(alignment_x)
//c2 = cos(alignment_y)
//c3 = cos(alignment_z)
//s1 = sin(alignment_x)
//s2 = sin(alignment_y)
//s3 = sin(alignment_z)
//matrix[0] = c1 * c2
//matrix[1] = -c2 * s1
//matrix[2] = s2
//matrix[4] = c3 * s1 + c1 * s2 * s3
//matrix[5] = c1 * c3 - s1 * s2 * s3
//matrix[6] = -c2 * s3
//matrix[8] = s1 * s3 - c1 * c3 * s2
//matrix[9] = c3 * s1 * s2 + c1 * s3
//matrix[10] = c2 * c3

从中提取实际角度是相当麻烦的，因为存在几个奇异点，如果我们忽略这些奇点，我们会得到:

Extracting the actual angles from this is rather messy because there are a couple of singularities, if we ignore these we get:

// Assumes c2 != 0, you'll need more code to handle the special cases
if (matrix[0] != 0.0f || matrix[1] != 0.0f) {
    const float alignment_x = atanf(-matrix[1], matrix[0]);
    float c2;
    if (0 != cosf(alignment_x)) {
        c2 = matrix(0) / cosf(alignment_x);
    } else {
        c2 = matrix(1) / -sinf(alignment_x);
    }
    const float alignment_y = atanf(matrix[2], c2);
    const float alignment_z = atanf(-matrix[6], matrix[10]);
} else {
    alignment_y = atanf(matrix[2], 0);
    //Too tired to deduce alignment_x and alignment_z, someone else?
}

以上所有代码均假定您仅使用旋转/平移，而没有缩放或倾斜.

All the above code assumes you're only using rotations/translations and no scalings or skewings.

让我最后说欧拉角是邪恶的，如果我是你，我会寻找替代方案来解决您试图解决的任何问题;)

Let me just finish by saying euler angles are evil, if I were you I would look for an alternative solution to whatever problem it is you're trying to solve ;)

/A.B.

这篇关于来自模型视图矩阵的openGL位置和方向的文章就介绍到这了，希望我们推荐的答案对大家有所帮助，也希望大家多多支持IT屋！