Texture combiners allow a greatly increased range of texturing functionality (per-pixel lighting, bump mapping, and other advanced rendering effects) while still using the OpenGL fixed-function pipeline. This extension increases that range even further compared to base OpenGL 1.3. For an even broader range of functionality, consider using fragment programs instead.

When glTexEnvi() or glTexEnvf() is called with a parameter name of GL_COMBINE_RGB or GL_COMBINE_ALPHA, this extension allows the corresponding parameter to take on one of the following values:

Table 8-1 shows the texture functions corresponding to these operations.

In Table 8-1, Arg0, Arg1, and Arg2 represent values determined by the values set for GL_SOURCE(0,1,2)_(RGB,ALPHA) and GL_OPERAND(0,1,2)_(RGB,ALPHA) with glTexEnv*(). In addition to the values defined by OpenGL 1.3 (GL_TEXTURE, GL_CONSTANT, GL_PRIMARY_COLOR, and GL_PREVIOUS), this extension allows GL_SOURCE(0,1,2)_(RGB,ALPHA) to take on the values GL_ZERO and GL_ONE. In this case, the values generated for the corresponding Arg(0,1,2) are shown in Table 8-2 and Table 8-3.

Floating point textures support greatly increased numerical range and precision compared to fixed-point textures, which can only represent values in the range [0,1]. This is important for many purposes, such as high dynamic range imaging, performing general-purpose numerical computations in the graphics processor, and representing input data naturally without needing to scale and bias it to fit in the limited range of fixed-point textures.

Floating point textures are especially useful when using fragment shaders, where a much wider range of computations can be performed than in the fixed-function graphics pipeline.

The new formats defined by this extension may be used as the internalformat parameter when specifying textures with one of the following:

The names of the new formats, the corresponding base internal format, and the precision of each component in a texture stored with those formats are shown in Table 8-4. In the table, “f32” means the component is stored as a 32-bit IEEE floating point number and “f16” means the component is stored as a 16-bit floating point number.

For textures that are symmetrical about one or more axes, texture mirroring reduces the amount of texture memory required by not storing the redundant symmetric portion of the texture. The choice of using GL_MIRRORED_REPEAT or the modes introduced by ATI_texture_mirror_once depends on whether or not an infinitely extended texture image is desired (as may be the case for synthetic textures used for backgrounds or high-frequency noise).

To specify texture mirroring, call glTexParameteri() with the following parameter specifications:

Depending on the nature of the textures, compressed textures can provide dramatic savings in texture memory at a relatively small cost in texture quality. Natural imagery tends to compress with fewer detectable artifacts than synthetic images, but it is always important to test and make sure that compressed image quality is adequate, particularly in high-fidelity domains such as flight simulation.

The core OpenGL compressed texture interface allows compressing textures to a internal format whose exact nature is unspecified. This format may differ between OpenGL implementations, and potentially even between driver releases on the same platform. This variance makes it difficult to ensure that the quality and size of images so compressed are adequate. It is also difficult to store or transport compressed images without knowing their exact format.

S3TC overcomes these constraints by defining specific formats for compressed images of several types, and these formats may be used by other tools such as image viewers and artwork creation applications. S3TC is a widely used informal standard for texture compression.

This extension introduces four new compressed texture formats, with corresponding RGB or RGBA base formats as shown in Table 8-5

The new compressed formats may be used as the internalformat parameter of glTexImage2D(), glCopyTexImage2D(), and glCompressedTexImage2D() when specifying a 2D texture, and as the format parameter of glCompressedTexSubImage2D() when respecifying a part of a texture.

When specifying a texture in already-compressed S3TC format—for example, when calling glCompressedTexImage2D() or glCompressedTexSubImage2D()—the required format of the input image is fully defined by the extension specification for EXT_texture_compression_s3tc. The specification is located on the following webpage:

http://oss.sgi.com/projects/ogl-sample/registry/EXT/texture_compression_s3tc.txt

Due to the definition of the formats, the following constraints on specifying texture images and subimages in the S3TC formats:

Note that these constraints represents a relaxation of the tighter constraints on generic compressed texture formats.

Texture mapping as defined in core OpenGL assumes that the projection of the pixel filter footprint into texture space is a square (that is, isotropic). In practice, however, the footprint may be long and narrow (that is, anisotropic). Consequently, mipmap filtering severely blurs images on surfaces angled obliquely away from the viewer. For example, in flight simulations, views of the runway during approaches are likely to be oversampled across the runway and undersampled along its length.

There are several approaches for improving texture sampling by accounting for the anisotropic nature of the pixel filter footprint into texture space. This extension provides a general mechanism for supporting such filtering schemes without specifying a particular formulation of anisotropic filtering.

