Shader: Was ist das, Arten von Shadern und wie sie funktionieren

Was ist ein Shader?

Shader ist ein kleines Programm, das in einer spezialisierten Sprache geschrieben und auf der GPU ausgeführt wird. Jeder Shader verarbeitet ein Datenelement — einen Vertex, ein Fragment (Pixel) oder ein Arbeitselement — unabhängig von anderen. Der Parallelismus der GPU ermöglicht es, Tausende von Shader-Instanzen gleichzeitig auszuführen.

Der Begriff wurde von Pixar in den 1980er Jahren geprägt, um Programme zu beschreiben, die das Aussehen von Oberflächen in RenderMan steuern. In Echtzeit erschienen Shader mit der NVIDIA GeForce 3 (2001) — der ersten Grafikkarte mit programmierbarer Pipeline. Vor Shadern wurde Grafik durch feste Parameter konfiguriert: Farbe, Textur, Mischmodus.

Laut Unity Technologies (2025) verwendet ein durchschnittliches mobiles Spiel 50–200 Shader. Jeder Shader hat Varianten für verschiedene Plattformen, Qualitätsstufen und Beleuchtungskonfigurationen. Die Anzahl der Varianten kann 10.000 pro Projekt erreichen.

Die Architektur eines Shaders gliedert sich in Eingabedaten (Attribute, Uniform-Variablen, Texturen), Programmcode und Ausgabedaten (Farbe, Position). Uniform-Variablen werden von der CPU vor der Shader-Ausführung gesetzt und bleiben für alle Elemente des Frames unverändert. Attribute sind Daten pro Element (Vertex-Koordinaten, Normale, UV-Koordinaten).

SIMT-Ausführungsmodell

SIMT (Single Instruction, Multiple Threads) ist das Ausführungsmodell von Shadern auf der GPU. Eine Anweisung wird einmal geladen und von Hunderten von Threads mit unterschiedlichen Daten ausgeführt. Zum Beispiel startet ein Fragment Shader für 1000 Pixel 1000 Threads mit demselben Code, aber jeder Thread erhält seine eigenen UV-Koordinaten und interpolierten Attribute.

Eine wichtige Konsequenz von SIMT: Verzweigungen in Shadern sind teuer. Wenn innerhalb eines if-Blocks die Hälfte der Threads einen Zweig nimmt und die andere Hälfte einen anderen, führt die GPU beide Zweige sequentiell für alle Threads aus. Die Leistung sinkt auf 50%. Vermeiden Sie dynamische Verzweigungen in Shadern oder minimieren Sie sie durch Vorabberechnungen auf der CPU.

Arten von Shadern

Moderne GPUs unterstützen mehrere Arten von Shadern, jede für ihre Stufe der Grafik- oder Rechenpipeline. Betrachten wir die wichtigsten Arten: Vertex-, Fragment-, Compute- und moderne Mesh-Shader.

Vertex Shader

Vertex Shader verarbeitet jeden Vertex der Geometrie: transformiert Koordinaten, berechnet Beleuchtung, übergibt Daten an den Fragment Shader. Dies ist eine obligatorische Stufe der Grafikpipeline — ohne sie gelangen keine Vertices auf den Bildschirm. Der Vertex Shader wird für jeden Vertex jedes Frames aufgerufen.

Fragment Shader

Fragment Shader (oder Pixel Shader) ist die ressourcenintensivste Stufe. Er berechnet die endgültige Farbe jedes Fragments unter Verwendung von Texturen, Beleuchtung und Material. Der Fragment Shader wird für jedes Pixel ausgeführt, das von Geometrie bedeckt ist, unter Berücksichtigung aller angewendeten Texturen und Effekte. Die Optimierung dieses Shaders bringt den größten Leistungsgewinn.

Compute Shader

Compute Shader ist ein universeller Shader für beliebige Berechnungen auf der GPU. Im Gegensatz zu Grafik-Shadern ist er nicht an Geometrie oder Pixel gebunden. Der Compute Shader arbeitet mit beliebigen Datenpuffern über Arbeitsgruppen. Er wird für Physik, Partikelsimulation, Nachbearbeitungseffekte und Inferenz von neuronalen Netzen verwendet.

Mesh Shader

Mesh Shader ist der neueste Shader-Typ, der mit NVIDIA Turing (2018) und Metal 3 eingeführt wurde. Der Mesh Shader ersetzt Vertex-, Geometry- und Tessellation-Shader durch eine einzige Mesh-Pipeline. Er arbeitet mit dem Task Shader zusammen: Der Task Shader entscheidet, welche Mesh-Gruppen gerendert werden, und der Mesh Shader erzeugt die Geometrie in Echtzeit.

Sprachen zum Schreiben von Shadern

Shader werden in spezialisierten Sprachen geschrieben, die in GPU-Maschinencode kompiliert werden. Die Wahl der Sprache hängt von der Plattform und API ab. Betrachten wir die wichtigsten Sprachen: GLSL, HLSL, Metal Shading Language und das Zwischenformat SPIR-V.

