<div class="refentry" lang="en" xml:lang="en"><a id="glDrawPixels"></a><div class="titlepage"></div><div class="refnamediv"><h2>Name</h2><p>glDrawPixels — write a block of pixels to the frame buffer</p></div><div class="refsynopsisdiv"><h2>C Specification</h2><div class="funcsynopsis"><table><tr><td><code class="funcdef">void <b class="fsfunc">glDrawPixels</b>(</code></td><td>GLsizei  </td><td><var class="pdparam">width</var>, </td></tr><tr><td> </td><td>GLsizei  </td><td><var class="pdparam">height</var>, </td></tr><tr><td> </td><td>GLenum  </td><td><var class="pdparam">format</var>, </td></tr><tr><td> </td><td>GLenum  </td><td><var class="pdparam">type</var>, </td></tr><tr><td> </td><td>const GLvoid *  </td><td><var class="pdparam">data</var><code>)</code>;</td></tr></table></div></div><div class="refsect1" lang="en" xml:lang="en"><a id="parameters"></a><h2>Parameters</h2><div class="variablelist"><dl><dt><span class="term"><em class="parameter"><code>width</code></em>, </span><span class="term"><em class="parameter"><code>height</code></em></span></dt><dd><p>

Specify the dimensions of the pixel rectangle to be written

into the frame buffer.

</p></dd><dt><span class="term"><em class="parameter"><code>format</code></em></span></dt><dd><p>

Specifies the format of the pixel data.

Symbolic constants

<code class="constant">GL_COLOR_INDEX</code>,

<code class="constant">GL_STENCIL_INDEX</code>,

<code class="constant">GL_DEPTH_COMPONENT</code>,

<code class="constant">GL_RGB</code>,

<code class="constant">GL_BGR</code>,

<code class="constant">GL_RGBA</code>,

<code class="constant">GL_BGRA</code>,

<code class="constant">GL_RED</code>,

<code class="constant">GL_GREEN</code>,

<code class="constant">GL_BLUE</code>,

<code class="constant">GL_ALPHA</code>,

<code class="constant">GL_LUMINANCE</code>, and

<code class="constant">GL_LUMINANCE_ALPHA</code> are accepted.

</p></dd><dt><span class="term"><em class="parameter"><code>type</code></em></span></dt><dd><p>

Specifies the data type for <em class="parameter"><code>data</code></em>.

Symbolic constants

<code class="constant">GL_UNSIGNED_BYTE</code>,

<code class="constant">GL_BYTE</code>,

<code class="constant">GL_BITMAP</code>,

<code class="constant">GL_UNSIGNED_SHORT</code>,

<code class="constant">GL_SHORT</code>,

<code class="constant">GL_UNSIGNED_INT</code>,

<code class="constant">GL_INT</code>,

<code class="constant">GL_FLOAT</code>,

<code class="constant">GL_UNSIGNED_BYTE_3_3_2</code>,

<code class="constant">GL_UNSIGNED_BYTE_2_3_3_REV</code>,

<code class="constant">GL_UNSIGNED_SHORT_5_6_5</code>,

<code class="constant">GL_UNSIGNED_SHORT_5_6_5_REV</code>,

<code class="constant">GL_UNSIGNED_SHORT_4_4_4_4</code>,

<code class="constant">GL_UNSIGNED_SHORT_4_4_4_4_REV</code>,

<code class="constant">GL_UNSIGNED_SHORT_5_5_5_1</code>,

<code class="constant">GL_UNSIGNED_SHORT_1_5_5_5_REV</code>,

<code class="constant">GL_UNSIGNED_INT_8_8_8_8</code>,

<code class="constant">GL_UNSIGNED_INT_8_8_8_8_REV</code>,

<code class="constant">GL_UNSIGNED_INT_10_10_10_2</code>, and

<code class="constant">GL_UNSIGNED_INT_2_10_10_10_REV</code>

are accepted.

</p></dd><dt><span class="term"><em class="parameter"><code>data</code></em></span></dt><dd><p>

Specifies a pointer to the pixel data.

</p></dd></dl></div></div><div class="refsect1" lang="en" xml:lang="en"><a id="description"></a><h2>Description</h2><p>

