GL ShadingLanguage(GLSL)

Transkript

1 Was ist GLSL C/Java ähnliche Hochsprache zur Erstellung von GPU-basierter Software (Shader) An die Open Graphics Library (OpenGL) gebunden Darstellung komplexer 2D- und 3D-Szenen auf Basis von Echtzeitberechnungen Heute als Standardschnittstelle auf praktisch allen Plattformen mit 3D-Unterstützung verfügbar (Auf Microsoft-Systemen allerdings Dominanz von Direct-3D) Vorteile gegenüber Fixed Functionality: Hohe Flexibilität Optimale Lastverteilung CPU - GPU Verbesserte Effekte für Licht, Schatten, Nebel etc. Neue Effekte wie Ocean Simulation, Interactive Flames etc. Neue Visualisierungsmethoden wie Raycasting / Raytracing für Volumen

2 Grundstruktur eines Shaders. // Globale Variablendeklaration varying float fvariable1; // Funktion mit einem Parameter vec3 berechnevektor (float par1) return (vec3(1.0, 0.0, par1)); // Main-Funktion für Shader void main () // Lokale Variablendeklaration vec3 cvektor; // Operationen und Anweisungen cvektor = dot (berechnevektor(0.5), vec3 (vektor2));

3 Datentypen Boolscher Datentyp: bool 0.0 oder 1.0 Ganzzahldatentyp: int Wertebereich entspr. Bitbreite GPU Gleitkommadatentyp: float Wertebereich entspr. Bitbreite GPU Vector 2D: vec2 float, float Vector 3D: vec3 float, float, float Vector 4D: vec4 float, float, float, float Matrix 2 Zeilen / 2 Spalten: mat2x2 alle Werte float Matrix 3 Zeilen / 3 Spalten: mat3x3 alle Werte float Matrix 4 Zeilen / 4 Spalten: mat4x4 alle Werte float 2D Textursampler: sampler2d dynamischer Byte-Buffer 3D Textursampler: sampler3d dynamischer Byte-Buffer

4 Deklaration von lokalen Variablen: Die Deklaration lokaler Variablen erfolgt über Datentyp und (unter Beachtung der Javatypischen Einschränkungen) frei wählbarem Variablennamen. z.b.: int ivar; float fvar; vec3 v3var; Deklaration von globalen Variablen: Bei der Deklaration globaler Variablen ist zusätzlich zur Angabe von Datentyp und Variablennamen die Angabe eines Qualifiers zwingend erforderlich (Beschreibung der Qualifier nachfolgend). z.b.: uniform int ivar; varying float fvar; const vec3 v3var;

5 Qualifiers für globale Variablen Folgende Qualifizierer stehen unter GLSL zur Verfügung: const: varying: uniform: unveränderlicher Dateninhalt identisch zu Java Variablen für die Kommunikation zwischen Vertex- und Fragment-Shader. Die Deklaration muss in beiden Shader-Programmen vorgenommen werden. Im Vertex-Shader read / write, im Fragment-Shader read only, im Anwendungsprogramm (CPU) nicht verfügbar. Variablen, die sowohl im Vertex- als auch im Fragment-Shader deklariert werden können. In Vertex- und Fragment-Shader read only, im Anwendungsprogramm (CPU) read / write. attribute: globale Variablen für die Referenz auf externe Datenströme. im Vertex-Shader read only, im Fragmant-Shader nicht verfügbar, im Anwendungsprogramm (CPU) read / write.

6 Initialisierung von Variablen Die Initialisierung von Variablen geschieht wie bei den meisten Programmiersprachen durch Wertzuweisung bei oder nach der Deklaration. Dabei muss die Datentypkonformität immer beachtet werden. Gegensatz zu Java ist kein typecast implementiert. Statt dessen ist die Benutzung eines konstruktorähnlichen Aufrufs vorgesehen: Beispiele: float a; a = 10; a = (float) 10; a = 10f; a = 10.0f; a = float(10f) a = 10.0; a = float(10); a = float(10.0) // falsch // funktioniert // richtig vec3 b; b = 5; b = vec3(5.0f); b = vec3(5.0f, 5.0f, 5.0f); // falsch b = vec3(5); // funktioniert (alle Werte 5) b = vec3(5, 5, 5); b = vec3(5.0, 5.0, 5.0); // richtig

7 Interner Zugriff auf Variablen Der Zugriff aus simple Datentypen erfolgt analog zu bei Java, C etc.: float var1 = float(2.0); float var2 = var1; Für Vektoren wurden Namensets definiert, über die der Zugriff auf die einzelnen Komponenten leicht möglich ist: x, y, z, w Für den Zugriff auf Vektoren die Vertexdaten repräsentieren. r, g, b, a Für den Zugriff auf Vektoren die Farbwerte repräsentieren. s, t, p, q Für den Zugriff auf Vektoren die Texturkoordinaten repräsentieren vec4 var3 = vec4(1.0, 0.5, 2.1, 0.0); float var4 = var3.y; var4 enthält den Wert 0.5 float var5 = var3.g; var5 enthält den Wert 0.5 float var6 = var3.p; var6 enthält den Wert 2.1 float var7 = var3.b; var7 enthält den Wert 2.1

