Table of Contents
glCopyPixels - copy pixels in the frame buffer
void
glCopyPixels( GLint x,
GLint y,
GLsizei width,
GLsizei height,
GLenum type )
eqn not supported
- x, y
- Specify the window coordinates of the
lower left corner of the rectangular region of pixels to be copied.
- width,
height
- Specify the dimensions of the rectangular region of pixels to be
copied. Both must be nonnegative.
- type
- Specifies whether color values, depth
values, or stencil values are to be copied. Symbolic constants GL_COLOR,
GL_DEPTH, and GL_STENCIL are accepted.
glCopyPixels copies a
screen-aligned rectangle of pixels from the specified frame buffer location
to a region relative to the current raster position. Its operation is well
defined only if the entire pixel source region is within the exposed portion
of the window. Results of copies from outside the window, or from regions
of the window that are not exposed, are hardware dependent and undefined.
x and y specify the window coordinates of the lower left corner of the
rectangular region to be copied. width and height specify the dimensions
of the rectangular region to be copied. Both width and height must not be
negative.
Several parameters control the processing of the pixel data while
it is being copied. These parameters are set with three commands: glPixelTransfer,
glPixelMap, and glPixelZoom. This reference page describes the effects on
glCopyPixels of most, but not all, of the parameters specified by these
three commands.
glCopyPixels copies values from each pixel with the lower
left-hand corner at (x + $i$, y + $j$) for 0 <= $i$ < width and 0 <= $j$ < height.
This pixel is said to be the $i$th pixel in the $j$th row. Pixels are copied
in row order from the lowest to the highest row, left to right in each
row.
type specifies whether color, depth, or stencil data is to be copied.
The details of the transfer for each data type are as follows:
- GL_COLOR
- Indices or RGBA colors are read from the buffer currently specified as
the read source buffer (see glReadBuffer). If the GL is in color index mode,
each index that is read from this buffer is converted to a fixed-point
with an unspecified number of bits to the right of the binary point. Each
index is then shifted left by GL_INDEX_SHIFT bits, and added to GL_INDEX_OFFSET.
If GL_INDEX_SHIFT is negative, the shift is to the right. In either case,
zero bits fill otherwise unspecified bit locations in the result. If GL_MAP_COLOR
is true, the index is replaced with the value that it references in lookup
table GL_PIXEL_MAP_I_TO_I. Whether the lookup replacement of the index is
done or not, the integer part of the index is then ANDed with $2 sup b
-1$, where $b$ is the number of bits in a color index buffer.
- If the GL is
in RGBA mode,
- the red, green, blue, and alpha components of each pixel
that is read are converted to an internal floating-point with unspecified
precision. The conversion maps the largest representable component value
to 1.0, and component value 0 to 0.0. The resulting floating-point color values
are then multiplied by GL_c_SCALE and added to GL_c_BIAS, where c is RED,
GREEN, BLUE, and ALPHA for the respective color components. The results
are clamped to the range [0,1]. If GL_MAP_COLOR is true, each color component
is scaled by the size of lookup table GL_PIXEL_MAP_c_TO_c, then replaced
by the value that it references in that table. c is R, G, B, or A.
- If the
GL_ARB_imaging extension is supported, the color values may
- be additionally
processed by color-table lookups, color-matrix transformations, and convolution
filters.
- The GL then converts the resulting indices or RGBA colors to fragments
- by attaching the current raster position z coordinate and texture coordinates
to each pixel, then assigning window coordinates ($x sub r ~+~ i , y sub
r ~+~ j$), where ($x sub r , y sub r$) is the current raster position,
and the pixel was the $i$th pixel in the $j$th row. 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.
- GL_DEPTH
- Depth values are read from the depth buffer and converted directly to an
internal floating-point with unspecified precision. The resulting floating-point
depth value is then multiplied by GL_DEPTH_SCALE and added to GL_DEPTH_BIAS.
The result is clamped to the range [0,1].
- 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
window coordinates ($x sub r ~+~ i , y sub r ~+~ j$), where ($x sub r ,
y sub r$) is the current raster position, and the pixel was the $i$th pixel
in the $j$th row. 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.
- GL_STENCIL
- Stencil indices are read from the stencil
buffer and converted to an internal fixed-point with an unspecified number
of bits to the right of the binary point. Each fixed-point index is then
shifted left by GL_INDEX_SHIFT bits, and added to GL_INDEX_OFFSET. If GL_INDEX_SHIFT
is negative, the shift is to the right. In either case, zero bits fill otherwise
unspecified bit locations in the result. If GL_MAP_STENCIL is true, the
index is replaced with the value that it references in lookup table GL_PIXEL_MAP_S_TO_S.
Whether the lookup replacement of the index is done or not, the integer
part of the index is then ANDed with $2 sup b -1$, where $b$ is the number
of bits in the stencil buffer. The resulting stencil indices are then written
to the stencil buffer such that the index read from the $i$th location
of the $j$th row is written to location ($x sub r ~+~ i , y sub r ~+~ j$),
where ($x sub r , y sub r$) is the current raster position. Only the pixel
ownership test, the scissor test, and the stencil writemask affect these
write operations.
The rasterization described thus far assumes pixel zoom
factors of 1.0. If
glPixelZoom is used to change the $x$ and $y$ pixel zoom factors, pixels
are converted to fragments as follows. If ($x sub r$, $y sub r$) is the
current raster position, and a given pixel is in the $i$th location in
the $j$th row of the source pixel rectangle, then fragments are generated
for pixels whose centers are in the rectangle with corners at
($x sub r
~+~ zoom sub x^ i$, $y sub r ~+~ zoom sub y^j$)
and
($x sub r ~+~ zoom sub x^ (i ~+~ 1)$, $y sub r ~+~ zoom sub y^ ( j ~+~ 1
)$)
where $zoom sub x$ is the value of GL_ZOOM_X and $zoom sub y$ is the
value of GL_ZOOM_Y.
To copy the color pixel in the lower left corner
of the window to the current raster position, use glCopyPixels(0, 0, 1,
1, GL_COLOR);
Modes specified by glPixelStore have no effect on the
operation of glCopyPixels.
GL_INVALID_ENUM is generated if type is
not an accepted value.
GL_INVALID_VALUE is generated if either width or
height is negative.
GL_INVALID_OPERATION is generated if type is GL_DEPTH
and there is no depth buffer.
GL_INVALID_OPERATION is generated if type
is GL_STENCIL and there is no stencil buffer.
GL_INVALID_OPERATION is generated
if glCopyPixels is executed between the execution of glBegin and the corresponding
execution of glEnd.
glGet with argument GL_CURRENT_RASTER_POSITION
glGet with argument GL_CURRENT_RASTER_POSITION_VALID
glColorTable(3G)
,
glConvolutionFilter1D(3G)
, glConvolutionFilter2D(3G)
, glDepthFunc(3G)
,
glDrawBuffer(3G)
, glDrawPixels(3G)
, glMatrixMode(3G)
, glPixelMap(3G)
, glPixelTransfer(3G)
,
glPixelZoom(3G)
, glRasterPos(3G)
, glReadBuffer(3G)
, glReadPixels(3G)
, glSeparableFilter2D(3G)
,
glStencilFunc(3G)
Table of Contents