EXT abgr

EXT_ABGR extends the list of host-memory color formats. Specifically, it provides a reverse-order alternative to image format RGBA. The ABGR component order matches the cpack Iris GL format on big-endian machines.

EXT blend color

Blending capability is extended by defining a constant color that can be included in blending equations. A typical usage is blending two RGB images. Without the constant blend factor, one image must have an alpha channel with each pixel set to the desired blend factor.

EXT blend logic op

A single additional blending equation is specified using the interface defined by EXT_BLEND_MINMAX. This equation is a simple logical combination of the source and destination colors, where the specific logical operation is as specified by LogicOp. While only the XOR operation may find wide application, the generality of full logical operations is allowed.

EXT blend minmax

Blending capability is extended by respecifying the entire blend equation. While this document defines only two new equations, the BlendEquationEXT procedure that it defines will be used by subsequent extensions to define additional blending equations.

 The two new equations defined by this extension produce the minimum (or maximum) color components of the source and destination colors. Taking the maximum is useful for applications such as maximum projection in medical imaging.

EXT blend subtract

Two additional blending equations are specified using the interface defined by EXT_BLEND_MINMAX. These equations are similar to the default blending equation but produce the difference of its left and right hand sides rather than the sum. Image differences are useful in many image processing applications.

SGI color matrix

This extension adds a 4 x 4 matrix stack to the pixel transfer path. The matrix operates on RGBA pixel groups, using the equation

 C' = MC

 where

    |R|
C = |G|
    |B|
    |A|

 and M is the 4 x 4 matrix on the top of the color matrix stack. After the matrix multiplication, each resulting color component is scaled and biased by a programmed amount. Color matrix multiplication follows convolution (and the scaling and biasing that are associated with convolution.) The color matrix can be used to reassign and duplicate color components. It can also be used to implement simple color space conversions.

SGI color table

This extension defines a new RGBA-format color lookup mechanism. It does not replace the color lookups defined by the GL specification but rather provides additional lookup capabilities with different operations. The key difference is that the new lookup tables are treated as 1-dimensional images with internal formats like texture images and convolution filter images. From this follows the fact that the new tables can operate on a subset of the components of passing pixel groups. For example, a table with internal format ALPHA modifies only the A component of each pixel group. The table leaves the R, G, and B components unmodified.

If EXT_COPY_TEXTURE is implemented, this extension also defines methods to initialize the color lookup tables from the framebuffer in addition to the standard memory source mechanisms.

EXT convolution

This extension defines 1- and 2-dimensional convolution operations at a fixed location in the pixel transfer process. Thus, pixel drawing, reading, and copying, as well as texture image definition, are all candidates for convolution. The convolution kernels are themselves treated as 1- and 2-dimensional images, which can be loaded from application memory or from the framebuffer.

This extension is designed to accommodate 3D convolution, but the API is left for a future extension.

EXT copy texture

This extension defines methods to load texture images directly from the framebuffer. Methods are defined for both complete and partial replacement of a texture image. Because it is not possible to define an entire 3D texture using a 2D framebuffer image, 3D textures are supported only for partial replacement.

SGIS detail texture

This extension introduces texture magnification filters that blend between the level 0 image and a separately defined detail image. The detail image represents the characteristics of the high frequency subband image above the band-limited level 0 image. The detail image is typically a rectangular portion of the subband image which is modified so that it can be repeated without discontinuities along its edges. Detail blending can be enabled for all color channels, for the alpha channel only, or for the red, green, and blue channels only. It is available only for 2D textures. .

SGIX fbconfig

This extension introduces a new way to describe the capabilities of a GLX drawable (that is, to describe the depth of color buffer components and the type and size of ancillary buffers), removes the similarity requirement when making a context current to a drawable, and supports RGBA rendering to 1- and 2-component windows and GLX pixmaps.

EXT histogram

This extension defines pixel operations that count occurrences of specific color component values (histogram) and that track the minimum and maximum color component values (minmax). An optional mode allows pixel data to be discarded after the histogram and/or minmax operations are completed. Otherwise, the pixel data continue on to the next operation unaffected.

EXT import context

This extension allows multiple X clients to share an indirect rendering context.

It also provides additional convenience procedures to get the current Display* bound to a context as well as other context information.