8 Funktionen für externer Zugriff auf uniform - Variablen Der Zugriff auf uniform - Shadervariablen aus dem Anwendungsprogramm erfolgt über die verschiedenen Varianten der Open GL Funktion gluniform: gluniform1i(glint location, GLint v0); gluniform2i(,, ); gluniform3i(,,, ); gluniform4i(glint location, GLint v0, GLint v1, GLint v2, GLint v3); gluniform1f(glint location, GLfloat v0); gluniform2f(,, ); gluniform3f(,,, ); gluniform4f(glint location, GLfloat v0, GLfloat v1, GLfloat v2, GLfloat v3); gluniformmatrix2fv(int location, int count, bool transpose, float[] value, int offset) gluniformmatrix3fv(int location, int count, bool transpose, float[] value, int offset) gluniformmatrix4fv(int location, int count, bool transpose, float[] value, int offset) Jeder Funktion muss ein Integerzeiger auf den entsprechenden Speicherbereich (location) übergeben werden. Dieser kann mit der Funktion GLint glgetuniformlocation(gluint program, const GLchar *name) ermittelt werden.

9 Funktionen für externer Zugriff auf attribute - Variablen Der Zugriff auf attribute Shadervariablen aus dem Anwendungsprogramm erfolgt über die Open GL Funktion glvertexattribpointer: void glvertexattribpointer(gluint location, GLint size, GLenum type, GLboolean normalized, GLsizei stride, const GLvoid * pointer); Der location Parameter wird wie beim Handling von uniform Variablen über die Funktion glgetuniformlocation() ermittelt. pointer ist ein Zeiger auf einen Speicherbereich, der die Startadresse der zu verarbeitenden Daten repräsentiert.

10 Build in Variablen: Für die Steuerung grundlegender Renderprozesse sind eine Reihe von Variablen ohne Deklaration durch den Entwickler verfügbar (build in). Die wichtigsten sind: gl_position: Besitzt den Datentyp vec4 und ist als write only Variable im Vertex-Shader verfügbar. Sie dient der Übermittlung der Vertex-Daten an den Rasterizer. gl_fragcolor: Besitzt ebenfalls den Datentyp vec4 und ist als write only Variable im Fragment-Shader verfügbar. Sie dient der Übermittlung der RGBA-Daten an das output merging. Die genannten build in Variablen müssen vom Vertex- und Fragmant-Shader immer mit den entsprechenden Daten gefüllt werden, da sonst keine Darstellung möglich ist.

11 if-anweisung If-Anweisungen sind identisch zu Java implementiert. Beispiel: if ( var1 > 0 ) var2 = 5; else var2 = 0;

12 Schleifen Auch Schleifen sind in gleicher Implementierung wie in wesentlichen Hochsprachen Verfügbar. Unterstützt werden folgende Schleifentypen : for (Startausdruck; Durchlaufbedingung; Wiederholungsausdruck) statement while (Durchlaufbedingung) statement do statement while (Durchlaufbedingung)

13 Funktionen Auch die Implementierung entwicklerdefinierter Funktionen orientiert sich an modernen Hochsprachen. Allerdings existiert keine Möglichkeit der Funktionsdeklaration beispielsweise über Header-Files. Deshalb müssen entwicklerdefinierte Funktionen im Quelltext immer vor dem ersten Funktionsaufruf platziert werden. RückgabeTyp FunktionsName(Typ0 Argument0, Typ1 Argument1,..., TypN ArgumentN) return RückgabeWert; Funktionen die nichts zurückgeben müssen mit dem RückgabeTyp void deklariert werden, außerdem entfällt dann logischerweise die return-anweisung: void Halbiere(float EingabeWert; out float AusgabeWert) AusgabeWert = EingabeWert / 2;

14 Build in - Funktionen Unter GLSL ist eine große Anzahl von Funktionen für mathematische Operationen (insbesondere Vektorarithmetik) verfügbar. Diese sind fester Bestandteil des Sprachcompilers und deshalb (zur Zeit noch?) nicht über Funktionsbibliotheken erweiterbar. Eine sinnvolle Auswahl vermeintlich besonders wichtiger Funktionen kann hier nicht getroffen werden. Deshalb wird auf das entsprechende Referenzhandbuch verwiesen.

15 GLSL Sprachcompiler Für die Ausführung der unter GLSL erstellten Shader-Programme müssen diese in einen von der GPU ausführbaren Binärcode übersetzt werden. Dies geschieht in gleicher Weise wie bei echten (ohne runtime environment) Sprachcompilern für CPU in einem zweistufigen Verfahren: 1. Compiler: Übersetzung der Quelltexte in Binärcode 2. Linker: Adressenvergabe zur Verbindung der Binärecode-Teile, Stack-Handling etc. Beide Prozesse werden in der Grafikkarte ausgeführt (build in compiler). Dazu müssen die Programmquelltexte (Vertexshader und Fragmentshader) der GPU als Zeichenketten übergeben werden. Dafür und für die Initialisierung der Prozesse zum Compilieren und Rendern stellt OpenGL Funktionen bereit. Zudem ist ein fester Ablauf definiert, der eingehalten werden muss (Nachfolgend):

16 GLSL Sprachcompiler - Compilierung glcreateshader: glshadersource: glcompileshader: Erzeugung eines leeren Shader-Objektes Zuweisung des Shader-Quelltextes Ausführung des build in Compilers Der dargestellte Ablauf ist für jeden Shader abzuarbeiten. GLSL Sprachcompiler - Linken glcreateprogram: glattachshader: gllinkprogram: Erzeugung eines leeren Programm-Objektes Zuweisung eines compilierten Shader-Objektes Ausführung des build in Linkers Über glattachshader müssen zumindest ein Vertex Shader Objekt und ein Fragment Shader Objekt zugewiesen werden. Ein gelinktes Shader-Programm wird der GPU über die Funktion gluseprogram zugewiesen.