# Why does GL divide `gl_Position` by W for you rather than letting you do it yourself?

I’d like to extent on BDL’s answer. It is not only about the perspective interpolation. It is also about the clipping. The space the value `gl_Position` is supposed to be provided in is called clip space, and this is before the division by w.

The (default) clip volume of OpenGL is defined in clip space as

``````-w <= x,y,z <= w   (with w varying per vertex)
``````

After the division by w we get

``````-1 <= x,y,z <= 1   (in NDC coordinates).
``````

However, if you try to do the clipping after the division by w, and would check against that cube in NDC, you get a problem, because all clip space points fullfilling this:

`````` w <= x,y,z <= -w (in clip space)
``````

will also fullfill the NDC constraint.

The thing here is that points behind the camera will be transformed to somewhere in front of the camera, mirrored (since `x/-1` is the same as `-x/1`). This also happens to the `z` coordinate. One might argue that this is irrelevant, because any point behind the camera is projected behind (in the sense of more far away than) the far plane, as per the construction of the typical projection matrix, so it will lie outside of the viewing volume in either case.

But if you have a primitive where at least one point is inside the view volume, and at least one point is behind the camera, you should have a primitive which intersects the near plane also. However, after the division by `w`, it will intersect the `far` plane now!. So clipping in NDC space, after the division, is much harder to get right. I tried to visualize this in this drawing:

(the drawing is to-scale, the depth range of projection is much shorter than anyone would typically use, to better illustrate the issue).

The clipping is done as a fixed-function stage in hardware and it has to be done before the division, hence you should provide the correct clip-space coordinates to work on.

(Note: actual GPUs might not use an extra clipping stage at all, they actually might also use a clipless rasterizer, like it is speculated in Fabian Giesen’s blog article there. There are some algorithms like Olano and Greer (1997). However, this all works by doing the rasterization directly in homogenous coordinates, so we still need the `w`…)