Why does OpenGL have a far clipping plane, and wha

Question

I've been learning OpenGL, and the one topic that continues to baffle me is the far clipping plane. While I can understand the reasoning behind the near clipping plane, and the side clipping planes (which never have any real effect because objects outside them would never be rendered anyway), the far clipping plane seems only to be an annoyance.

Since those behind OpenGL have obviously thought this through, I know there must be something I am missing. Why does OpenGL have a far clipping plane? More importantly, because you cannot turn it off, what are the recommended idioms and practices to use when drawing things at huge distances (for objects such as stars thousands of units away in a space game, a skybox, etc.)? Are you expected just to make the clipping plane very far away, or is there a more elegant solution? How is this done in production software?

Answer 1

It's just "the fact" that OpenGL depth test was performed in Window Space Coordinates (Normalized device coordinates in [-1,1]^3. With extra scaling glViewport and glDepthRange).

So from my point of view it's one of the design point of view of the OpenGL library.

---

One of approach to eliminate this OpenGL extension/OpenGL core functionality https://www.opengl.org/registry/specs/ARB/depth_clamp.txt if it is available in your OpenGL version.

---

I want to describe that in the perspective projection there is nothing about "far clipping plane".

3.1 For perspective projection you need to setup point \vec{c} as center of projection and plane on which projection will be performed. Let's call it image plane T: (\vec{r}-\vec{r_0},\vec{n})

3.2 Let's assume that projected plane T split arbitary point \vec{r} and \vec{c} central of projection. In other case \vec{r} and \vec{c} are in one hafe-space and point \vec{r} should be discarded.

3.4 The idea of projection is to find intersection \vec{i} with plane T \vec{i}=(1-t)\vec{c}+t\vec{r}

3.5 As it is (\vec{i}-\vec{r_0},\vec{n})=0

=>

( (1-t)\vec{c}+t\vec{r}-\vec{r_0},\vec{n})=0

=>

( \vec{c}+t(\vec{r}-\vec{c})-\vec{r_0},\vec{n})=0

3.6. From "3.5" derived t can be subtitute into "3.4" and you will receive projection into plane T.

3.7. After projection you point will lie in the plane. But if assume that image plane is parallel to OXY plane, then I can suggest to use original "depth" for point after projection.

So from geometry point of view it is possible not to use far plane at all. As also not to use [-1,1]^3 model explicitly at all.

p.s. I don't know how to type latex formulas in correct way, s.t. they will be rendered.

Answer 2

Why does OpenGL have a far clipping plane?

Because computers are finite.

There are generally two ways to attempt to deal with this. One way is to construct the projection by taking the limit as z-far approaches infinity. This will converge on finite values, but it can play havoc with your depth precision for distant objects.

An alternative (if you're willing to have objects beyond a certain distance fail to depth-test correctly at all) is to turn on depth clamping with glEnable(GL_DEPTH_CLAMP). This will prevent clipping against the near and far planes; it's just that any fragments that would have normalized z coordinates outside of the [-1, 1] range will be clamped to that range. As previously indicated, it screws up depth tests between fragments that are being clamped, but usually those objects are far away.

Answer 3

The only reason is depth-precision. Since you only have a limited number of bits in the depth buffer, you can also just represent a finite amount of depth with it.

However, you can set the far plane to infinitely far away: See this. It just won't work very well with the depth buffer - you will see a lot of artifacts if you have occlusion far away.

So since this revolves around the depth buffer, you won't have a problem dealing with further-away stuff, as long as you don't use it. For example, a common technique is to render the scene in "slabs" that each only use the depth buffer internally (for all the stuff in one slab) but some form of painter's algorithm externally (for the slabs, so you draw the furthest one first)