<code class="function">glDrawPixels</code> reads pixel data from memory and writes it into the frame buffer

relative to the current raster position, provided that the raster

position is valid. Use

<a class="citerefentry" href="glRasterPos"><span class="citerefentry"><span class="refentrytitle">glRasterPos</span></span></a> or <a class="citerefentry" href="glWindowPos"><span class="citerefentry"><span class="refentrytitle">glWindowPos</span></span></a> to set the current raster position; use

<a class="citerefentry" href="glGet"><span class="citerefentry"><span class="refentrytitle">glGet</span></span></a> with argument <code class="constant">GL_CURRENT_RASTER_POSITION_VALID</code>

to determine if the specified raster position is valid, and

<a class="citerefentry" href="glGet"><span class="citerefentry"><span class="refentrytitle">glGet</span></span></a> with argument <code class="constant">GL_CURRENT_RASTER_POSITION</code>

to query the raster position.

</p><p>

Several parameters define the encoding of pixel data in memory

and control the processing of the pixel data

before it is placed in the frame buffer.

These parameters are set with four commands:

<a class="citerefentry" href="glPixelStore"><span class="citerefentry"><span class="refentrytitle">glPixelStore</span></span></a>,

<a class="citerefentry" href="glPixelTransfer"><span class="citerefentry"><span class="refentrytitle">glPixelTransfer</span></span></a>,

<a class="citerefentry" href="glPixelMap"><span class="citerefentry"><span class="refentrytitle">glPixelMap</span></span></a>, and <a class="citerefentry" href="glPixelZoom"><span class="citerefentry"><span class="refentrytitle">glPixelZoom</span></span></a>.

This reference page describes the effects on <code class="function">glDrawPixels</code> of many,

but not all, of the parameters specified by these four commands.

</p><p>

Data is read from <em class="parameter"><code>data</code></em> as a sequence of signed or unsigned bytes,

signed or unsigned shorts, signed or unsigned integers, or

single-precision floating-point values, depending on <em class="parameter"><code>type</code></em>.

When <em class="parameter"><code>type</code></em> is one of <code class="constant">GL_UNSIGNED_BYTE</code>, <code class="constant">GL_BYTE</code>,

<code class="constant">GL_UNSIGNED_SHORT</code>, <code class="constant">GL_SHORT</code>, <code class="constant">GL_UNSIGNED_INT</code>,

<code class="constant">GL_INT</code>, or <code class="constant">GL_FLOAT</code> each of these bytes, shorts, integers, or

floating-point values is interpreted as one color or depth component, or

one index, depending on <em class="parameter"><code>format</code></em>.

When <em class="parameter"><code>type</code></em> is one of <code class="constant">GL_UNSIGNED_BYTE_3_3_2</code>,

<code class="constant">GL_UNSIGNED_SHORT_5_6_5</code>, <code class="constant">GL_UNSIGNED_SHORT_4_4_4_4</code>,

<code class="constant">GL_UNSIGNED_SHORT_5_5_5_1</code>, <code class="constant">GL_UNSIGNED_INT_8_8_8_8</code>, or

<code class="constant">GL_UNSIGNED_INT_10_10_10_2</code>, each unsigned value is interpreted as

containing all the components for a single pixel, with the color

components arranged according to <em class="parameter"><code>format</code></em>.

When <em class="parameter"><code>type</code></em> is one of <code class="constant">GL_UNSIGNED_BYTE_2_3_3_REV</code>,

<code class="constant">GL_UNSIGNED_SHORT_5_6_5_REV</code>, <code class="constant">GL_UNSIGNED_SHORT_4_4_4_4_REV</code>,

<code class="constant">GL_UNSIGNED_SHORT_1_5_5_5_REV</code>, <code class="constant">GL_UNSIGNED_INT_8_8_8_8_REV</code>, or

<code class="constant">GL_UNSIGNED_INT_2_10_10_10_REV</code>, each unsigned value is interpreted

as containing all color components, specified by <em class="parameter"><code>format</code></em>, for a single

pixel in a reversed order. Indices are always treated individually.

Color components are treated as groups of one, two, three, or four

