Benutzer:Mori/OGL3 Quickstart - Versionsgeschichte

Mori am 22. Juni 2013 um 13:34 Uhr

2013-06-22T13:34:44Z

Änderungen zeigen

Mori: /* Weiterführendes/Aussicht */

2013-04-03T12:50:00Z

‎Weiterführendes/Aussicht

Mori: /* Zeichnen */

2013-04-03T12:43:11Z

‎Zeichnen

Mori: /* Vorwort */

2013-04-03T12:42:37Z

‎Vorwort

Mori am 3. April 2013 um 12:36 Uhr

2013-04-03T12:36:36Z

Mori: /* OpenGL Objekte */

2013-04-01T16:30:02Z

‎OpenGL Objekte

Mori am 1. April 2013 um 16:29 Uhr

2013-04-01T16:29:39Z

Mori: /* Vertex Shader */

2013-04-01T15:22:23Z

‎Vertex Shader

Mori: /* Fragment Shader */

2013-04-01T10:40:48Z

‎Fragment Shader

Mori: /* Shader */

2013-04-01T10:39:15Z

‎Shader

@@ Zeile 404: / Zeile 404: @@
 </source>
-==Weiterführendes/Aussicht==
+==Aussicht==
-erläuterungen, weiterführende links
+Ich hoffe, dass du nach diesem Tutorial dein erstes OpenGL 3 Programm zum laufen gebracht hast und ein besseres Verständnis für die neue API Struktur erhalten hast. Falls du noch Probleme, Vorschläge oder Fragen zum Tutorial oder OpenGl allgemein hast kannst du jederzeit im [http://delphiGL.com/forum Forum] fragen.

@@ Zeile 355: / Zeile 355: @@
 Die Funktion gibt ein GLInt zurück, welcher die Position der Variablen im Shader-Programm angibt und welche wir im nächsten Abschnitt verwenden werden.
 ==Zeichnen==
-Nun kommen wir zum interessanten Teil des Programms, dem eigendlichen Rendern. Nachdem wir nun unsere VBOs, EAB und Shaderprogramme geladen haben, müssen wir OpenGL nur noch mitteilen, welche Daten wir rendern wollen. Zum Rendern benötigen wir eine einfache Render-Loop, wie sie im [[Quickstart Tutorial|Tutorial_Quickstart]] beschrieben ist. Die dort beschriebene Methode ''Render'' passen wir im folgenden an unser OpenGL 3 Programm an. Zunächst fangen wir wie gewohnt mit dem initialisieren der Szene an. Hierzu setzen wir mit '''glClearColor''' eine neue Hintergrundfarbe und reseten mit '''glClear''' den Farb- und Tiefenbuffer des vorherigen Frames. Zuletzt setzen wir die Auflösung unseres Programms, diese entspricht meistens der Fenstergröße.
+Nun kommen wir zum interessanten Teil des Programms, dem eigendlichen Rendern. Nachdem wir nun unsere VBOs, EAB und Shaderprogramme geladen haben, müssen wir OpenGL nur noch mitteilen, welche Daten wir rendern wollen. Zum Rendern benötigen wir eine einfache Render-Loop, wie sie im [[Tutorial_Quickstart|Quickstart Tutorial]] beschrieben ist. Die dort beschriebene Methode ''Render'' passen wir im folgenden an unser OpenGL 3 Programm an. Zunächst fangen wir wie gewohnt mit dem initialisieren der Szene an. Hierzu setzen wir mit '''glClearColor''' eine neue Hintergrundfarbe und reseten mit '''glClear''' den Farb- und Tiefenbuffer des vorherigen Frames. Zuletzt setzen wir die Auflösung unseres Programms, diese entspricht meistens der Fenstergröße.
 <source lang="pascal">  glClearColor(0.0,0.7,0.9,0.0);
    glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT);
@@ Zeile 403: / Zeile 403: @@
 glDrawElements(GL_TRIANGLES,EAB.elementsCount*3,EAB.valType,nil);
 </source>
 ==Weiterführendes/Aussicht==
 erläuterungen, weiterführende links

@@ Zeile 4: / Zeile 4: @@
 ==Vorwort==