SGI make current read

The association of the current context with a drawable is extended to allow separate write and read drawables. This paves the way for allowing preprocessing of image data in an off-screen window, which is then read into the visible window for final display. Similarly, it sets the framework for direct transfer of video to the GL by treating the video as a special kind of read drawable (readable).

EXT packed pixels

This extension provides support for packed pixels in host memory. A packed pixel is represented entirely by one unsigned byte, one unsigned short, or one unsigned integer. The fields with the packed pixel are not proper machine types, but the pixel as a whole is. Thus, the pixel storage modes, including PACK_SKIP_PIXELS, PACK_ROW_LENGTH, PACK_SKIP_ROWS, PACK_IMAGE_HEIGHT_EXT, PACK_SKIP_IMAGES_EXT, PACK_SWAP_BYTES, PACK_ALIGNMENT, and their unpacking counterparts all work correctly with packed pixels.

SGIX pbuffer

This extension defines pixel buffers (GLXPbuffers or pbuffer, for short). GLXPbuffers are additional non-visible rendering buffers for an OpenGL renderer. GLXPbuffers are equivalent to GLXPixmaps with the following exceptions:

-There is no associated X pixmap. Also, since a GLXPbuffer is a GLX resource, it may not be possible to render to it using X or an X extension other than GLX.

-The format of the color buffers and the type and size of any associated ancillary buffers for a GLXPbuffer can only be described with a GLXFBConfig ; an X Visual cannot be used.

-It is possible to create a GLXPbuffer whose contents may be asynchronously lost at any time.

-GLXPbuffers can be rendered to using either direct or indirect rendering contexts.

-The allocation of a GLXPbuffer can fail if there are insufficient resources (that is, all the pbuffer memory has been allocated and the implementation does not virtualize pbuffer memory.)

The intent of the pbuffer semantics is to enable implementations to allocate pbuffers in non-visible framebuffer memory. These pbuffers are intended to be static resources in that a program will typically allocate them only once rather than as a part of its rendering loop. However, they should be deallocated when the program is no longer using them (for example, if the program is iconified). The framebuffer resources that are associated with a pbuffer are also static and are deallocated only when the pbuffer is destroyed, or, in the case of a unpreserved pbuffer, as a result of X server activity that changes its framebuffer requirements.

 The geometry rasterization and pixel pipeline convert-to-fragment stages each produce fragments. The fragments are processed by a unified per-fragment pipeline that begins with the application of the texture to the fragment color. Because the pixel pipeline shares the per-fragment processing with the geometry pipeline, the fragments produced by the pixel pipeline must have the same fields as the ones produced by the geometry pipeline. When pixel groups are being converted to fragments, the parts of the fragment that are not derived from the pixel groups are taken from the associated values in the current raster position.

 A fragment consists of x and y window coordinates and their associated color value, depth value, and texture coordinates. In the 1.1 OpenGL specification, when the pixel group is RGBA, the fragment color is always derived from the pixel group, and the depth value and texture coordinates always come from the raster position.

SGIX pixel texture

This extension provides a way to specify how the texture coordinates of the fragments can be derived from RGBA pixel groups. When this option is enabled, the source of the fragment color value when the pixel group is RGBA can be specified to come from either the raster position or the pixel group.

 Deriving the fragment texture coordinates from the pixel group effectively converts a color image into a texture coordinate image. The multidimensional texture-mapping lookup logic also makes this extension useful for implementing multidimensional color lookups. Multidimensional color lookups can be used to implement very accurate color space conversions.

 Deriving texture coordinates from the pixel groups in the pixel pipeline introduces a problem with the lambda parameter in the texture mapping equations. When texture coordinates are being taken from the texture coordinates of the current raster position, the texture coordinate values do not change from pixel to pixel, and the equation for calculating lambda always produces zero. Enabling SGIX_PIXEL_TEXTURE introduces changes in the texture coordinates from pixel to pixel. These changes are not necessarily meaningful for texture lookups. This problem is addressed by specifying that lambda is always set to zero when SGIX_PIXEL_TEXTURE is enabled.

EXT polygon offset

