从窗口转换的深度分量 - ＆gt;世界坐标

Question

我正在制作一个绘制100x100网格的程序，并允许用户点击一个单元格并更改颜色。

单击也可以当前工作，但只有在查看网格面（即camPos.z等于camLook.z）并且网格位于屏幕中心时才会有效。

过去几天我一直在选择正确的单元格时，从不同的摄像机位置或屏幕上的不同区域查看网格。

我唯一的猜测是，深度缓冲区不会反映相机的当前位置，或者缓冲区深度范围与相机的近端和远端值之间存在一些不一致。或者我正在应用投影/视图矩阵的方式可以显示图像，但是当回到管道时会出现问题。但我无法弄明白。

（自最初发布以来更新/重构的代码）

顶点着色器：

#version 330

layout(location = 0) in vec4 position;

smooth out vec4 theColor;

uniform vec4 color;
uniform mat4 pv;

void main() {
  gl_Position = pv * position;
  theColor = color;
}

相机类（projectionViewMatrix()的结果是上面的pv制服）：

Camera::Camera()
{
  camPos = glm::vec3(1.0f, 5.0f, 2.0f);
  camLook = glm::vec3(1.0f, 0.0f, 0.0f);

  fovy = 90.0f;
  aspect = 1.0f;
  near = 0.1f;
  far = 1000.0f;
}

glm::mat4 Camera::projectionMatrix()
{
  return glm::perspective(fovy, aspect, near, far);
}

glm::mat4 Camera::viewMatrix()
{
  return glm::lookAt(
    camPos,
    camLook,
    glm::vec3(0.0f, 1.0f, 0.0f)
  );
}

glm::mat4 Camera::projectionViewMatrix()
{
  return projectionMatrix() * viewMatrix();
}

// view controls

void Camera::moveForward()
{
  camPos.z -= 1.0f;
  camLook.z -= 1.0f;
}

void Camera::moveBack()
{
  camPos.z += 1.0f;
  camLook.z += 1.0f;
}

void Camera::moveLeft()
{
  camPos.x -= 1.0f;
  camLook.x -= 1.0f;
}

void Camera::moveRight()
{
  camPos.x += 1.0f;
  camLook.x += 1.0f;
}

void Camera::zoomIn()
{
  camPos.y -= 1.0f;
}

void Camera::zoomOut()
{
  camPos.y += 1.0f;
}

void Camera::lookDown()
{
  camLook.z += 0.1f;
}

void Camera::lookAtAngle()
{
  if (camLook.z != 0.0f)
    camLook.z -= 0.1f;
}

我想要获取世界坐标的相机类中的特定功能（x和y是屏幕坐标）：

glm::vec3 Camera::experiment(int x, int y)
{
  GLint viewport[4];
  glGetIntegerv(GL_VIEWPORT, viewport);

  GLfloat winZ;
  glReadPixels(x, y, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);
  printf("DEPTH: %f\n", winZ);

  glm::vec3 pos = glm::unProject(
    glm::vec3(x, viewport[3] - y, winZ),
    viewMatrix(),
    projectionMatrix(),
    glm::vec4(0.0f, 0.0f, viewport[2], viewport[3])
  );

  printf("POS: (%f, %f, %f)\n", pos.x, pos.y, pos.z);

  return pos;
}

初始化和显示：

void init(void)
{
  glewExperimental = GL_TRUE;
  glewInit();

  glEnable(GL_DEPTH_TEST);
  glDepthMask(GL_TRUE);
  glDepthFunc(GL_LESS);
  glDepthRange(0.0f, 1.0f);

  InitializeProgram();
  InitializeVAO();
  InitializeGrid();

  glEnable(GL_CULL_FACE);
  glCullFace(GL_BACK);
  glFrontFace(GL_CW);
}

void display(void)
{
  glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

  glUseProgram(theProgram);
  glBindVertexArray(vao);

  glUniformMatrix4fv(projectionViewMatrixUnif, 1, GL_FALSE, glm::value_ptr(camera.projectionViewMatrix()));

  DrawGrid();

  glBindVertexArray(0);
  glUseProgram(0);

  glutSwapBuffers();
  glutPostRedisplay();
}