-warum ogl3 / nachteile /vorteile
+OpenGL gibt es nun schon seit einigen Jahren und entwickelt sich auch seitdem kontinuierlich weiter. Eine der größten Änderungen hielt Einzug mit OpenGL 3. Veraltete Befehle werden (unter bestimmten Umständen) nicht mehr supportet und es ist ein neuer Context erforderlich um OpenGL 3 nutzen zu können. Zu weiteren Änderungen zählen auch das Wegfallen der statischen Renderpipeline und vorgegebene Variablen in Shadern. Dies gibt uns als Programmierern größere Freiheiten in der Verwendung von OpenGL zwingt uns aber gleichzeitig, dass wir uns selber um bestimmte Dinge, wie Modelview- und Projectionmatrizen, kümmern. Dieses Tutorial soll einen kurzen Einstieg in die Möglichkeiten von OpenGL 3 geben und zeigen, wie man die erste Anwendung einfach selber compilieren kann. Da da dieses Tutorial nur einen kurzen Einstieg in OpenGl geben soll  sind an den entsprechenden Stellen Verlinkungen zu weiterführenden Artikeln angegeben, es ist weiterhin sinnvoll sich weitere [[Tutorial|Tutorials]] anzuschauen da eine ausführliche Erklärung aller Befehle und Techniken ganze Bücher füllen kann.
-OpenGL gibt es nun schon seit einigen Jahren und entwickelt sich auch seitdem kontinuierlich weiter. Einer der größten Änderungen erhielt Einzug mit OpenGL 3. Veraltete Befehle werden (unter bestimmten Umständen) nicht mehr supportet und es ist ein neuer Context erforderlich um OpenGL 3 nutzen zu können. Zu den weiteren Änderungen zählen auch das Wegfallen der statischen Renderpipeline und vorgegebene Variablen. Dies ermöglicht uns als Programmierern größere Freiheiten in der Verwendung von OpenGL erzwingt aber gleichzeitig, dass wir uns selber um bestimmte Dinge, wie Modelview- und Projectionmatrizen, kümmern. Dieses Tutorial soll einen kurzen Einstieg in die Möglichkeiten von OpenGL 3 geben und zeigen, wie man die erste Anwendung einfach selber compilieren kann. Da da dieses Tutorial nur einen kurzen Einstieg in OpenGl geben soll  sind an den entsprechenden Stellen Verlinkungen zu weiterführenden Artikeln angegeben.
 ==Context==
 Der erste wesentliche Unterschied zu OpenGL Versionen kleiner als 3.0 besteht in einem weiteren Rendercontext, welcher zusätzlich erstellt weren muss. Wie auch die 1.x/2.x Rendercontexte (im Folgenden RC), erzeugt man hiermit eine neue OpenGL "Instanz", welche zum Rendern auf einen DeviceContext(im Folgenden DC) genutzt werden kann. Der wesentliche Unterschied ist, dass wir einen gültigen 1.x/2.x RenderContext benötigen, um unseren 3.x'er Context anfordern zu können. Wesentliche Änderungen sind:

@@ Zeile 137: / Zeile 137: @@
 </source>
 Hierbei erzeugen wir mit glBufferData einen neuen EAB mit der entsprechenden Größe (bei ''size''=-1 lassen wir ein schon bestehendes EAB in der Größe unverändert). Wie schon beim VBO lassen wir uns danach mit glMapBuffer einen Pointer auf den reservierten Speicherbereich zurückgeben, welchen wir beschreiben können. Wie schon beim erzeugen müssen wir beim Binden  wieder '''GL_ELEMENT_ARRAY_BUFFER''' angeben, damit OpenGL unser gebundenes EAB auswählt und nicht ein VBO.
 ==Shader==
 Nun kommen wir zum eigendlich wichtigsten Punkt beim gesammten Zeichnen: Den Shadern. Mit der Einführung von OpenGL 3 sind wir verpflichtet uns selber um das Berechnen unserer Objekte auf der Grafikkarte zu kümmern. Ein Programm auf der Grafikkarte wird Shader genannt. Auf der Grafikkarte laufen beim Rendern des Bildes viele Shader gleichzeitig. Hierbei unterscheidet man verschiedene Shader Arten, welche verschiedene Aufgaben, wie zum Beispiel das berechnen der Vertexpositionen (Vertex Shader) oder das bestimmen der Pixelfarben (Fragment Shader),  erfüllen. Dieses Tutorial zeigt nur die pure Anwendung der beiden notwendigen Vertex und Fragment Shader. Ein ausführliches Tutorial über die Shadersprache glsl ist im [[Tutorial_glsl]] zu finden.