values, again based on <em class="parameter"><code>format</code></em>. Both individual indices and groups of

components are referred to as pixels.

If <em class="parameter"><code>type</code></em> is <code class="constant">GL_BITMAP</code>, the data must be unsigned bytes, and

<em class="parameter"><code>format</code></em> must be either <code class="constant">GL_COLOR_INDEX</code> or <code class="constant">GL_STENCIL_INDEX</code>.

Each unsigned byte is treated as eight 1-bit pixels, with bit ordering

determined by <code class="constant">GL_UNPACK_LSB_FIRST</code> (see <a class="citerefentry" href="glPixelStore"><span class="citerefentry"><span class="refentrytitle">glPixelStore</span></span></a>).

</p><p>

<math overflow="scroll">

<mrow>

<mi mathvariant="italic">width</mi>

<mo>×</mo>

<mi mathvariant="italic">height</mi>

</mrow>

</math>

pixels are read from memory,

starting at location <em class="parameter"><code>data</code></em>.

By default, these pixels are taken from adjacent memory locations,

except that after all <em class="parameter"><code>width</code></em> pixels are read,

the read pointer is advanced to the next four-byte boundary.

The four-byte row alignment is specified by <a class="citerefentry" href="glPixelStore"><span class="citerefentry"><span class="refentrytitle">glPixelStore</span></span></a> with

argument <code class="constant">GL_UNPACK_ALIGNMENT</code>,

and it can be set to one, two, four, or eight bytes.

Other pixel store parameters specify different read pointer advancements,

both before the first pixel is read

and after all <em class="parameter"><code>width</code></em> pixels are read.

See the <a class="citerefentry" href="glPixelStore"><span class="citerefentry"><span class="refentrytitle">glPixelStore</span></span></a> reference page for details on these options.

</p><p>

If a non-zero named buffer object is bound to the <code class="constant">GL_PIXEL_UNPACK_BUFFER</code> target

(see <a class="citerefentry" href="glBindBuffer"><span class="citerefentry"><span class="refentrytitle">glBindBuffer</span></span></a>) while a block of pixels is

specified, <em class="parameter"><code>data</code></em> is treated as a byte offset into the buffer object's data store.

</p><p>

The

<math overflow="scroll">

<mrow>

<mi mathvariant="italic">width</mi>

<mo>×</mo>

<mi mathvariant="italic">height</mi>

</mrow>

</math>

pixels that are read from memory are

each operated on in the same way,

based on the values of several parameters specified by <a class="citerefentry" href="glPixelTransfer"><span class="citerefentry"><span class="refentrytitle">glPixelTransfer</span></span></a>

and <a class="citerefentry" href="glPixelMap"><span class="citerefentry"><span class="refentrytitle">glPixelMap</span></span></a>.

The details of these operations,

as well as the target buffer into which the pixels are drawn,

are specific to the format of the pixels,

as specified by <em class="parameter"><code>format</code></em>.

<em class="parameter"><code>format</code></em> can assume one of 13 symbolic values:

</p><div class="variablelist"><dl><dt><span class="term"><code class="constant">GL_COLOR_INDEX</code></span></dt><dd><p>

Each pixel is a single value,

a color index.

It is converted to fixed-point format,

with an unspecified number of bits to the right of the binary point,

regardless of the memory data type.

Floating-point values convert to true fixed-point values.

Signed and unsigned integer data is converted with all fraction bits

set to 0.

Bitmap data convert to either 0 or 1.

</p><p>

Each fixed-point index is then shifted left by <code class="constant">GL_INDEX_SHIFT</code> bits

and added to <code class="constant">GL_INDEX_OFFSET</code>.

If <code class="constant">GL_INDEX_SHIFT</code> is negative,

the shift is to the right.

In either case, zero bits fill otherwise unspecified bit locations in the

result.

</p><p>

If the GL is in RGBA mode,

the resulting index is converted to an RGBA pixel

with the help of the <code class="constant">GL_PIXEL_MAP_I_TO_R</code>,

<code class="constant">GL_PIXEL_MAP_I_TO_G</code>,

<code class="constant">GL_PIXEL_MAP_I_TO_B</code>,

and <code class="constant">GL_PIXEL_MAP_I_TO_A</code> tables.