The maximum degree of anisotropy to account for in texture filtering may be defined per texture object, subject to a global upper bound determined by the implementation.

Increasing the degree of anisotropy will generally improve texture filtering quality, but at the cost of reducing the texture fill rate. Rather than setting the maximum possible anisotropy, choose the smallest degree of anisotropy that will provide the desired level of image quality and performance and consider providing interactive controls to allow users to adjust the anisotropy level further at run time.

To specify the degree of texture anisotropy, call glTexParameterf() with the following parameter specifications:

When the specified value of GL_TEXTURE_MAX_ANISOTROPY_EXT is 1.0, standard mipmap texture sampling is used as defined in core OpenGL. When the value is greater than 1.0, a texture filtering scheme that accounts for a degree of anisotropy defined by the minimum of the specified value and the value of GL_MAX_TEXTURE_MAX_ANISOTROPY_EXT is used.

While the exact anisotropic filtering scheme may vary, it will satisfy the following conditions:

Rectangle (non-power-of-two) textures are useful whenever working with texture images that have such dimensions. Representing such images at their natural resolutions avoids resampling artifacts and saves texture memory. Examples include (but are not limited to) video images, shadow maps, window-space texturing, and data arrays for general-purpose computation in fragment programs.

However, rectangle textures have the following additional constraints that may restrict their applicability relative to power-of-two textures:

To enable or disable rectangle texture mapping, call glEnable() or glDisable() with parameter GL_TEXTURE_RECTANGLE_EXT. When several types of of textures are enabled, the precedence order is the following:

This means that if both 2D and rectangle texturing are enabled, the currently bound rectangle texture will be used. If both 3D and rectangle texturing are enabled, the currently bound 3D texture will be used.

To define a rectangle texture, call glTexImage2D() or glCopyTexImage2D() with the parameter target set to GL_TEXTURE_RECTANGLE_EXT. The mipmap level and border size must both be zero. The dimensions of rectangle textures are not restricted to powers of two but are limited to the implementation-dependent maximum rectangle texture size, which can be queried by calling glGetIntegerv() with parameter GL_MAX_RECTANGLE_TEXTURE_SIZE_EXT.

Using a texture target of GL_TEXTURE_RECTANGLE_EXT, you can perform all other operations on rectangle textures (binding texture objects, specifying subimages, querying texture images, setting texture and texture level parameters). Using target GL_PROXY_TEXTURE_RECTANGLE_EXT, you can perform proxy texture queries on rectangle textures. The currently bound rectangle texture object may be queried by calling glGetIntegerv() with the parameter GL_TEXTURE_BINDING_RECTANGLE_EXT.

When rendering with a rectangle texture, texture coordinates are interpreted differently. Rather than clamping to the range [0,1], the s coordinate is clamped to the range [0,w] and the t coordinate is clamped to the range [0,h], where w and h are respectively the width and height of the rectangle texture. After clamping, you access texels directly using the clamped texture coordinates as indices into the rectangle texture, instead of first scaling them by the dimensions of the texture image as you do for normal power-of-two 2D textures.

3D textures are useful for the following:

Texel values defined in a 3D coordinate system form a texture volume. You can extract textures from this volume by intersecting it with a plane oriented in 3D space, as shown in Figure 8-2.

Figure 8-2. Extracting a Planar Texture From a 3D Texture Volume

The resulting texture, applied to a polygon, is the intersection of the volume and the plane. The orientation of the plane is determined from the texture coordinates of the vertices of the polygon.

To create a 3D texture, use glTexImage3DEXT(), which has the following format:

void glTexImage3DEXT( GLenum target,
                           GLint level,
                           GLenum internalformat,
                           GLsizei width,
                           GLsizei height,
                           GLsizei depth,
                           GLint border,
                           GLenum format,
                           GLenum type,
                           const GLvoid *pixels )

The function is defined like glTexImage2D() but has a depth argument that specifies the number of “slices” in the texture.

The extension provides the following additional features:

The code fragment presented in this section illustrates the use of the extension. The complete program is included in the example source tree.

/*
 * Shows a 3D texture by drawing slices through it.
 */
/* compile: cc -o tex3d tex3d.c -lGL -lX11 */

#include <GL/glx.h>
#include <GL/glu.h>
#include <X11/keysym.h>
#include <stdlib.h>
#include <stdio.h>

static int attributeList[] = { GLX_RGBA, None };

unsigned int tex[64][64][64];

