DGL Wiki - Benutzerbeiträge [de]

Doppelpuffer

2005-11-01T17:55:58Z

Slyh:

#REDIRECT [[Doppelpufferung]]

Double buffer

2005-11-01T17:55:45Z

Slyh:

#REDIRECT [[Doppelpufferung]]

Double buffering

2005-11-01T17:55:25Z

Slyh:

#REDIRECT [[Doppelpufferung]]

Team

2005-11-01T17:46:32Z

Slyh: /* Vorwort */

= Vorwort =

Auf dieser Seite befindet sich eine Auflistung der Personen, die momentan aktiv daran arbeiten, dass DGL Euch wie gewohnt im Netz mit Informationen versorgt. Bitte beachtet, dass die meisten der Personen nur einen begrenzten Vorrat an Zeit haben. Überlegt daher bitte sorgsam, an wem Ihr Euch wendet.

= Gruppen =

== DGLSDK ==

== Moderatoren ==

== Webseite ==

== Wiki ==

Doppelpufferung

2005-11-01T17:41:35Z

Slyh: Komplettüberarbeitung

Doppelpufferung (''double buffering'') ist eine Technik, um die Darstellung halbfertiger Bilder während dem Zeichnen zu vermeiden. Sie kommt dann zum Einsatz, wenn ein Bild nicht als Ganzes erzeugt werden kann, sondern erst durch einzelne Zeichenoperationen schrittweise aufgebaut werden muß.

== Technischer Hintergrund ==

Sämtliche Inhalte, die auf dem Monitor zu sehen sein sollen, müssen im Grafikkarten-Speicher abgelegt sein. Der aktuelle Inhalt des Grafikkarten-Speicher wird einstellungsabhängig etwa 80 Mal pro Sekunde von der Grafikkarte neu an den Bildschirm gesendet, der einzig für die Darstellung dieser Informationen zuständig ist. Der Bildschirm-Inhalt wird also etwa alle 12,5ms mit dem aktuellen Inhalt des Grafikkarten-Speichers ersetzt.

Würde man beim schrittweisen Aufbauen eines Bildes durch einzelne Zeichenoperationen die dafür nötigen Änderungen direkt im aktuell dargestellten Grafikkarten-Speicher vornehmen und würde der Aufbau des Bildes länger als diese 12,5ms dauern, würde der Benutzer ein nur teilweise gezeichnetes Bild sehen.

Um dies zu vermeiden, verwendet man Doppelpufferung. Hierbei wird der später darzustellende Bildschirm-Inhalt nicht direkt in den aktuell Grafikkarten-Speicher (''Frontbuffer'') geschrieben, sondern zuerst in einem anderen Speicherbereich der Grafikkarte, der aktuell nicht dargestellt wird, abgelegt (''Backbuffer''). Wurden alle Zeichenoperationen zur Erzeugung des darzustellenden Bildes durchgeführt, wird der Backbuffer mit dem Frontbuffer vertauscht, so daß der Backbuffer zum Frontbuffer wird und dessen Inhalt angezeigt wird. Der Speicherbereich, der zuvor Frontbuffer war, wird jetzt nicht mehr angezeigt und kann als Backbuffer verwendet werden. Ist das nächste Bild fertig gezeichnet, werden die beiden Puffer wieder getaucht.

== Gibt es Nachteile? ==

Der einzige Nachteil von Doppelpufferung ist der doppelt so hohe Speicherbedarf, da immer zwei Bilder im Grafikkartenspeicher gehalten werden müssen: Zum einen das aktuell angezeigte Bild. Zum anderen das Bild, das erst später gezeigt werden soll und das sich möglicherweise noch im Aufbau befindet.

Auf den aktuellen Standardkarten steht jedoch üblicherweise ausreichend viel Speicher zur Verfügung, so daß keinesfalls auf die Vorteile von Doppelpufferung verzichten werden sollte.

Diskussion:Hauptseite

2005-11-01T14:33:49Z

Slyh: /* [Forum]Link zu Wikidiskussion */

== Neuster Artikel report ==

Was würdet ihr davon halten auf der Hauptseite neue (halbwegs lesenswerte) Artikel gleich ganz am Anfang bringen würde vielleicht auch bei den News. Auch ein Box kleine Aufgaben zur Verbesserung des Wikis würde ich auch nicht schlecht finden.

So würde man es erreichen das man, die Hauptseite nicht nur besucht weil man den Linkteil "http://wiki.delphigl.com/index.php/" braucht. Das ist nämlich eigentlich bei mir einer der Hauptgründe warum ich überhaupt noch auf die Hauptseite mal ab und zu schaue. Ansonsten ist http://wiki.delphigl.com/index.php/Spezial:Recentchanges eigentlich immer die bessere Wahl gewesen.

== Leerzeichen statt Bindestriche ==

In Ermangelung einer besseren Diskussionseite, möchte ich hier kurz meinen Senf zu "Leerzeichen vs. Bindestrich" abgeben.

Mir ist beim Besuch des DGL Wiki schon mehrfach (negativ) aufgefallen, daß hier statt der Verwendung des Bindestrichs ein Leerzeichen verwendet wird. Das ist falsch! Aktuellstes Beispiel ist "SDL Funktionen" in der linken Navi. Korrekt wäre "SDL-Funktionen". Auf der Startseite finden sich sehr viele Beispiele. (Manches ist aber auch korrekt mit Bindestrich geschrieben.)

Vielleicht könnten diejenigen, die die Seiten, die nicht durch die Allgemeinheit editierbar sind, etwas besser darauf achten.

Weitere Infos:
* [http://www.spiegel.de/kultur/zwiebelfisch/0,1518,333774,00.html http://www.spiegel.de/kultur/zwiebelfisch/0,1518,333774,00.html] (Leider zwischenzeitlich kostenpflichtig)
* [http://www.spiegel.de/kultur/zwiebelfisch/0,1518,334066,00.html http://www.spiegel.de/kultur/zwiebelfisch/0,1518,334066,00.html] (Beispiele)
* [http://www.deppenleerzeichen.de/ http://www.deppenleerzeichen.de/] (Weitere Beispiele und Infos)

(Gäbe es für solche allgemein Fragen eine bessere Diskussionsseite? Wenn ja, bitte verlinken.)

----
Habe neben der Navigationsleiste noch ein solches Deppen-Leerzeichen gefunden und entfernt. Wenn noch was sein sollte einfach herschreiben.

Die beste Diskussionsplattform ist immer noch unser Forum bei DelphiGL.com. Aber so gehts auch.

--[[Benutzer:Flash (Kevin Fleischer)|Flash (Kevin Fleischer)]] 11:12, 1. Nov 2005 (CET)
----
Für das Board wäre wohl ein eigener Account notwendig. Das möchte ich vermeiden. (Ich habe eh schon so viele.)

Aber wenn die Diskussionsbeitrage hier gelesen werden, ist das ja prima und reicht völlig. :)

--[[Benutzer:Slyh|Slyh]] 11:43, 1. Nov 2005 (CET)
----

== Verwendung von ==

Mir ist aufgefallen, daß in fast allen Artikeln exzessiv von Gebrauch gemacht wird. In anderen Wikis, z.B. Wikipedia, habe ich das so noch nie gesehen. Eigentlich ist es in den allermeisten Fällen auch hier gar nicht notwendig. Oft reicht es, einfach zwei Zeilenumbrüche einzufügen, statt nur einen. Dann wird ein neuer Absatz gestartet.

Oft wird das -Tag hier auch zum stärkeren Absetzen von Überschriften (nach oben) verwendet. Auch hier sollte eigentlich eine weitere Leerzeile im Quelltext reichen. (Siehe Quellcode für die obenstehende Überschrift von "Verwendung von ".)

Da der zusätzliche Abstand aber vor fast jede Überschrift eingefügt wird, wäre es sicherlich auch nicht das Schlechteste, wenn man den größeren Abstand einfach in das zentrale CSS einpflegt. Diese Datei ist nämlich primär für Formatierungszwecke da. sollte IMHO nur in absoluten Notfällen verwendet werden.

Meinungen dazu?

----

@br
>Mir ist aufgefallen, daß in fast allen Artikeln exzessiv von Gebrauch gemacht wird.
Persönliche finde ich einen Brocken von Text schrecklich.
Es müssten dann Zeilenumbrüche eingefügt werden.
Da ein einfaches "Enter" von Wiki leider ignoriert wird und 2 Leerzeilen den Sinn im Quellcode zerreisen, sehe ich da keine Alternative.

>Oft wird das -Tag hier auch zum stärkeren Absetzen von Überschriften (nach oben) verwendet. Auch hier sollte eigentlich eine weitere >Leerzeile im Quelltext reichen. (Siehe Quellcode für die obenstehende Überschrift von "Verwendung von ".)
Könntest du ein Beispiel linken?

>Wenn man den größeren Abstand einfach in das zentrale CSS einpflegt. Diese Datei ist nämlich primär für Formatierungszwecke da. 
Wäre ne Alternative. Leider muss man dann alle Artikel nochmal durchgehen :(.
Du nimmst A-M, ich den Rest? :P

@Account:
Dann gib bitte in deinem 'Profil' Kontaktinformationen oder so an, damit man dich kontaktieren könnte.
Als Beispiel für einen Zweck wäre das Koordinieren von Verbesserungen, was über das Wiki nicht gut geht.
Könntest dich dann auch gleich vorstellen, damit du nicht der geheimnisvolle Helfer bleibst ;)

Oder als Alternative:
Kontaktiere [[Benutzer: Phobeus|Phobeus]], damit er Forum- und Wikiakkount zusammenlegt.
Das wäre die ultimative Lösung.
Das mit dem Akkount muss aber leider so bleiben.
--[[Benutzer:I0n0s|I0n0s]] 12:42, 1. Nov 2005 (CET)

----

@br

''> > Mir ist aufgefallen, daß in fast allen Artikeln exzessiv von Gebrauch gemacht wird.''

''> Persönliche finde ich einen Brocken von Text schrecklich.''

Ja, einfache Zeilenumbrüche werden in Wikimedia ignoriert. Wenn man zwei macht, wird ein neuer Absatz draus. Das ist eigentlich das, was man möchte.

''> Es müssten dann Zeilenumbrüche eingefügt werden.''

Genau.

''> Da ein einfaches "Enter" von Wiki leider ignoriert wird und 2 Leerzeilen den Sinn im Quellcode zerreisen, sehe ich da keine Alternative.''

Du meinst jetzt den Quellcode eines Artikels, richtig?
Normalerweise trennt man bei Fixed-Font-Text die Absätze durch eine Leerzeile. Zumindest in Mails wird das so praktiziert. In Büchern oder (Zeitungs-)Artikel wird zwischen den Absätzen ein kleiner Abstand gelassen. (In den Wiki-Artikeln ja auch.) Im Grunde kommen einfache Umbrüche (ohne neuen Absatz) in Publikationen gar nicht vor.

Ich denke, die Gedanken, die sich die Wiki-Gründer da gemacht haben, sind schon richtig.

''> > Oft wird das -Tag hier auch zum stärkeren Absetzen von Überschriften (nach oben) verwendet. Auch hier sollte eigentlich eine weitere >Leerzeile im Quelltext reichen. (Siehe Quellcode für die obenstehende Überschrift von "Verwendung von ".)''

''> Könntest du ein Beispiel linken?''

Dieser Artikel war das Beispiel. Blöderweise ist das Beispiel beim direkten Editieren wohl rausgeflogen.
Im Grunde müssen im Quelltext dann zwei Leerzeilen stehen. (Dann werden zwei Absätze gemacht. Das ist dann genug Platz.) Aber, wie gesagt, das ist allerhöchstens ein Workaround, wenn du mich fragst.

''> > Wenn man den größeren Abstand einfach in das zentrale CSS einpflegt. Diese Datei ist nämlich primär für Formatierungszwecke da. ''

''> Wäre ne Alternative. Leider muss man dann alle Artikel nochmal durchgehen :(. Du nimmst A-M, ich den Rest? :P''

Kein Problem. ;-)

Nee, kann man ja nach und nach machen. Also, wenn man eh schon an einem Artikel beschäftigt ist, mal die manuellen Zeilenumbrüche entfernen. Wenn dann (fast) alle Artikel korrigiert sind, kann man bei Bedarf ja dann das Style-Sheet ändern.

Aber, wie gesagt, nur so ein Gedanke.

''> @Account: Dann gib bitte in deinem 'Profil' Kontaktinformationen oder so an, damit man dich kontaktieren könnte. Als Beispiel für einen Zweck wäre das Koordinieren von Verbesserungen, was über das Wiki nicht gut geht. Könntest dich dann auch gleich vorstellen, damit du nicht der geheimnisvolle Helfer bleibst ;)''

Ja, das Diskutieren im Wiki ist wirklich nicht das Wahre... :)