The depth values of fragments generated by rendering polygons are displaced by an amount that is proportional to the maximum absolute value of the depth slope of the polygon, measured and applied in window coordinates. This displacement allows lines (or points) and polygons in the same plane to be rendered without interaction; the lines are rendered either completely in front of or behind the polygons (depending on the sign of the offset factor). It also allows multiple coplanar polygons to be rendered without interaction if different offset factors are used for each polygon. Applications include rendering hidden-line images, rendering solids with highlighted edges, and applying decals to surfaces.

EXT subtexture

This extension allows a contiguous portion of an already existing texture image to be redefined without affecting the remaining portion of the image or any of the other state that describe the texture. No provision is made to query a subregion of a texture.

Semantics for null image pointers are defined for glTexImage1D, glTexImage2D, and glTexImage3DEXT. Null image pointers can be used by applications to effectively support texture arrays whose dimensions are not a power of 2.

SGIX swap barrier

This extension provides the capability to synchronize the buffer swaps of different swap groups.

A swap group is bound to a _swap_barrier_. The buffer swaps of each swap group using that barrier will wait until every swap group using that barrier is ready to swap (where readiness is defined under extensions SGI swap control and SGIX swap group), after which time all buffer swaps of all groups using that barrier will take place concurrently.

SGI swap control

This extension extends the set of conditions that must be met before a buffer swap can take place. This extension allows an application to specify a minimum period of color buffer swaps, measured in video frame periods.

SGIX swap group

This extension, like SGI swap control, extends the set of conditions that must be met before a buffer swap can take place. This extension provides the capability to synchronize the buffer swaps of a group of GLX drawables. A swap group is created, and drawables are added as members to the swap group. Buffer swaps to members of the swap group will then take place concurrently.

EXT texture

The original intention of this extension was simply to support various numeric resolutions of color components in texture images. While it accomplishes this, it also accomplishes a larger task, that of formalizing the notion of an internal format for images that corresponds to the external format that already exists for image data in host memory. This notion of an internal image format will be used extensively in later extensions, especially those concerned with pixel manipulation.

The idea of an internal format is simple: rather than treating a retained image as having 1, 2, 3, or 4 components, treat it as though it has a specific format, such as LUMINANCE_ALPHA or just ALPHA. Then define the semantics of the use of internal images with these formats in a consistent way. Because texture mapping is already defined in GL, the semantics for internal-format images were chosen to match those of the 1-, 2-, 3- and 4-component internal images that already exist. The new semantics are a superset of the old ones. As such, this extension adds capabilities to the GL as well as allowing internal resolutions to be specified.

This extension also defines a robust method for applications to determine what combinations of texture dimensions and resolutions are supported by an implementation. It also introduces a new texture environment: REPLACE_EXT.

EXT texture 3D

This extension defines 3-dimensional texture mapping. In order to define a 3D texture image conveniently, this extension also defines the in-memory formats for 3D images and adds pixel storage modes to support them.

One important application of 3D textures is volume rendering.

SGIS texture border clamp

The base OpenGL provides clamping such that the texture coordinates are limited to exactly the range [0,1]. When a texture coordinate is clamped using this algorithm, the texture sampling filter straddles the edge of the texture image, taking 1/2 its sample values from within the texture image and the other 1/2 from the texture border. It is sometimes desirable for a texture to be clamped to the border color rather than to an average of the border and edge colors.

This extension defines an additional texture clamping algorithm, CLAMP_TO_BORDER_SGIS. It clamps texture coordinates at all mipmap levels such that NEAREST and LINEAR filters return the color of the border texels. When used with FILTER4 filters, the filter operation of CLAMP_TO_BORDER_SGIS is defined but does not result in a nice clamp-to-border color.

SGI texture color table

This extension adds a color lookup table to the texture mechanism. The table is applied to the filtered result of a texture lookup before that result is used in the texture environment equations.

The definition and application of the texture color table are similar to those of the color tables defined in SGI_COLOR_TABLE, though it is not necessary for that extension to be implemented.

Texture color tables can be used to expand luminance or intensity textures to full RGBA and also to linearize the results of color space conversions implemented by multidimensional texture table lookup.

SGIS texture lod

This extension imposes two constraints related to the texture level of detail parameter LOD, which is represented by the Greek character lambda in the GL specification. One constraint clamps LOD to a specified floating point range. The other limits the selection of mipmap image arrays to a subset of the arrays that would otherwise be considered.

