GLfloatvoidparam)

GLintparam)

**eqn not supported**

*pname*- Specifies the symbolic name of the pixel
transfer parameter to be set. Must be one of the following:
**GL_MAP_COLOR**,**GL_MAP_STENCIL**,**GL_INDEX_SHIFT**,**GL_INDEX_OFFSET**,**GL_RED_SCALE**,**GL_RED_BIAS**,**GL_GREEN_SCALE**,**GL_GREEN_BIAS**,**GL_BLUE_SCALE**,**GL_BLUE_BIAS**,**GL_ALPHA_SCALE**,**GL_ALPHA_BIAS**,**GL_DEPTH_SCALE**, or**GL_DEPTH_BIAS**.

Additionally, if the **GL_ARB_imaging**
extension is supported, the following symbolic names are accepted: **GL_POST_COLOR_MATRIX_RED_SCALE**,
**GL_POST_COLOR_MATRIX_GREEN_SCALE**, **GL_POST_COLOR_MATRIX_BLUE_SCALE**, **GL_POST_COLOR_MATRIX_ALPHA_SCALE**,
**GL_POST_COLOR_MATRIX_RED_BIAS**, **GL_POST_COLOR_MATRIX_GREEN_BIAS**, **GL_POST_COLOR_MATRIX_BLUE_BIAS**,
**GL_POST_COLOR_MATRIX_ALPHA_BIAS**, **GL_POST_CONVOLUTION_RED_SCALE**, **GL_POST_CONVOLUTION_GREEN_SCALE**,
**GL_POST_CONVOLUTION_BLUE_SCALE**, **GL_POST_CONVOLUTION_ALPHA_SCALE**, **GL_POST_CONVOLUTION_RED_BIAS**,
**GL_POST_CONVOLUTION_GREEN_BIAS**, **GL_POST_CONVOLUTION_BLUE_BIAS**, and **GL_POST_CONVOLUTION_ALPHA_BIAS**.

*param*- Specifies the value that
*pname*is set to.

Pixel transfer operations handle four fundamental pixel types: *color*, *color
index*, *depth*, and *stencil*. *Color* pixels consist of four floating-point values
with unspecified mantissa and exponent sizes, scaled such that 0 represents
zero intensity and 1 represents full intensity. *Color indices* comprise a
single fixed-point value, with unspecified precision to the right of the
binary point. *Depth* pixels comprise a single floating-point value, with unspecified
mantissa and exponent sizes, scaled such that 0.0 represents the minimum
depth buffer value, and 1.0 represents the maximum depth buffer value. Finally,
*stencil* pixels comprise a single fixed-point value, with unspecified precision
to the right of the binary point.

The pixel transfer operations performed on the four basic pixel types are as follows:

- Color
- Each of the four color
components is multiplied by a scale factor, then added to a bias factor.
That is, the red component is multiplied by
**GL_RED_SCALE**, then added to**GL_RED_BIAS**; the green component is multiplied by**GL_GREEN_SCALE**, then added to**GL_GREEN_BIAS**; the blue component is multiplied by**GL_BLUE_SCALE**, then added to**GL_BLUE_BIAS**; and the alpha component is multiplied by**GL_ALPHA_SCALE**, then added to**GL_ALPHA_BIAS**. After all four color components are scaled and biased, each is clamped to the range [0,1]. All color, scale, and bias values are specified with**glPixelTransfer**.

If **GL_MAP_COLOR** is true, each
color component is scaled by the size of the corresponding color-to-color
map, then replaced by the contents of that map indexed by the scaled component.
That is, the red component is scaled by **GL_PIXEL_MAP_R_TO_R_SIZE**, then
replaced by the contents of **GL_PIXEL_MAP_R_TO_R** indexed by itself. The green
component is scaled by **GL_PIXEL_MAP_G_TO_G_SIZE**, then replaced by the contents
of **GL_PIXEL_MAP_G_TO_G** indexed by itself. The blue component is scaled by
**GL_PIXEL_MAP_B_TO_B_SIZE**, then replaced by the contents of **GL_PIXEL_MAP_B_TO_B**
indexed by itself. And the alpha component is scaled by **GL_PIXEL_MAP_A_TO_A_SIZE**,
then replaced by the contents of **GL_PIXEL_MAP_A_TO_A** indexed by itself.
All components taken from the maps are then clamped to the range [0,1].
**GL_MAP_COLOR** is specified with **glPixelTransfer**. The contents of the various
maps are specified with **glPixelMap**.

