DGL Wiki - Benutzerbeiträge [de]

glDeleteTextures

2010-09-23T00:53:39Z

Tilman: typo

= glDeleteTextures =

== Name ==
'''glDeleteTextures''' - gibt die angegeben Texturen frei.

== Delphi-Spezifikation ==
procedure '''glDeleteTextures'''(''n'': TGLsizei; const ''textures'': PGLuint);

== Parameter ==

{| border="1" rules="all"
! ''n''
| Bestimmt die Anzahl freizugebender Texturen.
|-
! ''textures''
| Ist ein Zeiger auf ein Feld mit Texturen (die [[OpenGL Name]]n), die freigegeben werden sollen.
|}

== Beschreibung ==
'''glDeleteTextures''' gibt die ''n'' Texturen frei,die über die Elemente des Feldes ''textures'' benannt wurden. Nachdem eine Textur freigegeben wurde, hat diese keinen Inhalt oder Dimension mehr. Außerdem ist ihr Name wieder frei für eine erneute Benutzung (z.B. mittels [[glGenTextures]]).

Wenn die aktuell gebundene Textur gelöscht wird, wird 0 (die Standardtextur) anstelle dessen gebunden.

'''glDeleteTextures''' ignoriert (keine Fehlermeldung) den Texturnamen 0 und alle Namen die nicht zu einer existierenden Textur gehören.

== Hinweise ==
'''glDeleteTextures''' ist erst ab OpenGL Version 1.1 oder höher verfügbar.

== Fehlermeldungen ==
'''GL_INVALID_VALUE''' wird generiert, wenn ''n'' negativ ist.