Aber eigentlich will ich gar nicht so übermäßig viel Einfluss auf das DGL Wiki nehmen oder groß diskutieren.

Naja, ich habe jetzt mal eine eMail-Adresse in mein Profil eingetragen, wo ich kontaktiert werden kann, falls Bedarf besteht. Ansonsten werde ich mir mal einen Board-Account holen, falls, wie gesagt, Diskussionbedarf besteht. Gibt's zu allgemeinen Wiki-Diskussionen schon einen Thread?

--[[Benutzer:Slyh|Slyh]] 14:25, 1. Nov 2005 (CET)
----

== [Forum]Link zu Wikidiskussion ==

[http://www.delphigl.com/forum/viewforum.php?f=21 Hier] ist das Forum für Community Projekte.
Du kannst übrigens auch als Gast posten.
Solltest nur deinen Namen dann jedesmal eintragen damit wir wissen wer es war.

Bist du übrigens sicher, dass du deine Email-Adresse als Klartext da stehen lassen willst?
Eingefügt in ein Bild wäre von wegen Spam vermutlich sicherer.

--[[Benutzer:I0n0s|I0n0s]] 15:09, 1. Nov 2005 (CET)

Ah, danke!

(Diese eine eMail-Adresse findet Google 334 mal. Ich mache mir da keine Sorgen. :-))

--[[Benutzer:Slyh|Slyh]] 15:33, 1. Nov 2005 (CET)

glRasterPos

2005-11-01T14:31:05Z

Slyh: /* Beschreibung */

= glRasterPos =

== Name ==
'''glRasterPos''' - Legt die Rasterposition für Pixel-Operationen fest.

== Delphi-Spezifikation ==

procedure glRasterPos2d (x: TGLdouble; y: TGLdouble);
procedure glRasterPos2f (x: TGLfloat; y: TGLfloat);
procedure glRasterPos2i (x: TGLint; y: TGLint);
procedure glRasterPos2s (x: TGLshort; y: TGLshort);
procedure glRasterPos3d (x: TGLdouble; y: TGLdouble; z: TGLdouble);
procedure glRasterPos3f (x: TGLfloat; y: TGLfloat; z: TGLfloat);
procedure glRasterPos3i (x: TGLint; y: TGLint; z: TGLint);
procedure glRasterPos3s (x: TGLshort; y: TGLshort; z: TGLshort);
procedure glRasterPos4d (x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble);
procedure glRasterPos4f (x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat);
procedure glRasterPos4i (x: TGLint; y: TGLint; z: TGLint; w: TGLint);
procedure glRasterPos4s (x: TGLshort; y: TGLshort; z: TGLshort; w: TGLshort);

== Parameter ==

{| border="1" rules="all"
! ''x''
| X-Wert der neuen Rasterposition
|-
! ''y''
| Y-Wert der neuen Rasterposition
|-
! ''z''
| Z-Wert der neuen Rasterposition; Standardwert ist 0.
|-
! ''w''
| W-Wert der neuen Rasterposition; Standardwert ist 1.
|}

== Delphi-Spezifikation ==

procedure glRasterPos2dv(const v: PGLdouble);
procedure glRasterPos2fv(const v: PGLfloat);
procedure glRasterPos2iv(const v: PGLint);
procedure glRasterPos2sv(const v: PGLshort);
procedure glRasterPos3dv(const v: PGLdouble);
procedure glRasterPos3fv(const v: PGLfloat);
procedure glRasterPos3iv(const v: PGLint);
procedure glRasterPos3sv(const v: PGLshort);
procedure glRasterPos4dv(const v: PGLdouble);
procedure glRasterPos4fv(const v: PGLfloat);
procedure glRasterPos4iv(const v: PGLint);
procedure glRasterPos4sv(const v: PGLshort);

== Parameter ==

{| border="1" rules="all"
! ''v''
| Ein Zeiger auf 2,3 oder 4 Elemente je nach Funktions Typ
|}

== Beschreibung ==

Die GL speichert eine 3D-Position in Fenstekoordinaten ab. Diese Position wird ''Rasterposition'' genannt. Sie wird zur Positionierung von Pixel- und Bitmap-Schreibvorgängen genutzt. Diese werden mit absoluter Pixel-Genauigkeit durchgeführt. Siehe [[glBitmap]], [[glDrawPixels]], und [[glCopyPixels]].

Die aktuelle Rasterposition besteht aus den drei Fensterkoordinaten (''X'', ''Y'', ''Z''), der Clip-Koordinate ''W'', den Auge-Koordinaten Abstand, einem Gültigkeits-Bit, sowie zugewieser Farbwerte und [[glTexCoord|Texturkoordinaten]]. Die ''W''-Koordinate ist eine Clip-Koordinate, da sie nicht erst in Fensterkoordinaten umgerechnet wird. Falls ein Funktionsaufruf ''Z'' oder ''W'' nicht beinhaltet, werden diese auf ihre Standardwerte(''Z''=0; ''W''=1) gesetzt.

Die an '''glRasterPos''' übergebe Position wird so behandelt, als ob sie ein von [[glVertex]] erzeugter Punkt ist. Das heißt, daß auf sie die Projektions- und Model-View-[[Matrix]] angewandt und zurechtgeschnitten(en :"passed
to the clipping stage") wird. Falls der resultierende Punkt nicht weggeschnitten wurde, wird der Punkt auf die Fenstergröße angepasst, als neue Rasterposition übernommen und das Gültigkeits-Flag '''GL_CURRENT_RASTER_POSITION_VALID''' gesetzt. Falls der Punkt weggeschnitten würde, wird das Flag geleert und die aktuelle Rasterposition inklusive Farbe und Texturkoordinaten ist undefiniert.

Die aktuelle Rasterposition erhält ebenso einen Farbwert und Texturkoordinaten. Falls die [[Beleuchtung]] aktiviert wurde, wird '''GL_CURRENT_RASTER_COLOR''' (im RGBA-Farbmodus) oder '''GL_CURRENT_RASTER_INDEX''' (im Farb-Index-Modus) auf die Farbe gesetz, die durch die Lichtberechnungen ermittelt wird. (Siehe [[glLight]],
[[glLightModel]] und [[glShadeModel]].)

Ist die Beleuchtung deaktivert, so wird die aktuelle Farbe (im RGBA-Farbmodus die Statusvariable '''GL_CURRENT_COLOR''') oder der Farben-Index (im Farben-Index-Modus die Statusvariable '''GL_CURRENT_INDEX''') genutzt, um die neue Raster-Farbe zu bestimmen.

'''GL_CURRENT_RASTER_TEXTURE_COORDS''' wird so wie eine Funktion von '''GL_CURRENT_TEXTURE_COORDS''', basierend auf der Texturmatrix und den Textur-Generationsfunktionen aktualisiert.
Letztendlich ersetzt die Distanz zwischen Ursprung der Betrachterkoordinaten und dem durch die Model-View-Matrix transformierten Eckpunktes die '''GL_CURRENT_RASTER_DISTANCE'''.

Die '''Initialwerte''' der aktuellen Rasterposition sind (''X'':0; ''Y'':0; ''Z'':0; ''W'':1), der Abstand ist 0, die Farbe ist weiß (1, 1, 1, 1), der Farb-Index ist 1 und die Textur Koordinaten sind (0, 0, 0, 1). Das Gültigkeits-Flag ist gesetzt.

Im RGBA-Farbmodus ist '''GL_CURRENT_RASTER_INDEX''' immer 1, im Farben-Index-Modus hingegen enthält die RGBA-Farbe ihren Startwert.

== Hinweise ==

Die aktuelle Rasterposition kann nicht nur durch '''glRasterPos''' gesetzt, sondern auch durch [[glBitmap]] verschoben werden.

Wenn das Flag '''GL_CURRENT_RASTER_POSITION_VALID''' nicht gesetzt ist, also die aktuelle Rasterposition ungültig ist, werden sämtliche Zeichenbefehle ignoriert, die eine Rasterposition benötigen.

Ein Aufruf von [[glDrawElements]] hinterläßt eventuell eine nicht bestimmte Farbe bzw. Index. Wird '''glRasterPos''' aufgerufen, während die aktuelle Farbe bzw. der Index unbestimmt sind, so ist die aktuelle Rasterfarbe bzw. der Rasterindex undefiniert.

Durch einen Aufruf von [[glBitmap]] (mit dem Bild Parameter '''nil''') ist es möglich, die Rasterposition auch außerhalb des sichtbaren Bereichs zu positionieren.

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

== Zugehörige Wertrückgaben ==

[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_POSITION|GL_CURRENT_RASTER_POSITION]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_POSITION_VALID|GL_CURRENT_RASTER_POSITION_VALID]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_DISTANCE|GL_CURRENT_RASTER_DISTANCE]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_COLOR|GL_CURRENT_RASTER_COLOR]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_INDEX|GL_CURRENT_RASTER_INDEX]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_TEXTURE_COORDS|GL_CURRENT_RASTER_TEXTURE_COORDS]] 