If the **GL_ARB_imaging** extension is supported,
each of the four color components may be scaled and biased after transformation
by the color matrix. That is, the red component is multiplied by **GL_POST_COLOR_MATRIX_RED_SCALE**,
then added to **GL_POST_COLOR_MATRIX_RED_BIAS**; the green component is multiplied
by **GL_POST_COLOR_MATRIX_GREEN_SCALE**, then added to **GL_POST_COLOR_MATRIX_GREEN_BIAS**;
the blue component is multiplied by **GL_POST_COLOR_MATRIX_BLUE_SCALE**, then
added to **GL_POST_COLOR_MATRIX_BLUE_BIAS**; and the alpha component is multiplied
by **GL_POST_COLOR_MATRIX_ALPHA_SCALE**, then added to **GL_POST_COLOR_MATRIX_ALPHA_BIAS**.
After all four color components are scaled and biased, each is clamped
to the range [0,1].

Similiarly, if the **GL_ARB_imaging** extension is supported,
each of the four color components may be scaled and biased after processing
by the enabled convolution filter. That is, the red component is multiplied
by **GL_POST_CONVOLUTION_RED_SCALE**, then added to **GL_POST_CONVOLUTION_RED_BIAS**;
the green component is multiplied by **GL_POST_CONVOLUTION_GREEN_SCALE**, then
added to **GL_POST_CONVOLUTION_GREEN_BIAS**; the blue component is multiplied
by **GL_POST_CONVOLUTION_BLUE_SCALE**, then added to **GL_POST_CONVOLUTION_BLUE_BIAS**;
and the alpha component is multiplied by **GL_POST_CONVOLUTION_ALPHA_SCALE**,
then added to **GL_POST_CONVOLUTION_ALPHA_BIAS**. After all four color components
are scaled and biased, each is clamped to the range [0,1].

- Color index
- Each
color index is shifted left by
**GL_INDEX_SHIFT**bits; any bits beyond the number of fraction bits carried by the fixed-point index are filled with zeros. If**GL_INDEX_SHIFT**is negative, the shift is to the right, again zero filled. Then**GL_INDEX_OFFSET**is added to the index.**GL_INDEX_SHIFT**and**GL_INDEX_OFFSET**are specified with

**glPixelTransfer**.

From this point, operation diverges depending on the required
of the resulting pixels. If the resulting pixels are to be written to a
color index buffer, or if they are being read back to client memory in
**GL_COLOR_INDEX** , the pixels continue to be treated as indices. If **GL_MAP_COLOR**
is true, each index is masked by $2 sup n ~-~ 1$, where $n$ is **GL_PIXEL_MAP_I_TO_I_SIZE**,
then replaced by the contents of **GL_PIXEL_MAP_I_TO_I** indexed by the masked
value. **GL_MAP_COLOR** is specified with **glPixelTransfer**. The contents of the
index map is specified with **glPixelMap**.

If the resulting pixels are to be
written to an RGBA color buffer, or if they are read back to client memory
in a other than **GL_COLOR_INDEX**, the pixels are converted from indices
to colors by referencing the four maps **GL_PIXEL_MAP_I_TO_R**, **GL_PIXEL_MAP_I_TO_G**,
**GL_PIXEL_MAP_I_TO_B**, and **GL_PIXEL_MAP_I_TO_A**. Before being dereferenced,
the index is masked by $2 sup n ~-~ 1$, where $n$ is **GL_PIXEL_MAP_I_TO_R_SIZE**
for the red map, **GL_PIXEL_MAP_I_TO_G_SIZE** for the green map, **GL_PIXEL_MAP_I_TO_B_SIZE**
for the blue map, and **GL_PIXEL_MAP_I_TO_A_SIZE** for the alpha map. All components
taken from the maps are then clamped to the range [0,1]. The contents of
the four maps is specified with **glPixelMap**.

