glCopyPixels

Hinweis: Dieser Artikel ist noch unvollständig. (Mehr Informationen/weitere Artikel) {{{1}}}

---

glCopyPixels

Name

glCopyPixels - kopiert Pixel in den Framebuffer.

Delphi-Spezifikation

procedure  glCopyPixels(x: TGLint; y: TGLint; 
                        width: TGLsizei; height: TGLsizei; 
                        _type: TGLenum);

Parameter

x,y	Bestimmt die Fensterkoordinaten der linken unteren Ecke eines Rechtecks welches den Bereich umschließt der kopiert werden soll.
width	Bestimmt die Seitenlängen des Rechtecks. Beide Werte dürfen nicht negativ sein.
type	Bestimmt welche Werte kopiert werden sollen. Es können Farbwerte (mit der Konstante GL_COLOR), Stencil-Werte (GL_STENCIL) oder Tiefenwerte (GL_DEPTH) kopiert werden.

Beschreibung

glCopyPixels kopiert ein am Bildschirm ausgerichtetes Rechteck aus Pixel von der angegebenen Framebufferposition in einen Bereich relativ zur aktuellen Rasterposition. Diese Operation ist nur dann wohldefiniert, wenn alle Pixel der Quellregion innerhalb des angezeigten Fensterbereichs liegen. Die Ergebnisse von Kopiervorgängen die Pixel erfassen die entweder außerhalb des Fensters liegen oder von anderen Fenstern überdeckt werden sind hardwareabhängig und undefiniert.

x und y bestimmen die untere linke Ecke der rechteckigen Quellregion in Fensterkoordinaten. width und height bestimmen von diesem Punkt aus die Dimensionen des Rechtecks. Beide Werte, width und height, dürfen nicht negativ sein.

Verschiedene Parameter beeinflussen die Behandlung der Pixeldaten wären diese kopiert werden. Diese werden mit den drei Befehlen glPixelTransfer, glPixelMap und glPixelZoom gesetzt. Dieser Artikel beschreibt die Auswirkungen der meisten, aber nicht aller Parameter die durch diese Funktionen gesetzt werden können.

glCopyPixels kopiert Werte aller Pixel die im Bereich (x + i, y + j) mit 0<i<width und 0<j<height liegen. Die Pixel werden als i-tes Pixel in der j-ten Zeile bezeichnet. Die Pixel werden in folgender Reihenfolge kopiert: Zeilenweise beginnen bei der niedrigsten zur höchsten Zeile und in jeder Zeile von links nach rechts.

_type legt fest ob Farb-, Tiefen- oder Stencilwerte kopiert werden sollen. Die Details zu den Datentypen sind folgende:

GL_COLOR

Indizes und RGBA Farben werden von dem momentan als Quellpuffer festgelegten Puffer (siehe glReadBuffer) gelesen. Wenn die GL im Farbindexmodus ist wird jeder gelesene Index in eine Festkommazahl mit einer unbestimmten Anzahl von Bits rechts vom binären Punkt. Jeder Index wird dann mit GL_INDEX_SHIFT nach links geshiftet und zu GL_INDEX_OFFSET addiert. Wenn GL_INDEX_SHIFT ein negativer Wert ist erfolgt das shiften nach rechts. In beiden Fällen werden undefinierte Bitplätze mit Nullen im Ergebnis aufgefüllt. Wenn GL_MAP_COLOR = true ist, wird der Index ersetzt mit dem Wert der in der Color-Lookup-Table GL_PIXEL_MAP_I_TO_I dem Index entspricht. Egal ob die Ersetzung des Index durchgeführt wurde oder nicht, wird der Integer-Teil des Index mit 2b-1 geANDed, wobei b die Anzahl der Bits in einem Color-Index-Buffer darstellt.

Wenn die GL im RGBA-Modus ist wird die Rot-, Grün-, Blau- und Alphakomponente eines jeden gelesenen Pixels ins interne Fließkommaformat konvertiert, wobei die Präzision unspezifiziert ist. Die konvertierung bildet den größten darstellbaren komponentenwert auf 1.0 und den Komponentenwert 0 auf 0.0 ab. Die Resultierenden Fließkomma-Farbwerte werden dann mit GL_c_SCALE multipliziert und zu GL_c_BIAS addiert. Wobei für die einzelnen Farbkomponenten c durch RED, BLUE, GREEN und Alpha ersetzt werden muss. Die Ergebnisse werden auf das Interval [0,1] beschränkt. Wenn GL_MAP_COLOR = true ist wird jede Farbkomponente mit dem Wert von GL_PIXEL_MAP_c_TO_c skaliert und anschließend durch den referenzierten Wert aus der Tabelle ersetzt. c ist dabei R, G, B bzw A.