== Siehe auch ==
[[glBitmap]], [[glCopyPixels]], [[glDrawElements]], [[glDrawPixels]], [[glWindowPos]], [[glLight]], [[glLightModel]], [[glShadeModel]], [[glTexCoord]], [[glTexGen]], [[glVertex]]

[[Kategorie:GL|RasterPos]]

Diskussion:glRasterPos

2005-11-01T14:30:14Z

Slyh:

Der Artikel ist IMHO hochgradig unverständlich.

* Was soll ''W'' genau sein? 
* Was meint Auge-Koordinaten Abstand? 
* Was meint Gültigkeits-Bit? 
* Was macht der Satz "passed to the clipping stage" da drin?

Vielleicht kann den Artikel jemand, der von dem Thema mehr versteht als ich, mal ein paar Dinge klarer darstellen.

--[[Benutzer:Slyh|Slyh]] 15:30, 1. Nov 2005 (CET)

glRasterPos

2005-11-01T14:26:45Z

Slyh: Stil-, Schreib- und Kommafehler korrigiert, sofern möglich. (Ich konnte nicht alles verstehen.)

= glRasterPos =

== Name ==
'''glRasterPos''' - Legt die Rasterposition für Pixel-Operationen fest.

== Delphi-Spezifikation ==

procedure glRasterPos2d (x: TGLdouble; y: TGLdouble);
procedure glRasterPos2f (x: TGLfloat; y: TGLfloat);
procedure glRasterPos2i (x: TGLint; y: TGLint);
procedure glRasterPos2s (x: TGLshort; y: TGLshort);
procedure glRasterPos3d (x: TGLdouble; y: TGLdouble; z: TGLdouble);
procedure glRasterPos3f (x: TGLfloat; y: TGLfloat; z: TGLfloat);
procedure glRasterPos3i (x: TGLint; y: TGLint; z: TGLint);
procedure glRasterPos3s (x: TGLshort; y: TGLshort; z: TGLshort);
procedure glRasterPos4d (x: TGLdouble; y: TGLdouble; z: TGLdouble; w: TGLdouble);
procedure glRasterPos4f (x: TGLfloat; y: TGLfloat; z: TGLfloat; w: TGLfloat);
procedure glRasterPos4i (x: TGLint; y: TGLint; z: TGLint; w: TGLint);
procedure glRasterPos4s (x: TGLshort; y: TGLshort; z: TGLshort; w: TGLshort);

== Parameter ==

{| border="1" rules="all"
! ''x''
| X-Wert der neuen Rasterposition
|-
! ''y''
| Y-Wert der neuen Rasterposition
|-
! ''z''
| Z-Wert der neuen Rasterposition; Standardwert ist 0.
|-
! ''w''
| W-Wert der neuen Rasterposition; Standardwert ist 1.
|}

== Delphi-Spezifikation ==

procedure glRasterPos2dv(const v: PGLdouble);
procedure glRasterPos2fv(const v: PGLfloat);
procedure glRasterPos2iv(const v: PGLint);
procedure glRasterPos2sv(const v: PGLshort);
procedure glRasterPos3dv(const v: PGLdouble);
procedure glRasterPos3fv(const v: PGLfloat);
procedure glRasterPos3iv(const v: PGLint);
procedure glRasterPos3sv(const v: PGLshort);
procedure glRasterPos4dv(const v: PGLdouble);
procedure glRasterPos4fv(const v: PGLfloat);
procedure glRasterPos4iv(const v: PGLint);
procedure glRasterPos4sv(const v: PGLshort);

== Parameter ==

{| border="1" rules="all"
! ''v''
| Ein Zeiger auf 2,3 oder 4 Elemente je nach Funktions Typ
|}

== Beschreibung ==

Die GL speichert eine 3D-Position in Fenstekoordinaten ab. Diese Position wird ''Rasterposition'' genannt. Sie wird zur Positionierung von Pixel- und Bitmap-Schreibvorgängen genutzt. Diese werden mit absoluter Pixel-Genauigkeit durchgeführt. Siehe [[glBitmap]], [[glDrawPixels]], und [[glCopyPixels]].

Die aktuelle Rasterposition besteht aus den drei Fensterkoordinaten (''X'', ''Y'', ''Z''), der Clip-Koordinate ''W'', den Auge-Koordinaten Abstand, einem Gültigkeits-Bit, sowie zugewieser Farbwerte und [[glTexCoord|Texturkoordinaten]]. Die ''W''-Koordinate ist eine Clip-Koordinate, da sie nicht erst in Fensterkoordinaten umgerechnet wird. Falls ein Funktionsaufruf ''Z'' oder ''W'' nicht beinhaltet, werden diese auf ihre Standardwerte(''Z''=0; ''W''=1) gesetzt.