/* generate a simple 3D texture */
static void
make_texture(void) {
    int i, j, k;
    unsigned int *p = &tex[0][0][0];

    for (i=0; i<64; i++) {
        for (j=0; j<64; j++) {
            for (k=0; k<64; k++) {
                if (i < 10 || i > 48 ||
                    j < 10 || j > 48 ||
                    k < 10 || k > 48) {
                    if (i < 2 || i > 62 ||
                        j < 2 || j > 62 ||
                        k < 2 || k > 62) {
                        *p++ = 0x00000000;
                    } else {
                        *p++ = 0xff80ffff;
                    }
                } else {
                    *p++ = 0x000000ff;
}
            }
        }
    }
}

static void
init(void) {
    make_texture();
    glEnable(GL_TEXTURE_3D_EXT);
    glEnable(GL_BLEND);
    glBlendFunc(GL_SRC_ALPHA, GL_ONE);
    glClearColor(0.2,0.2,0.5,1.0);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

    glMatrixMode(GL_PROJECTION);
    gluPerspective(60.0, 1.0, 1.0, 100.0 );
    glMatrixMode(GL_MODELVIEW);
    glTranslatef(0.,0.,-3.0);
    glMatrixMode(GL_TEXTURE);


    /* Similar to defining a 2D texture, but note the setting of the */
    /* wrap parameter for the R coordinate.  Also, for 3D textures   */
    /* you probably won't need mipmaps, hence the linear min filter. */
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_MIN_FILTER, 
                                                         GL_LINEAR);
    glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_S, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_T, GL_CLAMP);
    glTexParameteri(GL_TEXTURE_3D_EXT, GL_TEXTURE_WRAP_R_EXT, 
                                                          GL_CLAMP);
    glTexImage3DEXT(GL_TEXTURE_3D_EXT, 0, 4, 64, 64, 64, 0,
                    GL_RGBA, GL_UNSIGNED_BYTE, tex);
}

#define NUMSLICES 256

static void
draw_scene(void) {
    int i;
    float r, dr, z, dz;
    
    glColor4f(1, 1, 1, 1.4/NUMSLICES);
    glClear(GL_COLOR_BUFFER_BIT);
    /* Display the entire 3D texture by drawing a series of quads */
    /* that  slice through the texture coordinate space.  Note that */
    /* the transformations below are applied to the texture matrix, */
    /* not the modelview matrix. */
       
    glLoadIdentity();
    /* center the texture coords around the [0,1] cube */
    glTranslatef(.5,.5,.5);
    /* a rotation just to make the picture more interesting */
    glRotatef(45.,1.,1.,.5);

    /* to make sure that the texture coords, after arbitrary */
    /* rotations, still fully contain the [0,1] cube, make them span */
    /* a range sqrt(3)=1.74 wide */
    r = -0.87; dr = 1.74/NUMSLICES;
    z = -1.00; dz = 2.00/NUMSLICES;
    for (i=0; i < NUMSLICES; i++) {
        glBegin(GL_TRIANGLE_STRIP);
        glTexCoord3f(-.87,-.87,r); glVertex3f(-1,-1,z); 
        glTexCoord3f(-.87, .87,r); glVertex3f(-1, 1,z); 
        glTexCoord3f( .87,-.87,r); glVertex3f( 1,-1,z); 
        glTexCoord3f( .87, .87,r); glVertex3f( 1, 1,z); 
        glEnd();
        r += dr;
        z += dz;
    }
}

/* process input and error functions and main(), which handles window  
 * setup, go here. 
 */ 

The EXT_texture3D extension introduces the following functions:

The following are two example situations in which the texture color table extension is useful:

To use a texture color table, define a color table, as described in “SGI_color_table—The Color Table Extension” in Chapter 10. Use GL_TEXTURE_COLOR_TABLE_SGI as the value for the target parameter of the various commands. Note the following points:

The following code fragment loads a table that inverts a texture. It uses a GL_LUMINANCE external format table to make identical R, G, and B mappings.

loadinversetable()
{    
    static unsigned char table[256];
    int i;

    for (i = 0; i < 256; i++) {
        table[i] = 255-i; 
    }

    glColorTableSGI(GL_TEXTURE_COLOR_TABLE_SGI, GL_RGBA8_EXT, 
                    256, GL_LUMINANCE, GL_UNSIGNED_BYTE, table);
    glEnable(GL_TEXTURE_COLOR_TABLE_SGI);
}

The contents of a texture color table are used to replace a subset of the components of each texel group, based on the base internal format of the table. If the table size is zero, the texture color table is effectively disabled. The texture color table is applied to the texture components Red (Rt), Green (Gt), Blue (Bt), and Alpha(At) texturing components according to Table 8-6.