If the GL is in color index mode,

and if <code class="constant">GL_MAP_COLOR</code> is true,

the index is replaced with the value that it references in lookup table

<code class="constant">GL_PIXEL_MAP_I_TO_I</code>.

Whether the lookup replacement of the index is done or not,

the integer part of the index is then ANDed with

<math overflow="scroll">

<mrow>

<msup><mn>2</mn>

<mi mathvariant="italic">b</mi>

</msup>

<mo>-</mo>

<mn>1</mn>

</mrow>

</math>,

where

<math overflow="scroll"><mi mathvariant="italic">b</mi></math>

is the number of bits in a color index buffer.

</p><p>

The GL then converts the resulting indices or RGBA colors to fragments

by attaching the current raster position <span class="emphasis"><em>z</em></span> coordinate and

texture coordinates to each pixel,

then assigning

<math overflow="scroll"><mi mathvariant="italic">x</mi></math>

and

<math overflow="scroll"><mi mathvariant="italic">y</mi></math>

window coordinates to the

<math overflow="scroll"><mi mathvariant="italic">n</mi></math>th

fragment such that

</p><div class="informalequation"><math overflow="scroll">

<mrow>

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">n</mi>

</msub>

<mo>=</mo>

<mrow>

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">r</mi>

</msub>

<mo>+</mo>

<mrow>

<mi mathvariant="italic">n</mi>

<mo>%</mo>

<mi mathvariant="italic">width</mi>

</mrow>

</mrow>

</mrow>

</math></div><p>

</p><p>

</p><div class="informalequation"><math overflow="scroll">

<mrow>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">n</mi>

</msub>

<mo>=</mo>

<mrow>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">r</mi>

</msub>

<mo>+</mo>

<mfenced open="&#x230A;" close="&#x230B;">

<mfrac>

<mi mathvariant="italic">n</mi>

<mi mathvariant="italic">width</mi>

</mfrac>

</mfenced>

</mrow>

</mrow>

</math></div><p>

</p><p>

</p><p>

</p><p>

</p><p>

where

<math overflow="scroll">

<mfenced open="(" close=")">

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">r</mi>

</msub>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">r</mi>

</msub>

</mfenced>

</math>

is the current raster position.

These pixel fragments are then treated just like the fragments generated by

rasterizing points, lines, or polygons.

Texture mapping,

fog,

and all the fragment operations are applied before the fragments are written

to the frame buffer.

</p></dd><dt><span class="term"><code class="constant">GL_STENCIL_INDEX</code></span></dt><dd><p>

Each pixel is a single value,

a stencil index.

It is converted to fixed-point format,

with an unspecified number of bits to the right of the binary point,

regardless of the memory data type.

Floating-point values convert to true fixed-point values.

Signed and unsigned integer data is converted with all fraction bits

set to 0.

Bitmap data convert to either 0 or 1.

</p><p>

Each fixed-point index is then shifted left by <code class="constant">GL_INDEX_SHIFT</code> bits,

and added to <code class="constant">GL_INDEX_OFFSET</code>.

If <code class="constant">GL_INDEX_SHIFT</code> is negative,

the shift is to the right.

In either case, zero bits fill otherwise unspecified bit locations in the

result.

If <code class="constant">GL_MAP_STENCIL</code> is true,

the index is replaced with the value that it references in lookup table

<code class="constant">GL_PIXEL_MAP_S_TO_S</code>.

Whether the lookup replacement of the index is done or not,

the integer part of the index is then ANDed with

<math overflow="scroll">

<mrow>

<msup><mn>2</mn>

<mi mathvariant="italic">b</mi>

</msup>

<mo>-</mo>

<mn>1</mn>

</mrow>

</math>,

where

<math overflow="scroll"><mi mathvariant="italic">b</mi></math>

is the number of bits in the stencil buffer.

The resulting stencil indices are then written to the stencil buffer

such that the

<math overflow="scroll"><mi mathvariant="italic">n</mi></math>th

index is written to location

</p><p>

</p><div class="informalequation"><math overflow="scroll">

<mrow>

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">n</mi>

</msub>

<mo>=</mo>

<mrow>

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">r</mi>