Die an '''glRasterPos''' übergebe Position wird so behandelt, als ob sie ein von [[glVertex]] erzeugter Punkt ist. Das heißt, daß auf sie die Projektions- und Modelview-[[Matrix]] angewandt und zurechtgeschnitten(en :"passed
to the clipping stage") wird. Falls der resultierende Punkt nicht weggeschnitten wurde, wird der Punkt auf die Fenstergröße angepasst, als neue Rasterposition übernommen und das Gültigkeits-Flag '''GL_CURRENT_RASTER_POSITION_VALID''' gesetzt. Falls der Punkt weggeschnitten würde, wird das Flag geleert und die aktuelle Rasterposition inklusive Farbe und Texturkoordinaten ist undefiniert.

Die aktuelle Rasterposition erhält ebenso einen Farbwert und Texturkoordinaten. Falls die [[Beleuchtung]] aktiviert wurde, wird '''GL_CURRENT_RASTER_COLOR''' (im RGBA-Farbmodus) oder '''GL_CURRENT_RASTER_INDEX''' (im Farb-Index-Modus) auf die Farbe gesetz, die durch die Lichtberechnungen ermittelt wird. (Siehe [[glLight]],
[[glLightModel]] und [[glShadeModel]].)

Ist die Beleuchtung deaktivert, so wird die aktuelle Farbe (im RGBA-Farbmodus die Statusvariable '''GL_CURRENT_COLOR''') oder der Farben-Index (im Farben-Index-Modus die Statusvariable '''GL_CURRENT_INDEX''') genutzt, um die neue Raster-Farbe zu bestimmen.

'''GL_CURRENT_RASTER_TEXTURE_COORDS''' wird so wie eine Funktion von '''GL_CURRENT_TEXTURE_COORDS''', basierend auf der Texturmatrix und den Textur-Generationsfunktionen aktualisiert.
Letztendlich ersetzt die Distanz zwischen Ursprung der Betrachterkoordinaten und dem durch die Model-View-Matrix transformierten Eckpunktes die '''GL_CURRENT_RASTER_DISTANCE'''.

Die '''Initialwerte''' der aktuellen Rasterposition sind (''X'':0; ''Y'':0; ''Z'':0; ''W'':1), der Abstand ist 0, die Farbe ist weiß (1, 1, 1, 1), der Farb-Index ist 1 und die Textur Koordinaten sind (0, 0, 0, 1). Das Gültigkeits-Flag ist gesetzt.

Im RGBA-Farbmodus ist '''GL_CURRENT_RASTER_INDEX''' immer 1, im Farben-Index-Modus hingegen enthält die RGBA-Farbe ihren Startwert.

== Hinweise ==

Die aktuelle Rasterposition kann nicht nur durch '''glRasterPos''' gesetzt, sondern auch durch [[glBitmap]] verschoben werden.

Wenn das Flag '''GL_CURRENT_RASTER_POSITION_VALID''' nicht gesetzt ist, also die aktuelle Rasterposition ungültig ist, werden sämtliche Zeichenbefehle ignoriert, die eine Rasterposition benötigen.

Ein Aufruf von [[glDrawElements]] hinterläßt eventuell eine nicht bestimmte Farbe bzw. Index. Wird '''glRasterPos''' aufgerufen, während die aktuelle Farbe bzw. der Index unbestimmt sind, so ist die aktuelle Rasterfarbe bzw. der Rasterindex undefiniert.

Durch einen Aufruf von [[glBitmap]] (mit dem Bild Parameter '''nil''') ist es möglich, die Rasterposition auch außerhalb des sichtbaren Bereichs zu positionieren.

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

== Zugehörige Wertrückgaben ==

[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_POSITION|GL_CURRENT_RASTER_POSITION]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_POSITION_VALID|GL_CURRENT_RASTER_POSITION_VALID]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_DISTANCE|GL_CURRENT_RASTER_DISTANCE]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_COLOR|GL_CURRENT_RASTER_COLOR]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_INDEX|GL_CURRENT_RASTER_INDEX]] 
[[glGet]] mit Token [[glGet#GL_CURRENT_RASTER_TEXTURE_COORDS|GL_CURRENT_RASTER_TEXTURE_COORDS]] 

== Siehe auch ==
[[glBitmap]], [[glCopyPixels]], [[glDrawElements]], [[glDrawPixels]], [[glWindowPos]], [[glLight]], [[glLightModel]], [[glShadeModel]], [[glTexCoord]], [[glTexGen]], [[glVertex]]

[[Kategorie:GL|RasterPos]]

Diskussion:Hauptseite

2005-11-01T13:25:47Z

Slyh:

Benutzer:Slyh

2005-11-01T13:14:30Z

Slyh:

Erreichbar bin ich u.a. unter [mailto:slyh@gmx.de]

Diskussion:Hauptseite

2005-11-01T10:43:47Z

Slyh: /* Leerzeichen statt Bindestriche */

Diskussion:Hauptseite

2005-11-01T10:05:10Z

Slyh:

glEnableClientState

2005-11-01T09:49:43Z

Slyh: Kommafehler und Typos

=glEnableClientState, glDisableClientState=

 
== Name ==
'''glEnableClientState''' und '''glDisableClientState''' aktivieren und deaktivieren Klientseitige Eigenschaften.

 

== Delphi-Spezifikation ==

'''procedure''' glEnableClientState(''cap'': TGLenum);
'''procedure''' glDisableClientState(''cap'': TGLenum);

 

==Parameter==
{| border=1 rules=all

! ''cap''
| Bestimmt, welche Eigenschaft aktiviert/deaktiviert werden soll. Mögliche Parameter sind: 
'''GL_COLOR_ARRAY, GL_EDGE_FLAG_ARRAY, GL_INDEX_ARRAY, GL_NORMAL_ARRAY, GL_TEXTURE_COORD_ARRAY,''' und '''GL_VERTEX_ARRAY'''
|}

 

== Beschreibung ==

'''glEnableClientState''' und '''glDisableClientState''' aktiviert oder deaktiviert clientseitig Ressourcen. Standardmäßig sind alle clientseitigen Resourcen deaktiviert. Der Parameter ''cap'' legt fest, welche Ressource durch den Aufruf von '''glEnableClientState''' aktiviert beziehungsweise durch '''glDisableClientState''' deaktivert werden soll.

Folgende Werte kann ''cap'' annehmen:

{| {{Prettytable}}
!GL_COLOR_ARRAY
|Wenn aktiviert, wird der Schreibzugriff des Farb-Arrays aktiviert und für die Aufrufe von [[glDrawArrays]] und [[glDrawElements]] benutzt. (Siehe [[glColorPointer]].)
|-
!GL_EDGE_FLAG_ARRAY
|Wenn aktiviert, wird der Schreibzugriff des EdgeFlag-Arrays aktiviert und für die Aufrufe von [[glDrawArrays]] und [[glDrawElements]] benutzt. (Siehe [[glEdgeFlagPointer]].)
|-
!GL_INDEX_ARRAY
|Wenn aktiviert, wird der Schreibzugriff des Index-Arrays aktiviert und für die Aufrufe von [[glDrawArrays]] und [[glDrawElements]] benutzt. (Siehe [[glIndexPointer]].)
|-
!GL_NORMAL_ARRAY
|Wenn aktiviert, wird der Schreibzugriff des Normalen-Arrays aktiviert und für die Aufrufe von [[glDrawArrays]] und [[glDrawElements]] benutzt. (Siehe [[glNormalPointer]].)
|-
!GL_TEXTURE_COORD_ARRAY
|Wenn aktiviert, wird der Schreibzugriff des Texturkoordinaten-Arrays aktiviert und für die Aufrufe von [[glDrawArrays]] und [[glDrawElements]] benutzt. (Siehe [[glTexCoordPointer]].)
|-
!GL_VERTEX_ARRAY
|Wenn aktiviert, wird der Schreibzugriff des Vertex-Arrays aktiviert und für die Aufrufe von [[glDrawArrays]] und [[glDrawElements]] benutzt. (Siehe [[glVertexPointer]].)
|-
|}

Momentan sind alle clientseitigen Eigenschaften Vertex-Arrays oder Array mit Vertexeigenschaften, welche von den Funktionen [[glDrawArrays]], [[glArrayElement]] und [[glDrawElements]] genutzt werden.

== Hinweise ==
Erst ab der OpenGL '''Version 1.1''' verfügbar.

 
== Fehlermeldungen ==
'''GL_INVALID_ENUM''' wird generiert, wenn für ''cap'' ein ungültiger Wert übergeben wurde.

'''glEnableClientState''' darf nicht innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen werden. Laut den [http://developer.3dlabs.com/glmanpage_index.htm GL Man Pages] ist nicht sichergestellt, dass bei einem Aufruf ein Fehler (normalerweise '''GL_INVALID_OPERATION''') generiert wird. Sollte kein Fehler generiert werden, ist das Verhalten undefiniert.

 

== Zugehörige Wertrückgaben ==
Die aktuellen Werte können mit [[glGet]] oder [[glIsEnabled]] ermittelt werden.

==Siehe auch==
[[glArrayElement]], [[glDrawElements]], [[glDrawArrays]], [[glVertexPointer]], [[glColorPointer]], [[glIndexPointer]], [[glEdgeFlagPointer]], [[glNormalPointer]] und [[glTexCoordPointer]]

[[Kategorie:GL|EnableClientState]]

glColor

2005-11-01T09:36:15Z

Slyh: Kommafehler

= glColor=

 
== Name ==
'''glColor''' - Setzt die aktuelle Farbe.

 
== Delphi-Spezifikationen ==
procedure '''glColor3b''' (red, green, blue: GLbyte);
procedure '''glColor3d''' (red, green, blue: GLdouble);
procedure '''glColor3f''' (red, green, blue: GLfloat);
procedure '''glColor3i''' (red, green, blue: GLint);
procedure '''glColor3s''' (red, green, blue: GLshort);
procedure '''glColor3ub''' (red, green, blue: GLubyte);
procedure '''glColor3ui''' (red, green, blue: GLuint);
procedure '''glColor3us''' (red, green, blue: GLushort);
procedure '''glColor4b''' (red, green, blue, alpha: GLbyte);
procedure '''glColor4d''' (red, green, blue, alpha: GLdouble);
procedure '''glColor4f''' (red, green, blue, alpha: GLfloat);
procedure '''glColor4i''' (red, green, blue, alpha: GLint);
procedure '''glColor4s''' (red, green, blue, alpha: GLshort);
procedure '''glColor4ub''' (red, green, blue, alpha: GLubyte);
procedure '''glColor4ui''' (red, green, blue, alpha: GLuint);
procedure '''glColor4us''' (red, green, blue, alpha: GLushort);

procedure '''glColor3bv''' (v: PGLByte);
procedure '''glColor3dv''' (v: PGLdouble);
procedure '''glColor3fv''' (v: PGLfloat);
procedure '''glColor3iv''' (v: PGLint);
procedure '''glColor3sv''' (v: PGLshort);
procedure '''glColor3ubv''' (v: PGLubyte);
procedure '''glColor3uiv''' (v: PGLuint);
procedure '''glColor3usv''' (v: PGLushort);
procedure '''glColor4bv''' (v: PGLbyte);
procedure '''glColor4dv''' (v: PGLdouble);
procedure '''glColor4fv''' (v: PGLfloat);
procedure '''glColor4iv''' (v: PGLint);
procedure '''glColor4sv''' (v: PGLshort);
procedure '''glColor4ubv''' (v: PGLubyte);
procedure '''glColor4uiv''' (v: PGLuint);
procedure '''glColor4usv''' (v: PGLushort);

 
== Parameter ==

Für alle '''glColor'''-Befehle, die direkt Werte annehmen (ohne ''v'') :

{| border="1" rules="all"
! ''red, green, blue''
| Setzt den neuen Rot-, Grün- und Blauwert für die aktuelle Farbe.
|-
! ''alpha''
| Setzt den neuen Alphawert für die aktuelle Farbe. Nur bei '''glColor4'''-Befehlen.
|}

Für alle '''glColor'''-Befehle, die einen Zeiger auf Werte bekommen (mit ''v'') :

{| border="1" rules="all"
! ''v''
| Zeiger auf eine Reihe von Werten, in denen nacheinander Rot-, Grün-, Blau- und (ggf.) der Alpha-Anteil der neuen Farbe abgelegt sind.
|}

 
== Beschreibung ==
Die GL speichert sowohl den aktuellen Einzelwert-Index und die aktuellen Vierwert-RGBA-Farbe. '''glColor''' setzt eine neue RGBA-Farbe, und kommt in zwei grundlegenden Varianten : '''glColor3f''' und '''glColor4f'''. Erstere gibt Rot-, Grün- und Blauanteil der neuen Farbe explizit an, während der Alphawert auf 1 gesetzt wird (volle Intensität). Bei der zweiten Variante hingegen werden alle vier Komponenten direkt angegeben.

[[glColor3b]], [[glColor4b]], [[glColor3s]], [[glColor4s]], [[glColor3i]] und [[glColor4i]] bekommen drei bzw. vier vorzeichenbehaftete Bytes, kurze- oder lange Integerwerte als Argumente. Wenn am Namen der Funktion ein ''v'' hängt, bekommen die Befehle ihre Argumente als einen Zeiger auf die Farbkomponenten.

Die aktuellen Farbwerte werden im Fließkommaformat abgelegt, ohne spezifizierte Mantissen- und Exponentengröße. Vorzeichenlose Integerfarbwerte (falls angegeben) werden linear auf das Fließkommaintervall [-1,0] abgebildet. Vorzeichenbehaftete Integerwerte werden linear auf das Fließkommaintervall [-1,1] abgebildet.

Weder Fließkomma, noch vorzeichenbehaftete werden auf den Interval [0,1] beschränkt, bevor die aktuelle Farbe aktualisiert wird. Farbwerte werden jedoch auf dieses Intervall beschränkt, bevor diese in den Farbpuffer geschrieben werden.

 

== Hinweise ==
Der Vorgabewert für die aktuelle Farbe ist (1, 1, 1, 1).

Die aktuelle Farbe kann zu jeder Zeit geändert werden, auch in einem [[glBegin]]-[[glEnd]] Block.

 

== Zugehörige Wertrückgaben ==
[[glGet]] mit dem Argument '''GL_CURRENT_COLOR'''. 
[[glGet]] mit dem Argument '''GL_RGBA_MODE'''.

 
== Siehe auch ==
[[glIndex]]

[[Kategorie:GL|Color]]

Diskussion:Hauptseite

2005-11-01T09:31:57Z

Slyh:

SDL WM SetIcon

2005-10-27T21:35:27Z

Slyh:

= SDL_WM_SetIcon=

 
== Name ==
'''SDL_WM_SetIcon''' - Setzt das Icon für das Displayfenster.

 
== Delphi-Spezifikation ==
procedure '''SDL_WM_SetIcon'''(''icon'' : PSDL_Surface; ''mask'' : Uint8)

 

== Parameter ==

{| border="1" rules="all"
! ''icon''
| Eine [[SDL_Surface]], die das Icon enthält.
|-
! ''mask''
| Ein Pointer, der auf ein Bild zeigt, das die Alphakanal-Informationen enthält.
|}

 

== Beschreibung ==
Setzt das Icon für das Displayfenster. 

Durch die Angabe der Maske (''mask'') läßt sich die Form des Icons bestimmen, indem - abhängig von den Maskenwerten - einzelne Pixel des Icons nicht dargestellt werden, so daß an der Stelle der nicht-gezeichneten Pixel der Untergrund durchscheint. Dadurch läßt sich ein einfacher Transparenzeffekt erzielen.

Die Maske muß im MSB-Format vorliegen. Jedes Byte in der Maske steht hierin für die Transparenz-Information von 8 Pixeln im Icon. Für jede Zeile im Icon sind somit ''(Iconbreite in Pixel / 8 Bit)'' Bytes notwendig. Ist diese Zahl keine ganze Zahl, wird aufgerundet. Das 1. Bit im 1. Byte der Zeile repräsentiert die Transparenz des 1. Pixel der zugehörigen Icon-Zeile. Das 2. Bit des 1. Bytes repräsentiert das 2. Pixel der Icon-Zeile, und so weiter. Die Bits des 2. Bytes repräsentieren die Pixel 9-16 der Zeile; das 3. Byte die Pixel 17-24. Bei einer Icon-Breite von 32 Pixeln wären somit 32/8 = 4 Bytes für jede Icon-Zeile notwendig. 
Ein Bit-Wert von '1' bedeutet, daß das zugehörige Pixel des Icons dargestellt wird. Analog dazu bedeutet ein Bit-Wert von '0', daß das zugehörige Pixel nicht dargestellt wird, der Hintergrund an dieser Stelle also zu sehen ist. 

Wird die Maske nicht angegeben (''nil''), wird der Alphakanal des Bildes verwendet, sofern ein solcher vorhanden ist. Enthält ''icon'' eine Oberfläche mit ColorKey-Information ([[SDL_SetColorKey]]), wird die festgelegte transparente Farbe zur Transparenzdarstellung verwendet. Die einzelnen Verfahren lassen sich kombinieren. 
Enthält das Bild weder Alphakanal noch ColorKey-Informationen und wird zudem keine Maske angegeben, wird das übergebene Icon ohne Transparenz, also als vollständig undurchsichtiges Rechteck angezeigt.

Bei Windows muss das Icon eine Größe von 32*32 Pixel besitzen.

 
== Hinweise ==
Die Procedure muss vor [[SDL_SetVideoMode]] aufgerufen werden.
 
''Der Sinn bzw. die Funktion der Maske ist nicht klar. Einige Dokumentationen geben unterschiedliche Hinweise.''
''Sicherer ist es mit dem Colorkey (siehe Beispiel).''

== Beispiel ==
<pascal>//einfaches Beispiel
SDL_WM_SetIcon(SDL_LoadBMP('icon.bmp'), 0);</pascal>
 
<pascal>//weiteres Beispiel mit Setzen des Farbschlüssels (hier lila)
var colorkey: Uint32;
image: PSDL_Surface;
begin
image:=SDL_LoadBMP('icon.bmp');

colorkey:=SDL_MapRGB(image.format, 255, 0, 255);

SDL_SetColorKey(image, SDL_SRCCOLORKEY, colorkey);

SDL_WM_SetIcon(image,0);
end;</pascal>

 

== Siehe auch ==
[[SDL_SetVideoMode]], [[SDL_WM_SetCaption]]

[[Kategorie:SDL|WM_SetIcon]]

glLoadMatrix

2005-10-27T20:15:55Z

Slyh: Typo, Kommas, Satzbau

= glLoadMatrix =

 
== Name ==
'''glLoadMatrix''' - ersetzt die aktuelle Matrix durch eine beliebige Matrix.

 

== Delphi-Spezifikation ==
'''procedure''' glLoadMatrixd('''const''' ''m'': PGLdouble); 
'''procedure''' glLoadMatrixf('''const''' ''m'': PGLfloat);

 
== Parameter ==
<table border=1 rules=all>
<tr>
<td>''m''</td>
<td>Ein Zeiger auf eine 4x4-Matrix, welche die aktuelle Matrix ersetzen soll.</td>
</tr>
</table>

 
== Beschreibung ==
'''glLoadMatrix''' ersetzt die aktuelle Matrix durch die 4x4-Matrix, auf die ''m'' zeigt. Abhängig vom aktuellen Matrix-Modus ([[glMatrixMode]]) wird dadurch die [[Projektions-Matrix]], die [[Modelview-Matrix]] oder die [[Texture-Matrix]] ersetzt. 
Der Parameter ''m'' zeigt auf eine 4x4-Matrix welche spaltenweise Fließkommazahlen mit einfacher oder doppelter Genauigkeit (Single oder Double) enthält. 

Die Matrix muß also in der folgenden Reihenfolge gespeichert sein: 

+- -+
| 0 4 8 12 |
| 1 5 9 13 |
| 2 6 10 14 |
| 3 7 11 15 |
+- -+

===Beispiel-Quelltext===
Als Ersatz für [[glPushMatrix]] / [[glPopMatrix]]:
{| border="0"
|
type
TVektor = record
X,Y,Z,W : glFloat
end;
TMatrix = array[(mat_XAchse,mat_YAchse,mat_ZAchse,mat_Position)] of TVektor; 
var
TempMatrix:TMatrix;
begin
glClearColor(0,0,0,0);
glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
glLoadIdentity; 
glTranslatef(-0.8,-0.5,0); //Vorgebene Startposition
glGetFloatv(GL_MODELVIEW_MATRIX,@TempMatrix); //Matrix wird gespeichert 
{Rotes Dreieck}
glColor3f(1,0,0);
gltranslatef(1,0,0);
glbegin(GL_TRIANGLES);
glvertex3f(1,0 ,-2);
glvertex3f(0,1 ,-2);
glvertex3f(0,0 ,-2);
glend;
glLoadMatrixf(@TempMatrix); //Gespeicherte Matrix wird wieder geladen 
{Grünes Dreieck}
glColor3f(0,1,0);
glbegin(GL_TRIANGLES);
glvertex3f(1,0 ,-2);
glvertex3f(0,1 ,-2);
glvertex3f(0,0 ,-2);
glend;
end;
|}

 

== Fehlermeldungen ==
GL_INVALID_OPERATION wird generiert, wenn ''glLoadMatrix'' innerhalb eines [[glBegin]]-[[glEnd]] Blocks aufgerufen wird.
 
== Zugehörige Wertrückgaben ==
[[glGet]] mit Token GL_MATRIX_MODE 
[[glGet]] mit Token GL_MODELVIEW_MATRIX 
[[glGet]] mit Token GL_PROJECTION_MATRIX 
[[glGet]] mit Token GL_TEXTURE_MATRIX 

 
== Siehe auch ==
[[glLoadIdentity]], [[glMatrixMode]], [[glMultMatrix]], [[glPushMatrix]]

[[Kategorie:GL|LoadMatrix]]

gluOrtho2D

2005-10-27T20:13:32Z

Slyh: Typo

= gluOrtho2D =

 
== Name ==
'''gluOrtho2D''' - Definiert eine zweidimensionale orthogonale Projektionsmatrix.

 
== Delphi-Spezifikation ==
procedure '''gluOrtho2D'''(left, right, bottom, top: TGLdouble);

 
== Paramter ==
<table border=1 rules=all>
<tr>
<td>left,right</td>
<td>Gibt die Koordinaten für die linke und rechte Clipping-Flächen an.</td>
</tr>
<tr>
<td>bottom,top</td>
<td>Gibt die Koordinaten für die untere und obere Clipping-Flächen an.</td>
</tr>
</table>

 
== Beschreibung ==
'''gluOrtho2D''' generiert eine zweidimensionale orthogonale Projektion. Diese entspricht einem Aufruf von [[glOrtho]] mit near=-1 und far=1.

 
== Siehe Auch ==
[[glOrtho]], [[gluPerspective]]

[[Kategorie:GLU|Ortho2D]]

SDL ThreadID

2005-10-27T19:57:59Z

Slyh: /* Name */

= SDL_ThreadID =

 
== Name ==
'''SDL_ThreadID''' - Gibt die ID des aktuellen Threads zurück.

 

== Delphi-Spezifikation ==
function '''SDL_ThreadID''': UInt32;

 

== Beschreibung ==
Gibt die ID des aktuellen Threads zurück.

 

== Siehe auch ==
[[SDL_CreateThread]], [[SDL_GetThreadID]]

[[Kategorie:SDL|ThreadID]]

SDL VideoModeOK

2005-10-27T19:56:20Z

Slyh: Kommafehler beseitigt und Beschreibung minimal detailliert.

= SDL_VideoModeOK =

 
== Name ==
'''SDL_VideoModeOK''' - Überprüft, ob die gewünschte Auflösung unterstützt wird.

 
== Delphi-Spezifikation ==

function '''SDL_VideoModeOK'''(''width'', ''height'', ''bpp'': Integer; ''flags'': Uint32): Integer
 

== Parameter ==

{| border="1" rules="all"
! ''width, height''
| Breite und Höhe des Fensters
|-
! ''bpp''
| Anzahl der Bit pro Pixel
|-
! ''flags''
| Die Flags, siehe [[SDL_Surface]]
|}

 

== Beschreibung ==
Überprüft, ob die Auflösung auf die gewünschte Breite, Höhe und [[bpp]] (bits per pixel = Bit pro Pixel) gesetzt werden kann.
''bpp'' kann ein beliebiger Wert sein, da SDL den Modus emuliert, falls die angegebene Farb-Tiefe nicht direkt unterstützt wird.

 
== Rückgabewert ==
0 wenn die gewünschte Auflösung nicht unterstützt wird.

 

== Beispiel ==
<pascal>var screen: PSDL_Surface;
bpp: Uint32;
begin
writeln('Checking mode 640x480@16bpp.');
bpp:=SDL_VideoModeOK(640, 480, 16, SDL_HWSURFACE);

if(bpp=0) then
begin
writeln('Mode not available.');
exit;
end;
end;</pascal>

 
== Siehe auch ==
[[SDL_SetVideoMode]], [[SDL_GetVideoInfo]]

[[Kategorie:SDL|VideoModeOK]]

Tutorial

2005-10-27T19:45:47Z

Slyh:

Nachfolgend finden Sie eine Übersicht über all die Tutorials, die bereits ins Wiki übertragen wurden. 
Alle Artikel sind auch weiterhin unter [http://www.delphigl.com/launcher.php?em=tutorials DelphiGL.com->Tutorials] erreichbar.

=Hinweise=
Bitte tragt selbst '''keine''' eigenen Tutorials ohne Absprache mit Flash (Kevin Fleischer) bzw. Phobeus hier ein. Tutorials werden prinzipiell vom DGL-Team gegengelesen, ''bevor'' Sie veröffentlich werden.

Wer mit dem Gedanken spielt, ein Tutorial für DGL zu schreiben, sollte sich bereits bei der Themenwahl mit dem DGL-Team absprechen. DGL ist sehr an neuen Tutorials interessiert. Nur sollte man beachten, dass nichts doppelt geschrieben wird, bzw. dass nicht 2 Mann zur selben Zeit das selbe Thema beackern.

=Tutorials=
{{Hinweis|Alle Tutorials sind der [[:Kategorie:Tutorial]] zugeordnet.}}
== Einsteiger-Tutorials ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial quickstart]]
|[[Bild:Tutorial_Lektion1.gif|right]] "Quickstart: OpenGL & Delphi" 
Für alle, die einen schnellen Einstieg in die OpenGL Programmierung mit Delphi suchen, hat Flash hier einen Einstieg geschaffen. Neben dem erstellen eines eigenen OpenGL-Templates hat er für alle, die Großes mit OpenGL vorhaben, am Ende noch einige Hinweise bereitgestellt.
|-
![[Tutorial lektion1]]
|[[Bild:Tutorial_Lektion1.gif|right]] "Nicht zu weit aus dem Fenster lehnen" 
Dieses Tutorial von Magellan ist für alle Neueinsteiger gedacht. Hier werden Grundlagen von ''Was ist OpenGL?'' bis zu ''Wie initialisiere ich OpenGL?'' besprochen.
|-
![[Tutorial lektion2]]
|[[Bild:Tutorial_Lektion2.jpg|right]] "Entdeckung einer neuen Welt" 
Unter dieser Überschrift empängt euch Phobeus zu eurem ersten OpenGL Tutorial welches sich mit der Anwendung der OpenGL-API befasst.
|-
![[Tutorial lektion3]]
|[[Bild:Tutorial_Lektion3.gif|right]] "Eine Welt des Grauens?" 
Hinter diesem Titel verbirgt sich ein Einsteigertutorial zum Thema Matrizen in OpenGL. Wiederum führt euch Phobeus durch den Stoff.
|-
![[Tutorial lektion4]]
|[[Bild:Tutorial_Lektion4.png|right]] "Texturen, Tapeten und Ihre Tücken" 
Wie bekomme ich ein Bild auf meine Primitiven? Wer sich diese Frage bei den vorigen Tutorials gestellt hat, der bekommt hier nun von Phobeus die Antworten.
|-
![[Tutorial 2D]]
|[[Bild:Tutorial_2D.jpg|right]] "2D mit OpenGL" 
OpenGL ist zwar primär eine 3D-API, es eignet sich aber nicht zuletzt dank seiner leistungsstarken Hardwarebeschleunigung und der damit verbundenen Features auch sehr gut für reine 2D-Anwendungen. Dieses Tutorial von Sascha Willems geht sehr ausführlich auf die Nutzung von OpenGL für 2D-Anwendungen ein.
|-
![[Tutorial Matrix2]]
|[[Bild:Tutorial_Matrix2.png|right]] "Matrix2 - Matrizen und Matrixmanipulationen" 
Das Thema Matrizen stellt OpenGL-Einsteiger regelmäßig vor "unlösbare" Aufgaben: 
''Wieso dreht sich der Würfel so komisch, und nicht um sich selbst?'' 
''Wieso verschiebt OpenGL die Kugel denn dahin, und nicht dorthin?'' 
Dieses Tutorial von Flash befasst sich mit den 3 Matrixtypen, die es in OpenGL gibt und erklärt was die Befehle glScale, glRotate und glTranslate wirklich machen.
|-
![[Tutorial SDL Einstieg]]
|[[Bild:Tutorial_Lektion1.gif|right]] "SDL-Einsteiger-Tutorial" 
Crossplattform-Programmierung ist das Zauberwort, welches in den letzten Jahren - dank verstärkter Präsenz von Linux - immer wieder in den Programmierforen des Internets auftaucht. Für Grafikprogrammier ist [[SDL]] hier das Mittel der Wahl. Bekannte Titel wie "Quake III" und "Civilisation - Call to Power" bauen bereits auf diese Bibiothek für ihre Linux-Ports. Phobeus zeigt euch in diesem ersten SDL-Tutorial was SDL ist und wie man es benutzt.
|-
|}
</div>

== Grundlagen-Tutorials ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Selection]]
|[[Bild:Tutorial_Selection.gif|right]] "Objectselection" 
Die Selektion von Objekten braucht man spätestens dann, wenn man ein komfortable Interaktion mit der Spielwelt erstellen will. Mit diesem Tutorial von DCW_MrT ist die Thematik kein Problem mehr.
|-
![[Tutorial TexFilter]]
|[[Bild:Tutorial_TexFilter.jpg|right]] "Texturfilterung - Texturen-Feintuning" 
Texturen sind seit langem ein wichtiger Bestandteil im Bereich der Echtzeitgrafik. OpenGL bietet auf diesem Gebiet auch diverse Möglichkeiten Texturen auch filtern zu lassen. Welche das sind und wie sie sich auswirken, könnt ihr in diesem Tutorial von Delphic nachlesen.
|-
|}
</div>