Together these constraints allow a large texture to be loaded and used initially at low resolution and to have its resolution raised gradually as more resolution is desired or available. Image array specification is necessarily integral rather than continuous. By providing separate, continuous clamping of the LOD parameter, it is possible to avoid popping artifacts when higher resolution images are provided.

Note: Because the shape of the mipmap array is always determined by the dimensions of the level 0 array, this array must be loaded for mipmapping to be active. If the level 0 array is specified with a null image pointer, however, no actual data transfer will take place. A sufficiently tuned implementation might not even allocate space for a level 0 array so specified until true image data is presented.

EXT texture object

This extension introduces named texture objects. The only way to name a texture in GL 1.0 is by defining it as a single display list. Because display lists cannot be edited, these objects are static. Yet, it is important to be able to change the images and parameters of a texture.

SGI transparent pixel

EXT vertex array

This extension adds the ability to specify multiple geometric primitives with very few subroutine calls. Instead of calling an OpenGL procedure to pass each individual vertex, normal, or color; separate arrays of vertexes, normals, and colors are pre-specified and are used to define a sequence of primitives (all of the same type) when a single call is made to glDrawArraysEXT. A stride mechanism is provided so that an application can choose to keep all vertex data staggered in a single array or sparsely in separate arrays. Single-array storage may optimize performance on some implementations.

This extension also supports the rendering of individual array elements, each specified as an index into the enabled arrays.

SGI video sync

This extension provides a means for synchronization with the video frame rate of a monitor. (In the case of an interlaced monitor, this is typically the rate of displaying both the even and odd fields of a frame.) The kernel maintains a video sync counter for each physical hardware pipe in a system; the counter is incremented upon the completion of the display of each full frame of video data. An OpenGL context always corresponds to a pipe. When an OpenGL process has a current context, it can put itself to sleep until the counter of that pipe reaches a desired value. The process can also query the value of the counter. The counter is an unsigned 32-bit integer.

The counter runs as long as the graphics subsystem is running; it is initialized by the /usr/gfx/gfxinit command. However, a process can query or sleep on the counter only when a direct context is current. An error code will be returned if you attempt to use this extension (and associated functions) with an indirect context.

EXT visual info

This extension allows you to request a particular X visual type to be associated with a GLX visual and to query the X visual type underlying a GLX visual.

 In addition, this extension provides a means to request a visual with a transparent pixel and to query whether a visual supports a transparent pixel value and to query its value. Note that the notions of level and transparent pixels are orthogonal, as both layer 1 and layer 0 visuals may or may not have a transparent pixel values.

SGIX async

This extension provides a framework for asynchronous OpenGL commands. It also provides commands allowing a program to wait for the completion of asynchronous commands.

Asynchronous commands have two properties:

- Asynchronous commands are non-blocking. For example, an asynchronous glReadPixels command returns control to the program immediately rather than blocking further program execution until the command completes. This property allows the program to issue other OpenGL commands in parallel with the execution of commands that normally block.

- Asynchronous commands may complete out-of-order with respect to other OpenGL commands. For example, an asynchronous glTexImage command may complete after subsequent OpenGL commands issued by the program rather than maintaining the normal serial order of the OpenGL command stream. This property allows the graphics accelerator to execute asynchronous commands in parallel with the normal command stream; for instance, the accelerator can use a secondary path to transfer data from or to the host without doing any dependency checking.

Programs that issue asynchronous commands must also be able to determine when the commands have completed. The completion status may be needed so that results can be retrieved (for example, the image data from a glReadPixels command) or so that dependent commands can be issued (for example. drawing commands that use texture data downloaded by an earlier asynchronous command). This extension provides fine-grain control over asynchronous commands by introducing a mechanism for determining the status of individual commands.

Each invocation of an asynchronous command is associated with an integer called a marker. A program specifies a marker before it issues an asynchronous command. The program may later issue a command to query if any asynchronous commands have completed. The query commands return a marker to identify the command that completed. This extension provides both blocking and non-blocking query commands.

SGIX async pixel

