Increasing depth buffer precision far from the camera

Question

I have a project I'm working on that is making movies from a simulation. The simulation is passed from another program that defines the projection matrix.

The issue I am running into is that the other program has a sort of 'fake' orthographic view, what I mean by this is that its projection matrix is as follows:

PerspectiveMatrix = glm::perspective(3.5, 1, 1.0f, 50.0f); 

And it uses the LookAt function:

ViewMatrix = glm::lookAt(
    (2000,-3000,2000), // eye 
    (0,0,0), // center 
    (0,0,1)//up 
);

So what I mean by 'fake' orthographic view is that they have positioned the camera far enough away (and small angle to zoom the scene) that the "view lines" (for lack of a better term) are almost parallel like in a real orthographic projection.

So this is all fine and well but what I've run into, and is an issue in the other program as well, is that all of the high precision depth testing is close to the camera and in my case this is empty space. This means that there is quite a lot of z fighting as shown in the link below:

  

So my question is what ways can I change my depth testing in order to maybe bias the buffer towards the far plane? or something along those lines. I have tried moving the NearPlane farther out, which has the result of zooming out the screen, so I compensate with a narrower angle in the perspective. But doing this enough times makes the problem worse, there isn't z fighting but it doesn't draw things at the right depth. The spheres end up on top of everything.

I did find some info at Outerra: http://outerra.blogspot.com/2012/11/maximizing-depth-buffer-range-and.html They had some ideas for reversing the depth buffer but it was Nvidia specific and I need to be compatible with both ATI and Nvidia

Answer 1

Both logarithmic depth and reversed depth mapping described in that blog post will work for you.

Reverse floating point is better, and it works normally in DirectX. In OpenGL it won't bring you any extra precision due to a design flaw, unless the driver exposes the NV_depth_buffer_float extension, through which you can effectively turn off the bias that makes it unusable normally.

AMD supports that extension since their 13.12 Catalyst drivers, so the technique is usable on all 5000+ series AMD GPUs (older series aren't supported by the drivers).