Vertex Shader: Was es ist, Aufgaben und Funktionsprinzip

Was ist Vertex Shader?

Vertex Shader ist eine programmierbare Stufe der Grafikpipeline, die jeden Scheitelpunkt eines 3D-Modells einzeln verarbeitet. Ein Scheitelpunkt (Vertex) ist ein Punkt im dreidimensionalen Raum, der Attribute enthält: xyz-Koordinaten, Normalen, Farbe und UV-Texturkoordinaten.

Im Gegensatz zur Fixed-Function-Pipeline, bei der Transformationen nach einem starren Algorithmus durchgeführt wurden, gibt der Vertex Shader dem Entwickler die vollständige Kontrolle über die Scheitelpunkttransformation. Dies ermöglicht die Implementierung von prozeduraler Animation, Modellverformung, Skelett-Skinning und beliebigen mathematischen Transformationen auf der GPU-Seite.

Position des Vertex Shader in der Grafikpipeline

Die OpenGL ES Grafikpipeline umfasst eine Abfolge von Stufen von den Eingabedaten bis zum endgültigen Bild. Vertex Shader befindet sich nach der Scheitelpunkt-Assemblierungsstufe und vor der Rasterisierungsstufe. Jeder von der CPU über einen Scheitelpunktpuffer gesendete Scheitelpunkt durchläuft den Vertex Shader genau einmal, und das Ergebnis wird zur Primitivassemblierung an die nächste Stufe weitergeleitet.

Wie funktioniert Vertex Shader?

Vertex Shader empfängt Scheitelpunktattribute aus dem Scheitelpunktpuffer (VBO) über Scheitelpunktattributzeiger, die im CPU-Code konfiguriert sind. Der Entwickler schreibt Shader-Code in GLSL (OpenGL Shading Language) oder einer gleichwertigen Sprache, die der GPU-Treiber in Maschinenanweisungen für den jeweiligen Chip kompiliert.

Scheitelpunktverarbeitungsablauf

Für jeden Scheitelpunkt führt der Vertex Shader nacheinander drei Operationen aus: Lesen der Eingabeattribute — Anwenden der vom Entwickler definierten Transformationen — Schreiben der Ergebnisse in Ausgabevariablen. Die mindestens erforderliche Ausgabe ist die Scheitelpunktposition im Clip-Raum (gl_Position). Alle anderen Ausgabedaten (Farbe, Normalen, Texturkoordinaten) werden interpoliert und an die nächste Stufe — den Fragment Shader — übergeben.

#version 300 es
in vec3 aPosition;
in vec2 aTexCoord;
uniform mat4 uMVP;
out vec2 vTexCoord;

void main() {
    gl_Position = uMVP * vec4(aPosition, 1.0);
    vTexCoord = aTexCoord;
}

Hauptaufgaben von Vertex Shader

Vertex Shader löst eine breite Palette von Grafikpipeline-Aufgaben im Zusammenhang mit Geometrietransformation. Jede Aufgabe wird durch mathematische Operationen an Vektoren und Matrizen implementiert, die parallel für Tausende von Scheitelpunkten gleichzeitig ausgeführt werden.

Koordinatentransformation über MVP

Die grundlegende und häufigste Aufgabe ist die Multiplikation der Scheitelpunktkoordinaten mit den Model-, View- und Projection-Matrizen (MVP). Die MVP-Matrix transformiert einen Scheitelpunkt vom lokalen Modellraum in den Clip-Raum, der dann in den automatischen Pipeline-Stufen normalisiert und in Bildschirmkoordinaten umgewandelt wird.

Skelettanimation (Skinning)

Für animierte Charaktere implementiert der Vertex Shader die Skelettanimation (Skinning). Jeder Scheitelpunkt ist mit bestimmten Gewichten an mehrere Knochen gebunden. Vertex Blending — eine gewichtete Summe der Transformationen der gebundenen Knochen — ermöglicht eine glatte Verformung der Haut des Charakters, wenn sich das Skelett bewegt.

Prozedurale Geometrieverformung

Der Vertex Shader kann Geometrie basierend auf Zeit oder anderen Uniform-Parametern ohne CPU-Beteiligung modifizieren. Wellenverformung, Perlin-Rausch-Verschiebung und Wasserwelleneffekte — all diese Effekte werden im Vertex-Shader implementiert, ohne Geometrie aus dem RAM neu zu laden.