This extension introduces a new asynchronous mode for texture download, pixel download, and pixel readback commands. It allows programs to transfer textures or images between the host and the graphics accelerator in parallel with the execution of other graphics commands (possibly taking advantage of a secondary path to the graphics accelerator). It also allows programs to issue non-blocking pixel readback commands that return immediately after they are issued so that the program can issue other commands while the readback takes place.

This extension does not define any asynchronous commands. See GL_SGIX_async_pixel documenatation for the asynchronous pixel commands.

SGIX blend alpha minmax

Two additional blending equations are specified using the interface defined by GL_EXT_blend_minmax. These equations are similar to the MIN_EXT and MAX_EXT blending equations, but the outcome for all four-color components is determined by a comparison of just the alpha component's source and destination values. These equations are useful in image processing and advanced shading algorithms.

EXT color subtable

This extension allows a portion of a color table to be redefined. If GL_EXT_copy_texture is implemented, this extension also defines a method to load a portion of a color lookup table from the framebuffer.

EXT compiled vertex array

This extension defines an interface which allows static vertex array data to be cached or pre-compiled for more efficient rendering. This is useful for implementations which can cache the transformed results of array data for reuse by several glDrawArrays, glArrayElement, or glDrawElements commands. It is also useful for implementations which can transfer array data to fast memory for more efficient processing.

For example, rendering an M x N mesh of quadrilaterals can be accomplished by setting up vertex arrays containing all of the vertexes in the mesh and issuing M glDrawElements commands, each of which operate on 2 * N vertexes. Each glDrawElements command after the first will share N vertexes with the preceding glDrawElements command. If the vertex array data is locked while the glDrawElements commands are executed, then OpenGL may be able to transform each of these shared vertexes just once.

SGIX compressed textures

This extension defines new host and internal formats for the storage of compressed images. The formats utilize a variant of color cell compression, in which 4 x 4 pixel blocks are represented by two-color values and a 2-bit index per pixel. Two additional values are interpolated between the two explicitly stored values, and each pixel's index selects one of these four values. For RGB and RGBA images, two RGB colors and a single index per pixel are used to store the R, G, and B channels. For RGBA and LUMINANCE_ALPHA formats, the alpha channel is encoded independently using two alpha values and an index per pixel.

SGIX decimation

This extension adds a decimation operation to the pixel transfer path. Decimation occurs after convolution and prior to the post-convolution color table.

The operation is controlled by two positive integer parameters, stepx and stepy, that specify the decimation step size in the x and y directions, respectively. During a pixel transfer, the decimation operation passes only those pixels which are at a position (i*stepx, j*stepy), for integers (i, j) relative to the bottom left corner of the image that is being transferred. All other pixels are discarded. Decimation is applied to the image that results from convolution, which may differ in size from the source image if convolution is enabled.
By default, stepx and stepy are both 1.

EXT draw range elements

SGIX fragment lighting

This extension adds a new lighting stage to the OpenGL pipeline. This stage occurs during fragment processing after the texture environment has been applied and before fog has been applied. The extension provides a mechanism for computing per-pixel lighting. Fragment lighting applies to fragments generated by all primitives including pixel images. This extension does not eliminate vertex lighting but can be used to complement it. For example, the diffuse contribution can be evaluated at each vertex, and the specular contribution can be evaluated at each fragment with the results summed together to generate the final result.

SGIX texture color mask

This extension implements the same functionality for texture updates that glColorMask implements for color buffer updates. Masks for updating textures with indexed internal formats (the analog for glIndexMask) should be supported by a separate extension.

The extension allows an application to update a subset of components in an existing texture. The masks are applied after all pixel transfer operations have been performed, immediately prior to writing the texel value into texture memory. They apply to all texture updates.

SGIS texture edge clamp

This extension defines a new texture clamping algorithm. The base OpenGL provides clamping such that the texture coordinates are limited to exactly the range [0,1]. When a texture coordinate is clamped using this algorithm, the texture sampling filter straddles the edge of the texture image. The filter takes 1/2 its sample values from within the texture image and the other 1/2 from the texture border. It is sometimes desirable to clamp a texture without requiring a border and without using the constant border color.

