gl.DrawPixelsRaw(width, height, format, type, pixels)
gl.DrawPixelsRaw()
liest Pixeldaten aus dem Speicher und schreibt sie in den
Rahmenpuffer relativ zur aktuellen Rasterposition, vorausgesetzt, die
Rasterposition ist gültig. Verwenden Sie gl.RasterPos()
zum Einstellen der aktuellen Rasterposition; verwenden Sie gl.Get()
mit dem Argument #GL_CURRENT_RASTER_POSITION_VALID
, um festzustellen, ob die
angegebene Rasterposition gültig ist und gl.Get() mit dem
Argument #GL_CURRENT_RASTER_POSITION
zur Abfrage der Rasterposition.
Mehrere Parameter definieren die Kodierung von Pixeldaten im Speicher und
steuern die Verarbeitung der Pixeldaten, bevor sie in den Rahmenpuffer
gestellt werden. Diese Parameter werden mit vier Befehlen eingestellt:
gl.PixelStore(), gl.PixelTransfer(),
gl.PixelMap() und gl.PixelZoom().
Diese Referenzseite beschreibt die Auswirkungen auf gl.DrawPixelsRaw()
von
vielen, aber nicht allen der durch diese vier Befehle angegebenen Parameter.
Daten werden von pixels
als eine Folge von vorzeichenbehafteten (signiert) oder
vorzeichenlosen (unsigniert) Bytes, vorzeichenbehafteten oder vorzeichenlosen Shorts,
vorzeichenbehafteten oder vorzeichenlosen Ganzzahlen oder Gleitkommawerten mit
einfacher Genauigkeit gelesen. Je nach type
kann der #GL_UNSIGNED_BYTE
,
#GL_BYTE
, #GL_BITMAP
, #GL_UNSIGNED_SHORT
, #GL_SHORT
, #GL_UNSIGNED_INT
, #GL_INT
oder #GL_FLOAT
sein. Jedes dieser Bytes, Shorts, Ganzzahlen oder Gleitkommazahlen-Werte
wird je nach Format als eine Farb- oder Tiefenkomponente oder ein Index
interpretiert. Indizes werden immer individuell behandelt. Farbkomponenten
werden als Gruppen von einem, zwei, drei oder vier Werten behandelt, wiederum
basierend auf format
. Beide einzelne Indizes und Gruppen von Komponenten
werden als Pixel bezeichnet. Wenn der Typ #GL_BITMAP
ist, müssen die Daten
vorzeichenlos sein. Bytes und das Format muss entweder #GL_COLOR_INDEX
oder
#GL_STENCIL_INDEX
sein. Jedes vorzeichenlose Byte wird als acht 1-Bit-Pixel
behandelt, mit Bitreihenfolge bestimmt durch #GL_UNPACK_LSB_FIRST
.
(Siehe gl.PixelStore für Details.)
width
* height
Pixel werden aus dem Speicher gelesen, beginnend mit der
Position pixels
. Standardmäßig werden diese Pixel von benachbarten
Speicherplätzen entnommen, mit der Ausnahme, dass nach dem Lesen aller
Pixelbreite der Lesezeiger auf die nächste 4-Byte-Grenze bewegt wird. Die
Ausrichtung der Vier-Byte-Zeile wird durch gl.PixelStore()
mit dem Argument #GL_UNPACK_ALIGNMENT
angegeben und es kann auf ein, zwei, vier
oder acht Bytes gesetzt werden. Andere Pixelspeicherparameter geben
unterschiedliche Lesezeigerfortschritte an, sowohl vor dem Lesen des ersten
Pixels als auch nach dem Lesen aller Pixelbreite. Siehe gl.PixelStore für Details.
Die aus dem Speicher gelesenen Pixel der width
* height
werden jeweils auf
die gleiche Weise bearbeitet, basierend auf den Werten mehrerer Parameter, die
durch gl.PixelTransfer() und gl.PixelMap()
definiert sind. Die Details dieser Operationen sowie der Zielpuffer, in
den die Pixel gezeichnet werden, sind spezifisch für das Format der Pixel,
wie durch format
festgelegt. format
kann einen von 13 symbolischen
Werten annehmen:
#GL_COLOR_INDEX
Jeder Festkommaindex wird dann um #GL_INDEX_SHIFT-Bits nach links verschoben
und zu #GL_INDEX_OFFSET
hinzugefügt. Wenn #GL_INDEX_SHIFT
negativ ist, ist
die Verschiebung nach rechts. In beiden Fällen füllen Nullbits ansonsten
nicht spezifizierte Bitpositionen im Ergebnis.
Befindet sich GL im RGBA-Modus, wird der resultierende Index konvertiert
zu einem RGBA Pixel mit Hilfe der #GL_PIXEL_MAP_I_TO_R
, #GL_PIXEL_MAP_I_TO_G
,
#GL_PIXEL_MAP_I_TO_B
und #GL_PIXEL_MAP_I_TO_A
Tabellen. Wenn sich GL im
Farbindexmodus befindet und #GL_MAP_COLOR
True
ist, wird der Index durch den
Wert ersetzt, auf den er in der Lookup-Tabelle #GL_PIXEL_MAP_I_I_TO_I
verweist. Unabhängig davon, ob die Ersetzung des Index durchgeführt
wird oder nicht, wird der ganzzahlige Teil des Index dann mit 2^b-1 hinzugefügt,
wobei b
die Anzahl der Bits in einem Farbindexpuffer ist.
GL konvertiert dann die resultierenden Indizes oder RGBA-Farben in Fragmente, indem die aktuellen Rasterpositions-Z-Koordinaten und Texturkoordinaten an jedes Pixel anfügt und dann dem n-ten Fragment x- und y-Fensterkoordinaten zuordnet, so dass
xn = xr + n % width yn = yr + n / width |
ist, wobei (xr,yr) die aktuelle Rasterposition angibt. Diese Pixelfragmente werden dann genauso behandelt wie die Fragmente, die durch das Rastern von Punkten, Linien oder Polygonen erzeugt werden. Texturabbildung, Nebel und alle Fragmentoperationen werden angewendet, bevor die Fragmente in den Rahmenpuffer geschrieben werden.
#GL_STENCIL_INDEX
Jeder Festkommaindex wird dann um #GL_INDEX_SHIFT-Bits nach links verschoben
und zu #GL_INDEX_OFFSET
hinzugefügt. Wenn #GL_INDEX_SHIFT
negativ ist, wird die
Verschiebung nach rechts vorgenommen. In beiden Fällen füllen Nullbits ansonsten
nicht die definierte Bitpositionen das Ergebnis auf. Wenn #GL_MAP_STENCIL
True
ist, wird der Index durch den Wert ersetzt, auf den er in der Lookup-Tabelle
#GL_PIXEL_MAP_S_TO_S
verweist. Unabhängig davon, ob die Ersetzung
des Index durchgeführt wird oder nicht, wird der ganzzahlige Teil des Index
dann mit 2^b-1 hinzugefügt, wobei b
die Anzahl der Bits im Schablonenpuffer
ist. Die resultierenden Schablonenindizes werden dann in die Schablonenpuffer
geschrieben, so dass der n-te Index in die Position geschrieben wird.
xn = xr + n % width yn = yr + n / width |
wobei (xr,yr) die aktuelle Rasterposition ist. Nur der Pixelbesitztest, der Scherentest und die Schablonen-Schreibmaske beeinflussen diese Schreibvorgänge.
#GL_DEPTH_COMPONENT
#GL_DEPTH_SCALE
multipliziert und zu #GL_DEPTH_BIAS
hinzugefügt. Das Ergebnis wird auf den Bereich [0,1] festgelegt.
GL konvertiert dann die resultierenden Tiefenkomponenten in Fragmente, indem er die aktuelle Rasterpositionsfarbe oder den Farbindex und die Texturkoordinaten an jedes Pixel anfügt und dann dem n-ten Fragment x- und y-Fensterkoordinaten zuordnet, so dass
xn = xr + n % width yn = yr + n / width |
ist, wobei (xr,yr) die aktuelle Rasterposition angibt. Diese Pixelfragmente werden dann genauso behandelt wie die Fragmente, die durch das Rastern von Punkten, Linien oder Polygonen erzeugt werden. Texturabbildung, Nebel und alle Fragmentoperationen werden angewendet, bevor die Fragmente in den Rahmenpuffer geschrieben werden.
#GL_RGBA
#GL_RGBA
ist die rote
Komponente zuerst, gefolgt von grün, dann von blau und am Schluss von alpha.
Gleitkommawerte werden mit unbestimmter Genauigkeit direkt in ein internes
Gleitkommaformat umgewandelt. Die resultierenden Fließkomma-Farbwerte werden
dann mit #GL_c_SCALE
multipliziert und zu #GL_c_BIAS
addiert, wobei c ROT,
GRÜN, BLAU oder ALPHA für die jeweiligen Farbkomponenten ist. Die Ergebnisse
werden in den Bereich [0,1] festgelegt.
Wenn #GL_MAP_COLOR
True
ist, wird jede Farbkomponente um die Größe der
Ersetzungstabelle #GL_PIXEL_MAP_c_TO_c
skaliert und dann durch den Wert
ersetzt, auf den sie in dieser Tabelle verweist. c ist R, G, B bzw. A.
GL konvertiert dann die resultierenden RGBA-Farben in Fragmente, indem die aktuellen Koordinaten der Rasterposition z und Texturkoordinaten an jedes Pixel anhängt und dann dem n-ten Fragment x- und y-Fensterkoordinaten zuordnet, so dass
xn = xr + n % width yn = yr + n / width |
ist, wobei (xr,yr) die aktuelle Rasterposition angibt. Diese Pixelfragmente werden dann genauso behandelt wie die Fragmente, die durch das Rastern von Punkten, Linien oder Polygonen erzeugt werden. Texturabbildung, Nebel und alle Fragmentoperationen werden angewendet, bevor die Fragmente in den Rahmenpuffer geschrieben werden.
#GL_RED
#GL_GREEN
#GL_BLUE
#GL_ALPHA
#GL_RGB
#GL_LUMINANCE
#GL_LUMINANCE_ALPHA
Die bisher beschriebene Rasterung geht von einem Pixelzoomfaktoren von 1 aus, wenn gl.PixelZoom() verwendet wird, um die Zoomfaktoren x und y zu ändern, werden Pixel wie folgt in Fragmente umgewandelt. Wenn (xr,yr) die aktuelle Rasterposition ist und sich ein bestimmtes Pixel in der n-ten Spalte und m-ten Zeile des Pixelrechtecks befindet, dann werden Fragmente für Pixel erzeugt, deren Mittelpunkt im Rechteck mit Ecken bei
(xr + zoomx_n, yr + zoomy_m) |
und
(xr + zoomx_(n + 1), yr + zoomy_(m + 1)) |
ist, wobei zoomx
der Wert von #GL_ZOOM_X
und zoomy
der Wert von #GL_ZOOM_Y
angibt.
Bitte beachten Sie, dass dieser Befehl direkt mit Speicherzeigern arbeitet. Es gibt auch eine Version, die mit Tabellen anstelle von Speicherzeigern arbeitet, aber das ist natürlich langsamer. Siehe gl.DrawPixels für Details. Siehe Mit Zeigern arbeiten für Details zur Verwendung von Speicherzeigern mit Hollywood.
Weitere Informationen finden Sie in einem OpenGL-Referenzhandbuch.
#GL_INVALID_ENUM
wird erzeugt, wenn format
oder type
nicht zu den
akzeptierten Werten gehört.
#GL_INVALID_ENUM
wird erzeugt, wenn type
#GL_BITMAP
ist und format
nicht #GL_COLOR_INDEX
oder #GL_STENCIL_INDEX
ist.
#GL_INVALID_VALUE
wird erzeugt, wenn entweder width
oder height
negativ ist.
#GL_INVALID_OPERATION
wird erzeugt, wenn format
#GL_STENCIL_INDEX
ist und
es keinen Schablonenpuffer gibt.
#GL_INVALID_OPERATION
wird erzeugt, wenn format
#GL_RED
, #GL_GREEN
, #GL_BLUE
,
#GL_ALPHA
, #GL_RGB
, #GL_RGBA
, #GL_LUMINANCE
, oder #GL_LUMINANCE_ALPHA
ist
und GL sich im Farbindexmodus befindet.
#GL_INVALID_OPERATION
wird erzeugt, wenn gl.DrawPixelsRaw()
zwischen
gl.Begin() und gl.End() ausgeführt wird.
#GL_CURRENT_RASTER_POSITION
gl.Get() mit dem Argument #GL_CURRENT_RASTER_POSITION_VALID