The texture color table extension is currently implemented on Fuel, Infinite Performance, and InfiniteReality systems. For a detailed discussion of machine-dependent issues, see the glColorTableParameterSGI man page. This section summarizes the most noticeable restrictions.

InfiniteReality systems reserve an area of 4K 12-bit entries for texture color tables. Applications can use four 1KB tables, two 2KB tables, or one 4KB table. Not all combinations of texture and texture color tables are valid. InfiniteReality systems support the combinations shown in Table 8-7.

Because the high-frequency detail in a texture (for example, a road) is often approximately the same across the entire texture, the detail from an arbitrary portion of the texture image can be used as the detail across the entire image.

When you use the detail texture extension, the high-resolution texture image is represented by the combination of a low-resolution texture image and a small high-frequency detail texture image (the detail texture). OpenGL combines these two images during rasterization to create an approximation of the high-resolution image.

This section first explains how to create the detail texture and the low-resolution texture that are used by the extension ,then briefly describes how detail texture works and how to customize the LOD interpolation function, which controls how OpenGL combines the two textures.

glTexParameteri(GL_TEXTURE_2D, GL_DETAIL_TEXTURE_MODE_SGIS, GL_ADD);

Customizing the Detail Function

In the road example, the 512 x 512 base texture is LOD 0. The detail texture combined with the base texture represents LOD -2, which is called the maximum-detail texture.

By default, OpenGL performs linear interpolation between LOD 0 and LOD -2 when a pixel's LOD is between 0 and -2. Linear interpolation between more than one LOD can result in aliasing. To minimize aliasing between the known LODs, OpenGL lets you specify a nonlinear LOD interpolation function.

Figure 8-3 shows the default linear interpolation curve and a nonlinear interpolation curve that minimizes aliasing when interpolating between two LODs.

Figure 8-3. LOD Interpolation Curves

The basic strategy is to use very little of the detail texture until the LOD is within one LOD of the maximum-detail texture. More of the information from the detail texture can be used as the LOD approaches LOD -2. At LOD -2, the full amount of detail is used, and the resultant texture exactly matches the high-resolution texture.

Use  glDetailTexFuncSGIS() to specify control points for shaping the LOD interpolation function. Each control point contains a pair of values; the first value specifies the LOD, and the second value specifies the weight for that magnification level. Note that the LOD values are negative.

The following control points can be used to create a nonlinear interpolation function (as shown above in Figure 8-3):

GLfloat points[] = { 0.0, 0.0, -1.0, 0.3, -2.0, 1.0, -3.0, 1.1 }; glDetailTexFuncSGIS(GL_TEXTURE_2D, 4, points);

Note that how these control points determine a function is system-dependent. For example, your system may choose to create a piecewise linear function, a piecewise quadratic function, or a cubic function. However, regardless of which kind of function is chosen, the function passes through the control points.

Example 8-2 is a code fragment taken from a simple detail texture example program. The complete example is included in the source tree as detail.c. It is also available through the developer toolbox under the same name. For information on toolbox access, see http://www.sgi.com/Technology/toolbox.html.

unsigned int tex[128][128];
unsigned int detailtex[256][256];

static void
make_textures(void) {
    int i, j;
    unsigned int *p;

    /* base texture is solid gray */
    p = &tex[0][0];
    for (i=0; i<128*128; i++) *p++ = 0x808080ff;

    /* detail texture is a yellow grid over a gray background */
    /* this artificial detail texture is just a simple example */
    /* you should derive a real detail texture from the original */
    /* image as explained in the text. */
    p = &detailtex[0][0];
    for (i=0; i<256; i++) {
        for (j=0; j<256; j++) {
            if (i%8 == 0 || j%8 == 0) {
                *p++ = 0xffff00ff;
            } else {
                *p++ = 0x808080ff;
            }
        }
    }
}

static void
init(void) {
    make_textures();
    
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION);
    gluPerspective(90.0, 1.0, 0.3, 10.0 );
    glMatrixMode(GL_MODELVIEW);
    glTranslatef(0.,0.,-1.5);
    
    glClearColor(0.0, 0.0, 0.0, 1.0);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_MODULATE);
    
    /* NOTE: parameters are applied to base texture, not the detail */
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                    GL_LINEAR_DETAIL_SGIS);
    glTexParameteri(GL_TEXTURE_2D, GL_DETAIL_TEXTURE_LEVEL_SGIS, -1);
    glTexImage2D(GL_TEXTURE_2D,
                 0, 4, 128, 128, 0, GL_RGBA, GL_UNSIGNED_BYTE, tex);
    glTexImage2D(GL_DETAIL_TEXTURE_2D_SGIS,
                 0, 4, 256, 256, 0, GL_RGBA, GL_UNSIGNED_BYTE, 
                 detailtex);
}