The new texture clamping algorithm, CLAMP_TO_EDGE_SGIS, clamps texture coordinates at all mipmap levels such that the texture filter never samples a border texel. When used with a NEAREST or a LINEAR filter, the color returned when clamping is derived only from texels at the edge of the texture image. When used with FILTER4 filters, the filter operations of CLAMP_TO_EDGE_SGIS are defined but do not result in a nice clamp-to-edge color.

CLAMP_TO_EDGE_SGIS is supported by 1-, 2-, and 3-dimensional textures only.

SGIX texture env add

A new texture environment function ADD is supported with the following equation:

Cv = Cf + CcCt + Cb

A new function may be specified by calling glTexEnv with GL_ADD token. New parameter Cb (bias) may be specified by calling glTexEnv with TEXTURE_ENV_BIAS_SGIX token.

SGIX texture lod bias

This extension modifies the calculation of texture level of detail parameter LOD, which is represented by the Greek character lambda in the GL specification. The LOD equation assumes that a 2ⁿ x 2^m x 2^l texture is band-limited at 2^(n-1), 2^(m-1), 2^(l-1). Often a texture is oversampled or filtered such that the texture is band-limited at lower frequencies in one or more dimensions. The result is that texture-mapped primitives appear excessively blurry. This extension provides biases for n, m, and l in the LOD calculation to compensate for under- or over-sampled texture images. Mipmapped textures can be made to appear sharper or blurrier by supplying a negative or positive bias, respectively.

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

-video-capture images which are filtered differently horizontally and vertically

-a texture which appears blurry because it is mapped with a nonuniform scale, such as a road texture which is repeated hundreds of times in one dimension and only once in the other

-textures which had to be magnified to a power of 2 for mipmapping

SGIX texture scale bias

This extension adds scale, bias, and clamp to [0, 1] operations to the texture pipeline. These operations are applied to the filtered result of a texture lookup before that result is used in the texture environment equations and before the texture color lookup table of GL_SGI_texture_color_table, if that extension exists. These operations are distinct from the scale, bias, and clamp operations that appear in the GL_SGI_color_table extension, which are used to define a color lookup table.

 Scale and bias operations on texels can be used to better utilize the color resolution of a particular texture internal format (see EXT texture).

SGIX_subsample

Many video image formats and compression techniques utilize various component subsamplings. So, it is necessary to provide a mechanism to specify the up- and down-sampling of components as pixel data is drawn from and read back to the client. Though subsampled components are normally associated with the video color space, YCrCb, use of subsampling in OpenGL does not imply a specific color space.

This extension defines new pixel storage modes that are used in the conversion of image data to and from component subsampled formats on the client side. The extension defines a new pixel storage mode to specify these sampling patterns. There are three valid values:

SAMPLING_UNIFORM_SGIX
SAMPLING_422_SGIX
SAMPLING_4224_SGIX

When pixel data is received from the client and an unpacking upsampling mode other than SAMPLING_UNIFORM_SGIX is specified, the up-sampling is performed by one of two methods: RESAMPLE_REPLICATE_SGIX or RESAMPLE_ZERO_FILL_SGIX. Replicate and zero-fill are provided to give the application greatest performance and control over the filtering process.

Similarly, when pixel data is read back to the client and a packing down-sampling mode other than SAMPLING_UNIFORM_SGIX is specified, down-sampling is performed. If either replicate or zero-fill is specified, then the down-sampling is performed by simple component decimation.

EXT bgr, EXT bgra

EXT_BGRA extends the list of host-memory color formats. Specifically, it provides formats which match the memory layout of Windows DIBs so that applications can use the same data in both Windows API calls and OpenGL pixel API calls.

EXT separate specular color

This extension adds a second color to rasterization when lighting is enabled. Its purpose is to produce textured objects with specular highlights, which are the color of the lights. It applies only to RGBA lighting.

The two colors are computed at the vertexes. They are both clamped, flat-shaded, clipped, and converted to fixed point just like the current RGBA color. Rasterization interpolates both colors to fragments. If texture is enabled, the first (or primary) color is the input to the texture environment; the fragment color is the sum of the second color and the color resulting from texture application. If texture is not enabled, the fragment color is the sum of the two colors.

