by Bryan McNett

Before you begin, you should read my article on Multitexture and the Quake 3 Graphics Engine. If you can, play with the accompanying Photoshop file to get a feel for texture editing in Quake 3. Now, let’s proceed to write a Quake 3 graphics engine in OpenGL!

This article will explain in plain language how to implement the multitexture effects of Quake 3 in the OpenGL graphics language. You are expected to understand a pseudocode that looks like C++. Concepts like the multiplication of colors should be familiar to you. Other Quake graphics technologies are not covered by this article. With the exception of dynamic LOD geometry management, you will find many fine tutorials on the remaining Quake graphics technologies in books and on the Internet. Please refer to them if you have any questions after reading this article.

It is possible to implement multitexture in OpenGL using its alpha blend unit, multiple texture units, or a combination of both. In May, 1998, very few people own multiple texture units. Correspondingly, Quake 3’s important multitexture effects should not require multiple texture units - but they will require an alpha blend unit. For this reason and for the sake of simplicity, this article will cover only the alpha blend unit.

First, I will explain what the alpha blend unit is and how it works.

When OpenGL is drawing a polygon, it has the option of blending the polygon with the colors already on the screen. This is customarily called "alpha blending".

The following OpenGL function controls the blending process:

For example, the following OpenGL function makes all subsequent polygons translucent:

…and the following OpenGL function makes all subsequent polygons opaque:

Unless you understand the inner workings of the alpha blend unit, however, it may not be clear what the terms SRC_ALPHA, ONE_MINUS_SRC_ALPHA, ONE, or ZERO are supposed to mean in this context. Now to explain:

Once this OpenGL function is called:

The alpha blend unit blends subsequent polygons with the screen via the following function, which is executed once for each pixel in each polygon:

screen = polygon * src + screen * dst;

When we plug the following terms into the function:

screen = polygon * alpha + screen * (1-alpha);

screen = polygon * 1 + screen * 0;

or simplified further…

screen = polygon;

screen = polygon * 0 + screen * 1;

or simplified further…

screen = screen;

When we plug these terms into OpenGL’s alpha blending function:

The pseudocode executes as follows:

screen = polygon * 1 + screen * 0;

Algebra can simplify this to the following:

screen = polygon;

Therefore, no blending takes place. The polygon is copied directly to the screen. This is an opaque polygon, as we have noted before.

Just as it is possible to draw an opaque or a translucent polygon, it is possible to add a polygon to the screen, or to multiply the screen by a polygon. If this makes no sense to you, you may wish to refer to Multitexture and the Quake 3 Graphics Engine, which attempts to explain these ideas using plain language.

To add subsequent polygons to the screen, issue the following OpenGL command:

The pseudocode is as follows:

screen = polygon * 1 + screen * 1;

which can be simplified via algebra to the following:

screen = polygon + screen;

Clearly, subsequent polygons will be added to the screen, as we noted previously.

To multiply the screen by subsequent polygons, issue the following OpenGL command:

screen = polygon * screen + screen * 0;

which can be simplified to the following:

screen = polygon * screen;

Clearly, the screen will be multiplied by subsequent polygons, as we noted previously.

You may not realize that we’ve just covered the three OpenGL commands used for multitexture in Quake 3:

BlendFunc(ONE,ZERO);        // copy the polygon to the screen
BlendFunc(ONE,ONE);         // add the polygon to the screen
BlendFunc(DST_COLOR,ZERO);  // multiply the polygon with the screen

The following code fragment tells you where these three commands are used:

// we now begin drawing one polygon
BlendFunc ( ONE, ZERO ) ;          // screen = polygon
// draw the light map here
BlendFunc ( ONE, ONE ) ;           // screen = screen + polygon
// draw all the bump maps here
BlendFunc ( DST_COLOR, ZERO ) ;    // screen = screen * polygon
// draw the texture map here
BlendFunc ( ONE, ONE ) ;           // screen = screen + polygon
// draw the specular map here
// we now end drawing one polygon 

note: To copy polygons without blending in the real world, you will probably want to disable alpha blending with Disable(BLEND) rather than by calling BlendFunc(ONE,ZERO)! We use BlendFunc(ONE,ZERO) only as an example to help explain the concept of blending.

Let’s extract the pseudocode from the comments on the right:

Now let’s replace the word "polygon" with the names of the respective maps:

using algebra, we can simplify further…

Hey… this looks a lot like the equation from Multitexture and the Quake 3 Graphics Engine: