Computer graphics & visualization 3D Graphics APIs: OpenGL & Fixed Function Pipeline

computer graphics & visualization

3D Graphics APIs: OpenGL & Fixed Function Pipeline


3D Graphics APIs: OpenGL & Fixed Function PipelineJan-Hendrik Behrmann

Übersicht1. OpenGL• Was ist das?• Wer ist das?• Programmbeispiel

2. Fixed Function Pipeline• Vom Modell zum Bild• Grundbegriffe• Die OpenGL-Pipeline

• Per-Vertex Operations• Rasterization• Per-Fragment Operations



OpenGL – Was ist das?OpenGL = Open Graphics Library

• Spezifikation einer API zur Entwicklung von 3D-Grafik-Anwendungen

• API = Application Programming Interface– Bibliothek von Funktionen zum Zugriff auf ein

darunterliegendes Softwaresystem.– Beispiel: Dateisystem-API eines Betriebssystems.



OpenGL – Ziele• Erleichterung für den Programmierer – Einheitliche API für die Grafikprogrammierung

• Plattformunabhängigkeit– Verbindlicher Leistungsumfang

• Hardwarenahe Grafikprogrammierung– Zugriff auf Hardwarefeatures

• Ständige Weiterentwicklung– Nutzung und Anpassung an neue Technologien



OpenGL – Wer ist das?• Entwickelt von Silicon Graphics (sgi)• Version 1.0 veröffentlich am 1. Juli 1992• Weiterentwicklung durch das Architecture

Review Board (ARB)– Konsortium von Unternehmen aus der Branche– Gründungsmitglied Microsoft steigt 2003 aus

• Seit September 2006 eingegliedert in die Khronos Group



Aus Sicht des Programmierers• OpenGL Library in gängigen

Entwicklungsumgebungen bereits enthalten• Nutzung über Einbindung der Library und

zugehörigen Headerdatei• Viele zusätzliche hilfreiche Libraries verfügbar• Breite Unterstützung bei Grafikkarten und

Betriebssystemen



Programmausschnittint DrawGLScene(GLvoid) // Here's Where We Do All The Drawing{

glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Clear Screen And Depth // Buffer

glLoadIdentity(); // Reset The Current Modelview MatrixglTranslatef(-1.5f,0.0f,-6.0f); // Move Left 1.5 Units And Into The

// Screen 6.0glBegin(GL_TRIANGLES); // Drawing Using Triangles

glColor3f(1.0f,0.0f,0.0f); // Set The Color To RedglVertex3f( 0.0f, 1.0f, 0.0f); // TopglColor3f(0.0f,1.0f,0.0f); // Set The Color To GreenglVertex3f(-1.0f,-1.0f, 0.0f); // Bottom LeftglColor3f(0.0f,0.0f,1.0f); // Set The Color To BlueglVertex3f( 1.0f,-1.0f, 0.0f); // Bottom Right

glEnd(); // Finished Drawing The TriangleglTranslatef(3.0f,0.0f,0.0f); // Move Right 3 UnitsglColor3f(0.5f,0.5f,1.0f); // Set The Color To Blue One Time OnlyglBegin(GL_QUADS); // Draw A Quad

glVertex3f(-1.0f, 1.0f, 0.0f); // Top LeftglVertex3f( 1.0f, 1.0f, 0.0f); // Top RightglVertex3f( 1.0f,-1.0f, 0.0f); // Bottom RightglVertex3f(-1.0f,-1.0f, 0.0f); // Bottom Left

glEnd(); // Done Drawing The Quadreturn TRUE; // Keep Going

}



Programmausgabe



Übersicht1. OpenGL ✓2. Fixed Function Pipeline• Vom Modell zum Bild• Grundbegriffe• Die OpenGL-Pipeline• Per-Vertex Operations• Rasterization• Per-Fragment Operations



Vom Modell zum Bild• Aus der dreidimensionalen mathematischen

Beschreibung einer Szene soll ein zweidimensionales Bild erzeugt werden.

• Dieser Vorgang heißt Rendering.

Rendering



RaytracingGrundlegendes Verfahren:• Aussendung eines

Strahls vom Augpunkt durch die Bildebene.

• Trifft der Strahl auf ein Objekt, so nimmt der Bildpunkt seine Farbe an.

• Berechnung von Schatten durch Schattenstrahlen.



Rendering in OpenGL• OpenGL nutzt stattdessen eine Rendering-

Pipeline.• Die Pipeline erhält verschiedene Parameter als

Eingabe und berechnet aus ihnen ein Rasterbild.

• Der Ablauf der Berechnungen und die verwendeten Verfahren sind in OpenGL fest vorgegeben (Fixed Function Pipeline).

• Dadurch gut in Hardware umsetzbar.



Primitive und Vertices• Alle Grafikobjekte

bestehen aus Primitiven.• Primitive sind Punkte,

Linien, Dreiecke und andere Polygone.

• Primitive sind definiert durch ihre Eckpunkte (Vertices).



Primitive und Vertices• Vertices speichern Attribute:– Koordinaten– Farbinformationen– ggf. Texturkoordinaten– andere Informationen …



OpenGL Rendering Pipeline

(vereinfachte Darstellung)



Per-Vertex Operations• Die übergebenen Vertices werden bearbeitet :– Im dreidimensionalen Raum platzieren– In Kamerakoordinaten umrechnen– Auf 2-dimensionale Koordinaten projizieren

• Dies geschieht jeweils durch Multiplikation der Vertices mit geeigneten Matrizen.



Model Transformation• Eingabe: Vertices in lokalen Koordinaten• Die lokalen Koordinaten des Primitivs werden

durch Drehung, Skalierung und Verschiebung in Weltkoordinaten überführt.

• Ausgabe: Vertices in Weltkoordinaten(0,1)

(1,-1)(-1,-1)

lokale KoordinatenWeltkoordinatensystem

Model Transformation



Viewing Transformation• Eingabe: Vertices in Weltkoordinaten• Analog zur Model Transformation werden alle Vertices

entsprechend zur Kameraposition transformiert.• Die Kamera befindet sich nun im Ursprung, und blickt

die Tiefenachse hinunter.• Ausgabe: Vertices in Kamerakoordinaten.

In OpenGL: Model und Viewing Transformation zu ModelView-Matrix zusammengefasst.



Lighting• Für jeden Vertex wird ein Beleuchtungswert

berechnet.– Abhängig von Lichtquellen und den Normalenvektoren der

Vertices.– OpenGL nutzt das Phong-Beleuchtungsmodell.







Projection Transformation• Eingabe: Vertices in Kamerakoordinaten• Sichtbarer Bereich wird als Pyramidenstumpf

aufgefasst (Frustum).



Projection Transformation• Der Stumpf wird nun zu einem Einheitswürfel

transformiert. Dabei tritt die typische perspektivische Verzerrung auf.

• Der Würfel enthält den gesamten sichtbaren Bereich.



Primitive Assembly• OpenGL gruppiert zusammengehörige Vertices

zu Primitiven.• Unsichtbare Primitive (die uns ihre Rückseite

zuwenden) werden entfernt (Backface Culling).• Primitive, die über den Würfel hinausragen,

werden entlang der Würfelkanten beschnitten.

Clippingneuer Vertex



Viewport Transformation• Die verbliebenen Vertices werden auf eine

zweidimensionale Ebene (Viewing Plane) projiziert. Der Tiefenwert bleibt allerdings noch erhalten.

• Die entstandenen normierten 2D-Koordinaten werden schließlich auf echte Pixelkoordinaten des Bildschirms transformiert.







Rasterization• Allgemein: Umwandeln einer vektoriell

beschriebenen Bildinformation zu einem Rasterbild.

• Hier: Umwandeln der noch durch Vertices beschriebenen Primitiven in darstellbare Bildinformationen.



Scanline Rendering• Prüfung jedes Bildpunkts

auf Überdeckung mit dem Grafikprimitiv.

• Ablauf zeilenweise (in „Scanlines“).

• Bei Überdeckung Erstellung eines Fragments.



Rasterization• Durch Interpolation aus den Vertexattributen

werden die Beleuchtungs-, Farb- und ggf. Texturkoordinaten für das Fragment gewonnen.

rot

blaugrün







Per-Fragment Operations1. Wenn für ein Fragment Texturkoordinaten

vorliegen, wird dem Fragment der passende Farbwert aus der Textur zugewiesen.

2. Durch eine Reihe von (optionalen) Tests, wird geprüft, ob das Fragment dargestellt werden soll.



Per-Fragment Operations• Tiefentest– Tiefeninformation des Fragments wird mit Depth

Buffer verglichen– Wenn ein Objekt mit geringerer Tiefe (vor dem

aktuellen Objekt) existiert, wird Fragment verworfen

– Ansonsten wird Framebuffer an dieser Stelle überschrieben bzw. mit neuem Farbwert vermischt.



Ausblick• Fixed Function Pipeline inzwischen überholt.• Hardware-Entwicklung macht weiterhin

Fortschritte.• OpenGL jetzt in Version 2.1 (mit in Teilen

programmierbarer Rendering-Pipeline)• Bald: Version 3.0– Größerer Umbau der API– Nicht mehr abwärtskompatibel zu Vorversionen– Keine Fixed Function Pipeline mehr



Fragen

Documents

Computer graphics & visualization 3D Graphics APIs: OpenGL & Fixed Function Pipeline