static void
draw_scene(void) {
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_TRIANGLE_STRIP);
        glTexCoord2f( 0, 0); glVertex3f(-1,-0.4, 1); 
        glTexCoord2f( 0, 1); glVertex3f(-1,-0.4,-1); 
        glTexCoord2f( 1, 0); glVertex3f( 1,-0.4, 1); 
        glTexCoord2f( 1, 1); glVertex3f( 1,-0.4,-1); 
    glEnd();
    glFlush();
}

The SGIS_detail_texture extension introduces the following functions:

Applications use the Filter4 Parameter extension in conjunction with the Texture Filter4 extension to generate coefficients that are then used as the weights parameter of glTexFilterFuncSGIS().

To generate the coefficients, call gluTexFilterFuncSGI() with the following argument values:

Note that gluTexFilterFuncSGI() and glTexFilterFuncSGI() only customize filter4 filtering behavior; texture filter4 functionality needs to be enabled by calling glTexParameter*() with pname set to TEXTURE_MIN_FILTER or TEXTURE_MAG_FILTER, and params set to GL_FILTER4_SGIS. See “Using the Texture Filter4 Extension” for more information.

The extension is useful for certain volumetric rendering effects. For example, applications could compute fogging based on distance from an eyepoint.

This section first explains how to use the sharpen texture extension to sharpen the component of your choice. It then gives some background information about how the extension works and explains how you can customize the LOD extrapolation function.

glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                               GL_LINEAR_SHARPEN_ALPHA_SGIS);

LODn = LOD0 + weight(n) * (LOD0 - LOD1)

Customizing the LOD Extrapolation Function

With the default linear LOD extrapolation function, the weight may be too large at high levels of magnification, that is, as n becomes more negative. This can result in so much extrapolation that noticeable bands appear around edge features, an artifact known as “ringing.” In this case, it is useful to create a nonlinear LOD extrapolation function.

Figure 8-4 shows LOD extrapolation curves as a function of magnification factors. The curve on the left is the default linear extrapolation, where weight(n) = -n/4. The curve on the right is a nonlinear extrapolation, where the LOD extrapolation function is modified to control the amount of sharpening so that less sharpening is applied as the magnification factor increases. The function is defined for n less than or equal to 0.

Figure 8-4. LOD Extrapolation Curves

Use glSharpenTexFuncSGIS() to specify control points for shaping the LOD extrapolation function. Each control point contains a pair of values; the first value specifies the LOD, and the second value specifies a weight multiplier for that magnification level. Remember that the LOD values are negative.

For example, to gradually ease the sharpening effect, use a nonlinear LOD extrapolation curve—as shown on the right in Figure 8-4—with these control points:

GLfloat points[] = { 0., 0., -1., 1., -2., 1.7, -4., 2. }; glSharpenTexFuncSGIS(GL_TEXTURE_2D, 4, points);

Note that how these control points determine the function is system-dependent. For example, your system may choose to create a piecewise linear function, a piecewise quadratic function, or a cubic function. However, regardless of the kind of function you choose, the function will pass through the control points.

Example 8-3 illustrates the use of sharpen texture. Because of space limitations, the sections dealing with X Window System setup and some of the keyboard input are omitted. The complete example is included in the source tree as sharpen.c. It is also available through the developer toolbox under the same name. See http://www.sgi.com/Technology/toolbox.html for information on toolbox access.

/* tree texture: high alpha in foreground, zero alpha in background */
#define B 0x00000000
#define F 0xA0A0A0ff
unsigned int tex[] = {
    B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,
    B,B,B,B,B,B,B,F,F,B,B,B,B,B,B,B,
    B,B,B,B,B,B,B,F,F,B,B,B,B,B,B,B,
    B,B,B,B,B,B,F,F,F,F,B,B,B,B,B,B,
    B,B,B,B,B,B,F,F,F,F,B,B,B,B,B,B,
    B,B,B,B,B,F,F,F,F,F,F,B,B,B,B,B,
    B,B,B,B,B,F,F,F,F,F,F,B,B,B,B,B,
    B,B,B,B,F,F,F,F,F,F,F,F,B,B,B,B,
    B,B,B,B,F,F,F,F,F,F,F,F,B,B,B,B,
    B,B,B,F,F,F,F,F,F,F,F,F,F,B,B,B,
    B,B,B,F,F,F,F,F,F,F,F,F,F,B,B,B,
    B,B,F,F,F,F,F,F,F,F,F,F,F,F,B,B,
    B,B,F,F,F,F,F,F,F,F,F,F,F,F,B,B,
    B,B,B,B,B,B,F,F,F,F,B,B,B,B,B,B,
    B,B,B,B,B,B,F,F,F,F,B,B,B,B,B,B,
    B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,B,
};