</msub>

<mo>+</mo>

<mrow>

<mi mathvariant="italic">n</mi>

<mo>%</mo>

<mi mathvariant="italic">width</mi>

</mrow>

</mrow>

</mrow>

</math></div><p>

</p><p>

</p><div class="informalequation"><math overflow="scroll">

<mrow>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">n</mi>

</msub>

<mo>=</mo>

<mrow>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">r</mi>

</msub>

<mo>+</mo>

<mfenced open="&#x230A;" close="&#x230B;">

<mfrac>

<mi mathvariant="italic">n</mi>

<mi mathvariant="italic">width</mi>

</mfrac>

</mfenced>

</mrow>

</mrow>

</math></div><p>

</p><p>

</p><p>

where

<math overflow="scroll">

<mfenced open="(" close=")">

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">r</mi>

</msub>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">r</mi>

</msub>

</mfenced>

</math>

is the current raster position.

Only the pixel ownership test,

the scissor test,

and the stencil writemask affect these write operations.

</p></dd><dt><span class="term"><code class="constant">GL_DEPTH_COMPONENT</code></span></dt><dd><p>

Each pixel is a single-depth component.

Floating-point data is converted directly to an internal floating-point

format with unspecified precision.

Signed integer data is mapped linearly to the internal floating-point

format such that the most positive representable integer value maps to 1.0,

and the most negative representable value maps to

<math overflow="scroll">

<mn>-1.0</mn>

</math>.

Unsigned integer data is mapped similarly:

the largest integer value maps to 1.0,

and 0 maps to 0.0.

The resulting floating-point depth value is then multiplied

by <code class="constant">GL_DEPTH_SCALE</code> and added to <code class="constant">GL_DEPTH_BIAS</code>.

The result is clamped to the range

<math overflow="scroll">

<mfenced open="[" close="]">

<mn>0</mn>

<mn>1</mn>

</mfenced>

</math>.

</p><p>

The GL then converts the resulting depth components to fragments

by attaching the current raster position color or color index and

texture coordinates to each pixel,

then assigning

<math overflow="scroll"><mi mathvariant="italic">x</mi></math>

and

<math overflow="scroll"><mi mathvariant="italic">y</mi></math>

window coordinates to the

<math overflow="scroll"><mi mathvariant="italic">n</mi></math>th

fragment such that

</p><p>

</p><div class="informalequation"><math overflow="scroll">

<mrow>

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">n</mi>

</msub>

<mo>=</mo>

<mrow>

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">r</mi>

</msub>

<mo>+</mo>

<mrow>

<mi mathvariant="italic">n</mi>

<mo>%</mo>

<mi mathvariant="italic">width</mi>

</mrow>

</mrow>

</mrow>

</math></div><p>

</p><p>

</p><div class="informalequation"><math overflow="scroll">

<mrow>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">n</mi>

</msub>

<mo>=</mo>

<mrow>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">r</mi>

</msub>

<mo>+</mo>

<mfenced open="&#x230A;" close="&#x230B;">

<mfrac>

<mi mathvariant="italic">n</mi>

<mi mathvariant="italic">width</mi>

</mfrac>

</mfenced>

</mrow>

</mrow>

</math></div><p>

</p><p>

</p><p>

where

<math overflow="scroll">

<mfenced open="(" close=")">

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">r</mi>

</msub>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">r</mi>

</msub>

</mfenced>

</math>

is the current raster position.

These pixel fragments are then treated just like the fragments generated by

rasterizing points, lines, or polygons.

Texture mapping,

fog,

and all the fragment operations are applied before the fragments are written

to the frame buffer.

</p></dd><dt><span class="term"><code class="constant">GL_RGBA</code></span></dt><dd></dd><dt><span class="term"><code class="constant">GL_BGRA</code></span></dt><dd><p>

Each pixel is a four-component group: For <code class="constant">GL_RGBA</code>, the red

component is first, followed by green, followed by blue, followed by

alpha; for <code class="constant">GL_BGRA</code> the order is blue, green, red and then alpha.

Floating-point values are converted directly to an internal floating-point

format with unspecified precision.

Signed integer values are mapped linearly to the internal floating-point