@@ Zeile 353: / Zeile 349: @@
 Es macht Sinn für die Kamera und für jedes Objekt eine eigene ModelView-Matrix zu erstellen, um bei einer Bewegung der Kamera, nicht jede Matrix neu berechnen zu müssen. Bei einer Änderung, zB. der Verschiebung der Kamera Position, kann man die neue modelviewMatrix der Objekte durch Multiplizieren der Objekt-ModelviewMatrix mit der Kamera-ModelviewMatrix erhalten. Da dieses Tutorial nur ein kurzer Einstieg in OpenGl ist, beschäftigen wir uns hier nicht ausführlich mit Matrizen, weiterführende Erklärungen zur Matrizenrechnung kann man im [[Tutorial_Nachsitzen]] finden.
 ==Zeichnen==
-eab/vbo/shader binding
+Nun kommen wir zum interessanten Teil des Programms, dem eigendlichen Rendern. Nachdem wir nun unsere VBOs, EAB und Shaderprogramme geladen haben, müssen wir OpenGL nur noch mitteilen, welche Daten wir rendern wollen. Zum Rendern benötigen wir eine einfache Render-Loop, wie sie im [[Quickstart Tutorial|Tutorial_Quickstart]] beschrieben ist. Die dort beschriebene Methode ''Render'' passen wir im folgenden an unser OpenGL 3 Programm an. Zunächst fangen wir wie gewohnt mit dem initialisieren der Szene an. Hierzu setzen wir mit '''glClearColor''' eine neue Hintergrundfarbe und reseten mit '''glClear''' den Farb- und Tiefenbuffer des vorherigen Frames. Zuletzt setzen wir die Auflösung unseres Programms, diese entspricht meistens der Fenstergröße.
 ==Weiterführendes/Aussicht==
 erläuterungen, weiterführende links

@@ Zeile 31: / Zeile 31: @@
 ==OpenGL Objekte==
 Mit der Umstellung auf OpenGL 3 wurde die API in einigen Bereichen grundlegend verändert. Hierzu zählt auch eine stärkere Kapselung der Daten in Objekten, welche über Handles angesprochen werden können. Verschiedene Befehle manipulieren, somit immer das aktuell gebundene Objekt eines Bereichs. Das nachfolgende Schaubild zeigt grafisch die Verknüpfung von Handles zu aktiven Objekten und den Zugriff durch bestimmte Befehle.<br>
