How a vertex becomes a pixel

In the graphics libraries of OpenGL and Direct3D (*pre-DirectX10), the
common method for learning how to properly compute the position, and
other properties, of a vertex has been through the implementation of
the Fixed Function Geometry Pipeline.

This is the main pipeline in which the graphics engine calculates the
proper rendering to a vertex in the system.
This pipeline can be dissected into different sub-phases:

1. Model Transformation

   This is the initial entry point of
   a vertex into the pipeline. At this stage, no transformations have yet
   been applied to the vertex, and the vertex is currently using a local
   coordinate system. In other words, you have drawn a 3D model and
   have everything done to a local coordinate system relative to that model.

2. World Transformation

   During the first phase through the
   pipeline, the geometry engine must translate the vertex from the local
   coordinate system it’s using to that of the coordinate system used by the
   current “World”. The coordinates of the vertex after the tranformation are
   referred to be using world coordinates.

3. View Transformation

   The next stage through the pipeline, is
   where the geometry engine calculates the vertex information with respect
   to the camera for the scene. In other words, when your game chooses a
   “point-of-view” to render the world, the world coordinates of all the
   vertices are re-aligned to properly reflect the camera.

4. Projection Transformation

   takes place after the View
   Transformation stage, in which the geometry pipeline calculates the
   proper depth of the vertex. This information is used to scale the vertex
   according to distance from the camera, such that closer vertices appear
   larger than vertices further away.

5. Viewport Clipping

is the final stage of the geometry pipeline
in which a final “acid” test is given to the vertex; if it’s position
lies outside of the viewport (created by the Camera), then the vertex
is tossed from the scene and removed.

*Post DirectX9.0c Information

Until DirectX9.0c, both Direct3D and OpenGL used the Fixed Function
Geometry Pipeline for vertex calculations. As the development of
programmable shaders (introduced in DirectX8.1) grew, there became
a seperation from the pipeline in which programmable vertices were able
to bypass some of the fixed function tranformation stages and inject
themselves into the View Transformation stage directly.

However, as of DirectX9.0c, I believe that “under the covers” of Direct3D,
the entire Fixed Function Geometry pipeline has been replaced by one aimed at
taking advantage of programmable vertices, however the engine will still
always accept the “old” way of positioning your objects.

Feedback? Comments?

Either comment to this posting, or use our contact form to get in
touch with us.