int main(int argc, char** argv)
{
  glutInit(&argc, argv);

  glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH);
  glutInitContextVersion(3, 2);
  glutInitContextProfile(GLUT_CORE_PROFILE);

  glutInitWindowSize(500, 500);
  glutInitWindowPosition(300, 200);

  glutCreateWindow("testing");

  init();

  glutDisplayFunc(display);
  glutReshapeFunc(reshape);
  glutKeyboardFunc(keyboard);
  glutMouseFunc(mouse);
  glutMainLoop();
  return 0;
}

Answer 1

在光标下投射光线以实现拾取实际上非常简单。它总是适用于任何投影和模型视图矩阵（除了一些无效的奇异情况，它们将整个场景转换为无限等）。

为了简单起见，我编写了一个使用弃用的固定功能管道的小型演示，但代码也适用于着色器。首先从OpenGL中读取矩阵：

glm::mat4 proj, mv;
glGetFloatv(GL_PROJECTION_MATRIX, &proj[0][0]);
glGetFloatv(GL_MODELVIEW_MATRIX, &mv[0][0]);
glm::mat4 mvp = proj * mv;

此处mvp是您传递给顶点着色器的内容。然后我们定义两点：

glm::vec4 nearc(f_mouse_x, f_mouse_y, 0, 1);
glm::vec4 farc(f_mouse_x, f_mouse_y, 1, 1);

这些是标准化空间中的近和远光标坐标（因此f_mouse_x和f_mouse_y位于[-1, 1]区间内。请注意，z坐标不需要是0和1，它们只需要是两个不同的任意数字。现在我们可以将mvp unproject 用于世界空间：

nearc = glm::inverse(mvp) * nearc;
nearc /= nearc.w; // dehomog
farc = glm::inverse(mvp) * farc;
farc /= farc.w; // dehomog

请注意，均匀划分在这里很重要。这为我们提供了光标在世界空间中的位置，您可以在其中定义对象（除非它们有自己的模型矩阵，但很容易合并）。

最后，演示计算nearc和farc之间的光线以及有纹理的平面（您的100x100网格）的交点：

glm::vec3 plane_normal(0, 0, 1); // plane normal
float plane_d = 0; // plane distance from origin
// this is the plane with the grid

glm::vec3 ray_org(nearc), ray_dir(farc - nearc);
ray_dir = glm::normalize(ray_dir);
// this is the ray under the mouse cursor

float t = glm::dot(ray_dir, plane_normal);
if(fabs(t) > 1e-5f)
    t = -(glm::dot(ray_org, plane_normal) + plane_d) / t;
else
    t = 0; // no intersection, the plane and ray is collinear
glm::vec3 isect = ray_org + t * ray_dir;
// calculate ray-plane intersection

float grid_x = N * (isect.x + 1) / 2;
float grid_y = N * (isect.y + 1) / 2;
if(t && grid_x >= 0 && grid_x < N && grid_y >= 0 && grid_y < N) {
    int x = int(grid_x), y = int(grid_y);
    // calculate integer coordinates

    tex_data[x + N * y] = 0xff0000ff; // red
    glBindTexture(GL_TEXTURE_2D, n_texture);
    glTexSubImage2D(GL_TEXTURE_2D, 0, 0, 0, N, N, GL_RGBA, GL_UNSIGNED_BYTE, &tex_data[0]);
    // change the texture to see
}
// calculate grid position in pixels

输出相当不错：

这只是一个20x20的纹理，但是达到100x100是微不足道的。您可以获得完整的演示源和预编译的win32二进制文件here。它依靠glm。您可以使用鼠标转动或使用WASD移动。

比平面更复杂的对象是可能的，它基本上是raytracing。使用光标下的深度组件（窗口z）同样简单 - 只要注意标准化坐标（[0, 1]与[-1, 1]）。另请注意，回读z值可能会降低性能，因为它需要CPU / GPU同步。