== Effekte ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Nebel]]
|[[Bild:Tutorial_Nebel.jpg|right]] "DGL Fogging Tutorial". 
Erstaunlich einfach lässt sich mit OpenGL Nebel darstellen. Wie einfach, zeigt euch Lithander in diesem Tutorial.
|-
![[Tutorial Partikel1]]
|[[Bild:Tutorial_Partikel1.gif|right]] "Partikel-Tutorial I". 
Eine Partikel-Engine sollte in (fast) jeder Engine enthalten sein. Anhand dieses Tutorials von Lithander könnt ihr den Grundstein dazu legen.
|-
![[Tutorial BumpMap]]
|[[Bild:Tutorial_BumpMap.png|right]] "Bumpmapping - Plastisches 2D". 
Bumpmapping ist eine immer stärker genutzte Technik, um polygonarme Oberflächen ohne Tesselation mit vorgegaukelten Details - abhängig vom Lichteinfall - zu versehen. In diesem Tutorial zeigt euch HomerS, wie man Bumpmapping über die NVIDIA-spezifischen Combiner realisiert.
|-
![[Tutorial Bumpmaps mit Blender]]
|[[Bild:Tutorial_BumbBlend_Preview.png|right]]
Mit dem kostenlosen 3D-Program Blender können einfache Bumpmaps erstellt werden. Wie das geht, erfahrt ihr in diesem Tutorial von Flo.

{{Hinweis|Das Programm "Blender" bekommt ihr kostenlos auf [http://blender3d.org blender3d.org]}}

|-
![[Tutorial StencilSpiegel]]
|[[Bild:Tutorial_StencilSpiegel.jpg|right]] "Spiegelungen mit dem Stencil-Buffer". 
Eine Echtzeit-Spiegelung ist einer der schönsten Effekte einer 3D-Welt und trägt viel zum Realismus bei. Eine Möglichkeit Spiegelungen über den Stencilpuffer zu realisieren, wird in diesem Tutorial von Sascha Willems erklärt.
|-
![[Tutorial StereoSehen]]
|[[Bild:Tutorial_StereoSehen.gif|right]]Auch wenn moderne Grafikkarten durch eine immer besser werdende Darstellung dem Benutzer versuchen das Betreten einer virtuellen 3D-Welt vorzugaukeln, so schafft es doch auch das beste Doom3-Monster nur bis zur Glasröhre zu erschrecken, rutscht dann aber quietschend davon ab. Was also tun, wenn man einen Schritt weiter gehen und dem Anwender wirkliches 3D bieten möchte? Wer eine 3D-Brille hat, wird mit diesem Tutorial von Nico Mechaelis eine Möglichkeit finden, die dritte Dimension am Computer zur erschließen.
|}
</div>

== Shader ==
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial glsl]]
|[[Bild:Tutorial_glsl1.png|right]] "Einführung in GLSL". 
Nach langem Ringen und Handeln hat es das ARB letztendlich doch geschafft, eine einheitliche Shaderhochsprache für OpenGL zu veröffentlichen, nämlich ''glSlang''. Mit glSlang können nun auch unter OpenGL Vertex- und Fragment-Shader in einer lesbaren, C-ähnlichen Hochsprache geschrieben werden, was deren Entwicklung stark vereinfacht. Diese Einführung von Sascha Willems ist weniger ein Tutorial, als ein kompletter Überblick über glSlang. Hier erfährt der Leser nicht nur etwas über die Benutzung von Shadern im Programm, sondern auch alles über die Sprachelemente, inklusive diverser Beispiele.
|-
![[Tutorial glsl2]]
|[[Bild:Tutorial_na.jpg|right]] "GLSL-Ergänzungen und Beispiele". 
Dieses Tutorial von La_Boda ist eine direkte Fortsetzung des GLSL-Tutorials. Es behandelt verstärkt die Praxis und liefert anhand von einigen Beispielen eine bessere Sicht auf die bereits gelernte Theorie.
|-
|}