GLSL (OpenGL Shading Language)

GLSL ist die Shader-Sprache für OpenGL, OpenGL ES und WebGL. Die Syntax basiert auf C mit zusätzlichen Vektortypen (vec2, vec4, mat4) und eingebauten Funktionen (texture, normalize, reflect). GLSL ES ist die Version für mobile Geräte mit eingeschränkter Präzision (lowp, mediump, highp). Laut Khronos (2025) bleibt GLSL aufgrund seiner plattformübergreifenden Natur die am weitesten verbreitete Shader-Sprache.

#version 300 es
precision mediump float;
in vec2 v_texCoord;
uniform sampler2D u_texture;
out vec4 fragColor;

void main() {
    fragColor = texture(u_texture, v_texCoord);
}

Ein einfacher Fragment Shader liest die Farbe aus der Textur anhand der UV-Koordinaten. precision mediump weist die GPU an, halbe Genauigkeit für float zu verwenden — das beschleunigt die Ausführung auf mobilen Geräten um 25–40%.

HLSL (High-Level Shader Language)

HLSL ist die Shader-Sprache von Microsoft für DirectX. Die Syntax ähnelt C++ mit Unterstützung für Klassen, Strukturen und Templates. HLSL wird in Windows-Anwendungen verwendet und unterstützt ab Shader Model 6.7+ Ray Tracing, Mesh Shaders und Sampler Feedback. Für die mobile Entwicklung wird HLSL nicht direkt verwendet, aber für Vulkan in SPIR-V kompiliert.

Metal Shading Language

MSL (Metal Shading Language) ist Apples Shader-Sprache, basierend auf C++14. Im Gegensatz zu GLSL und HLSL wird MSL zusammen mit der Anwendung kompiliert, was eine JIT-Kompilierung auf dem Gerät überflüssig macht. MSL unterstützt Zeiger, Templates und die C++-Standardbibliothek. Es wird auf allen Apple-Geräten verwendet: iPhone, iPad, Mac, Apple TV.

#include <metal_stdlib>
using namespace metal;
struct VertexOut {
    float4 position [[position]];
    float2 texCoord;
};

fragment float4
myFragment(VertexOut in [[stage_in]],
            texture2d<float> tex [[texture(0)]]) {
    constexpr sampler s = sampler(filter::linear);
    return tex.sample(s, in.texCoord);
}

MSL verwendet Attribute [[position]], [[stage_in]] und [[texture(N)]] zur Ressourcenbindung. Der Apple-Compiler erzeugt optimierten Code für die aktuelle GPU unter Berücksichtigung der Registeranzahl und des Caches.

SPIR-V

SPIR-V ist ein binäres Zwischenformat für Shader, der Standard für Vulkan. Shader werden in GLSL oder HLSL geschrieben, in SPIR-V kompiliert und in die Vulkan-Anwendung geladen. SPIR-V ist nicht an eine bestimmte Sprache gebunden — es gibt Compiler von Rust, Python, OpenCL C nach SPIR-V.

Shader in der mobilen Entwicklung

Shader auf mobilen Plattformen haben im Vergleich zu Desktop-Einschränkungen: weniger Register, begrenzte Genauigkeit und fehlende Unterstützung für einige Anweisungen. Betrachten wir die Besonderheiten von Shadern auf Android (Vulkan/OpenGL ES) und iOS (Metal).

Shader auf Android

Android verwendet GLSL ES für OpenGL und SPIR-V für Vulkan. OpenGL ES 3.2 unterstützt Shader standardmäßig mit mediump. Vulkan erfordert die explizite Kompilierung von GLSL in SPIR-V über glslangValidator. Auf Android werden Shader aus String-Ressourcen oder aus kompilierten SPIR-V-Dateien geladen.

Qualcomm Adreno GPU optimiert Shader auf Treiberebene. Empfehlungen: Verwenden Sie mediump für Farbe und UV, highp nur für Positionen; vermeiden Sie Texturabfragen in Vertex-Shadern; gruppieren Sie Berechnungen in Vektoren (vec4 statt 4x float). Laut Qualcomm (2025) bringen diese Optimierungen einen Gewinn von 30–50%.

Shader auf iOS

iOS verwendet ausschließlich Metal Shading Language. Shader werden zusammen mit der Anwendung über Xcode in Maschinencode kompiliert. Metal bietet Shader Debugger und GPU Capture zur Profilerstellung von Shadern. Die Apple GPU (TBDR) hat spezifische Optimierungen: Early Fragment Test, Memoryless Render Targets und Programmable Blending.

Laut Apple WWDC 2024 ist es für iOS-Shader kritisch, half statt float zu verwenden, den Registerdruck zu begrenzen (max. 64 Register) und abhängige Texturabfragen zu vermeiden. iOS-Shader müssen kompakt sein — optimale Größe 50–100 ALU-Instruktionen.

Shader in Unity und Unreal Engine