static void
init(void) {
    glEnable(GL_TEXTURE_2D);
    glMatrixMode(GL_PROJECTION);
    gluPerspective(60.0, 1.0, 1.0, 10.0 );
    glMatrixMode(GL_MODELVIEW);
    glTranslatef(0.,0.,-2.5);

    glColor4f(0,0,0,1);
    glClearColor(0.0, 0.0, 0.0, 1.0);
    glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
    glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_DECAL);
    glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
    /* sharpening just alpha keeps the tree outline crisp */
    glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER,
                    GL_LINEAR_SHARPEN_ALPHA_SGIS);
    /* generate mipmaps; levels 0 and 1 are needed for sharpening */
    gluBuild2DMipmaps(GL_TEXTURE_2D, 4, 16, 16, GL_RGBA, 
                      GL_UNSIGNED_BYTE, tex);
}

static void
draw_scene(void) {
    glClear(GL_COLOR_BUFFER_BIT);
    glBegin(GL_TRIANGLE_STRIP);
        glTexCoord2f( 0, 1); glVertex2f(-1,-1); 
        glTexCoord2f( 0, 0); glVertex2f(-1, 1); 
        glTexCoord2f( 1, 1); glVertex2f( 1,-1); 
        glTexCoord2f( 1, 0); glVertex2f( 1, 1); 
    glEnd();
    glFlush();
}

The SGIS_sharpen_texture extension introduces the following functions:

OpenGL provides clamping of texture coordinates: any values greater than 1.0 are set to 1.0, any values less than 0.0 are set to 0.0. Clamping is useful for applications that want to map a single copy of the texture onto a large surface. Clamping is discussed in detail in the section “Repeating and Clamping Textures” on page 360 of the OpenGL Programming Guide, Second Edition.

When a texture coordinate is clamped using the default OpenGL algorithm and a GL_LINEAR filter or one of the LINEAR mipmap filters is used, the texture sampling filter straddles the edge of the texture image. This action takes half its sample values from within the texture image and the other half from the texture border.

It is sometimes desirable to alter the default behavior of OpenGL texture clamping operations as follows:

Both clamping extensions are supported for 1D, 2D, and 3D textures. Clamping always occurs for texture coordinates less than zero and greater than 1.0.

To specify texture clamping, call glTexParameteri() with the following specifications:

To use Filter4 filtering, you have to first define the filter function. Filter4 uses an application-defined array of weights (see “Determining the weights Array”). There is an implementation-dependent default set of weights.

Determining the weights Array

The weights array contains samples of the filter function expressed as follows:

f(x), 0<=x<=2

Each element weights[i] is the value of the following expression:

f((2*i)/(n-1)), 0<=i<=n-1

OpenGL stores and uses the filter function as a set of samples, expressed as follows:

f((2*i)/(Size-1)), 0<=i<=Size-1

The Size variable is the implementation-dependent constant GL_TEXTURE_FILTER4_SIZE. If n equals Size, the array weights is stored directly in OpenGL state. Otherwise, an implementation-dependent resampling method is used to compute the stored samples.

---

Note: “SGIS_filter4_parameters—The Filter4 Parameters Extension” provides interpolation coefficients just as they are required for GL_FILTER4_SGIS filtering.

---

The variable Size must equal 2**m + 1 for some integer value of m greater than or equal to 4. The value Size for texture target is returned by params when glGetTexParameteriv() or glGetTexParameterfv() is called with pname set to TEXTURE_FILTER4_SIZE_SGIS.

The SGIS_texture_filter4 extension introduces the following functions:

To specify a minimum or maximum level of detail for a specific texture, call glTexParameter*() with the following specifications:

LOD is clamped to the specified range before it is used in the texturing process. Whether the minification or magnification filter is used depends on the clamped LOD.

The OpenGL Specification describes a “complete” set of mipmap image arrays at levels 0 (zero) through p, where p is a well-defined function of the dimensions of the level 0 image.

This extension lets you redefine any image level as the base level (or maximum level). This is useful, for example, if your application runs under certain time constraints, and you want to make it possible for the application to load as many levels of detail as possible but stop loading and continue processing while choosing from the available levels after a certain period of time has elapsed. Availability in that case does not depend on what is explicitly specified in the program but on what could be loaded in a specified time.

To set a new base (or maximum) level, call glTexParameteri(), glTexParemeterf(), glTexParameteriv(), or glTexParameterfv() and use the following specifications:

Note that the number used for the maximum level is absolute, not relative to the base level.

On InfiniteReality graphics systems, the smallest texel supported by the hardware is 16 bits. The extension allows you to pack multiple independent textures together to efficiently fill up space in texture memory. The extension itself refers to each of the independent textures as component groups.

The extension allows developers to work with these components by providing several new texture internal formats. For example, assume that a texture internal format of GL_DUAL_LUMINANCE4_SGIS is specified. Now there are two component groups, where each group has a format of GL_LUMINANCE4. One of the two GL_LUMINANCE groups is always selected. Each component can be selected and interpreted as a GL_LUMINANCE texture.

---

Note: The point of this extension is to save texture memory. Applications that need only 8-bit or 4-bit texels would otherwise use half or one quarter of texture memory. However, applications that use 16-bit or larger texels (such as RGBA4, LA8) will not benefit from this extension.

---

To use the texture select extension, first call glTexImage*D() to define the texture using one of the new internal formats as follows:

glTexImage[n]D[EXT] ( /* Definition */ 
     internalFormat = 
         GL_DUAL_{ ALPHA, LUMINANCE, INTENSITY * }{4, 8, 12, 16 }_SGIS
         GL_DUAL_LUMINANCE_ALPHA{ 4, 8 } _SGIS
         GL_QUAD_{ ALPHA, LUMINANCE, INTENSITY*}{ 4, 8 }_SGIS
         );

The system then assigns parts of the texture data supplied by the application to parts of the 16-bit texel, as illustrated in Table 8-11.

To select one of the component groups for use during rendering, the application then calls glTexParameter*() as follows:

glTexParameteri ( /* Selection & Usage */ 
        target = GL_TEXTURE_[n]D[_EXT],
        param = GL_DUAL_TEXTURE_SELECT_SGIS GL_QUAD_TEXTURE_SELECT_SGIS
        value = { 0, 1 },
                { 0, 1, 2, 3 }
         );

There is always a selection defined for both DUAL_TEXTURE_SELECT_SGIS and QUAD_TEXTURE_SELECT_SGIS formats. The selection becomes active when the current texture format becomes one of the DUAL* or QUAD* formats, respectively. If the current texture format is not one of DUAL* or QUAD* formats, this extension has no effect.

Component mapping from standard RGBA to the new internal formats is as follows:

The interpretation of the bit resolutions of the new internal formats is implementation-dependent. To query the actual resolution that is granted, call glGetTexLevelParameter() with pname set appropriately—for example, GL_TEXTURE_LUMINANCE_SIZE. The bit resolution of similar type components in a group, such as multiple LUMINANCE components, is always the same.

Clipmaps avoid the size limitations of normal mipmaps by clipping the size of each level of a mipmap texture to a fixed area called the clip region (see Figure 8-5). A mipmap contains a range of levels, each four times the size of the previous one. Each level (size) determines whether clipping occurs as follows:

To use clipmaps, an application has to take care of the following two distinct tasks, described in this section:

The following sections provide background information for the steps in “Using Clipmaps From OpenGL”.

Moving the Clip Center

Only a small part of each clipped level of a clipmap actually resides in texture memory. As a result, moving the clip center requires updating the contents of texture memory so it contains the pixel data corresponding to the new location of the region of interest.

Updates must usually happen every frame, as shown in Figure 8-6. Applications can update the clipmaps to the new center using toroidal loading (see “Toroidal Loading”).

Figure 8-6. Moving the Clip Center

The clip center is set by the application for level 0, the level with the highest resolution. The clipmap code has to derive the clip center location on all levels. As the viewer roams over a clipmap, the centers of each mipmap level move at a different rate. For example, moving the clip center one unit corresponds to the center moving one half that distance in each dimension in the next-coarser mipmap level.

When applications use clipmaps, most of the work consists of updating the center properly and updating the texture data in the clipped levels reliably and efficiently for each frame.To facilitate loading only portions of the texture at a time, the texture data should first be subdivided into a contiguous set of rectangular areas called tiles. These tiles can then be loaded individually from disk into texture memory.

Invalid Borders

Applications can improve performance by imposing alignment requirements to the regions being downloaded to texture memory. Clipmaps support the concept of an invalid border to provide this feature. The border is an area around the perimeter of a clip region that is guaranteed not to be displayed. The invalid border shrinks the usable area of the clip region and can be used to dynamically change the effective size of the clip region.