format such that the most positive representable integer value maps to 1.0,

and the most negative representable value maps to

<math overflow="scroll">

<mn>-1.0</mn>

</math>.

(Note that

this mapping does not convert 0 precisely to 0.0.)

Unsigned integer data is mapped similarly:

The largest integer value maps to 1.0,

and 0 maps to 0.0.

The resulting floating-point color values are then multiplied

by <code class="constant">GL_c_SCALE</code> and added to <code class="constant">GL_c_BIAS</code>,

where <span class="emphasis"><em>c</em></span> is RED, GREEN, BLUE, and ALPHA

for the respective color components.

The results are clamped to the range

<math overflow="scroll">

<mfenced open="[" close="]">

<mn>0</mn>

<mn>1</mn>

</mfenced>

</math>.

</p><p>

If <code class="constant">GL_MAP_COLOR</code> is true,

each color component is scaled by the size of lookup table

<code class="constant">GL_PIXEL_MAP_c_TO_c</code>,

then replaced by the value that it references in that table.

<span class="emphasis"><em>c</em></span> is R, G, B, or A respectively.

</p><p>

The GL then converts the resulting RGBA colors to fragments

by attaching the current raster position <span class="emphasis"><em>z</em></span> coordinate and

texture coordinates to each pixel,

then assigning

<math overflow="scroll"><mi mathvariant="italic">x</mi></math>

and

<math overflow="scroll"><mi mathvariant="italic">y</mi></math>

window coordinates to the

<math overflow="scroll"><mi mathvariant="italic">n</mi></math>th

fragment such that

</p><p>

</p><div class="informalequation"><math overflow="scroll">

<mrow>

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">n</mi>

</msub>

<mo>=</mo>

<mrow>

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">r</mi>

</msub>

<mo>+</mo>

<mrow>

<mi mathvariant="italic">n</mi>

<mo>%</mo>

<mi mathvariant="italic">width</mi>

</mrow>

</mrow>

</mrow>

</math></div><p>

</p><p>

</p><div class="informalequation"><math overflow="scroll">

<mrow>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">n</mi>

</msub>

<mo>=</mo>

<mrow>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">r</mi>

</msub>

<mo>+</mo>

<mfenced open="&#x230A;" close="&#x230B;">

<mfrac>

<mi mathvariant="italic">n</mi>

<mi mathvariant="italic">width</mi>

</mfrac>

</mfenced>

</mrow>

</mrow>

</math></div><p>

</p><p>

</p><p>

where

<math overflow="scroll">

<mfenced open="(" close=")">

<msub><mi mathvariant="italic">x</mi>

<mi mathvariant="italic">r</mi>

</msub>

<msub><mi mathvariant="italic">y</mi>

<mi mathvariant="italic">r</mi>

</msub>

</mfenced>

</math>

is the current raster position.

These pixel fragments are then treated just like the fragments generated by

rasterizing points, lines, or polygons.

Texture mapping,

fog,

and all the fragment operations are applied before the fragments are written

to the frame buffer.

</p></dd><dt><span class="term"><code class="constant">GL_RED</code></span></dt><dd><p>

Each pixel is a single red component.

This component is converted to the internal floating-point format in

the same way the red component of an RGBA pixel is. It is

then converted to an RGBA pixel with green and blue set to 0,

and alpha set to 1.

After this conversion, the pixel is treated as if it had been read

as an RGBA pixel.

</p></dd><dt><span class="term"><code class="constant">GL_GREEN</code></span></dt><dd><p>

Each pixel is a single green component.

This component is converted to the internal floating-point format in

the same way the green component of an RGBA pixel is.

It is then converted to an RGBA pixel with red and blue set to 0,

and alpha set to 1.

After this conversion, the pixel is treated as if it had been read

as an RGBA pixel.

</p></dd><dt><span class="term"><code class="constant">GL_BLUE</code></span></dt><dd><p>

Each pixel is a single blue component.

This component is converted to the internal floating-point format in

the same way the blue component of an RGBA pixel is.

It is then converted to an RGBA pixel with red and green set to 0,

and alpha set to 1.

After this conversion, the pixel is treated as if it had been read

as an RGBA pixel.

