 Und ihr werdet hier unsere wunderschönen Übersetzungen hören. Es geht um 3D-Programmierung, insbesondere bei Raspberry Pi's. Und Folkert wird es uns vorstellen. Er mag diese Sachen zu tun. Also 3D-Programmierung insbesondere in der Lebenszeit. Weil er denkt, dass er in normaler Arbeit ein bisschen langweilig ist. Also, großen Applaus für Folkert. Hallo. Hallo. Ja, vielen Dank für den Einlättung. Ich bin ein Systemarchitekt. Es ist nicht immer langweilig, aber es ist schon ziemlich unterschiedlich, als wenn man eine 3D-Programmierung macht. Und wenn ich die ganzen Obstrakten, Clouds, Sachen mag, dann ist es viel Spaß, eine Programmierung so nah an der Hardware zu machen. In den letzten Monaten habe ich hauptsächlich mit Raspberry Pi's rumgespielt und geschaut, was man damit OpenGL machen kann, OpenGL ES. Und medialfall wisst ihr nach dem Vortrag, was ihr machen müsst, wenn ihr OpenGL 3D-Software schreiben wollt. Also, dieser Vortrag geht über OpenGL ES-Programmierung. Wir reden über drei Sachen. Zuerst über OpenGL ES, wo die Rendering-Pipeline funktioniert, die Shader. Dann wird es ein bisschen mathematisch betickt, ein bisschen linearer eingebrallen, ein kleines bisschen, und dann zu dritt, total letztlich gibt es ein Beispiel-Programm, dass der Plan ist, das Logo, das Cloud-Communication kommt, der sich einfach dreht. Das unterschiedliche Gründen hat das jetzt noch nicht so wirklich funktioniert. Das heißt, ihr werdet keine schönen Animationen sehen, aber wenn ihr später in den nächsten paar Tagen nachschaut, dann bin ich ziemlich sicher, dass das funktionieren wird. Und es sollte euch eine gute Einleitung und das ganze Konzept geben. Ich werde die Folien auf meine Webseite stellen und die werden auch unter media.cc.de verfügbar festhalten. Nicht in diesem Vortrag. OpenGL ist eine sehr komplexe Technologie. Es gibt viele unterschiedliche Dinge, viele Sachen. Wir haben einfach keine Zeit für 45 Minuten. Also, wenn ihr euch irgendwas fehlt, fragt mich später. Das ist uns anfangen. OpenGL ES, eine kurze Einführung. Wir fangen damit an. OpenGL, open-graphisch Sprache. Es ist eine API, die zwei D- und 3D-Computer-Grafiken erstellt im 1990er-Garten von Silicon Graphics entwickelt. Heutzutage ist ein offener Standard, aktuell von der Chronos Group, und es wird überall benutzt. Computer-Aided Design, Visualisierung, Bildschirmen, Kompositoren bei MacOS-Geräten, Kunst, Spiele, Virtual Reality, Commanded Reality. Das ist alles OpenGL. Es sind viele Obstraktionsschichten dazwischen. Unity, 3D, zum Beispiel, und andere Programmen, mehr OpenGL-Impgebung. Im Endeffekt ist es in der Regel OpenGL irgendwo da unten. OpenGL ES ist OpenGL für embedded systems. Es ist die aktuellerer Standard, die Implementation für NVIDIA und AMD, die das in GPUs einbauen. OpenGL ES ist verfügbar in allen dünnvollen Betriebssystemen, also allen großen Betriebssystemen. Es gibt Beidnings für die meisten Sprachen, C++, Java, sogar Python und Ruby. Tendenziell möchte man eine kompilierte Sprache benutzen und einfach um die Geschwindigkeit hinzukriegen. Ich mag Go, weil es ein bisschen, genau so schnell ist wie OSC, aber die syntax lesbarer ist. So, die aktuelle Version ist OpenGL ES 3.2, aber Stretch hat nur OpenGL ES 2.0. Alle wichtigen Komponenten ist gut, also es ist ausreichend. Dann gibt es eine weitere Sache, das ist EGL, Native Platform Interface. Das braucht man, um der Umgebung in den Betriebssystemen zu sagen, dass wir in OpenGL Umgebung haben möchten. Bevor wir OpenGL ausführen können, brauchen wir ein OpenGL Kontext. Der funktioniert sehr unterschiedlich, ob man deno, das ist ein Fullscreen oder in einem Fenster, ob es in einem Phone oder irgendwo sonst so ist. In der Regel heißt es EGL, aber für unterschiedliche Plattformen gibt es unterschiedliche Libraries, WGL, CGL, MESA, das ist eine Ops-Source-Implementation, GLX. Wenn man ein Programm für seine Plattform haben möchte, muss man ein entsprechendes Interface benutzen, dass die OpenGL einfach ausführt. Es ist das Plattform spezifisch. Wenn man erst mal den Kontext hat, dann sind die unterschiedlichen Plattformen relativ kompatibel. Das ist in der Vorteil von OpenGL, dass da einfach eine Sektionsschicht ist. Also, ganz kurz, OpenGL ist ein Rasterizer. Das bedeutet, das Ziel ist, eine virtuelle Szene zu beschreiben. Eine virtuelle Szene hat Geometrie, also z.B. Ramiden und Würfel, und man möchte einen Hasen haben, dann muss man den Hasen beschreiben als Dreiecke. Und jeder dieser Geometrien wird auch irgendeine Farbe oder ein Material haben. Die Geometrie wird als Dreiecke dargestellt, und die Dreiecke werden als Vertices dargestellt. Also, in diesem Beispiel dieser Würfe können wir mit seinen 8 Punkten beschreiben, und diese 8, jeder Punkt ist ein Wert. Und die Kanten beschreiben die Oberfläche des Würfels. Auf der rechten Seite, wenn wir ein schönes Logo haben wollen, dann ist das eine Texture, das sind Bitmaps, z.B. in PNG. Die Rasterizer funktioniert so, dass wir unsere Geometrie definieren in Koordinaten. Das ist alles Kot in der GPU, im dreidimensionalen Raum. Der Rasterizer nimmt diese ganze Geometrie und projiziert das auf eine Projektionsschicht, eine zweidimensionalen Schicht, z.B. unser Bildschirm, und danach wird zweidimensional in die zweidimensionalen Fragmenten. Die Vertices heißen Fragmente, wenn sie projiziert wurden, und dort werden dann Farben oder Bilder darauf angezeigt. Es gibt diese 3 Schritte. Geometrie in dreidimensionalen Raum, das wird projiziert auf eine zweidimensionale Oberfläche. Für jedes der 3 Ecke auf dieser flachen Oberfläche schauen wir uns an, wie sie eingefärbt werden sollen. Wenn wir uns ein 3-Eck haben, mit 3 Fäben, dann wird der Rasterizer die Werte zwischen diesen Farben anpassen, sodass jeder Pixel auf der Bildschirm die richtige Farbe hat. Es ist eine sehr hochschichtige Definition von diesem Rasterizer. Jetzt lassen wir uns mal anschauen, wie das bei OpenGL funktioniert. Links ist das OpenGL-Programm, das ist das C++ oder GO-Programm, das läuft auf der CPU. Und auf der rechten Seite ist die GPU, also die Grafikkarte, die viel schneller ist. Und da haben wir 2 Sachen, die laufen. Die haben wir selber geschrieben, den Vertex-Shader und den Fragment-Shader, der in einer speziellen OpenGL Sprache geschrieben wurde, die Projekte, die aufhören der Texturen machen. Das OpenGL-Programm wird die Daten in den Vertex-Speicher speichern. Man setzt eine Bitmaps hoch in den Texturen-Speicher. Das wollen wir so wenig wie möglich machen, weil die Brücke zwischen der CPU und GPU langsam und teuer ist. Aber wenn es auf der GPU ist, dann können die Vertex-Shader und den Fragment-Shader darauf zugreifen. Also das OpenGL-Programm wird die Vertex-C hoch und den definiert sie. Und dann, wenn wir eine Szene berechnen, ist der Vertex-Shader dafür nötig, Auftrags alles rumzuschieben, skalieren und dem Endeffekt zu projizieren. Dann wird es in die Rasterizer-Schicht geschoben, der die Projektion durchführt, welche diese Vertex-C's wo landen. Vertex-C's, as well and what. paar Vertex-C's, die er weggeschmissen und so weiter. Es gibt viele Regeln, aber im Endeffekt kriegen wir viele Fragmente, die in den Fragment-Shader weitergeleitet werden. Und der Fragment-Shader nimmt diese Werte und die Texturen und schreibt dann Farbwerte in die Fragment-Pipeline rein. Aber Endeffekt, das, was wir anzeigen wollen, ist im Frame Buffer und wird auf dem Bildschirm angezeigt. Und wir können sehen, was passiert ist oder was wir erreicht haben. So viel über die Architektur. Dass uns ein bisschen über die Shader-Sprache reden, wie die Fragmente und Vertex-Shader ist, ist eine eigene Sprache. Es ist ein bisschen C-ähnlich. Es hat nur sehr einfache Features. Es ist halt integrierte Vektor-Typen und Matrix-Typen. Wir werden da später drüber reden, ein bisschen detaillierter. Aber wir haben Typen für zwei und drei und vier-dimensionale Vektorinnen und Matrizen. Und wir haben auch eine Reihe von nationalen Funktionen, die Trivium-Methisch, Sinus, Cosinus, Quadriern, Logarithmos und Vektor-Funktionen. Wir haben keine Rekursionen, wir können Funktionen machen. Wir können uns aber die selber nicht aufrufen und wir haben nur limitierte Funktionen für Loops. Wir können sie haben, aber wir müssen beim Kompellieren wissen, wie häufig sie durchgeführt werden, ausgeführt werden. In der Rendering-Pipeline ist der Platz relativ gering und die GPU muss wissen, wie lange es dauert, um alles richtig einzurichten. Wir gucken uns kurz an, wie die Vertex-Shader und die Fragmentshader im Detail arbeiten, weil das der Kern dessen ist, der auch interessanten Dinge, die in OpenGL in den Shaders passieren und welche Eingaben und Ausgaben diese Shader haben. Wir starten mit dem Vertex-Shader. Der Vertex-Shader läuft einmal für jeden Vertex, der die Geometrie beschreibt. Wenn man einen Dreieck hat, dann läuft er einmal für jeden Punkt. Wenn man ein Wirbel hat, dann läuft er entsprechend häufiger. Je mehr Vertex-Shader man in der Szene hat, desto häufiger läuft der Vertex-Shader. Und jeder Vertex wird von diesem Shader verarbeitet. Die wichtigsten Eingabendaten sind die Vertex-Attribute. Die können für jeden Vertex anders sein. Die kann man selbst beschreiben. Typischerweise ist das die Position. Sehr häufig ist eine Textur-Koordinate mit dem Vertex verbunden und häufig auch eine Farbe, die mit dem Vertex verbunden ist oder was immer man braucht. Das ist komplett unter der Kontrolle des Programmierers. Da kann beliebige Vertex-Attribute definieren. Dann gibt es globale Parameter. Die sind für jeden Vertex-Shader des Processes gleich. Die heißen Uniforms. Das ist zum Beispiel die Projektionsmatrix. In der beschrieben ist genau aus welcher Richtung man auf die Szene guckt und in wie es auf die Projektionsfläche abgebildet wird. Der Vertex-Shader ist dafür zuständig, dass er alle Daten, die der Fragmentshader brauchen wird, später auch an den anderen Shaders weitergegeben hat. Das ist ein Variable. Die muss man explizit dann an den Fragmentshader übergeben. Die wichtigste Aufgabe des Vertex-Shaders ist natürlich, die endgültige Position jedes Vertex festzulegen, an der er abgebildet wird. Das wird gemacht und man diese GL-Position-Variable setzt. Typischerweise multipliziert man die Position mit einer Matrix, die endgültige Position in der Szene beschreibt. Da gehen wir weiter mit dem Fragmentshader. Der läuft für jedes Fragment, das dargestellt wird. Jeder Vertex, der proiziert wird, wird ein Fragment und der Fragmentshader läuft für jeden dieser Fragmente und legt zum Beispiel die Farbe von jedem dieser Fragmente fest. Wir haben wieder pro Vertex den Input. Wir eingaben, das sind die Werte, die der Vertex-Shader in den Variable an den Fragmentshader weitergeben muss. Hier haben wir die Texturkoordinate und die Farbattribute, die der Vertex-Shader weitergegeben hat. Das Wichtigste, um zu den Texturdaten zu kommen, ist, dass man einen Fragment colorieren will, dann findet man irgendeine Bitmap und man guckt dann eine Sampler2D-Variable, die in dem Textur. Die wichtigste Aufgabe ist dann halt, die endgültige Frage Farbe eines jeden Fragments festzulegen, indem man diese GL-Fragcolor spezielle Variable setzt. Das sind die Grundlagen. Ganz verwirrend im Moment. Aber ich bin sicher, dass es klarer wird, wenn wir an die aktuelle... Tatsächlich in den Code gucken. Aber vorher wird es ein bisschen komplizierter. Wir müssen ein klein wenig Mathematik machen. Wir müssen das, was wir tun, mit linearer Algebra modellieren. Ja, linearer Algebra ist der Teil der Mathematik, den wir hier brauchen. Und danach ist es einfacher Algebra durchzulernen, indem man programmiert als umgekehrt. Also es ist einfacher, wenn man einfach ein bisschen damit spielt. Wir beschreiben ein dreidimensionelles Objekt mit drei Koordinaten x, y und z. Das heißt, wir haben drei Achsen. Das ist ein recht händiges Koordinatensystem. Man macht ne Pritz. Dieses, der Daumen ist der x-Achse, zeigt nach... Rechts ist die x-Achse, der Zeigefinger ist die y-Achse, zeigt nach oben. Und der Mittelfinder zeigt auf einen selbst, ist die z-Achse. Das heißt, ebenso gibt es auch left- linkseindige Koordinaten, die arbeiten halt entsprechend anders. Das ist einfach zu erinnern, indem ihr die Hand vorstellt. Wir haben zwei grundlegende Konstrukte, Vektoren und Matrizen. Vektoren beschreiben Koordinaten und Matrizen beschreiben Transformationen. Wir gehen ja nicht zu viel in die Details. Ich will nur kurz zeigen, was ihr wissen wirst, um mir dann selbst weiterstudieren zu können. Vektoren beschreiben Positionen im Raum, dreidimensional x, y und z, zweidimensional y und z.B. eine Textur-Koordinate auf einer oberfläche. Sie können aber auch Farben sein, in diesem Fall Rot, Grün, Blau und Alpha. Dann gibt es Vektor-Operationen. Das gibt die Skalare-Multiplikation oder... Ja, Dot-Produkt. Skalarprodukt, ja. Wenn man den... Den Vektor wird sich selbst multipliziert, bekommt man die Länge des Vektors. Wenn man die... bei zwei Vektoren multipliziert, dann kriegt man den Cosinus zwischen den beiden. Das ist auch eine sehr wichtige Sache. Der andere ist die Vektor-Multiplikation oder Kreuzprodukt. Wenn man zwei Vektoren multipliziert, kriegt man einen dritten, der orthogonal auf den anderen beiden steht. Also wenn man den X und den Y-Vektor miteinander... ein Cosproduktbild, kriegt man halt den Z-Vektor, der den Krecht auf beiden steht. So viel für die Vektoren. Also jetzt Matritzen. Matritzen beschreiben Transformationen im Raum, im dreidimensionalen Raum. Wir haben vier mal vier Zellen, also 16 Zellen. Glücklicherweise muss man Matritzen zum Teil verstehen. Denn OpenGL hat einen ganzen Haufen Hilffunktionen, die einem die entsprechenden Matritzen erzeugen. Man hat zum Beispiel Verschiebungsmatritzen, die einen Vektor in irgendeine Richtung verschieben. Man kann einen Vektor um einen anderen Vektor drehen, um einen bestimmten Winkel, um eine Rotationsmatrix. Und wir können etwas skalieren. Man kann das weiter oder höher alles zusammen machen. Dann gibt es auch die Projektionsmatrix, die ein Vektor aus dem dreidimensionalen Raum in den zweidimensionalen Raum bringt. Das heißt also ein Perspektiv. Projektionsmatriktion, also eine Fluchtpunktprätspektive. Das heißt im Wesentlichen, dass Dinge, die kürzer, dichter sind, größer erscheinen als die, die weiter weg sind. Wesentlich ist es eine Matrix, die einen Vektor zweidimensional macht. Für Matritzen haben wir zwei Operationen, die wichtig sind, die Multiplikation einem Vektor. Das bedeutet, dass die Operation der Matrix auf den Vektor angewendet wird. Und man kann Matritzen miteinander multiplizieren. Das verquettet im Wesentlichen die Operationen, die man mit den Matritzen machen kann. Und wenn man halt die gleiche Konferenz und Mehrfach hat, dann muss man die Matritzen nur einmal machen. Das ist die Übersicht über die Algebra. Lass uns an den Coach gucken. Jetzt werden wir uns unsere Datei hellocamp.go anschauen. Das Ziel ist das Chaos Communication Camp Logo zu rendern auf einem Bildschirm in der Mitte des Bildschirms und ein bisschen um sich selber zu rotieren. Wir wollen die Farben spezifizieren und dann die richtige Form aus einer Textur herausladen. Der Beispielcode. Ich kann es euch noch nicht vorschüllen, ob es für euch funktioniert. Das heißt, ihr könnt es euch von meiner Webseite herunterladen. Das sollte auf einem Raspberry Pi 3 funktionieren. Das heißt, wir benutzen unser OpenGL Programm. Das folgende Programmfluss. Wir müssen unser OpenGL Kontext konfigurieren. Da benutzen wir EGL. Wir sagen der Maschine, wo sie ihre OpenGL Sachen tun soll, wie die Gebung, in der sie der OpenGL Code laufen soll, ist. Das ist ziemlich langweilig. Dann müssen wir die Szene initialisieren. Es hat mehrere Schritte. Da müssen die Geometriedaten und die Wehretricksdaten hinzufügen. Wir müssen die Farben- und Texturdaten initialisieren. Wir müssen den Fragmentshader initialisieren. Wir werden zusammengelegt. Wir haben ein Shader-Programm. Wir haben ein Shader-Programm. Wir haben ein Shader-Programm. Wir werden zusammengelegt. Wir haben ein Shader-Programm. Wir wollen in der Regel eine Kamera initialisieren, wo wir schauen können, von wo aus wir auf die Szene schauen. Das werden wir später genauer anschauen. Jetzt, wo die Szene initialisiert ist, schauen wir den Render-Loop an. Der update die Szene mit dem Benutzer-Input oder mit Zeit. Dann retrop den Scene-Ablauf. Und die Szene neut und neut ungefähr 60 mal pro Sekunde. So, den OpenGL-Context konfigurieren. Hängt davon ab, auf welcher Plattform man ist. Beim Raspberry Pi sieht es so aus. Create Context. Wir können Fehler herausfinden, ob ein Fehler passiert ist. Wir können die Frage nach der Höhe und der Breitdiff fragen. Man sagt, dass es wie es sein soll, und wir starten das GL-Subsystem. Scene Initialisierung. Man muss auch die ganzen Sachen initialisieren, wie vorgeschrieben. Wir sollten auch den Beginn-Timer irgendwo speichern, dass wir die aktuelle Zeit haben. Wir werden uns genauer anschauen, wie funktioniert die Initialisierung aus. Jeder initialisiert die Geometrie, die Vertex-Daten. Die einfachste Art, wie wir das machen, ist, dass wir ein stadtliches Array von Float-Pointern erstellen, die jetzt Vektoren gepasst werden können. Wir haben zwei Dreiecke. Ein Dreieck mit den Vertices A, B, C. Und das nächste mit den Vertices A, C, D. Jeder der Vertices hat seinerzeit eine Variable. Jeder hat mehrere Komponenten. Die Position, XYZ. Die Position im Raum. Die Texture-Koordinate dazugehört. Also, wo die Texture auf dieser Vertice gemappt werden soll. Und dann die Farbe, Rot, Grün, Blau und Alpha. Die zwischen den Ecken des Dreiecks gehört. Das ist in diesem Fall hart reinkodiert. Und dann sagen wir OpenGL, dass es die laden soll. In die Vertex-Speicher laden soll. Wir generieren einen Buffer. Wir verbinden den Buffer, zeigen die Vertex-Daten, sagen wie viele Daten wir haben, und dann schauen wir, ob es Fehler gab. Als nächstes wollen wir die Texture-Daten initialisieren. In diesem Fall das Chaos-Communication-Camp-Logo. Zuerst laden wir die Daten von der Datei, die BNG. Dann malen wir damit in den Bildern das RGBA im Bildobjekt. Malen wir die Daten, die wir gerade gestellt haben, da rein. Im RGBA-Format. Und nach den ersten vier Schritten haben wir die Texture-Variable. Dann sagen wir OpenGL, dass er die Daten in die Texture-Speicher laden soll. Malerweise macht man diese GL-Generate einen Text der Text-Image-Studie, die OpenGL erzählt, dass es die Daten nehmen soll und sie in die GPU Text-Tour-Speicher schreiben soll. Als nächstes initialisieren wir den Vertex-Shader. Den können wir in einem statischen String behalten. Den können wir einfach reinkudieren. Dieser Vertex-Shader ist sehr einfach. Es nimmt eine Kamera-Matrix um die Projektion zu definieren, um die Drehungen zu machen. Wir nehmen die Positionen und die Texture-Informationen und die Farben, die wir vorher definiert haben. Dann geben wir die Texture-Koordinator und so weiter. Und dann sagen wir, wo die OpenGL-Position sein soll. Also drei Zeilen-Shader. Und jetzt, wo wir diesen String haben, haben wir OpenGL-Lade und kompilieren diesen Shader. GL-Shader-Source GL-Compile-Shader und dann schauen wir, ob es Fehler gab. Danach ist der Vertex-Shader in einer kompletierten Version auf der GPU. Sechst mit den Fragments-Shaders ebenfalls relativ einfach, nehmen die Texture und die beiden Variablen vom Vertex-Shader, die Farbe und die Texture-Koordinator und in dem Shader nehmen wir die Farbe an dieser spezifischen Stelle. Also wir nehmen Texture und Text-Koordinator um die Farbe in diese Haare zu finden. Dann definieren wir die GL-Fragment-Farbe und aber das sind die RGBA wie es dort in den Werten gespeichert wird. Aber wir nehmen die Alphabere Farbe von der Texture, die wir in den Texture-Speicher haben. Dann machen wir wieder dasselbe Code, GL-Create-Shader am Ende die Fehlerabfrage. Das haben wir unsere beiden Shader im Arbeitsspeich. Hier ist das die Zusammenlinke, das Shader-Programm. Das sieht wieder sehr endlich aus. Die beiden Shader und check for error again und dann schauen wir doch mal nach vieren. Sind die gelingt? Die variablen Wissen voneinander und letztens müssen wir spezifizieren, wo die Vertex-Daten sind. Da müssen wir GL-Vertex-Attract- Chip-Pointer müssen die drei Blöcker, die ziemlich ähnlich sind und geben Farbe und Texture-Koordinate die Vertex-Daten und sagen wir, hey, an dieser Stelle haben wir so viele Floats, die nacheinander folgen, die entsprechend den Wertizisten beschreiben. Danach ist das Programm im Arbeitsspeicher und fertig. Wir können laufen, jetzt müssen wir noch unsere Kamera definieren. Wir müssen unsere Projektionsmatrix erstellen, die können wir berechnen. Da ist es für die Breite und wir müssen die Höhe gegen die Breite definieren. Wir müssen einen Bereich schauen, den wir uns anschauen, 45 Grad und stellen wir da einfach alles. Wir haben eine nahe und ferne Projektionsfläche. Dann wollen wir definieren, wo im Braum unsere Kamera ist. Da soll ein bisschen unterm sein auf der Z-Achse, dass wir auf Null auf den Punkt des Koordinat-Systems schauen. Wir haben unsere drei Ecke direkt um den Nullpunkt definiert. Wir wollen ein bisschen Abstand darauf schauen und wir script mgl.locatevector der die die Kamera sagt, wo sie hinschauen soll und den Vector nach oben zeigen. Jetzt haben wir die Projektion und den View-Matrix-Matrix haben. Wenn wir zusammen multiplizieren zu einer Kamera-Matrix-Variable die benutzt, im Shader benutzt wird dann nehmen wir die Identity-Matrix, multiplizieren die Matrix sind da drauf und dann haben wir unsere Kamera initialisiert. Das ist der Textezeug die Initialisierung ist in der Regel das Beschreibungs-Code Wir müssen ihn nur einmal ausführen am Anfang unseres Codes. Jetzt, wo die Szene initialisiert ist können wir den Render-Loop anfangen wie schon vorher gesagt, wir müssen unsere Szene updaten dann müssen wir sie neu zeichnen updaten ist relativ einfach, wir wollen nur wissen wie viel Zeit seit dem Stempel, dass gerade es ablaufen ist wir nehmen den aktuellen Zeit-Stempel und zubrieren den Anfangszeit-Stempel davon generieren davon den Winkel wie die Dreiecke rotiert werden sollten dann nehmen wir den Zinos von der abgelaufenen Zeit und multiplizieren das mit 45 Grad bei Werten zwischen 1 und minus 1 minus 1 also 45 und minus 45 Grad und im Winkel können wir eine Rotationsmatrix erstellen das FGL32.Home Rotate 3DY Nimm den Winkel das Rotationsmatrix um die Y-Achse und dann haben wir die Rotationsmatrix und die können wir mit der Kamera multiplizieren die wir vorher erstellt haben und dann sagen wir OpenGL hey, in den Index des ersten Elements der Matrix als Pointer die wir schon im Vertex-Shader definiert haben und nachdem dieses Schritt geupdatet würde ist da der richtige Wert der berechnete Wert beschrieben aus der bisher abgelaufenen Zeit und jetzt wo die Szene geupdatet wurde müssen wir das neu zeichnen das ist wieder relativ einfach wir haben die ganze schere Arbeit schon gemacht wir müssen den Bildschirm klären also alles was bis jetzt darauf ist müssen wir einfach löschen wir müssen das Programm das wir schon definiert haben benutzen welchen Buffer wir benutzen wer aufgebaut eingerichtet haben wenn jetzt alles ist wenn es da ist dann müssen wir einfach sagen hey, mal die 6 Vertices als 3 Ecke als 2 mal 3 2, 3 Ecke, 3 Vertices dann schauen wir wieder ob es Entfehler gab so jetzt sollte die Szene gezeigt werden, das heißt wieder anfangen und Render Loop nochmal machen das ganze 60 mal pro Sekunde malerweise haben wir den Sleep von dem 60. da drin bessere Methoden schönere Frameworks zu bekommen aber das ist einfach ein bisschen komplexer also wir das ist der Loop den wir so häufig wie möglich machen das ist jetzt mal so 60 das ist jetzt was ganz am Ende leider kann ich euch jetzt das echte Animation oder visuelle Zeichen nicht zeigen, worüber ich die letzte halbe Stunde geredet habe tut mir leid ich werde das zum funktionieren bringen in den nächsten paar Tagen also wenn ihr Interesse habt, geht sie zur URL die ich euch vorher gezeigt habe lasst das Programm herunter und ihr könnt es euch in Detail ansehen beinhalten den ganzen Code den wir bis jetzt uns angeschaut haben und hier sind noch ein paar Ressourcen solltet euch die interessieren chronos.org veröffentlicht Referenz Material sind auf einer Standard das heißt ihr könnt die ganzen Sachen herunterladen ohne euch zu registrieren der URL oben Referenzkarten zum Programmieren es gibt das Buch den OpenGL ist 2.0 Programmier Guide es ist relativ hilfreich den Überblick über das Ganze zu haben und es gab das rote Buch es war die Bibel OpenGL Programmierung Guide aber es ist ein bisschen veraltet inzwischen aber es kann immer noch wert sein zu lesen vielen Dank Danke Frau Kurt haben wir irgendwelche Fragen hier gibt es Mikrofon-Engel ein Hier, ein Da und der Signal Angel den ich hier gerade nicht sehen kann für Fragen, aber es gibt keine Fragen aus dem Internet oh, jetzt gibt es eine Frage Hallo, danke für den Talk soweit ich das verstanden habe wenn ich ist wenn du eine Szene verändern willst dann dann änderst du die Transformationsmark dann berechnest du die Transformationsmatrix in deiner Programmiersprache und dann schickst du die Transformationsmatrix an die GPU und dann dann zeichnest du die Szene neu indem du der GPU sagst die soll alle alle Pixel mitern ja, das ist korrekt man kann auch die Zeit in die Vertex-Shader übertragen und dann die gleichen Berechnungen auf der Karte machen oder du kannst den Winkel in den Shader schicken und dann die entsprechenden Berechnungen auf der Shader machen es hängt davon ab was das teuerste ist das gibt es und man kann entscheiden was das Beste ist aber am Ende kannst du es so machen wie es in deinem Fall einfacher ist was einfacher auf der CPU ist was auf das einfache Shader zu machen ist also ich könnte nur den neuen Winkel an die GPU schicken und ja klar, du kannst die Start Time und die aktuelle Zeilen oder du berechnest den Winkel auf der CPU an die GPU oder du berechnest die Matrix auf den CPU und schickst die ganze Matrix an die GPU aber du musst die Projektionsmatrix ohnehin an die GPU übertragen insofern kann es sinnvoll sein die Transformationsmatrix auf der CPU zu berechnen aber das hängt davon ab mehr Fragen mehr Fragen wow das ist rar es ist selten dass so wenig kommt ja es ist spät, okay keine Fragen mehr übrig, eine gute Vortrag noch einmal Applaus für Volker und dann können wir den Talk