-[[Datei:oglObjects.png|500px]]
+[[Datei:oglObjects.png|500px]]<br>
 Wie man erkennen kann müssen nicht immer Objekte gebunden sein, sollte in diesem Zustand jedoch ein Befehl versuchen das Objekt zu verändern gibt OpenGL einen Fehler aus. Das gleiche gilt, wenn man versucht Handles verschiedener Gruppen, zum Beispiel ein VBO, als aktives Objekt für Texturen zu binden.
 ==VBOs==
 Ein elementarer Bestandteil auf dem Weg zu einer sichtbaren Ausgabe sind Vertex Buffer Arrays (im Folgenden: VBO's). Diese beinhalten die 3D-Daten welche auf der Grafikkarte verarbeitet und gezeichnet werden.

@@ Zeile 300: / Zeile 300: @@
 Nachdem wir nun mit OpenGL Programme und Shader ansprechen können fehlt uns nur noch eines: Der Shader Code selber! Shader werden mit der oben beschriebenen Shader Sprache glsl geschrieben, welche im Aufbau der C-Syntax ähnelt. Für dieses Tutorial benötigen wir einen Vertex, welcher unsere Vertices positioniert, sowie Normalen oder Texturen festlegt und einen Fragment Shader, welcher die Berechnung der Pixel übernimmt.
 ====Vertex Shader====
-Der Vertex Shader beginnt mit der Versionsangabe der Shader Sprache, diese legt die verfügbaren Befehle und Schnittstellen fest. Für OpenGL 3.1 muss mindestens Version 1.40 gewählt werden. Als nächstes sehen wir 2 Deklarationen mit dem Schlüsselwort '''uniform'''. Diese Variablen können von unserem Programm gesetzt und anschließend im Shader verwendet werden. Im folgenden Shader werden die Projection- und die Modelview-Matrix vom Programm an den Shader übergeben, welche wir im Anschluss für die Berechnung der Vertex Positionen auf dem Bildschirm benötigen. Hiernach sehen wir das Schlüsselwort '''in''', dieses regelt genauso wie das folgende ''out'', den Zugriff auf die Variablen. Variablen, welche im Vertex Shader mit '''in''' deklariert sind, müssen von unserem Programm bereit gestellt werden. '''out''' Variablen im Vertex Shader werden an den Fragment Shader weitergereicht. Zuletzt sehen wir in der Funktion ''main'' das eigendliche Programm. Dieses berechnet aus Projektions- und Modelviewmatrix, sowie der Positionsdaten unseres VBOs die entgültige Vertexposition und übergibt diese an die Build-In Variable ''gl_Position''. Die Parameter texture und normal werden nicht verändert und an den Fragmentshader weitergeleitet.
+Der Vertex Shader beginnt mit der Versionsangabe der Shader Sprache, diese legt die verfügbaren Befehle und Schnittstellen fest. Für OpenGL 3.1 muss mindestens Version 1.40 gewählt werden. Als nächstes sehen wir 2 Deklarationen mit dem Schlüsselwort '''uniform'''. Diese Variablen können von unserem Programm gesetzt und anschließend im Shader verwendet werden. Im folgenden Shader werden die Projection- und die Modelview-Matrix vom Programm an den Shader übergeben, welche wir im Anschluss für die Berechnung der Vertex Positionen auf dem Bildschirm benötigen. Hiernach sehen wir das Schlüsselwort '''in''', dieses regelt genauso wie das folgende '''out''', den Zugriff auf die Variablen. Variablen, welche im Vertex Shader mit '''in''' deklariert sind, müssen von unserem Programm bereit gestellt werden. '''out''' Variablen im Vertex Shader werden an den Fragment Shader weitergereicht. Zuletzt sehen wir in der Funktion ''main'' das eigendliche Programm. Dieses berechnet aus Projektions- und Modelviewmatrix, sowie der Positionsdaten unseres VBOs die entgültige Vertexposition und übergibt diese an die Build-In Variable ''gl_Position''. Die Parameter texture und normal werden nicht verändert und an den Fragmentshader weitergeleitet.
 <source lang="C">#version 330
@@ Zeile 319: / Zeile 319: @@
    norm=normal;
 }</source>
 ====Fragment Shader====
 Die eigendliche Berechnung der Pixelfarbe, Tiefe und sonstiger Werte wird im Fragmentshader vorgenommen. Auch dieser Shader fängt wieder mit einer Versionsangabe an, welche, wie oben beschrieben, für verschiedene OpenGL Versionen eine minimale Versionsnummer benötigt. In diesem Shader wird zuerst eine zusätzliche sampler2D Uniform angegeben, welche eine, von uns gebundene, Textur repräsentiert. Danach sehen wir die '''out'''-Parameter des Vertex Shaders, welche nun mit '''in''' gekennzeichnet sind und somit in unserem Shader verarbeitet werden können. Zusätzlich werden 3 '''out''' Variablen deklariert. Diese werden mit einem zusätzlichen '''location'''-Attribut versehen, so dass wir sie später an einen [[Tutorial_Framebufferobject|Framebuffer]] binden können. Wollen wir direkt auf den Bildschirm zeichnen brauchen wir nur das frag_color-Varying zu berechnen. Dieses wird ohne gebundenen Framebuffer direkt auf dem Bildschirm ausgegeben. Zum Schluss sehen wir wieder das eigentliche Programm. Mit der Funktion ''texture2D'' können wir, durch Angabe der Textur und der Leseposition, Farbewerte aus der Texturlesen und diese als Farbe für den aktuellen Pixel setzen. Die restlichen Parameter werden nur für eine weitergehende Verarbeitung durch einen zweiten Renderpass benötigt und können zum einfachen Rendern verworfen werden.

@@ Zeile 139: / Zeile 139: @@
 </source>
 ==Shader==