- Depth
- Each depth value is multiplied
by
**GL_DEPTH_SCALE**, added to**GL_DEPTH_BIAS**, then clamped to the range [0,1]. - Stencil
- Each index is shifted
**GL_INDEX_SHIFT**bits just as a color index is, then added to**GL_INDEX_OFFSET**. If**GL_MAP_STENCIL**is true, each index is masked by $2 sup n ~-~ 1$, where $n$ is**GL_PIXEL_MAP_S_TO_S_SIZE**, then replaced by the contents of**GL_PIXEL_MAP_S_TO_S**indexed by the masked value.

The following table gives the type, initial value, and range of valid values
for each of the pixel transfer parameters that are set with **glPixelTransfer**.

pname | Type | Initial Value | Valid Range |

GL_MAP_COLOR | boolean | false | true/false |

GL_MAP_STENCIL | boolean | false | true/false |

GL_INDEX_SHIFT | integer | 0 | (-if,if) |

GL_INDEX_OFFSET | integer | 0 | (-if,if) |

GL_RED_SCALE | float | 1 | (-if,if) |

GL_GREEN_SCALE | float | 1 | (-if,if) |

GL_BLUE_SCALE | float | 1 | (-if,if) |

GL_ALPHA_SCALE | float | 1 | (-if,if) |

GL_DEPTH_SCALE | float | 1 | (-if,if) |

GL_RED_BIAS | float | 0 | (-if,if) |

GL_GREEN_BIAS | float | 0 | (-if,if) |

GL_BLUE_BIAS | float | 0 | (-if,if) |

GL_ALPHA_BIAS | float | 0 | (-if,if) |

GL_DEPTH_BIAS | float | 0 | (-if,if) |

GL_POST_COLOR_MATRIX_RED_SCALE | float | 1 | (-if,if) |

GL_POST_COLOR_MATRIX_GREEN_SCALE | float | 1 | (-if,if) |

GL_POST_COLOR_MATRIX_BLUE_SCALE | float | 1 | (-if,if) |

GL_POST_COLOR_MATRIX_ALPHA_SCALE | float | 1 | (-if,if) |

GL_POST_COLOR_MATRIX_RED_BIAS | float | 0 | (-if,if) |

GL_POST_COLOR_MATRIX_GREEN_BIAS | float | 0 | (-if,if) |

GL_POST_COLOR_MATRIX_BLUE_BIAS | float | 0 | (-if,if) |

GL_POST_COLOR_MATRIX_ALPHA_BIAS | float | 0 | (-if,if) |

GL_POST_CONVOLUTION_RED_SCALE | float | 1 | (-if,if) |

GL_POST_CONVOLUTION_GREEN_SCALE | float | 1 | (-if,if) |

GL_POST_CONVOLUTION_BLUE_SCALE | float | 1 | (-if,if) |

GL_POST_CONVOLUTION_ALPHA_SCALE | float | 1 | (-if,if) |

GL_POST_CONVOLUTION_RED_BIAS | float | 0 | (-if,if) |

GL_POST_CONVOLUTION_GREEN_BIAS | float | 0 | (-if,if) |

GL_POST_CONVOLUTION_BLUE_BIAS | float | 0 | (-if,if) |

GL_POST_CONVOLUTION_ALPHA_BIAS | float | 0 | (-if,if) |

**glPixelTransferf** can be used to set any pixel transfer parameter. If the
parameter type is boolean, 0 implies false and any other value implies
true. If *pname* is an integer parameter, *param* is rounded to the nearest
integer.

Likewise, **glPixelTransferi** can be used to set any of the pixel
transfer parameters. Boolean parameters are set to false if *param* is 0 and
to true otherwise. *param* is converted to floating point before being assigned
to real-valued parameters.

**GL_INVALID_OPERATION** is generated if **glPixelTransfer**
is executed between the execution of **glBegin** and the corresponding execution
of **glEnd**.