Vertex Shader vs Fragment Shader: Unterschiede

Obwohl beide Shader-Typen programmierbare Stufen der Grafikpipeline sind, lösen Vertex Shader und Fragment Shader grundlegend unterschiedliche Aufgaben und arbeiten auf verschiedenen Stufen der Bildverarbeitung.

Der Hauptunterschied ist die Aufruffrequenz. Der Vertex Shader wird einmal pro Scheitelpunkt aufgerufen, während der Fragment Shader für jedes Fragment (Pixel) aufgerufen wird. In einer hochauflösenden Szene übersteigt die Anzahl der Fragment-Shader-Aufrufe die Anzahl der Vertex-Shader-Aufrufe um das Tausendfache, was die Optimierung von Pixelshäddern noch kritischer macht.

Leistung und Optimierung von Vertex Shader

Die Leistung des Vertex Shader ist für Echtzeitanwendungen äußerst wichtig, insbesondere in der mobilen Entwicklung mit begrenztem Energieverbrauch. Die Hauptleistungsfaktoren sind die Anzahl der Scheitelpunkte, die Komplexität des Shader-Codes und die GPU-Speicherbandbreite.

Faktoren, die die Leistung beeinflussen

• Scheitelpunktanzahl — die Anzahl der pro Frame an die GPU gesendeten Scheitelpunkte. Modelle mit Millionen von Polygonen erzeugen eine hohe Belastung des Vertex-Shaders.
• Shader-Komplexität — die Anzahl der Anweisungen im Shader. Verschachtelte Schleifen und bedingte Verzweigungen (Divergenz) verringern die parallele Leistung von SIMD-Einheiten.
• Bandbreite — die Geschwindigkeit des Lesens von Scheitelpunktdaten aus dem Videospeicher. Das Attributformat (float32, float16, normalisierte ganze Zahl) wirkt sich direkt auf den Durchsatz aus.

Optimierungsmethoden für Vertex-Shader

Zur Reduzierung der Last auf den Vertex Shader werden folgende Ansätze verwendet. Level of Detail (LOD) — Umschalten auf vereinfachte Modellversionen, wenn sich die Kamera vom Objekt entfernt. Instancing — wiederholtes Zeichnen derselben Geometrie mit verschiedenen Transformationsmatrizen in einem einzigen Draw-Aufruf.

// Vertex Shader mit Instancing-Unterstützung
in vec3 aPosition;
in mat4 aInstanceMatrix;
uniform mat4 uViewProjection;

void main() {
    vec4 worldPos = aInstanceMatrix * vec4(aPosition, 1.0);
    gl_Position = uViewProjection * worldPos;
}

Vertex Shader Codebeispiele

Vertex Shader hat über verschiedene Grafik-APIs hinweg eine ähnliche Logik, aber unterschiedliche Syntax und Namenskonventionen. Sehen wir uns die Implementierung eines einfachen Vertex-Shaders in GLSL für OpenGL ES 3.0 und in Metal Shading Language für iOS und macOS an.

GLSL-Beispiel für OpenGL ES 3.0

#version 300 es
in vec4 position;
in vec3 normal;
in vec2 texcoord;

uniform mat4 modelViewMatrix;
uniform mat4 projectionMatrix;
uniform mat3 normalMatrix;

out vec3 vNormal;
out vec2 vTexCoord;
out vec3 vPosition;

void main() {
    vec4 mvPosition = modelViewMatrix * position;
    vPosition = mvPosition.xyz;
    vNormal = normalMatrix * normal;
    vTexCoord = texcoord;
    gl_Position = projectionMatrix * mvPosition;
}

Metal Shading Language Beispiel

#include <metal_stdlib>
using namespace metal;

struct VertexIn {
    float3 position [[attribute(0)]];
    float3 normal   [[attribute(1)]];
};

struct VertexOut {
    float4 position [[position]];
    float3 worldNormal;
};

vertex VertexOut
vertexMain(VertexIn in [[stage_in]],
           constant float4x4& mvp [[buffer(1)]]) {
    VertexOut out;
    out.position = mvp * float4(in.position, 1.0);
    out.worldNormal = in.normal;
    return out;
}