-Nun kommen wir zum eigendlich wichtigsten Punkt beim gesammten Zeichnen: Den Shadern. Mit der Einführung von OpenGL 3 sind wir verpflichtet uns selber um das Berechnen unserer Objekte auf der Grafikkarte zu kümmern. Ein Programm auf der Grafikkarte wird Shader genannt. Auf der Grafikkarte laufen beim Rendern des Bildes viele Shader gleichzeitig. Hierbei unterscheidet man verschiedene Shader Arten, welche verschiedene Aufgaben, wie zum Beispiel das berechnen der Vertexpositionen (Vertex Shader) oder das bestimmen der Pixelfarben (Fragment Shader),  erfüllen. Dieses Tutorial zeigt nur die pure Anwendung der beiden notwendigen Vertex und Fragment Shader. Ein ausführliches Tutorial über die Shadersprache glsl ist <<hier>> zu finden.
+Nun kommen wir zum eigendlich wichtigsten Punkt beim gesammten Zeichnen: Den Shadern. Mit der Einführung von OpenGL 3 sind wir verpflichtet uns selber um das Berechnen unserer Objekte auf der Grafikkarte zu kümmern. Ein Programm auf der Grafikkarte wird Shader genannt. Auf der Grafikkarte laufen beim Rendern des Bildes viele Shader gleichzeitig. Hierbei unterscheidet man verschiedene Shader Arten, welche verschiedene Aufgaben, wie zum Beispiel das berechnen der Vertexpositionen (Vertex Shader) oder das bestimmen der Pixelfarben (Fragment Shader),  erfüllen. Dieses Tutorial zeigt nur die pure Anwendung der beiden notwendigen Vertex und Fragment Shader. Ein ausführliches Tutorial über die Shadersprache glsl ist im [[Tutorial_glsl]] zu finden.
 ===Programme===
 Shader werden in OpenGL zu sogenannten Programmen zusammengefasst, welche die zur Bildberechnung notwendigen Shader enthalten. Nachdem ein solches Programm die entsprechenden Shader erhalten hat, wird es zusammengelinkt. Hierbei werden die einzelnen Shader vom Treiber auf ihre Lauffähigkeit überprüft und zur Anwendung auf der Grafikkarte "freigegeben". Der folgende Code enthält eine Beispielhafte implementation.
@@ Zeile 298: / Zeile 298: @@
 Im Code sehen wir, das wir mit ''glCreateShader(ShaderType)'' uns wieder einen Namen für unser Shaderobjekt holen. Danach übergeben wir unseren Code mit ''glShaderSource(hid, 1, @Code, @Len);'' an den OpenGL und compilieren ihn mit ''glCompileShader(hid);''. Falls alles funktioniert hat gibt die Funktion ''IsValidShader'' True zurück und wir können unseren Shader zu einem oben beschriebenen Program hinzufügen.
 ===Shader Code===
-Nachdem wir nun mit OpenGL Programme und Shader ansprechen können fehlt uns nur noch eines: Der Shader Code selber!
+Nachdem wir nun mit OpenGL Programme und Shader ansprechen können fehlt uns nur noch eines: Der Shader Code selber! Shader werden mit der oben beschriebenen Shader Sprache glsl geschrieben, welche im Aufbau der C-Syntax ähnelt. Für dieses Tutorial benötigen wir einen Vertex, welcher unsere Vertices positioniert, sowie Normalen oder Texturen festlegt und einen Fragment Shader, welcher die Berechnung der Pixel übernimmt.
--Unterschiede Vertex Fragment / Reihnfolge
+====Vertex Shader====
--Demo Shader Code
+Der Vertex Shader beginnt mit der Versionsangabe der Shader Sprache, diese legt die verfügbaren Befehle und Schnittstellen fest. Für OpenGL 3.1 muss mindestens Version 1.40 gewählt werden. Als nächstes sehen wir 2 Deklarationen mit dem Schlüsselwort '''uniform'''. Diese Variablen können von unserem Programm gesetzt und anschließend im Shader verwendet werden. Im folgenden Shader werden die Projection- und die Modelview-Matrix vom Programm an den Shader übergeben, welche wir im Anschluss für die Berechnung der Vertex Positionen auf dem Bildschirm benötigen. Hiernach sehen wir das Schlüsselwort '''in''', dieses regelt genauso wie das folgende ''out'', den Zugriff auf die Variablen. Variablen, welche im Vertex Shader mit '''in''' deklariert sind, müssen von unserem Programm bereit gestellt werden. '''out''' Variablen im Vertex Shader werden an den Fragment Shader weitergereicht. Zuletzt sehen wir in der Funktion ''main'' das eigendliche Programm. Dieses berechnet aus Projektions- und Modelviewmatrix, sowie der Positionsdaten unseres VBOs die entgültige Vertexposition und übergibt diese an die Build-In Variable ''gl_Position''. Die Parameter texture und normal werden nicht verändert und an den Fragmentshader weitergeleitet.
--Einbinden in das Programm
+<source lang="C">#version 330
--vorrausetzungen (benötigte matrizen + daten vbo mapping)
--shader arten
+uniform mat4 projection;
 ==Matrizen==