18

I want to access the depth buffer value at the currently processed pixel in a pixel shader.

How can we achieve this goal? Basically, there seems to be two options:

  1. Render depth to texture. How can we do this and what is the tradeoff?
  2. Use the value provided by gl_FragCoord.z - But: Is this the correct value?
genpfault
  • 51,148
  • 11
  • 85
  • 139
0xbadf00d
  • 17,405
  • 15
  • 67
  • 107
  • 3
    `gl_FragCoord.z` is the depth value of the currently processed fragment, not the current value in the depth buffer. To get a depth texture, create a texture with a depth format, render to an FBO with your depth texture attached to GL_DEPTH_ATTACHMENT, and then bind the depth texture for sampling in your fragment shader. – Reto Koradi Apr 29 '14 at 16:11
  • @RetoKoradi, that sounds like an answer, why did you make it a comment? – JWWalker Apr 29 '14 at 17:31
  • @JWWalker: Because I was in a rush, and normally try to formulate my answers a little more carefully, and with more detail. I'll turn it into an answer. – Reto Koradi Apr 29 '14 at 17:40

2 Answers2

33

On question 1: You can't directly read from the depth buffer in the fragment shader (unless there are recent extensions I'm not familiar with). You need to render to a Frame Buffer Object (FBO). Typical steps:

  1. Create and bind an FBO. Look up calls like glGenFramebuffers and glBindFramebuffer if you have not used FBOs before.
  2. Create a texture or renderbuffer to be used as your color buffer, and attach it to the GL_COLOR_ATTACHMENT0 attachment point of your FBO with glFramebufferTexture2D or glFramebufferRenderbuffer. If you only care about the depth from this rendering pass, you can skip this and render without a color buffer.
  3. Create a depth texture, and attach it to the GL_DEPTH_ATTACHMENT attachment point of the FBO.
  4. Do your rendering that creates the depth you want to use.
  5. Use glBindFramebuffer to switch back to the default framebuffer.
  6. Bind your depth texture to a sampler used by your fragment shader.
  7. Your fragment shader can now sample from the depth texture.

On question 2: gl_FragCoord.z is the depth value of the fragment that your shader is operating on, not the current value of the depth buffer at the fragment position.

Reto Koradi
  • 53,228
  • 8
  • 93
  • 133
  • 1
    Suppose I render into a frame buffer of the same size as my second pass. Will texture(depth_texture,vec2(float(gl_FragCoord.x)/width,float(gl_FragCoord.y)/height)).r index _exactly the right texture value and retrieve the depth value of the previous pass? I'm seeing "ringing" artifacts near large discontinuities in the depth buffer. – Alec Jacobson May 30 '15 at 06:21
  • How to convert back a depth value you get with a `texture()` call inside the fragment shader back to 'real' world coordinates ? If I understand correctly the depth values are clamped to `[0;1]` - so what it is value to multiply the clamped depth with ? – PinkTurtle Jun 01 '15 at 07:41
  • 2
    The depth is found by using the near and far values set in the projection matrix. Simply multiply by the difference between near and far and add the near value to get your original value ( ((far - near) * Depth) + near). – MasterPlanMan Oct 09 '15 at 18:51
  • 1
    Note: Renderbuffer can not be used to sample with in later shading stages. – Entalpi Nov 19 '17 at 18:43
8

gl_FragCoord.z is the window-space depth value of the current fragment. It has nothing to do with the value stored in the depth buffer. The value may later be written to the depth buffer, if the fragment is not discarded and it passes a stencil/depth test.

Technically there are some hardware optimizations that will write/test the depth early, but for all intents and purposes gl_FragCoord.z is not the value stored in the depth buffer.

Unless you render in multiple passes, you cannot read and write to the depth buffer in a fragment shader. That is to say, you cannot use a depth texture to read the depth and then turn around and write a new depth. This is akin to trying to implement blending in the fragment shader, unless you do something exotic with DX11 class hardware and image load/store, it just is not going to work.

If you only need the depth of the final drawn scene for something like shadow mapping, then you can do a depth-only pre-pass to fill the depth buffer. In the second pass, you would read the depth buffer but not write to it.

Andon M. Coleman
  • 42,359
  • 2
  • 81
  • 106