Tutorial

2005-10-27T19:28:57Z

Slyh: Schreibfehler, Kommafehler und Stil'fehler' entfernt.

Nochfolgend finden Sie eine Übersicht über all die Tutorials, die bereits ins Wiki übertragen wurden. 
Alle Artikel sind auch weiterhin unter [http://www.delphigl.com/launcher.php?em=tutorials DelphiGL.com->Tutorials] erreichbar.

=Hinweise=
Bitte tragt selbst '''keine''' eigenen Tutorials ohne Absprache mit Flash (Kevin Fleischer) bzw. Phobeus hier ein. Tutorials werden prinzipiell vom DGL-Team gegengelesen, ''bevor'' Sie veröffentlich werden.

Wer mit dem Gedanken spielt, ein Tutorial für DGL zu schreiben, sollte sich bereits bei der Themenwahl mit dem DGL-Team absprechen. DGL ist sehr an neuen Tutorials interessiert. Nur sollte man beachten, dass nichts doppelt geschrieben wird, bzw. dass nicht 2 Mann zur selben Zeit das selbe Thema beackern.

=Tutorials=
{{Hinweis|Alle Tutorials sind der [[:Kategorie:Tutorial]] zugeordnet.}}
== Einsteiger-Tutorials ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial quickstart]]
|[[Bild:Tutorial_Lektion1.gif|right]] "Quickstart: OpenGL & Delphi" 
Für alle, die einen schnellen Einstieg in die OpenGL Programmierung mit Delphi suchen, hat Flash hier einen Einstieg geschaffen. Neben dem erstellen eines eigenen OpenGL-Templates hat er für alle, die Großes mit OpenGL vorhaben, am Ende noch einige Hinweise bereitgestellt.
|-
![[Tutorial lektion1]]
|[[Bild:Tutorial_Lektion1.gif|right]] "Nicht zu weit aus dem Fenster lehnen" 
Dieses Tutorial von Magellan ist für alle Neueinsteiger gedacht. Hier werden Grundlagen von ''Was ist OpenGL?'' bis zu ''Wie initialisiere ich OpenGL?'' besprochen.
|-
![[Tutorial lektion2]]
|[[Bild:Tutorial_Lektion2.jpg|right]] "Entdeckung einer neuen Welt" 
Unter dieser Überschrift empängt euch Phobeus zu eurem ersten OpenGL Tutorial welches sich mit der Anwendung der OpenGL-API befasst.
|-
![[Tutorial lektion3]]
|[[Bild:Tutorial_Lektion3.gif|right]] "Eine Welt des Grauens?" 
Hinter diesem Titel verbirgt sich ein Einsteigertutorial zum Thema Matrizen in OpenGL. Wiederum führt euch Phobeus durch den Stoff.
|-
![[Tutorial lektion4]]
|[[Bild:Tutorial_Lektion4.png|right]] "Texturen, Tapeten und Ihre Tücken" 
Wie bekomme ich ein Bild auf meine Primitiven? Wer sich diese Frage bei den vorigen Tutorials gestellt hat, der bekommt hier nun von Phobeus die Antworten.
|-
![[Tutorial 2D]]
|[[Bild:Tutorial_2D.jpg|right]] "2D mit OpenGL" 
OpenGL ist zwar primär eine 3D-API, es eignet sich aber nicht zuletzt dank seiner leistungsstarken Hardwarebeschleunigung und der damit verbundenen Features auch sehr gut für reine 2D-Anwendungen. Dieses Tutorial von Sascha Willems geht sehr ausführlich auf die Nutzung von OpenGL für 2D-Anwendungen ein.
|-
![[Tutorial Matrix2]]
|[[Bild:Tutorial_Matrix2.png|right]] "Matrix2 - Matrizen und Matrixmanipulationen" 
Das Thema Matrizen stellt OpenGL-Einsteiger regelmäßig vor "unlösbare" Aufgaben: 
''Wieso dreht sich der Würfel so komisch, und nicht um sich selbst?'' 
''Wieso verschiebt OpenGL die Kugel denn dahin, und nicht dorthin?'' 
Dieses Tutorial von Flash befasst sich mit den 3 Matrixtypen, die es in OpenGL gibt und erklärt was die Befehle glScale, glRotate und glTranslate wirklich machen.
|-
![[Tutorial SDL Einstieg]]
|[[Bild:Tutorial_Lektion1.gif|right]] "SDL-Einsteiger-Tutorial" 
Crossplattform-Programmierung ist das Zauberwort, welches in den letzten Jahren - dank verstärkter Präsenz von Linux - immer wieder in den Programmierforen des Internets auftaucht. Für Grafikprogrammier ist [[SDL]] hier das Mittel der Wahl. Bekannte Titel wie "Quake III" und "Civilisation - Call to Power" bauen bereits auf diese Bibiothek für ihre Linux-Ports. Phobeus zeigt euch in diesem ersten SDL-Tutorial was SDL ist und wie man es benutzt.
|-
|}
</div>

== Grundlagen-Tutorials ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Selection]]
|[[Bild:Tutorial_Selection.gif|right]] "Objectselection" 
Die Selektion von Objekten braucht man spätestens dann, wenn man ein komfortable Interaktion mit der Spielwelt erstellen will. Mit diesem Tutorial von DCW_MrT ist die Thematik kein Problem mehr.
|-
![[Tutorial TexFilter]]
|[[Bild:Tutorial_TexFilter.jpg|right]] "Texturfilterung - Texturen-Feintuning" 
Texturen sind seit langem ein wichtiger Bestandteil im Bereich der Echtzeitgrafik. OpenGL bietet auf diesem Gebiet auch diverse Möglichkeiten Texturen auch filtern zu lassen. Welche das sind und wie sie sich auswirken, könnt ihr in diesem Tutorial von Delphic nachlesen.
|-
|}
</div>

== Effekte ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Nebel]]
|[[Bild:Tutorial_Nebel.jpg|right]] "DGL Fogging Tutorial". 
Erstaunlich einfach lässt sich mit OpenGL Nebel darstellen. Wie einfach, zeigt euch Lithander in diesem Tutorial.
|-
![[Tutorial Partikel1]]
|[[Bild:Tutorial_Partikel1.gif|right]] "Partikel-Tutorial I". 
Eine Partikel-Engine sollte in (fast) jeder Engine enthalten sein. Anhand dieses Tutorials von Lithander könnt ihr den Grundstein dazu legen.
|-
![[Tutorial BumpMap]]
|[[Bild:Tutorial_BumpMap.png|right]] "Bumpmapping - Plastisches 2D". 
Bumpmapping ist eine immer stärker genutzte Technik, um polygonarme Oberflächen ohne Tesselation mit vorgegaukelten Details - abhängig vom Lichteinfall - zu versehen. In diesem Tutorial zeigt euch HomerS, wie man Bumpmapping über die NVIDIA-spezifischen Combiner realisiert.
|-
![[Tutorial Bumpmaps mit Blender]]
|[[Bild:Tutorial_BumbBlend_Preview.png|right]]
Mit dem kostenlosen 3D-Program Blender können einfache Bumpmaps erstellt werden. Wie das geht, erfahrt ihr in diesem Tutorial von Flo.

{{Hinweis|Das Programm "Blender" bekommt ihr kostenlos auf [http://blender3d.org blender3d.org]}}

|-
![[Tutorial StencilSpiegel]]
|[[Bild:Tutorial_StencilSpiegel.jpg|right]] "Spiegelungen mit dem Stencil-Buffer". 
Eine Echtzeit-Spiegelung ist einer der schönsten Effekte einer 3D-Welt und trägt viel zum Realismus bei. Eine Möglichkeit Spiegelungen über den Stencilpuffer zu realisieren, wird in diesem Tutorial von Sascha Willems erklärt.
|-
![[Tutorial StereoSehen]]
|[[Bild:Tutorial_StereoSehen.gif|right]]Auch wenn moderne Grafikkarten durch eine immer besser werdende Darstellung dem Benutzer versuchen das Betreten einer virtuellen 3D-Welt vorzugaukeln, so schafft es doch auch das beste Doom3-Monster nur bis zur Glasröhre zu erschrecken, rutscht dann aber quietschend davon ab. Was also tun, wenn man einen Schritt weiter gehen und dem Anwender wirkliches 3D bieten möchte? Wer eine 3D-Brille hat, wird mit diesem Tutorial von Nico Mechaelis eine Möglichkeit finden, die dritte Dimension am Computer zur erschließen.
|}
</div>

== Shader ==
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial glsl]]
|[[Bild:Tutorial_glsl1.png|right]] "Einführung in GLSL". 
Nach langem Ringen und Handeln hat es das ARB letztendlich doch geschafft, eine einheitliche Shaderhochsprache für OpenGL zu veröffentlichen, nämlich ''glSlang''. Mit glSlang können nun auch unter OpenGL Vertex- und Fragment-Shader in einer lesbaren, C-ähnlichen Hochsprache geschrieben werden, was deren Entwicklung stark vereinfacht. Diese Einführung von Sascha Willems ist weniger ein Tutorial, als ein kompletter Überblick über glSlang. Hier erfährt der Leser nicht nur etwas über die Benutzung von Shadern im Programm, sondern auch alles über die Sprachelemente, inklusive diverser Beispiele.
|-
![[Tutorial glsl2]]
|[[Bild:Tutorial_na.jpg|right]] "GLSL-Ergänzungen und Beispiele". 
Dieses Tutorial von La_Boda ist eine direkte Fortsetzung des GLSL-Tutorials. Es behandelt verstärkt die Praxis und liefert anhand von einigen Beispielen eine bessere Sicht auf die bereits gelernte Theorie.
|-
|}