'''GL_INVALID_OPERATION''' wird generiert, wenn '''glDeleteTextures''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.

== Zugehörige Wertrückgaben ==
[[glIsTexture]]

== Siehe auch ==
[[glAreTexturesResident]], [[glBindTexture]], [[glCopyTexImage1D]], [[glCopyTexImage2D]], [[glGenTextures]], [[glGet]], [[glGetTexParameter]], [[glPrioritizeTextures]], [[glTexImage1D]], [[glTexImage2D]], [[glTexImage3D]], [[glTexParameter]]

[[Kategorie:GL|DeleteTextures]]
[[Kategorie:GL1.1|DeleteTextures]]

GetObject

2010-09-05T14:27:50Z

Tilman: /* Beschreibung */

= getObject =

== Name ==
'''getObject''' - liefert die Pixeldaten für ein TBitmap-Objekt, welche dann z.B. für [[glTexImage2D]] weiterverwendet werden können.

== Delphi-Spezifikation ==
function '''getObject'''(''hgdiobj'': Cardinal; ''cbBuffer'': Integer; ''lpvObject'': Pointer): Integer;

==Parameter==
<table border=1 rules=all>
<tr>
<td>''hgdiobj''</td>
<td>Hier muss ein Handle zu einem Bitmap übergeben werden.</td>
</tr>
<tr>
<td>''cbBuffer''</td>
<td>Größe des Puffers für die Rückgabe.</td>
</tr>
<tr>
<td>''lpvObject''</td>
<td>Zeiger auf ein windows.BITMAP-Objekt</td>
</tr>
</table>

== Beschreibung ==
'''getObject''' liefert zu einem Bitmap-Handle die Windows-Bitmap-Struktur, aus der einfach die Adresse der Pixeldaten gelesen werden kann, um sie z.B. für [[glTexImage2D]] weiter zu verwenden.

Anwendungsbeispiel:
<source lang="pascal">
var
bm: tBitmap; // Delphi-Bitmap
buffer: windows.BITMAP;
begin
bm := tBitmap.Create;
// Weitere Operationen, wie bm.loadFromFile o.ä.
getObject(bm.Handle,sizeof(buffer),@buffer);
// buffer.bmBits enthält nun die Adresse der Pixeldaten, die von glTexImage2D genutzt werden kann.
</source>

== Alternativen ==
getObject ist eine Windows-API-Funktion und funktioniert generell mit allen Bitmaps für die ein Bitmap-Handle bekannt ist; für TBitmap im speziellen kann alternativ auch die Property Scanline mit dem Index height-1 aufgerufen werden:
<source lang="pascal">
var
bm: tBitmap; // Delphi-Bitmap
begin
bm := tBitmap.Create;
// Weitere Operationen, wie bm.loadFromFile o.ä.
// bm.ScanLine[bm.height-1] enthält nun die Adresse der Pixeldaten, die von glTexImage2D genutzt werden kann.
</source>

glTexImage2D

2010-09-05T12:36:24Z

Tilman: /* Siehe auch */

= glTexImage2D =

== Name ==
'''glTexImage2D''' - Spezifiziert ein zweidimensionales Texturbild.

== Spezifikation ==
procedure '''glTexImage2D'''(''target'': TGLenum; ''level'': TGLint; ''internalformat'': TGLint; ''width'': TGLsizei;
''height'': TGLsizei; ''border'': TGLint; ''format'': TGLenum; ''_type'': TGLenum;
'''const''' ''pixels'': PGLvoid);

== Parameter ==
<table border=1 rules=all>
<tr>
<td>''target''</td>
<td>Gibt das Ziel der Textur an.

'''GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z''' oder '''GL_PROXY_TEXTURE_CUBE_MAP'''
</tr>
<tr>
<td>''level''</td>
<td>Gibt den Detailgrad für das gewünschte Bild an. 
''level'' '''0''' ist das Basisbild. Level n ist die n-te Mipmap-Reduzierung des Bildes.</td>
</tr>
<tr>
<td>''internalformat''</td>
<td>'''1''' für '''R''' '''2''' für '''R''' und '''A''' '''3''' für '''RGB''' '''4''' für '''RGBA''' 
oder eine der folgenden symbolischen Konstanten : 
'''GL_ALPHA, GL_ALPHA4, GL_ALPHA8, GL_ALPHA12, GL_ALPHA16, GL_COMPRESSED_ALPHA, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_RGB, GL_COMPRESSED_RGBA, GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24, GL_DEPTH_COMPONENT32, GL_LUMINANCE, GL_LUMINANCE4, GL_LUMINANCE8, GL_LUMINANCE12, GL_LUMINANCE16, GL_LUMINANCE_ALPHA, GL_LUMINANCE4_ALPHA4, GL_LUMINANCE6_ALPHA2, GL_LUMINANCE8_ALPHA8, GL_LUMINANCE12_ALPHA4, GL_LUMINANCE12_ALPHA12, GL_LUMINANCE16_ALPHA16, GL_INTENSITY, GL_INTENSITY4, GL_INTENSITY8, GL_INTENSITY12, GL_INTENSITY16, GL_R3_G3_B2, GL_RGB, GL_RGB4, GL_RGB5, GL_RGB8, GL_RGB10, GL_RGB12, GL_RGB16, GL_RGBA, GL_RGBA2, GL_RGBA4, GL_RGB5_A1, GL_RGBA8, GL_RGB10_A2, GL_RGBA12, GL_RGBA16, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA, GL_SLUMINANCE8_ALPHA8, GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA''' oder '''GL_SRGB8_ALPHA8'''.</td>
</tr>
<tr>
<td>''width''</td>
<td>Breite = Anzahl der Pixel pro Zeile muss als Wert ''2^n + 2 * border'' für n Integerwerte haben.</td>
</tr>
<tr>
<td>''height''</td>
<td>Höhe = Anzahl der Zeilen muss als Wert ''2^n + 2 * border'' für n Integerwerte haben</td>
</tr>
<tr>
<td>''border''</td>
<td>Breite des Rahmens || '''0''' oder '''1'''</td>
</tr>
<tr>
<td>''format''</td>
<td>Bestimmt das Format der Pixeldaten. 
Folgende symbolische Werte werden akzeptiert: 
'''GL_COLOR_INDEX, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_BGR, GL_RGBA, GL_BGRA, GL_LUMINANCE,''' und '''GL_LUMINANCE_ALPHA'''</td>
</tr>
<tr>
<td>''_type''</td>
<td>Bestimmt den Pixeltyp für den Inhalt von ''pixels''. 
Folgende Typen werden unterstützt: 
'''GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT, GL_FLOAT, GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2''' und '''GL_UNSIGNED_INT_2_10_10_10_REV.'''</td>
</tr>
<tr>
<td>''pixels''</td>
<td>Die Texture-Image Daten vom Typ, der in ''format'' angegeben wurde (Array, in dem die Pixel gespeichert sind) </td>
</tr>
</table>

== Beschreibung ==
Texturierung bildet einen bestimmten Teil eines Texturbildes auf alle [[Primitive|Grafikprimitiven]] ab für die Texturierung aktiviert ist.

Zur Aktivierung einer zweidimensionalen Textur ruft man [[glEnable]] mit dem Parameter '''GL_TEXTURE_2D''' auf. Die Deaktivierung erfolgt entsprechend mittels [[glDisable]].
Um Texturierung für [[Cubemap]]-Texturen zu aktivieren oder zu deaktivieren, ruft man [[glEnable]] oder [[glDisable]] mit Argument '''GL_TEXTURE_CUBE_MAP''' auf.

Das Texturbild wird durch die Funktion '''glTexImage2D''' definiert. Die Argumente der Funktion beschreiben die Eigenschaften des Texturbildes wie z.B. Breite, Höhe, Tiefe (je nach Dimension), Breite des Randes, [[LOD]]-Nummer (siehe [[glTexParameter]]) und Anzahl der unterstützen Farbkomponenten. Die letzten 3 Argumente beschreiben wie das Bild im Speicher abgelegt wird. Die 3 Argumente sind identisch mit denen, die das Pixelformat bei [[glDrawPixels]] steuern.

Falls ''target'' '''GL_PROXY_TEXTURE_2D''' oder '''GL_PROXY_TEXTURE_CUBE_MAP''' ist, werden keine Daten von ''data'' gelesen, sondern der Zustand des Texturbildes neu berechnet, auf Konsistenz überprüft und gegen die Fähigkeiten der Implementation geprüft. Falls die Implementation mit einer Textur der angeforderten Grösse nicht klarkommt, setzt sie jeden Bildzustand auf 0, generiert jedoch keinen Fehler ( siehe [[glGetError]] ). Um ein vollständiges Mipmap-Array abzufragen, sollte man ''level'' grösser oder gleich 1 wählen.

Falls ''target'' '''GL_TEXTURE_2D''' oder eins der '''GL_TEXTURE_CUBE_MAP'''-targets ist, werden die Daten aus ''pixels'' als Sequenz von vorzeichenlosen oder -behafteten Byte-, Shortint- oder Longint-Werten oder als Fließkommazahlen einfacher Genauigkeit gelesen. Der Typ wird über ''type'' festgelegt. 
Die ausgelesen Werte werden abhängig von ''format'' gruppiert zu Gruppen mit je einem, zwei, drei oder vier Werten. Diese Gruppen entsprechen einem Element.

Wenn ''type'' gleich '''GL_BITMAP''' ist, werden die Daten als Folge (orig.: "String") von vorzeichenlosen Bytewerten angesehen (wobei ''format'' '''GL_COLOR_INDEX''' sein muss). Jedes Byte des Datenblocks wird als Gruppe von 8 1-Bit Elementen interpretiert. Die Reihenfolge der Bits wird durch '''GL_UNPACK_LSB_FIRST''' (siehe [[glPixelStore]]) festgelegt.

Falls ein nichtnull benamtes [[VBO | Pufferobjekt]] an das '''GL_PIXEL_UNPACK_BUFFER '''-target gebunden ist ( siehe [[glBindBuffer]] ) während ein Texturbild definiert wird, wird ''data'' als Byte-Offset im Datenspeicher des Pufferobjektes behandelt.

Das erste Element entspricht der unteren linken Ecke des Texturbildes. Nachfolgende Elemente laufen von links nach rechts durch die verbleibenden Texel in der untersten Zeile und dann in nachfolgenden höheren Zeilen. Das letzte Element entspricht der oberen rechten Ecke.

Der ''format'' Parameter bestimmt die Zusammenstellung der Elemente aus ''pixels''. Folgende 13 möglichen Werte kann ''format'' haben:

'''GL_COLOR_INDEX'''
:Jedes Element entspricht einem einzelnen Wert, dem Farbindex. Jeder Index wird in eine Festkommazahl (mit einer unbestimmten Anzahl 0 Bits rechts vom Komma) konvertiert, abhängig von Wert und Vorzeichen von '''GL_INDEX_SHIFT''' bitweise nach rechts bzw. links verschoben und zu '''GL_INDEX_OFFSET''' addiert ( siehe [[glPixelTransfer]] ). Dann werden die Indizes durch ihre entsprechenden Werte aus den Tabellen '''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''' ersetzt und auf das Intervall [0, 1] heruntergerechnet.

'''GL_RED'''
:Jedes Element entspricht einer roten Farbkomponente. Der Wert wird in eine Fließkommazahl konvertiert und zu einem RGBA Wert ergänzt, indem man 0.0 für die beiden anderen Farben und 1.0 für den Alphakanal hinzufügt. Jede Komponente wird mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll. (siehe [[glPixelTransfer]])

'''GL_GREEN'''
:Jedes Element entspricht einer grünen Farbkomponente. Der Wert wird in eine Fließkommazahl konvertiert und zu einem RGBA Wert ergänzt, indem man 0.0 für die beiden anderen Farben und 1.0 für den Alphakanal hinzufügt. Jede Komponente wird mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll. (siehe [[glPixelTransfer]])

'''GL_BLUE'''
:Jedes Element entspricht einer blauen Farbkomponente. Der Wert wird in eine Fließkommazahl konvertiert und zu einem RGBA Wert ergänzt, indem man 0.0 für die beiden anderen Farben und 1.0 für den Alphakanal hinzufügt. Jede Komponente wird mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll. (siehe [[glPixelTransfer]])

'''GL_ALPHA'''
:Jedes Element entspricht einer Alpha-Farbkomponente. Der Wert wird in eine Fließkommazahl konvertiert und zu einem RGBA Wert ergänzt, indem man 0.0 für die drei anderen Farben hinzufügt. Jede Komponente wird mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll. (siehe [[glPixelTransfer]])

'''GL_INTENSITY'''
:Jedes Element entspricht einem einzelnem Intesivitäts-Wert. OpenGL wandelt dieses in eine Fließkommazahl um und setzt es zu einem RGBA-Element zusammen, indem der Intensitätswert drei Mal für Rot, Grün, Blau und Alpha kopiert wird. Jede Komponente wird dann mit dem vorzeichenbehafteten Skalierungsfaktor '''GL_'''''c'''''_SCALE''' multipliziert, zu dem vorzeichenbehafteten Bias '''GL_'''''c'''''_BIAS''' addiert und auf den Bereich [0,1] begrenzt ( siehe [[glPixelTransfer]] ).

'''GL_RGB''' 
'''GL_BGR'''
:Jedes Element entspricht den drei RGB-Farbwerten. Die Werte werden in Fließkommazahlen konvertiert und zu einem RGBA Wert ergänzt, indem man 1.0 für den Alphakanal hinzufügt. Jede Komponente wird mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll. (siehe [[glPixelTransfer]])

'''GL_RGBA''' 
'''GL_BGRA'''
:Jedes Element enthält alle vier Farbkomponenten. Jede Komponente wird mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll. (siehe [[glPixelTransfer]])

'''GL_LUMINANCE'''
:Jedes Element entspricht einem Helligkeitswert. Der Wert wird in Fließkommazahlen konvertiert und zu einem RGBA Wert ergänzt, indem man den Helligkeitswert drei mal für R, G und B einsetzt und 1.0 für den Alphakanal hinzufügt. Jede Komponente wird mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll. (siehe [[glPixelTransfer]])

'''GL_LUMINANCE_ALPHA'''
:Jedes Element entspricht einem Paar aus Helligkeitswert und Alphawert. Beide Werte werden in Fließkommazahlen konvertiert und zu einem RGBA Wert ergänzt, indem man den Helligkeitswert drei mal für R, G und B einsetzt und den Alphawert hinzufügt. Jede Komponente wird mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll. (siehe [[glPixelTransfer]])

'''GL_DEPTH_COMPONENT'''
:Jedes Element ist ein einzelner Tiefenwert. OpenGL wandelt diesen in eine Fließkommazahl um, multipliziert diese mit dem vorzeichenbehafteten Skalierungsfaktor '''GL_DEPTH_SCALE''', addiert den vorzeichenbehafteten Bias '''GL_DEPTH_BIAS''' und begrenzt auf den Bereich [0,1] ( siehe [[glPixelTransfer]] ).

Lesen Sie den Artikel [[glDrawPixels]] um eine Beschreibung der zulässigen Werte für ''type'' zu erhalten.

Wenn eine Anwendung die Textur in einer bestimmten Auflösung oder in einem bestimmten Format speichern möchte, kann sie die Auflösung und das Format mit ''internalFormat'' abfragen. OpenGL wird eine interne Repräsentation wählen die das gewünschte ''internalFormat'' approximiert, aber das Format muß nicht exakt übereinstimmen. ( Die Repräsentationen spezifiziert durch '''GL_LUMINANCE, GL_LUMINANCE_ALPHA, GL_RGB''' und '''GL_RGBA''' müssen exakt übereinstimmen ). Die numerischen Werte 1, 2, 3 und 4 dürfen ebenfalls benutzt werden um die obrigen Repräsentationen zu spezifizieren.

Wenn der Parameter ''internalFormat'' eins der generischen gepackten Formate '''GL_COMPRESSED_ALPHA, GL_COMPRESSED_INTENSITY, GL_COMPRESSED_LUMINANCE, GL_COMPRESSED_LUMINANCE_ALPHA, GL_COMPRESSED_RGB''' oder '''GL_COMPRESSED_RGBA''' ist, wird OpenGL das interne Format mit der symbolischen Konstante für ein spezifisches internes Format ersetzen und die Textur vor der Speicherung komprimieren. Falls kein entsprechendes internes Format zu Verfügung steht oder OpenGL das Bild aus irgendeinem Grund nicht komprimieren kann, wird das interne Format stattdessen durch das entsprechende interne Basisformat ersetzt.

Falls der Parameter ''internalFormat'' '''GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, GL_SRGB8_ALPHA8, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA''' oder '''GL_SLUMINANCE8_ALPHA8''' ist, wird die Textur behandelt als wären die roten, grünen, blauen oder Luminance-Komponenten im [[sRGB-Farbraum]] kodiert. Jegliche Alpha-Komponente bleibt unverändert. Die Umwandlung von der sRGB kodierten Komponente ''cs'' in eine lineare Komponente ''cl'' ist :

[[Bild:Formel_sRGB.png]]

Vorausgesetzt ''cs'' ist die sRGB-Komponente im Bereich [0,1].

Man kann als ''target'' '''GL_PROXY_TEXTURE_2D''' oder '''GL_PROXY_TEXTURE_CUBE_MAP''' nutzen um zu überprüfen, ob eine bestimmte Resolution und ein bestimmtes Format akzeptiert werden. Die Implementation wird ihre beste Anpassung für die geforderte Speicherauflösung und das Format aktualisieren und neu berechnen. Um dann den neu berechneten Zustand abzufragen ruft man [[glGetTexLevelParameter]]. Falls die Textur nicht gespeichert werden kann wird der Texturzustand auf 0 gesetzt.

Ein Einkomponenten-Texturbild benutzt nur die aus ''data'' extrahierte rote Komponente der RGBA-Farbe. Ein Zweikomponenten-Bild benutzt die R und A Werte. Ein Dreikomponenten-Bild benutzt die R, G und B Werte. Ein Vierkomponenten-Bild benutzt alle RGBA-Komponenten.

Tiefentexturen können während der Texturfilterung und -anwendung als '''LUMINANCE, INTENSITY''' oder '''ALPHA'''-Texturen behandelt werden. [[Image-based shadowing]] kann aktiviert werden, indem die r-Koordinaten der Textur mit den Werten der Tiefentextur verglichen werden um ein Boolsches Ergebnis zu erhalten. Für mehr Details beim Texturvergleich siehe [[glTexParameter]].

===Verwendungsmöglichkeit===
Abseits dem einfachen Laden von Texturen wird diese Funktion auch benutzt um Speicherbereiche für die spätere Verwendung zu reservieren. Ruft man glTexImage mit ''pixels'' = '''nil''' auf, wird der Speicherbereich zwar angelegt aber nicht gefüllt. Dies kann zum Beispiel gewünscht sein, wenn man einen Screenshot als Textur verwenden möchte ("Render To Texture"). Man kann dann den [[Framebuffer]] (=Screenshot) mittels [[glCopyTexImage]] in den durch glTexImage reservierten Speicherbereich kopieren. (Siehe dazu auch diesen [http://www.delphigl.com/forum/viewtopic.php?p=59156 Thread im Forum])

== Hinweise ==
Texturierung hat im Farbindexmodus keinen Effekt.

Falls die [[ARB_imaging]]-Erweiterung unterstützt wird dürfen RGBA-Elemente auch in der [[Image-Pipeline]] verarbeitet werden.
Die folgenden Stufen dürfen an eine RGBA-Farbe angewendet werden, bevor die Farbkomponenten auf den Bereich [0, 1] eingegrenzt werden :

# Ersetzung der Farbkomponenten durch die Farbtabelle, die durch '''GL_COLOR_TABLE''' definiert wurde, falls aktiviert. Siehe [[glColorTable]]. 
# Zweidimensionale [[Convolution | Convolution-Filterung]], falls aktiviert. Siehe [[glConvolutionFilter]]. Falls ein Convolution-Filter die Breite der Textur ändert ( z.B. durch Abarbeitung mit einem '''GL_CONVOLUTION_BORDER_MODE''' von '''GL_REDUCE''' ) und OpenGL [[NPOT]]-Texturen nicht unterstützt, muss nach der Filterung die Breite ''2^n + 2*border'' für eine Integerzahl n und die Höhe muss ''2^m + 2*border'' für eine Integer-Zahl m sein. 
# RGBA-Komponenten können mit '''GL_POST_CONVOLUTION_'''''c'''''_SCALE''' multipliziert und mit '''GL_POST_CONVOLUTION_'''''c'''''_BIAS''' addiert werden, falls aktiviert. Siehe [[glPixelTransfer]]. 
# Ersetzung der Farbkomponenten durch die Farbtabelle, die durch '''GL_POST_CONVOLUTION_COLOR_TABLE''' definiert wurde, falls aktiviert. Siehe [[glColorTable]]. 
# Transformation durch die [[Farbmatrix]]. Siehe [[glMatrixMode]]. 
# RGBA-Komponenten können mit '''GL_POST_COLOR_MATRIX_'''''c'''''_SCALE''' multipliziert und mit '''GL_POST_COLOR_MATRIX_'''''c'''''_BIAS''' addiert werden, falls aktiviert. Siehe [[glPixelTransfer]]. 
# Ersetzung der Farbkomponenten durch die Farbtabelle, die durch '''GL_POST_COLOR_MATRIX_COLOR_TABLE''' definiert wurde, falls aktiviert. Siehe [[glColorTable]]. 

Das Texturbild kann in den selben Datenformaten vorliegen wie die Pixel bei [[glDrawPixels]] ausgenommen '''GL_STENCIL_INDEX''' und '''GL_DEPTH_COMPONENT'''. [[glPixelStore]] und [[glPixelTransfer]] beeinflussen das Texturbild in exakt der Art und Weise, wie sie auch [[glDrawPixels]] beeinflussen.

Eine Textur die 0 Pixel hoch oder breit ist, stellt die NULL-Textur dar. Wenn die NULL-Textur für die LOD-Stufe 0 spezifiziert wird entspricht das Verhalten dem bei deaktivierter Texturierung.

== Änderungen ==
Folgende Erweiterungen hat die Funktion erfahren:

=== Ab OpenGL Version 1.1 ===
'''glTexImage2D''' und '''GL_PROXY_TEXTURE_2D''' stehen zur Verfügung.

Andere interne Formate als 1, 2, 3 oder 4 dürfen benutzt werden.

''data'' darf ein Null-Pointer sein. In diesem Fall wird Texturspeicher allokiert um eine Textur der Breite ''width'' und Höhe ''height'' aufzunehmen. Man kann dann Sub-Texturen laden um diesen Texturspeicher zu initialisieren. Das Bild ist undefiniert, falls der Nutzer versucht einen nichtinitialisierten Teil des Texturbildes auf eine Primitive anzuwenden.

=== Ab OpenGL Version 1.2 ===
Die Formate '''GL_BGR''' und '''GL_BGRA''' und die Typen ''' GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5, GL_UNSIGNED_SHORT_5_6_5_REV, GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2''' und '''GL_UNSIGNED_INT_2_10_10_10_REV''' stehen zur Verfügung.

=== Ab OpenGL Version 1.3 ===
'''glTexImage2D''' gibt die zweidimensionale Textur der aktuellen, mit [[glActiveTexture]] definierten Textur-Einheit an ( oder schon vorher, falls die [[ARB_multitexture]]-Erweiterung unterstützt wird ).

'''GL_TEXTURE_CUBE_MAP''' und '''GL_PROXY_TEXTURE_CUBE_MAP''' stehen zur Verfügung.

=== Ab OpenGL Version 1.4 ===
'''GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24''' und '''GL_DEPTH_COMPONENT32''' stehen zur Verfügung.

=== Ab OpenGL Version 2.0 ===
[[NPOT]]-Texturen werden unterstützt ( oder schon vorher, falls die Implementation die [[GL_ARB_texture_non_power_of_two]]-Erweiterung unterstützt ).

=== Ab OpenGL Version 2.1 ===
Die internen Formate '''GL_SRGB, GL_SRGB8, GL_SRGB_ALPHA, GL_SRGB8_ALPHA8, GL_SLUMINANCE, GL_SLUMINANCE8, GL_SLUMINANCE_ALPHA''' und '''GL_SLUMINANCE8_ALPHA8''' stehen zur Verfügung.

== Fehlermeldungen ==

'''GL_INVALID_ENUM''' wird generiert wenn ''target'' nicht '''GL_TEXTURE_2D, GL_PROXY_TEXTURE_2D, GL_PROXY_TEXTURE_CUBE_MAP, GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z''' oder '''GL_TEXTURE_CUBE_MAP_NEGATIVE_Z''' ist. 

'''GL_INVALID_ENUM''' wird generiert, falls ''target'' einer der sechs Cubemap ''target''-Parameter für '''glTexImage2D''' ist und ''width'' und ''height'' nicht gleich sind.

'''GL_INVALID_ENUM''' wird generiert wenn ''format'' ungültige Werte übergeben wurden. Akzeptiert werden alle Formatangaben außer '''GL_STENCIL_INDEX''' und '''GL_DEPTH_COMPONENT''' 

'''GL_INVALID_ENUM''' wird generiert wenn ''type'' keine gültige Typkonstante übergeben wurde. 

'''GL_INVALID_ENUM''' wird generiert wenn '''GL_BITMAP''' als ''type'' und '''GL_COLOR_INDEX''' nicht(!) als ''format'' angegeben wurde. 

'''GL_INVALID_VALUE''' wird generiert wenn ''level'' kleiner 0 oder größer ''ld(max)'' ist, wobei ''max'' der Rückgabewert von '''GL_MAX_TEXTURE_SIZE''' ist. (ld = Logarithmus Dualis = Basis 2). 

'''GL_INVALID_VALUE''' wird generiert wenn für ''internalformat'' etwas anderes als ''1'', ''2'', ''3'', ''4'' oder eine der akzeptieren Resolutions- und symbolischen Formatkonstanten angegeben wurde. 

'''GL_INVALID_VALUE''' wird generiert wenn ''width'' bzw. ''height'' kleiner als 0 oder größer als 2 + '''GL_MAX_TEXTURE_SIZE''' ist, oder die Bedingung ''2^k + 2 * border'' (k=Integerwerte) nicht erfüllt. 

'''GL_INVALID_VALUE''' wenn ''border'' nicht ''0'' oder ''1'' ist. 

'''GL_INVALID_OPERATION''' wird generiert, falls ''type'' eine der Konstanten '''GL_UNSIGNED_BYTE_3_3_2, GL_UNSIGNED_BYTE_2_3_3_REV, GL_UNSIGNED_SHORT_5_6_5''' oder '''GL_UNSIGNED_SHORT_5_6_5_REV''' ist und ''format'' nicht '''GL_RGB'''.

'''GL_INVALID_OPERATION''' wird generiert, falls ''type'' eine der Konstanten '''GL_UNSIGNED_SHORT_4_4_4_4, GL_UNSIGNED_SHORT_4_4_4_4_REV, GL_UNSIGNED_SHORT_5_5_5_1, GL_UNSIGNED_SHORT_1_5_5_5_REV, GL_UNSIGNED_INT_8_8_8_8, GL_UNSIGNED_INT_8_8_8_8_REV, GL_UNSIGNED_INT_10_10_10_2''' oder '''GL_UNSIGNED_INT_2_10_10_10_REV''' und ''format'' weder '''GL_RGBA''' noch '''GL_BGRA''' ist.

'''GL_INVALID_OPERATION''' wird generiert, falls ''target'' nicht '''GL_TEXTURE_2D''' oder '''GL_PROXY_TEXTURE_2D''' und ''internalFormat'' '''GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24''' oder '''GL_DEPTH_COMPONENT32''' ist.

'''GL_INVALID_OPERATION''' wird generiert, falls ''format'' '''GL_DEPTH_COMPONENT'''' und ''internalFormat'' nicht '''GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24''' oder '''GL_DEPTH_COMPONENT32''' ist.

'''GL_INVALID_OPERATION''' wird generiert, falls ''internalFormat'' '''GL_DEPTH_COMPONENT, GL_DEPTH_COMPONENT16, GL_DEPTH_COMPONENT24''' oder '''GL_DEPTH_COMPONENT32''' und ''format'' nicht '''GL_DEPTH_COMPONENT''' ist.

'''GL_INVALID_OPERATION''' wird generiert, falls ein Pufferobjekt-Name ungleich null an das '''GL_PIXEL_UNPACK_BUFFER'''-target gebunden ist und der Datenspeicher des Pufferobjektes währenddessen gemappt wird.

'''GL_INVALID_OPERATION''' wird generiert, falls ein Pufferobjekt-Name ungleich null an das '''GL_PIXEL_UNPACK_BUFFER'''-target gebunden ist und die Daten derart vom Pufferobjekt entpackt werden, dass der gelesene Speicher die Grösse des Speichers der Daten überschreitet.

'''GL_INVALID_OPERATION''' wird generiert, falls ein Pufferobjekt-Name ungleich null an das '''GL_PIXEL_UNPACK_BUFFER'''-target gebunden ist und ''data'' nicht gleichartig auf die Anzahl der Bytes aufgeteilt werden kann, um im Speicher ein Datum abzuspeichern welches durch ''type'' angegeben wurde.

'''GL_INVALID_OPERATION''' wird generiert wenn eine '''glTexImage'''-Funktion in einem [[glBegin]]- und [[glEnd]]-Block aufgerufen wird. 

== Zugehörige Wertrückgaben ==
[[glGetTexImage]] 
[[glIsEnabled]] mit dem Token '''GL_TEXTURE_2D''' oder '''GL_TEXTURE_CUBE_MAP'''. 
[[glGet]] mit Argument '''GL_PIXEL_UNPACK_BUFFER_BINDING'''

== Links ==
http://www.opengl.org/sdk/docs/man/xhtml/glTexImage2D.xml

== Siehe auch ==
[[glActiveTexture]], [[glColorTable]], [[glConvolutionFilter2D]], [[glCopyPixels]], [[glCopyTexImage1D]], [[glCopyTexImage2D]], [[glCopyTexSubImage1D]], [[glCopyTexSubImage2D]], [[glCopyTexSubImage3D]], [[glDrawPixels]], [[glMatrixMode]], [[glPixelStore]], [[glPixelTransfer]], [[glSeparableFilter2D]], [[glTexEnv]], [[glTexGen]], [[glTexImage1D]], [[glTexImage3D]], [[glTexSubImage1D]], [[glTexSubImage2D]], [[glTexSubImage3D]], [[glTexParameter]]

*[[getObject]] (Pixeldaten eines TBitmap bekommen)

[[Kategorie:GL|TexImage2D]]
[[Kategorie:GL1.0]]

GetObject

2010-09-05T12:36:19Z

Tilman: Die Seite wurde neu angelegt: „= getObject = == Name == '''getObject''' - liefert die Pixeldaten für ein TBitmap-Objekt, welche dann z.B. für glTexImage2D weiterverwendet werden könne…“

Benutzer:Tilman

2010-09-04T06:45:33Z

Tilman:

Hi, ich bin Tilman. Seit ca. einem Jahr bin ich im Forum aktiv. Ich verfolge ein Projekt, das ich demnächst vorzustellen gedenke. In der deutschen Wikipedia bin ich auch mehr oder weniger aktiv: [http://de.wikipedia.org/wiki/Benutzer:E-qual http://de.wikipedia.org/wiki/Benutzer:E-qual]

Ich bin ausserdem Moderator im Forum von [http://www.fernsehkritik.tv Fernsehkritik-TV], wofür ich hier gerne Werbung mache ^^

Benutzer:Tilman

2010-09-04T06:38:38Z

Tilman: Die Seite wurde neu angelegt: „Hi, ich bin Tilman. Seit ca. einem Jahr bin ich im Forum aktiv. Ich verfolge ein Projekt, das ich demnächst vorzustellen gedenke. In der deutschen Wikipedia bin …“

Screenshot

2010-09-04T03:14:51Z

Tilman: /* Bilddaten besorgen */

== Allgemeines zum Screenshot erstellen ==
=== Einleitung ===
Ein '''Screenshot''' ist ein Abbild des aktuellen Bildschirm Inhaltes.

Im Falle von OpenGL greifen wir nicht auf das Fenster zurück sondern auf den [[Framebuffer]]. Neben dem eigentlichen Vorgang des Bilddatenbesorgens ist es meistens auch noch sinnvoll die Daten dem Benutzer verfügbar zu machen. Dies geschieht meistens in Form einer Bild-Datei oder eines Eintrages in der Zwischenablage.

=== Bilddaten besorgen ===
Mit Hilfe des [[glReadPixels]] Befehls kann der [[Framebuffer]] ausgelesen werden. Für einen Screenshot sind meistens die [[RGB]]-Werte interessant. Bei diesen Werten ergibt sich auch schon das erste Problem: OpenGL speichert die Daten in der Reihenfolge Rot Grün Blau, während es in einigen Bildformaten (nämlich denen die auf Bitmaps aufbauen) üblich ist, die Daten in der Reihenfolge Blau Grün Rot zu speichern. Glücklicherweise kann man in aktuellen OpenGL Versionen [[glReadPixels]] anweisen die Daten auch in dieser Reihenfolge zu liefern.

Der [[glReadPixels]] Befehl für neue Grafikkarten könnte in etwa so aussehen:
<source lang="pascal">
// ungünstige Reihenfolge Rot Grün Blau
glReadPixels( 0, 0, Breite, Hoehe, GL_RGB, GL_UNSIGNED_BYTE, Daten );
// auf neueren Grafikkarten:
glReadPixels( 0, 0, Breite, Hoehe, GL_BGR, GL_UNSIGNED_BYTE, Daten );
</source>

Was die einzelnen Parameter bedeuten, könnt ihr im [[glReadPixels]] Artikel nachlesen. Es sei hier nur gesagt das das letzte Argument der Speicherplatz ist, an dem OpenGL die Daten abspeichern soll (meist ein Pointer z.B. auf ein Array).
{{Hinweis|Möchte man, dass die Pixeldaten hintereinanderweg im Speicher erscheinen, so sollte man glPixelStoref(GL_PACK_ALIGNMENT,1) setzen, ansonten werden die Daten je nach Format durch Pixelstore weiter formatiert.}}

=== Hinweis ===
Unter [[SDL]] finden sich die Bilddaten schon in der [[SDL_Surface|Displaysurface]] unter ''pixels''.

== Speichern des Screenshots ==
Die Speicherung der Screenshots ist, sofern man erst einmal die Rohdaten der einzelnen Pixel hat, nicht mehr allzu kompliziert. Da der Computer aber ohne zusätzliche Informationen zu diesen Rohdaten später nichts mehr mit ihnen anfangen könnte, muss man einige zusätzliche Informationen mit in seine Zieldatei schreiben, die oftmals als "Header" bezeichnet werden und Informationen zu Breite, Höhe und "Pixelformat" beinhalten.

=== Speichern im BMP Format ===

Eine BMP-Datei hat einen relativ einfachen Aufbau. Als erstes kommen Header-Informationen (das Zeugs, was die Daten als Bitmap ausweist ;-)), dann FileInfo-Informationen (das, was angibt, wie groß das Bitmap ist) und schließlich die eigentlichen Bilddaten.

Der Header sieht so aus:
<source lang="pascal"> BITMAPFILEHEADER = packed record
bfType: Word;
bfSize: DWORD;
bfReserved1: Word;
bfReserved2: Word;
bfOffBits: DWORD;
end;

BITMAPINFOHEADER = packed record
biSize: DWORD;
biWidth: Longint;
biHeight: Longint;
biPlanes: Word;
biBitCount: Word;
biCompression: DWORD;
biSizeImage: DWORD;
biXPelsPerMeter: Longint;
biYPelsPerMeter: Longint;
biClrUsed: DWORD;
biClrImportant: DWORD;
end;</source>

Nun zur Speicherfunktion für einen Screenshot:
<source lang="pascal">procedure ScreenShot(const Name : string);
var F : file;
FileInfo: BITMAPINFOHEADER;
FileHeader : BITMAPFILEHEADER;
pPicData:Pointer;
Viewport : array[0..3] of integer;
begin
//Speicher für die Speicherung der Header-Informationen vorbereiten
ZeroMemory(@FileHeader, SizeOf(BITMAPFILEHEADER));
ZeroMemory(@FileInfo, SizeOf(BITMAPINFOHEADER));

//Größe des Viewports abfragen --> Spätere Bildgrößenangaben
glGetIntegerv(GL_VIEWPORT, @Viewport);

//Initialisieren der Daten des Headers
FileHeader.bfType := 19778; //$4D42 = 'BM'
FileHeader.bfOffBits := SizeOf(BITMAPINFOHEADER)+SizeOf(BITMAPFILEHEADER);

//Schreiben der Bitmap-Informationen
FileInfo.biSize := SizeOf(BITMAPINFOHEADER);
FileInfo.biWidth := Viewport[2];
FileInfo.biHeight := Viewport[3];
FileInfo.biPlanes := 1;
FileInfo.biBitCount := 32;
FileInfo.biSizeImage := FileInfo.biWidth*FileInfo.biHeight*(FileInfo.biBitCount div 8);

//Größenangabe auch in den Header übernehmen
FileHeader.bfSize := FileHeader.bfOffBits + FileInfo.biSizeImage;

//Speicher für die Bilddaten reservieren
GetMem(pPicData, FileInfo.biSizeImage);
try
//Bilddaten von OpenGL anfordern (siehe oben)
glReadPixels(0, 0, Viewport[2], Viewport[3], GL_BGRA, GL_UNSIGNED_BYTE, pPicData);

//Und den ganzen Müll in die Datei schieben ;-)
//Moderne Leute nehmen dafür auch Streams ...
AssignFile(f, name);
Rewrite( f,1 );
try
BlockWrite(F, FileHeader, SizeOf(BITMAPFILEHEADER));
BlockWrite(F, FileInfo, SizeOf(BITMAPINFOHEADER));
BlockWrite(F, pPicData^, FileInfo.biSizeImage );
finally
CloseFile(f);
end;
finally
//Und den angeforderten Speicher wieder freigeben ...
FreeMem(pPicData, FileInfo.biSizeImage);
end;
end;</source>

=== Speichern im TGA Format ===

Eine TGA-Datei hat einen ähnlich einfachen Aufbau. Als erstes kommen auch hier Header-Informationen und dannach die eigentlichen Daten.

Der Header sieht diesmal so aus:
<source lang="pascal">type
TTGAHEADER = packed record
tfType : Byte;
tfColorMapType : Byte;
tfImageType : Byte;
tfColorMapSpec : Array[0..4] of Byte;
tfOrigX : Word; //Array [0..1] of Byte;
tfOrigY : Word;
tfWidth : Word;
tfHeight : Word;
tfBpp : Byte;
tfImageDes : Byte;
end;
</source>
Nun zur Speicherfunktion für ein Screenshot ohne Alpha Wert
<source lang="pascal">
procedure ScreenShot(const Name : string);
var
DataBuffer : array of Byte;
f : file;
tgaHeader : TTGAHEADER;
width, height : integer;
DataSize:Integer;
viewport : Array[0..3] of integer;
begin
//Viewport-Größe lesen
glGetIntegerv(GL_VIEWPORT, @viewport);
width := viewport[2];
height := viewport[3];

//Größe der Daten berechnen
DataSize := Width * Height * 3;

//Größe des Puffers festlegen (Speicher reservieren)
SetLength(DataBuffer,DataSize);

// TGA Kopf mit Daten füllen
ZeroMemory(@tgaHeader, SizeOf(tgaHeader));
tgaHeader.tfImageType := 2; // TGA_RGB = 2
tgaHeader.tfWidth := Width;
tgaHeader.tfHeight := Height;
tgaHeader.tfBpp := 24;

//Daten von OpenGL anfordern
glReadPixels(0,0,Width, Height, GL_BGR, GL_UNSIGNED_BYTE, @DataBuffer[0]);

//Datei erstellen
AssignFile(f, Name);
Rewrite( f,1 );
try
// TGA Kopf in die Datei reinschreiben
BlockWrite(F, tgaHeader, SizeOf(tgaHeader));

// Die eigentlichen Bilddaten in die Datei schreiben
BlockWrite(f, DataBuffer[0], DataSize );
finally
CloseFile(f);
end;
end;
</source>

=== Speichern im TGA-Format bei Nutzung von SDL ===

Das Speichern eines Screenshots im TGA-Format sieht auch bei Nutzung von SDL nicht wesentlich anders aus. Als erstes müssen die Units sdl und sdl_utils eingebunden sein, was aber sicherlich schon der Fall ist. Ansonsten einfach kurz

<source lang="pascal">uses
sdl, sdl_utils;</source>

und wir hätten auch dies erledigt.

Was sich allerdings etwas unterscheided, ist, dass man gegebenenfalls einige Vorkehrungen treffen muss, um die richtige Reihenfolge der einzelnen Farbkanäle zu gewährleisten, was mit folgender Routine ein leichtes ist:

<source lang="pascal">procedure SwapBGR(Surface: PSDL_Surface);
var
x,y: Integer;
pixel: UInt32;
pred, pgreen, pblue, palpha: PUInt8;
red, green, blue, alpha: UInt8;
begin
for y:=0 to (Surface.h-1) do
for x:=0 to (Surface.w-1) do
begin
//reads the pixels them
pixel:=SDL_GetPixel(Surface, x, y);

pred:=@red;
pgreen:=@green;
pblue:=@blue;
palpha:=@alpha;

//read and swap color
SDL_GetRGBA(pixel,Surface.format, pred, pgreen, pblue, palpha);
pixel:=SDL_MapRGBA(Surface.format, blue, green, red, alpha);

SDL_PutPixel(Surface, x, y, pixel);
end;
end;</source>

Auch hier benötigen wir wieder den TGA-Header als Record:

<source lang="pascal">type
TTGAHEADER = packed record
tfType : Byte;
tfColorMapType : Byte;
tfImageType : Byte;
tfColorMapSpec : Array[0..4] of Byte;
tfOrigX : Word;
tfOrigY : Word;
tfWidth : Word;
tfHeight : Word;
tfBpp : Byte;
tfImageDes : Byte;
end;
</source>

Nach diesen kleinen Vorbereitungen folgt eigentlich auch, wie gewohnt, der normale Code zum Speichern, nur eben mit SDL:

<source lang="pascal">//Speichert eine Surface in eine TGA-Datei.
//Surface wird am Ende freigegeben. Die Videosurface sollte also vorher geblittet werden
//und diese dann weitergereicht werden.
function SaveSurfacetoTGA(filename: String; surface: PSDL_Surface): Boolean;
var
TGAHEADER : TTGAHEADER;

rwop: PSDL_RWops;
ImageSize: Integer;
i : Integer;
begin
Result:=False;

//Prüfen, ob's was zu Speichern gibt ...
if not Assigned(surface) then
begin
writeln('Keine Surface übergeben');
exit;
end;

//Haben wir ein Pixelformat mit mindestens 24 Bit?
if surface.format.BytesPerPixel<3 then
begin
writeln('Farbtiefe nicht unterstützt');
exit;
end;

//Müssen wir die Reihenfolge der Farbkanäle anpassen?
if SDL_BYTEORDER<>SDL_BIG_ENDIAN then
begin
SwapBGR(surface);
end;

//Na gut, füllen wir den Header aus ...
with TGAHEADER do
begin
tfType:=0;
tfColorMapType:=0;
tfImageType:=2;
for i:=0 to 4 do
tfColorMapSpec[i]:=0;
tfOrigX:=0;
tfOrigY:=0;
tfWidth:=surface.w;
tfHeight:=surface.h;
tfBpp:=surface.format.BitsPerPixel;
tfImageDes:=0;
end;

//Ermitteln des benötigten Speicherplatze...
ImageSize:=surface.w*surface.h*surface.format.BytesPerPixel;

//Datei zum Schreiben öffnen.
rwop:=SDL_RWfromFile(PChar(filename),'w+b');
if rwop=nil then
begin
Writeln('Fehler beim Erstellen des Rwops');
exit;
end;
try
//Versuchen, den Header in die Datei zu schreiben
if SDL_RWWrite(rwop,@TGAHEADER,SizeOf(TGAHEADER),1)<>1 then
begin
writeln('Fehler beim Schreiben des Headers');
exit;
end;

//Versuchen, die Bilddaten in die Datei zu schreibenSchreiben der Bilddaten
if SDL_RWWrite(rwop,surface.pixels,ImageSize,1)<>1 then
begin
writeln('Fehler beim Schreiben der Daten');
exit;
end;

//Scheinbar waren wir erfolgreich
Result:=True;
finally
//Datei schließen ...
SDL_RWClose(rwop);

//Und das Surface freigeben
SDL_FreeSurface(surface);
end;
end;</source>

That's it. Have a nice day!

== Siehe Auch ==
[[Tutorial Renderpass]] (Dieses Tutorial erklärt wie man das gerenderte zu anderen Zwecken verwenden kann.)

[[Kategorie:Anleitung]] [[Kategorie:Technik_oder_Algorithmus]]

glReadPixels

2010-09-04T03:13:37Z

Tilman: /* Beschreibung */

= glReadPixels =

== Name ==
'''glReadPixels''' - ließt einen Block von Pixel aus dem [[Framebuffer]].

== Delphi-Spezifikation ==
procedure '''glReadPixels'''(''x'': TGLint; ''y'': TGLint;
''width'': TGLsizei; ''height'': TGLsizei;
''format'': TGLenum; ''_type'': TGLenum;
''pixels'': PGLvoid);

== Parameter ==
<table border=1 rules=all>
<tr>
<td>''x, y''</td>
<td>Beschreibt die Fensterkoordinaten des ersten Pixels, dass aus dem [[Framebuffer]] gelesen wird. Diese Position ist die untere, linke Ecke eines Rechtecks von Pixeln.</td>
</tr>
<tr>
<td>''width, height''</td>
<td>Beschreibt die Dimensionen des Pixelrechtecks. Die Angaben werden dabei in Pixel gemacht.</td>
</tr>
<tr>
<td>''format''</td>
<td>Bestimmt das Format der Pixeldaten. Folgende symbolische Werte werden akzeptiert: 
'''GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_RGBA, GL_LUMINANCE,''' und '''GL_LUMINANCE_ALPHA'''</td>
</tr>
<tr>
<td>''type''</td>
<td>Beschreibt den Datentyp der Pixeldaten. Muss einer der Folgenden sein: 
'''GL_UNSIGNED_BYTE, GL_BYTE, GL_BITMAP, GL_UNSIGNED_SHORT, GL_SHORT, GL_UNSIGNED_INT, GL_INT,''' oder '''GL_FLOAT'''</td>
</tr>
<tr>
<td>''pixels''</td>
<td>Liefert die Pixeldaten zurück.</td>
</tr>
</table>

== Beschreibung ==
'''glReadPixels''' kopiert Pixeldaten aus dem [[Framebuffer]] in den Klientspeicher der für ''pixels'' reserviert wurde. Der Kopiervorgang beginnt dabei mit dem Pixel, dessen linke untere Ecke am Punkt(''x, y'') liegt.
Verschiedene Parameter kontrollieren die Verarbeitung der Pixeldaten bevor diese in den Klientspeicher geschrieben werden. Diese Parameter werden mit drei Befehlen gesetzt: 
[[glPixelStore]], [[glPixelTransfer]] und [[glPixelMap]]. 
Dieser Artikel beschreibt die Effekte welche die meisten, aber nicht alle Parameter der genannten Artikel auf '''glReadPixels''' haben.
{{Hinweis|Möchte man, dass die Pixeldaten hintereinanderweg im Speicher erscheinen, so sollte man glPixelStoref(GL_PACK_ALIGNMENT,1) setzen, ansonten werden die Daten je nach Format durch Pixelstore weiter formatiert.}}
'''glReadPixels''' liefert die Werte der Pixel die im Rechteck [''x''+i, ''y''+j] liegen. (mit 0<=i<''width'' bzw. 0<=j<height) 
Dabei bezeichnet [i,j] das i-te Pixel in der j-ten Zeile. Die Pixel werden zeilenweise beginnend mit der niedrigsten Zeile und von links nach rechts (innerhalb der Zeile) zurück geliefert.

Der Parameter ''format'' bestimmt das Format der zurück gelieferten Pixelwerte. Akzeptiert werden:

=== Format Parameter ===
'''GL_COLOR_INDEX'''
: Farbindizes werden aus dem von glReadBuffer ausgewählten [[Farbpuffer]] gelesen. Jeder Index wird in eine Festkommazahl konvertiert, abhängig von Wert und Vorzeichen von GL_INDEX_SHIFT bitweise nach rechts bzw. links verschoben und zu '''GL_INDEX_OFFSET''' addiert. Ist '''GL_MAP_COLOR''' auf '''GL_TRUE''' gesetzt, werden Indizes durch ihre entsprechenden Werte aus der '''GL_PIXEL_MAP_I_TO_I''' Tabelle ersetzt.

'''GL_STENCIL_INDEX'''
: Stencilwerte werden aus dem Stencilbuffer gelesen. Jeder Index wird in eine Festkommazahl konvertiert, abhängig von Wert und Vorzeichen von '''GL_INDEX_SHIFT''' bitweise nach rechts bzw. links verschoben und zu '''GL_INDEX_OFFSET''' addiert. Ist '''GL_MAP_STENCIL''' auf '''GL_TRUE''' gesetzt, werden Indizes durch ihre entsprechenden Werte aus der '''GL_PIXEL_MAP_S_TO_S''' Tabelle ersetzt.
'''GL_DEPTH_COMPONENT'''
: Tiefenwertkomponenten werden aus dem Z-Buffer gelesen. Jede Komponente wird in eine Gleitkommazahl umgewandelt, so dass der minimale Wert auf 0.0 abgebildet wird und der maximale auf 1.0. Dann wird der Wert mit '''GL_DEPTH_SCALE''' multipliziert und zu '''GL_DEPTH_BIAS''' addiert und am Schluss auf den Bereich [0,1] begrenzt.

'''GL_RED''' 
'''GL_GREEN''' 
'''GL_BLUE''' 
'''GL_ALPHA''' 
'''GL_RGB''' 
'''GL_RGBA''' 
'''GL_LUMINANCE''' 
'''GL_LUMINANCE_ALPHA'''

: Hierbei verhält sich die Verarbeitung unterschiedlich, abhängig davon, ob Farbindizes oder Farbkomponenten im Colorbuffer geschpeichert sind. Wenn Indizes gespeichert sind, werden sie aus dem mit glReadBuffer gesetzen Colorbuffer gelesen. Jeder Index wird in eine Festkommazahl konvertiert, abhängig von Wert und Vorzeichen von '''GL_INDEX_SHIFT''' bitweise nach rechts bzw. links verschoben und zu '''GL_INDEX_OFFSET''' addiert. Dann werden die Indizes durch ihre entsprechenden Werte aus den Tabellen '''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''' ersetzt.
: Sind RGBA Farbkomponenten gespeichert, werden sie aus dem mit glReadBuffer gesetzen Colorbuffer gelesen.
:Jede Farbkomponente wird so in eine Gleitkommazahl umgewandelt, dass der minimale Wert auf 0.0 abgebildet wird und der maximale auf 1.0. Dann wird der Wert mit '''GL_'''''c'''''_SCALE''' multipliziert und zu '''GL_'''''c'''''_BIAS''' addiert, und am Schluss auf den Bereich [0,1] begrenzt, wobei ''c'' durch R, G, B oder A ersetzt werden soll.
:Ist '''GL_MAP_COLOR''' auf '''GL_TRUE''' gesetzt, wird jeder Farbkomponente durch die entsprechende Ersetzung aus der '''GL_PIXEL_MAP_'''''c'''''_TO_'''''c'' Tabelle (wobei ''c'' wieder R, G, B oder A ist) ersetzt. Davor wird jede Komponente auf die Größe der entsprechenden Tabelle skaliert.
: Abschließend werden die unbenötigen Daten verworfen, z.B.: '''GL_RED''' ignoriert die Grün, Blau und Alpha Komponente, und '''GL_RGB''' ignoriert nur den Alphawert. '''GL_LUMINANCE''' berechnet eine einzige Farbkomponente durch die Summe von Rot, Grün und Blau. '''GL_LUMINANCE_ALPHA''' hat zusätzlich noch einen Alphawert.

Die shift-, scale-, bias-, und lookup-Faktoren die weiter oben beschrieben wurden, werden alle durch [[glPixelTransfer]] spezifiziert. Der Inhalt der lookup-table wiederum wird über [[glPixelMap]] spezifiziert.

Der letzte Schritt beinhaltet eine Umwandlung der Indizes oder Komponenten in das in ''_type'' angegebene Format. Falls das Format '''GL_COLOR_INDEX''' or '''GL_STENCIL_INDEX''' ist, und der angegebene Typ nicht '''GL_FLOAT''' ist, dann wird jeder wert mit dem Masken der der folgenden Tabelle maskiert. Falls der Typ '''GL_FLOAT''' ist werden die ganzen Zahlen (Typ Integer) in einen Gleitkommerwert umgerechnet.

Falls das Format '''GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA, GL_RGB, GL_RGBA, GL_LUMINANCE''' oder '''GL_LUMINANCE_ALPHA''' ist und der Typ nicht '''GL_FLOAT''' ist, wird jede Komponente mit einen Wert multipliziert, welcher folgender Tabelle entnommen werden kann. Falls der Typ '''GL_FLOAT''' ist werden alle Komponten beibehalten wie sie sind.(Oder in das entsprechend Gleitkommaformat konventiert, falls sich dieses von dem der in GL genutzten unterscheidet)

{| border="1" rules="all"
! '''Type''' || '''Index Mask''' || '''Komponenten Konvertierung'''
|-
! '''GL_UNSIGNED_BYTE''' || 2^8-1 || (2^8-1)c
|-
! '''GL_BYTE''' || 2^7-1 || ([2^7-1]c-1)/2
|-
! '''GL_BITMAP''' || 1 || 1
|-
! '''GL_UNSIGNED_SHORT''' || 2^16-1 || (2^16-1) c
|-
! '''GL_SHORT''' || 2^15-1 || [(2^15-1) c-1] / 2
|-
! '''GL_UNSIGNED_INT''' || 2^32-1 || (2^32-1) c
|-
! '''GL_INT''' || 2^31-1 || [(2^31-1) c-1] / 2
|-
! '''GL_FLOAT''' || keine || c
|-
|}

[[glReadPixels_Beispiel| Ein Rechenbeispiel zum besseren Verständnis.]]

Die zurückgegeben Werte werden wie folgt im Speicher plaziert: Falls das Format '''GL_COLOR_INDEX, GL_STENCIL_INDEX, GL_DEPTH_COMPONENT, GL_RED, GL_GREEN, GL_BLUE, GL_ALPHA,''' oder '''GL_LUMINANCE''' ist, wird ein einzelner Wert zurückgebenen und die Daten für die '''i'''ten [[Pixel]] in der '''j'''ten Reihe werden an der Stelle (j) width + i plaziert.
'''GL_RGB''' gibt drei Werte zurück, '''GL_RGBA''' vier, und '''GL_LUMINANCE_ALPHA''' zwei für jeden Pixel. Alle Werte die zu einem einzelnen Pixel gehören liegen nebeneinander im Feld ''pixels''.
Speicher Parameter werden von [[glPixelStore]] gesetzt, zum Beispiel legen '''GL_PACK_SWAP_BYTES''' und '''GL_PACK_LSB_FIRST''' fest, auf welche Art die Daten in den Speicher geschrieben werden.

== Hinweise ==
Werte von Pixeln außerhalb des Fensters, das mit dem aktuellen GL-Kontext verbunden ist, sind undefiniert.

Wenn ein Fehler bei der Durchführung der Funktion auftritt, werden keine Veränderungen am Inhalt von ''pixels'' durchgeführt.

== Fehlermeldungen ==
'''GL_INVALID_ENUM''' wird generiert wenn ''format'' oder ''type'' ein ungültiger Wert übergeben wird. 
'''GL_INVALID_VALUE''' wird generiert wenn entweder ''width'' oder ''height'' negativ ist. 
'''GL_INVALID_OPERATION''' wird generiert wenn ''format'' '''GL_COLOR_INDEX''' ist und der [[Farbpuffer]] RGBA Werte enthält. 
'''GL_INVALID_OPERATION''' wird generiert wenn ''format'' '''GL_STENCIL_INDEX''' ist und kein Schablonen-(/Stencil-)Puffer existiert. 
'''GL_INVALID_OPERATION''' wird generiert wenn ''format'' '''GL_DEPTH_COMPONENT''' ist und kein [[Tiefenpuffer]] existiert. 
'''GL_INVALID_OPERATION''' wird generiert wenn '''glReadPixels''' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.

== Zugehörige Wertrückgaben ==
[[glGet]] mit Token [[glGet#GL_INDEX_MODE|GL_INDEX_MODE]]

== Anwendungs Möglichkeiten ==
Dies ist die Funktion mit welcher [[Screenshot]]s erzeugt werden können. Durch das Auslesen des [[Tiefenpuffer]], können [[Heightmap]]s erstellt werden. Auch erhält man so die nötige Z-Koordinate wenn man mit [[gluUnProject]] die ursprüngliche Koordinate errechnen möchte.
 

== Siehe auch ==
[[glCopyPixels]], [[glDrawPixels]], [[glPixelMap]], [[glPixelStore]], [[glPixelTransfer]], [[glReadBuffer]]

[[Kategorie:GL|ReadPixels]]
[[Kategorie:GL1.0]]