When texturing requires texels from a portion of an invalid border at a given mipmap level, the texturing system moves down a level and tries again. It keeps going down to coarser levels until it finds texels at the proper coordinates that are not in the invalid region. This is always guaranteed to happen, because each level covers the same area with fewer texels. Even if the required texel is clipped out of every clipped level, the unclipped pyramid levels will contain it.

The invalid border forces the use of lower levels of the mipmap. As a result, it

• Reduces the abrupt discontinuity between mipmap levels if the clip region is small.

  Using coarser LODs blends mipmap levels over a larger textured region.

• Improves performance when a texture must be roamed very quickly.

Because the invalid border can be adjusted dynamically, it can reduce the texture and system memory loading requirements at the expense of a blurrier textured image.

Figure 8-7. Invalid Border

You can use the texture LOD extension in conjunction with mipmapping to change the base level from zero to something else. Using different base levels results in clipmaps with more levels than the hardware can store at once when texturing.

These larger mipmapped textures can be used by only accessing a subset of all available mipmap levels in texture memory at any one time. A virtual offset is used to set a virtual “level 0” in the mipmap while the number of effective levels indicates how many levels starting from the new level 0 can be accessed. The minLOD and maxLOD are also used to ensure that only valid levels are accessed. Using the relative position of the viewer and the terrain to calculate the values, the application typically divides the clipmapped terrain into pieces and sets the values as each piece is traversed.

Figure 8-8. Virtual Clipmap

To index into a clipmap of greater than GL_MAX_CLIPMAP_DEPTH_SGIX levels of detail, additional parameters are provided to restrictively index a smaller clipmap of (N+1) levels located wholly within a complete, larger clipmap. Figure 8-8 illustrates how a virtual clipmap fits into a larger clipmap stack. The clipmap extension specification explains the requirements for the larger and smaller clipmap in more detail.

When creating a virtual clipmap, an application calls glTexParameteriv() or glTexParameterfv() with the following specifications:

If the depth of the virtual clipmap is zero, clipmap virtualization is ignored, and texturing proceeds as with a non-virtual clipmap.

If you have virtualized the clipmap, you will be adjusting the LOD offset and possibly the number of displayable levels as you render each chunk of polygons that need a different set of clipmap levels to be rendered properly. The application has to compute the levels needed.

If an application uses an image as a texture map, the image may have to be scaled down to a smaller size on the screen. During this process the image must be filtered to produce a high-quality result. Nearest-neighbor or linear filtering do not work well when an image is scaled down; for better results, an OpenGL program can use mipmapping. A mipmap is a series of prefiltered texture maps of decreasing resolution. Each texture map is referred to as one level of detail (LOD). Applications create a mipmap using the routines gluBuild1DMipmaps() or gluBuild2DMipmaps(). Mipmaps are discussed starting on page 338 of the OpenGL Programming Guide, Second Edition.

Graphics systems from Silicon Graphics automatically select an LOD for each textured pixel on the screen. However, in some situations the selected LOD results in an image that is too crisp or too blurry for the needs of the application. For example, 2D mipmapping works best when the shape of the texture on the screen is a square. If that is not the case, then one dimension of the texture must be scaled down more than the other to fit on the screen. By default, the LOD corresponding to the larger scale factor is used; so, the dimension with the smaller scale factor will appear too blurry.

Figure 8-9 shows an image that is too blurry with the default LOD bias. You can see that the marker in the middle of the road is blurred out. In Figure 8-10, this effect is exaggerated by a positive LOD bias. Figure 8-11 shows how the markers become visible with a negative LOD bias.

Figure 8-9. Original Image

Figure 8-10. Image With Positive LOD Bias

Figure 8-11. Image with Negative LOD Bias

As another example, the texture data supplied by the application may be slightly oversampled or undersampled; so, the textured pixels drawn on the screen may be correspondingly blurry or crisp.

The texture LOD bias extension allows applications to bias the default LOD to make the resulting image sharper or more blurry. An LOD of 0 corresponds to the most-detailed texture map, an LOD of 1 corresponds to the next smaller texture map, and so on. The default bias is zero, but if the application specifies a new bias, that bias will be added to the selected LOD. A positive bias produces a blurrier image, and a negative bias produces a crisper image. A different bias can be used for each dimension of the texture to compensate for unequal sampling rates.

Examples of textures that can benefit from this LOD control include the following:

To make a mipmapped texture sharper or blurrier, applications can supply a negative or positive bias by calling glTexParameter*() with the following specifications:

You can specify a bias independently for one or more texture dimensions. The final LOD is at least as large as the maximum LOD for any dimension; that is, the texture is scaled down by the largest scale factor, even though the best scale factors for each dimension may not be equal.

Applications can also call glGetTexParameter*() to check whether one of these values has been set.