Tutorial

2005-10-27T18:56:46Z

Slyh: /* Hinweise */ Kommafehler korrigiert

Nochfolgend finden Sie eine Übersicht über all die Tutorials die bereits ins Wiki übertragen wurden. 
Alle Artikel sind auch weiterhin unter [http://www.delphigl.com/launcher.php?em=tutorials DelphiGL.com->Tutorials] erreichbar.

=Hinweise=
Bitte tragt selbst '''keine''' eigenen Tutorials ohne Absprache mit Flash (Kevin Fleischer) bzw. Phobeus hier ein. Tutorials werden prinzipiell vom DGL-Team gegengelesen, ''bevor'' Sie veröffentlich werden.

Wer mit dem Gedanken spielt, ein Tutorial für DGL zu schreiben, sollte sich bereits bei der Themenwahl mit dem DGL-Team absprechen. DGL ist sehr an neuen Tutorials interessiert. Nur sollte man beachten, dass nichts doppelt geschrieben wird, bzw. dass nicht 2 Mann zur selben Zeit das selbe Thema beackern.

=Tutorials=
{{Hinweis|Alle Tutorials sind der [[:Kategorie:Tutorial]] zugeordnet.}}
== Einsteiger Tutorials ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial quickstart]]
|[[Bild:Tutorial_Lektion1.gif|right]] "Quickstart: OpenGL & Delphi." 
Für alle die einen schnellen Einstieg in die OpenGL Programmierung mit Delphi suchen hat Flash hier einen Einstieg geschaffen. Neben dem erstellen eines eigenen OpenGL-Templates hat er für alle die großes mit OpenGL vorhaben, am Ende noch einige Hinweise bereitgestellt.
|-
![[Tutorial lektion1]]
|[[Bild:Tutorial_Lektion1.gif|right]] "Nicht zu weit aus dem Fenster lehnen." 
Dieses Tutorial von Magellan ist für alle Neueinsteiger gedacht. Hier werden Grundlagen von "Was ist OpenGL" bis zu "wie initialisiere ich OpenGL" besprochen.
|-
![[Tutorial lektion2]]
|[[Bild:Tutorial_Lektion2.jpg|right]] "Entdeckung einer neuen Welt." 
Unter dieser Überschrift empängt euch Phobeus zu eurem ersten OpenGL Tutorial welches sich mit der Anwendung der OpenGL-API befasst.
|-
![[Tutorial lektion3]]
|[[Bild:Tutorial_Lektion3.gif|right]] "Eine Welt des Grauens?" 
Hinter diesem Titel verbirgt sich ein Einsteigertutorial zum Thema Matrizen in OpenGL. Wiederum führt euch Phobeus durch den Stoff.
|-
![[Tutorial lektion4]]
|[[Bild:Tutorial_Lektion4.png|right]] "Texturen, Tapeten und Ihre Tücken" 
Wie bekomme ich ein Bild auf meine Primitiven? Wer sich diese Frage bei den vorigen Tutorials gestellt hat, der bekommt hier nun von Phobeus die Antworten.
|-
![[Tutorial 2D]]
|[[Bild:Tutorial_2D.jpg|right]] "2D mit OpenGL" 
OpenGL ist zwar primär eine 3D-API, aber eignet sich nicht zuletzt dank seiner leistungsstarken Hardwarebeschleunigung und der damit verbundenen Features auch sehr gut für reine 2D-Anwendungen. Dieses Tutorial von Sascha Willems geht sehr ausführlich auf die Nutzung von OpenGL für 2D-Anwendungen ein.
|-
![[Tutorial Matrix2]]
|[[Bild:Tutorial_Matrix2.png|right]] "Matrix2 - Matrizen und Matrixmanipulationen" 
Das Thema Matrizen stellt OpenGL Einsteiger regelmäßig vor "unlösbare" Aufgaben: 
''Wieso dreht sich der Würfel so komisch, und nicht um sich selbst?'' 
''Wieso verschiebt OpenGL die Kugel denn dahin, und nicht dorthin?'' 
Dieses Tutorial von Flash befasst sich mit den 3 Matrixtypen die es in OpenGL gibt, und erklärt was die Befehle glScale, glRotate und glTranslate wirklich machen.
|-
![[Tutorial SDL Einstieg]]
|[[Bild:Tutorial_Lektion1.gif|right]] "SDL-Einsteiger-Tutorial" 
Crossplattform-Programmierung ist das Zauberwort welches in den letzten Jahren, dank verstärkter Präsenz von Linux, immer wieder in den Programmierforen des Internets auftaucht. Für Grafikprogrammier ist [[SDL]] hier das Mittel der Wahl. Bekannte Titel wie "Quake III" und "Civilisation - Call to Power" bauen bereits auf diese Bibiothek für ihre Linuxports. Phobeus zeigt euch in diesem erstem SDL Tutorial was SDL ist, und wie man es benutzt.
|-
|}
</div>

== Grundlagen Tutorials ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Selection]]
|[[Bild:Tutorial_Selection.gif|right]] "Objectselection" 
Die Selektion von Objekten braucht man spätestens wenn man ein komfortable Interaktion mit der Spielwelt erstellen will. Mit diesem Tutorial von DCW_MrT ist die Thematik kein Problem mehr.
|-
![[Tutorial TexFilter]]
|[[Bild:Tutorial_TexFilter.jpg|right]] "Texturfilterung - Texturen Feintuning" 
Texturen sind seit langem ein wichtiger Bestandteil im Bereich der Echtzeitgrafik und OpenGL bietet auf diesem Gebiet auch diverse Möglichkeiten eben diese Filtern zu lassen. Welche das sind und wie sie sich auswirken, könnt ihr in diesem Tutorial von Delphic nachlesen.
|-
|}
</div>

== Effekte ==
<div align="center">
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial Nebel]]
|[[Bild:Tutorial_Nebel.jpg|right]] "DGL Fogging Tutorial". 
Erstaunlich einfach lässt sich mit OpenGL Nebel darstellen. Wie einfach zeigt euch Lithander in diesem Tutorial.
|-
![[Tutorial Partikel1]]
|[[Bild:Tutorial_Partikel1.gif|right]] "Partikel Tutorial I". 
Eine Partikel-Engine sollte in (fast) jeder Engine enthalten sein. Anhand dieses Tutorials von Lithander könnt ihr den Grundstein dazu legen.
|-
![[Tutorial BumpMap]]
|[[Bild:Tutorial_BumpMap.png|right]] "Bumpmapping - Plastisches 2D". 
Bumpmapping ist eine immer stärker genutzte Technik, um polygonarme Oberflächen ohne Tesselation mit vorgegaukelten Details, abhängig vom Lichteinfall, zu versehen. In diesem Tutorial zeigt euch HomerS wie man Bumpmapping über die NVidia-spezfischen Combiner realisiert.
|-
![[Tutorial Bumpmaps mit Blender]]
|[[Bild:Tutorial_BumbBlend_Preview.png|right]]
Mit dem kostenlosten 3D Program Blender können einfache Bumbmaps erstellt werden. Wie das geht erfahrt ihr in diesem Tutorial von Flo.

{{Hinweis|Das Programm "Blender" bekommt ihr kostenlos auf [http://blender3d.org blender3d.org]}}

|-
![[Tutorial StencilSpiegel]]
|[[Bild:Tutorial_StencilSpiegel.jpg|right]] "Spiegelungen mit dem Stencil-Buffer". 
Eine Echt-Zeit-Spiegelung ist einer der schönsten Effekte einer 3D-Welt und trägt auch viel zum Realismus bei. Eine Möglichkeit wie man Spiegelungen über den Stencilpuffer realisieren kann wird in diesem Tutorial von Sascha Willems erklärt.
|-
![[Tutorial StereoSehen]]
|[[Bild:Tutorial_StereoSehen.gif|right]]Auch wenn einem moderne Grafikkarten versuchen mit einem immer besseren Darstellung vorzugaukeln, dass man eine virtuelle 3D-Welt betritt, so kann einen auch das beste Doom3-Monster nur bis zur Glasröhre erschrecken und rutscht dann quietschend davon ab. Was also tun, wenn man einen Schritt weiter gehen und dem Anwender wirkliches 3D bieten möchte? Wer eine 3D-Brille hat wird mit diesem Tutorial von Nico Mechaelis eine Möglichkeit finden, die dritte Dimension am Computer zur erschließen.
|}
</div>

== Shader ==
{|{{Prettytable}}
!width="15%"|Link
!width="85%"|Beschreibung
|-
![[Tutorial glsl]]
|[[Bild:Tutorial_glsl1.png|right]] "Einführung in GLSL". 
Nach langem Ringen und Handeln hat es das ARB letztendlich doch geschaft eine einheitliche Shaderhochsprache für OpenGL zu veröffentlichen, nämlich glSlang. Mit glSlang können nun auch unter OpenGL Vertex- und Fragmentshader in einer lesbaren, C-ähnlichen Hochsprache geschrieben werden, was deren Entwicklung stark vereinfacht. Diese Einführung von Sascha Willems ist weniger ein Tutorial als ein kompletter Überblick über glSlang. Hier erfährt der Leser nicht nur wie man die Shader im Programm nutzt, sondern auch alles über die Sprachelemente, inklusive diverser Beispiele.
|-
![[Tutorial glsl2]]
|[[Bild:Tutorial_na.jpg|right]] "GLSL Ergänzungen und Beispiele". 
Dieses Tutorial von La_Boda ist eine direkte Fortsetzung des GLSL Tutorials. Es behandelt verstärkt die Praxis und liefert anhand von einigen Beispielen eine bessere Sicht auf die bereits gelernte Theorie.
|-
|}