如何用OpenGL ES 1讀取像素的深度？ （屏幕像素的Z座標）

Question

我需要傳遞給gluUnProject像素的winZ值。爲了獲得我需要讀取給定像素的深度值的winZ值，這是一個標準化的z座標。

做到這一點的方式是這樣的，在C glReadPixels(winX, winY, 1, 1, GL_DEPTH_COMPONENT, GL_FLOAT, &winZ);

的問題是，我與Android 1.5和OpenGL ES 1編程，那麼我沒有使用GL_DEPTH_COMPONENT和glReadPixels的可能性。

如何獲取屏幕上像素的深度？

Answer 1

解決了，這是根本不可能做到這一點上的OpenGL ES 1.x的

如果有人發現的方式，告訴我，但搜索的星期後，我只是認爲這是不可能的。

Answer 2

看看這個漂亮的文章，我覺得它有你想找的：

自定義GLunproject，使您能夠計算出近及遠的載體：

private boolean unProject(float winx, float winy, float winz, 
         float[] modelMatrix, int moffset, 
         float[] projMatrix, int poffset, 
         int[] viewport, int voffset, 
         float[] obj, int ooffset) { 
float[] finalMatrix = new float[16]; 
float[] in = new float[4]; 
float[] out = new float[4]; 

Matrix.multiplyMM(finalMatrix, 0, projMatrix, poffset, 
    modelMatrix, moffset); 
if (!Matrix.invertM(finalMatrix, 0, finalMatrix, 0)) 
return false; 

in[0] = winx; 
in[1] = winy; 
in[2] = winz; 
in[3] = 1.0f; 

// Map x and y from window coordinates 
in[0] = (in[0] - viewport[voffset])/viewport[voffset + 2]; 
in[1] = (in[1] - viewport[voffset + 1])/viewport[voffset + 3]; 

// Map to range -1 to 1 
in[0] = in[0] * 2 - 1; 
in[1] = in[1] * 2 - 1; 
in[2] = in[2] * 2 - 1; 

Matrix.multiplyMV(out, 0, finalMatrix, 0, in, 0); 
if (out[3] == 0.0f) 
    return false; 

out[0] /= out[3]; 
out[1] /= out[3]; 
out[2] /= out[3]; 
obj[ooffset] = out[0]; 
obj[ooffset + 1] = out[1]; 
obj[ooffset + 2] = out[2]; 

return true; 
} 

爲了獲得在屏幕上的點x/y的三維座標，您只需爲遠近剪裁平面的每個交點調用一次新方法：

// near clipping plane intersection 
float[] objNear = new float[4]; 
unProject(screenX, screenY, 0.1f, 
     viewMatrix, 0, projectionMatrix, 0, view, 0, objNear, 0); 

// far clipping plane intersection 
float[] objFar = new float[4]; 
unProject(screenX, screenY, 1.0f, 
     viewMatrix, 0, projectionMatrix, 0, view, 0, objFar, 0); 

然後，您可以計算差異向量（objFar - objNear），並檢查3D空間中的哪個位置對應於屏幕事件。 這是一個簡單的功能，我用它來尋找兩個向量之間的距離：

public float distanceBetweenVectors(float[] vec1, float[] vec2){ 
    float distance = 0; 
    // Simple math 
    distance = (float) Math.sqrt(
      Math.pow((vec1[0]-vec2[0]), 2) + 
      Math.pow((vec1[1]-vec2[1]), 2) + 
      Math.pow((vec1[2]-vec2[2]), 2) + 
      Math.pow((vec1[3]-vec2[3]), 2) 
      ); 
    return distance; 

}