Die GL konvertiert anschließend die resultierenden Indices oder RGBA Farben in Fragmente indem zu jedem Pixel die aktuelle z-Koordinate und Texturkoordinate der Rasterposition hinzugefügt wird. Anschließend werden die Fensterkoordinaten (x +i, y +j) hinzugefügt, wobei (x,y) die aktuelle Rasterposition ist und das Pixel das i-te Pixel in der j-ten Zeile war. Diese Pixelfragmente werden dann genauso behandelt wie die Fragmente die durch die Rasterisierung (siehe Feste Funktionspipeline) von Punkten, Linien oder Polygonen entstehen. Texture Mapping, Nebel und alle Fragment Operationen werden anschließend, noch bevor die Fragmente in den Framebuffer geschrieben werden angewendet.

Zur Korrektur

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 format 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 2b-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 format 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.

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 +i,y +j), where (x ,y ) is the current raster position, and the pixel was the ith pixel in the jth 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

Tiefenwerte werden aus dem Tiefenpuffer gelesen und direkt in das interene Fließkommaformat mit unspezifizierter Genauigkeit umgewandelt. Die resultierenden Tiefenwerte werden dann mit GL_DEPTH_SCALE multipliziert und zu GL_DEPTH_BIAS addiert. Das Ergebnis wird auf das Interval [0,1] beschränkt.

Anschließend konvertiert die GL die Tiefenwerte in Fragmente indem die Farbe bzw. Farbindex sowie die Texturkoodinaten der aktuellen Rasterposition an edes Pixel angehängt wird. Anschließend werden die Fensterkoordinaten (x +i, y +j) zugewiesen, wobei (x, y) die aktuelle Rasterposition ist und das betreffende Pixel das i-te Pixel in der j-ten Zeile war. Diese Pixelfragmente werden dann wie normale Fragmente die aus Punkten, Linien oder Polygonen erzeugt wurden behandelt. Texture Mapping, Nebel und alle Fragment Operationen werden anschließend, noch bevor die Fragmente in den Framebuffer geschrieben werden angewendet.

zur Korrektur

Depth values are read from the depth buffer and converted directly to an internal floating-point format 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 +i,y +j), where (x ,y ) is the current raster position, and the pixel was the ith pixel in the jth 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 format 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 2b-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 ith location of the jth row is written to location (x +i,y +j), where (x ,y ) is the current raster position. Onlyrthe 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 , y ) is the current raster position, and a given pixel isrin the ith location in the jth row of the source pixel rectangle, then fragments are generated for pixels whose centers are in the rectangle with corners at

(x +zoom i, y +zoom j)
r x r y
and
(x +zoom (i+1), y +zoom (j+1))<b> r x r y
where zoom is the value of GL_ZOOM_X and zoom is the value of GL_ZOOM_Y.

Beispiel

Um die Farbe des Pixels in der linken unteren Ecke an die aktuelle Rasterposition zu kopieren rufen sie glCopyPixels so auf:

glCopyPixels(0, 0, 1, 1, GL_COLOR);

Hinweise

Einstellungen die durch glPixelStore gemacht wurden haben keinen Einfluss auf glCopyPixels.

Fehlermeldungen

GL_INVALID_ENUM wird generiert wenn type kein gültiger Wert übergeben wurde.
GL_INVALID_VALUE wird generiert wenn width oder height einen negativen Wert haben.
GL_INVALID_OPERATION wird generiert wenn type GL_DEPTH ist und kein Tiefenpuffer existiert.
GL_INVALID_OPERATION wird generiert wenn type GL_STENCIL ist und kein Stencilbuffer existiert.
GL_INVALID_OPERATION wird generiert wenn glCopyPixels innerhalb eines glBegin-glEnd Blocks aufgerufen wird.

Zugehörige Wertrückgaben

glGet mit Token GL_CURRENT_RASTER_POSITION
glGet mit Token GL_CURRENT_RASTER_POSITION_VALID

Siehe auch

glDepthFunc, glDrawBuffer, glDrawPixels, glPixelMap, glPixelTransfer, glPixelZoom, glRasterPos, glReadBuffer, glReadPixels, glStencilFunc