A new control to glLightModel*, LIGHT_MODEL_COLOR_CONTROL_EXT, manages the values of the two colors. The new control can have one of two values: SINGLE_COLOR_EXT, a compatibility mode, or SEPARATE_SPECULAR_COLOR_EXT, the object of this extension. In single color mode, the primary color is the current final color and the secondary color is 0.0. In separate specular mode, the primary color is the sum of the ambient, diffuse, and emissive terms of final color and the secondary color is the specular term.

There is much concern that this extension may not be compatible with the future direction of OpenGL with regards to better lighting and shading models. Until those impacts are resolved, give this serious consideration before using this extension ( allowing the user to specify a second input color).

HP convolution border modes

This extension provides some additional border modes for the EXT_CONVOLUTION extension.

SGIX flush raster

This extensions provides a way to ensure that all raster operations currently in the pipeline will be completed before the next raster operation begins. We define a raster operation as an operation that involves the rasterization stage of the OpenGL pipeline. The implementation is free to decide what constitutes flushing the raster subsystem.

The motivation is to allow accurate instrumentation by including this call before stopping rasterization measurements. There are cases where glFinish() is used, but glFlushRaster() would suffice; so, this extension is deliberately kept independent of the instruments extension.

SGIS fog func

This extension allows you to define an application-specific fog blend-factor function. The function is defined by the set of the control points and should be monotonic. A value pair represents each control point: the eye-space distance value and corresponding value of the fog blending factor. The minimum number of control points is one. The maximum number is implementation-dependent.

SGIX fog offset

This extension allows you to make objects look brighter in the foggy environment. FOG_OFFSET_VALUE_SGIX parameter specifies point coordinates in eye space, an offset amount toward viewpoint. Once fog offset is specified and enabled using the FOG_OFFSET_SGIX parameter, it is subtracted from the depth value (to make objects closer to the viewer) right before fog calculation. As a result, objects look less foggy.

This extension specifies that the fragment lighting vectors; including the view vector, light vectors, half-angle vectors, and spotlight direction vectors; be transformed into either eye space, object space or tangent space on a per-vertex basis. The default is eye space.

SGIX instruments

This extension allows the gathering and return of performance measurements from within the graphics pipeline by adding instrumentation.

There are two reasons to do this. The first is as a part of some type of fixed-frame-rate load management scheme. If we know that the pipeline is stalled or struggling to process the amount of data we have given it so far, we can reduce the level of detail of the remaining objects in the current frame or the next frame, or we can adjust the framebuffer resolution for the next frame if we have a video-zoom capability available. We can call this type of instrumentation load monitoring.

The second is for performance tuning and debugging of an application. It might tell us how many triangles were culled or clipped before being rasterized. We can call this simply tuning.

Load monitoring requires that the instrumentation and the access of the measurements be efficient; otherwise, the instrumentation itself will reduce performance more than any load management scheme could hope to offset. Tuning does not have the same requirements.

The proposed extension adds a call to set up a measurements return buffer similar to glFeedbackBuffer but with an asynchrounous behavior to prevent filling the pipeline with NOPs while waiting for the data to be returned.

Note that although the extension has been specified without any particular instruments, defining either a device-dependent or device-independent instrument should be as simple as introducing an extension consisting primarily of a new enumerant to identify the instrument.

SGIX list priority

This extension provides a mechanism for specifying the relative importance of display lists. This information can be used by an OpenGL implementation to guide the placement of display list data in a storage hierarchy.

SGIS sharpen texture

This extension introduces texture magnification filters that sharpen the resulting image by extrapolating from the level 1 image to the level 0 image. Sharpening can be enabled for all color channels, for the alpha channel only, or for the red, green, and blue channels only.

EXT rescale normal

When normal rescaling is enabled, a new operation is added to the transformation of the normal vector into eye coordinates. The normal vector is rescaled after it is multiplied by the inverse model view matrix and before it is normalized.

The rescale factor is chosen so that in many cases normal vectors with unit length in object coordinates will not need to be normalized as they are transformed into eye coordinates.

SGIX texture coordinate clamp

This extension provides a mechanism to specify the maximum texture coordinate clamping values. Standard OpenGL always clamps the upper bound to 1.0 when the wrap mode is set to CLAMP. This mechanism can be used to guarantee that non-existent texel data will not be accessed when the texture image has dimensions that are not a power of 2.