</p></dd><dt><span class="term"><code class="constant">GL_ALPHA</code></span></dt><dd><p>

Each pixel is a single alpha component.

This component is converted to the internal floating-point format in

the same way the alpha component of an RGBA pixel is.

It is then converted to an RGBA pixel with red, green, and blue set to 0.

After this conversion, the pixel is treated as if it had been read

as an RGBA pixel.

</p></dd><dt><span class="term"><code class="constant">GL_RGB</code></span></dt><dd></dd><dt><span class="term"><code class="constant">GL_BGR</code></span></dt><dd><p>

Each pixel is a three-component group:

red first, followed by green, followed by blue; for <code class="constant">GL_BGR</code>, the

first component is blue, followed by green and then red.

Each component is converted to the internal floating-point format in

the same way the red, green, and blue components of an RGBA pixel are.

The color triple is converted to an RGBA pixel with alpha set to 1.

After this conversion, the pixel is treated as if it had been read

as an RGBA pixel.

</p></dd><dt><span class="term"><code class="constant">GL_LUMINANCE</code></span></dt><dd><p>

Each pixel is a single luminance component.

This component is converted to the internal floating-point format in

the same way the red component of an RGBA pixel is.

It is then converted to an RGBA pixel with red, green, and blue set to the

converted luminance value,

and alpha set to 1.

After this conversion, the pixel is treated as if it had been read

as an RGBA pixel.

</p></dd><dt><span class="term"><code class="constant">GL_LUMINANCE_ALPHA</code></span></dt><dd><p>

Each pixel is a two-component group:

luminance first, followed by alpha.

The two components are converted to the internal floating-point format in

the same way the red component of an RGBA pixel is.

They are then converted to an RGBA pixel with red, green, and blue set to the

converted luminance value,

and alpha set to the converted alpha value.

After this conversion, the pixel is treated as if it had been read

as an RGBA pixel.

</p></dd></dl></div><p>

The following table summarizes the meaning of the valid constants for the

<span class="emphasis"><em>type</em></span> parameter:

</p><p>

</p><div class="informaltable"><table><colgroup><col /><col /></colgroup><thead><tr><th><span class="bold"><strong>

Type

</strong></span></th><th><span class="bold"><strong>

Corresponding Type

</strong></span></th></tr></thead><tbody><tr><td>

<code class="constant">GL_UNSIGNED_BYTE</code>

</td><td>

unsigned 8-bit integer

</td></tr><tr><td>

<code class="constant">GL_BYTE</code>

</td><td>

signed 8-bit integer

</td></tr><tr><td>

<code class="constant">GL_BITMAP</code>

</td><td>

single bits in unsigned 8-bit integers

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_SHORT</code>

</td><td>

unsigned 16-bit integer

</td></tr><tr><td>

<code class="constant">GL_SHORT</code>

</td><td>

signed 16-bit integer

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_INT</code>

</td><td>

unsigned 32-bit integer

</td></tr><tr><td>

<code class="constant">GL_INT</code>

</td><td>

32-bit integer

</td></tr><tr><td>

<code class="constant">GL_FLOAT</code>

</td><td>

single-precision floating-point

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_BYTE_3_3_2</code>

</td><td>

unsigned 8-bit integer

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_BYTE_2_3_3_REV</code>

</td><td>

unsigned 8-bit integer with reversed component ordering

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_SHORT_5_6_5</code>

</td><td>

unsigned 16-bit integer

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_SHORT_5_6_5_REV</code>

</td><td>

unsigned 16-bit integer with reversed component ordering

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_SHORT_4_4_4_4</code>

</td><td>

unsigned 16-bit integer

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_SHORT_4_4_4_4_REV</code>

</td><td>

unsigned 16-bit integer with reversed component ordering

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_SHORT_5_5_5_1</code>

</td><td>

unsigned 16-bit integer

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_SHORT_1_5_5_5_REV</code>

</td><td>

unsigned 16-bit integer with reversed component ordering

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_INT_8_8_8_8</code>

</td><td>

unsigned 32-bit integer

</td></tr><tr><td>

<code class="constant">GL_UNSIGNED_INT_8_8_8_8_REV</code>

</td><td>