CODEWITHSUNDEEP
opengl-esaugmented-realityandroid-augmented-reality
dustymax
dustymax

Reputation: 330

Set depth texture for Z-testing in OpenGL ES 2.0 or 3.0

Having a 16-bit uint texture in my C++ code, I would like to use it for z-testing in an OpenGL ES 3.0 app. How can I achieve this?

To give some context, I am making an AR app where virtual objects can be occluded by real objects. The depth texture of real environment is generated, but I can't figure out how to apply it.

In my app, I first use glTexImage2D to render backdrop image from the camera feed, then I draw some virtual objects. I would like the objects to be transparent based on a depth texture. Ideally, the occlusion testing needs to be not binary, but gradual, so that I can alpha blend the objects with background near the occlusion edges.

I can pass and read the depth texture in the fragment shader, but not sure how to use it for z-testing instead of rendering.

Upvotes: 1

Views: 323

Answers (1)

Rabbid76
Rabbid76

Reputation: 210968

Lets assume you have a depth texture uniform sampler2D u_depthmap and the internal format of the depth texture is a floating point format.

To read the texel from the texture, where the current fragment is on, you have to know the size of the viewport (uniform vec2 u_vieport_size). gl_FragCoord contains the window relative coordinate (x, y, z, 1/w) values for the fragment. So the texture coordinate for the depth map is calcualted by:

vec2 map_uv = gl_FragCoord.xy / u_vieport_size;

The depth from the depth texture u_depthmap is given in range [0.0, 1.0], because of the internal floating point format. The depth of the fragment is contained in the gl_FragCoord.z, in range [0.0, 1.0], too.

That means that the depth of the map and the depth of the fragment can be calculated as follows:

uniform sampler2D u_depthmap;
uniform vec2 u_vieport_size;

void mian()
{
    vec2  map_uv      = gl_FragCoord.xy / u_vieport_size; 
    float map_depth   = texture(u_depthmap, map_uv).x;

    float frag_depth  = gl_FragCoord.z;        

    .....
}

Note, map_depth and frag_depth are both in the range [0.0, 1.0]. If the were generated both with the same projection (especially the same near and far plane), then they are comparable. This means you have to ensure that the shader generates the same depth values as the ones in the depth map, for the same point in the world. If this is not the case, then you have to linearize the depth values and you have to calculate the view space Z-coordinate.

Upvotes: 2

Related Questions