Die Spiele-Engines Unity und Unreal Engine bieten visuelle Shader-Editoren (Shader Graph, Material Editor) und abstrakte Sprachen (ShaderLab, USF). Der Entwickler schreibt den Shader in einer high-level Sprache, und die Engine kompiliert für die Zielplattform. Unity verwendet HLSL als Zwischensprache, Unreal verwendet USF (Unreal Shader Format).

Shader-Optimierung

Shader-Optimierung ist ein entscheidender Schritt in der Grafikentwicklung für mobile Geräte. Ein schlecht geschriebener Shader kann die FPS von 60 auf 20 senken. Betrachten wir die wichtigsten Optimierungsregeln und -techniken.

Rechengenauigkeit

Verwenden Sie die minimal ausreichende Genauigkeit: lowp für Farbe und UV, mediump für Normalen und Beleuchtung, highp nur für Positionen und Matrizen. Laut ARM (2025) sind mediump-Operationen auf Mali GPUs 2-mal schneller als highp. In GLSL ES wird dies durch precision-Qualifizierer festgelegt.

Minimierung von Texturabfragen

Texturabfragen sind die teuerste Operation in einem Shader (10–30 Zyklen gegenüber 1–2 für eine ALU-Instruktion). Reduzieren Sie die Anzahl der Abfragen: fassen Sie Texturen in Atlanten zusammen, speichern Sie Daten in Uniform-Arrays statt Texturen, cachen Sie Ergebnisse benachbarter Pixel durch Ableitungsinstruktionen.

Verzweigungen vermeiden

Dynamische Verzweigungen (if mit Uniform-Variable) reduzieren die Leistung der SIMT-Pipeline. Ersetzen Sie Verzweigungen durch mathematische Funktionen: mix(), step(), smoothstep() und clamp(). Diese Funktionen werden in 1–2 Instruktionen ausgeführt, während eine Verzweigung aufgrund von Thread-Divergenz 8–16 Instruktionen kosten kann.

// Schlecht: dynamische Verzweigung im Shader
if (u_enableLight) {
    color *= computeLighting(normal);
}

// Gut: mathematische Verzweigungsersetzung
color *= mix(1.0, computeLighting(normal),
              float(u_enableLight));

mix() führt eine lineare Interpolation zwischen zwei Werten durch. Wenn u_enableLight=0, wird 1.0 zurückgegeben — die Farbe ändert sich nicht. Wenn u_enableLight=1, wird das Beleuchtungsergebnis zurückgegeben. Keine Verzweigung — alle Threads führen denselben Code aus.

Shader-Beispiele

Betrachten wir praktische Shader-Beispiele für die mobile Entwicklung — von einfacher Schattierung bis zur prozeduralen Texturgenerierung. Jedes Beispiel demonstriert eine bestimmte Technik.

Phong-Beleuchtung (Vertex Shader)

Phong-Modell ist das klassische Beleuchtungsmodell mit diffusen und spekularen Komponenten. Der Vertex Shader berechnet die Beleuchtung für jeden Vertex, der Fragment Shader interpoliert nur das Ergebnis (Gouraud Shading). Geeignet für mobile Geräte aufgrund der geringen Kosten.

#version 300 es
layout(location = 0) in vec4 a_position;
layout(location = 1) in vec3 a_normal;
uniform mat4 u_mvp;
uniform mat4 u_modelView;
out vec3 v_color;

void main() {
    vec3 normal = normalize(mat3(u_modelView) * a_normal);
    vec3 lightDir = normalize(vec3(0.0, 1.0, 1.0));
    float diff = max(dot(normal, lightDir), 0.0);
    v_color = vec3(0.8, 0.2, 0.2) * (0.3 + diff * 0.7);
    gl_Position = u_mvp * a_position;
}

Der Shader berechnet die diffuse Beleuchtung: Skalarprodukt von Normale und Lichtrichtung. Das Ergebnis wird mit den Ambient- (0.3) und Diffuse-Anteilen (0.7) gemischt. Führt 10–15 ALU-Instruktionen pro Vertex aus — akzeptabel für 100.000 Polygone bei 60 FPS auf einer mobilen GPU.

Prozedurale Textur (Fragment Shader)

Prozedurale Texturen werden im Fragment Shader ohne Laden aus einer Datei generiert. Spart Videospeicher und vereinfacht Animationen. Beispiel — ein Schachbrett mit einstellbarer Zellgröße. Nur wenige ALU-Instruktionen — minimale Last auf der GPU.

#version 300 es
precision mediump float;
in vec2 v_uv;
uniform float u_cells;
out vec4 fragColor;

void main() {
    vec2 cell = floor(v_uv * u_cells);
    float isWhite = mod(cell.x + cell.y, 2.0);
    fragColor = mix(vec4(0.1, 0.1, 0.1, 1.0),
                     vec4(0.9, 0.9, 0.9, 1.0),
                     isWhite);
}

8 ALU-Instruktionen — ein idealer Shader für mobile Geräte. u_cells gibt die Anzahl der Zellen pro Achse an. floor und mod sind günstige Operationen, die in 1 Takt auf allen mobilen GPUs ausgeführt werden.