High Level Shading Language

aus Wikipedia, der freien Enzyklopädie

High Level Shading Language (HLSL) ist eine für DirectX entwickelte Programmiersprache, die für die Programmierung von Shader-Bausteinen eingesetzt wird. Gelegentlich wird auch die gesamte Gruppe der höheren Programmiersprachen für Shader als HLSL bezeichnet.

Aufgabe

Unter „Shading“ versteht die Computergrafik die Veränderung einzelner Vertices bzw. Fragmente innerhalb der Grafikpipeline. Dabei wird möglichst hardwarenah gearbeitet, was lange die Verwendung von Assembler nötig machte. Die Programmierung mit Assembler ist jedoch recht unpraktisch, fehleranfällig und vom Hardwarehersteller abhängig. Diesen Umstand sollen High Level Shading Languages beheben. Sie stellen hochsprachliche Strukturen zur Verfügung, die die Programmierung vereinfachen und damit dem Programmierer ermöglichen, sich auf sein Ziel zu konzentrieren. Ein Compiler übersetzt den Code der Hochsprache in Maschinensprache für den Grafikprozessor. Die DirectX-spezifische Hochsprache HLSL wird zur Laufzeit der Applikation von der DirectX-Bibliothek mit Hilfe des Grafiktreibers in die für die aktuelle Grafikhardware geeignete Assemblersprache übersetzt. Unterschiedliche Shader für Nvidia- oder ATI/AMD-Grafikkarten sind damit nicht mehr notwendig.

Sprach-Elemente

HLSL bietet keine OOP-Ansätze wie andere Sprachen. Es ist stark an C orientiert, stellt aber für die Shader-Programmierung optimierte Datentypen und Operationen zur Verfügung.

Globale Shader-Parameter

Parameter, die an einen Shader übergeben werden, stehen in HLSL global im kompletten Code zur Verfügung. Sie werden außerhalb von Methoden oder Structs geschrieben, meist zu Beginn des Codes. 

 float4x4 world; // Definiert eine 4x4-Fließkomma-Matrix, hier die Welt-Matrix 
 float4x4 worldViewProj; // Die Welt-View-Projektionsmatrix, gerechnet als World*View*Proj.
 float3 lightDir; // Ein 3-Element Vektor. 
 float4 LightColor = {0.5, 0.5, 0.5, 1}; // Lichtfarbe (Vektor mit vordefiniertem Wert)
 float4 Ambient = {0.5, 0.5, 0.5, 1}; // Lichtfarbe des Umgebungslichtes
 float4 LightDir = {0, 0, -1, 0}; // Richtung des Sonnenlichtes (hier: Senkrecht von oben)

 texture2D Tex0; // Eine Textur

 SamplerState DefaultSampler // Der "Sampler" definiert die Parameter für das Texture-Mapping
 {
     filter = MIN_MAG_MIP_LINEAR; // Interpolationsfilter für Texturstreckung 
     AddressU = Clamp; // Texturkoordinaten ausserhalb [0..1] beschneiden
     AddressV = Clamp;
 };

Für die Bedeutung der obigen Matrizen siehe den Artikel Grafikpipeline.

Eingabe und Ausgabe des Vertex-Shaders

Statt jeden Parameter einzeln in die Parameterliste einer Shader-Methode zu schreiben, sind in der Praxis einheitliche Structs üblich. Dies spart Schreibarbeit und schafft mehr Übersichtlichkeit. Im Prinzip können beliebige Werte und Vektoren mit der Eingabestruktur übergeben werden, eine Position ist aber fast immer dabei. 

 // Eingabe für den Vertex-Shader. 
 struct MyShaderIn
 {
     float4 Position : POSITION; // Dem Compiler wird bekannt gegeben, was die Variable "bedeutet". Hier: Das ist eine Position
     float4 Normal : NORMAL0; // Die Vertex-Normale, wird für die Beleuchtung verwendet
     float2 TexCoords : TEXCOORD0; // Texturkoordinaten
 }

 struct MyShaderOut
 {
     float4 Position : POSITION;
     float4 TexCoords : TEXCOORD0;
     float4 Normal : TEXCOORD1;
 }

Der „In-Struct“ gibt die Datenstruktur an, wie sie vom Drahtgittermodell an den Shader gereicht wird, also an den VertexShader. Dieser verarbeitet die Daten und gibt einen „Out-Struct“ als Rückgabetyp zurück. Dieser wird dann an den PixelShader weitergereicht, der am Ende nur noch einen float4 oder ähnliches zurückgibt, mit der endgültigen Pixelfarbe.

Vertex/Pixel Shader Methode

Für Vertex-Shader und Pixel-Shader muss eine Methode vorhanden sein. Diese nimmt eine Datenstruktur auf und verarbeitet sie entsprechend. Der Vertex-Shader wird einmal für jeden Vertex aufgerufen, der Pixel-Shader einmal pro zu renderndem Texturpixel. 

 MyShaderOut MyVertexShader(MyShaderIn In)
 {
     MyShaderOut Output = (MyShaderOut)0;
     // Die nächste Zeile ist die Projektionsmultiplikation. Sie multipliziert die Position des aktuellen Punktes mit
     // der aus Welt-, Kamera- und Projektionsmatrix kombinierten 4x4-Matrix, um die Bildschirmkoordinaten zu erhalten
     Output.Position = mul(In.Position, WorldViewProj); 
     Output.TexCoords = In.TexCoords; // Texturkoordinaten werden in diesem einfachen Beispiel einfach durchgereicht
     Output.Normal = normalize(mul(In.Normal, (float3x3)World)); // Die Normale wird rotiert
     return Output;
 }

 // Eine Hilfsfunktion
 float DotProduct(float3 lightPos, float3 pos3D, float3 normal)
 {
     float3 lightDir = normalize(pos3D - lightPos);
     return dot(-lightDir, normal);    
 }

  // Der Pixel-Shader gibt als Rückgabewert lediglich eine Farbe (ggf. mit Alpha) zurück
 float4 MyPixelShader(MyShaderIn In): COLOR0
 {
     // Beleuchtungsstärke der Fläche (Das Skalarprodukt aus negativem Lichtvektor und 
     // Normalvektor der Fläche ist > 0 wenn die Fläche der Lichtquelle zugewandt ist)
     float sunLight = dot((float3)-LightDir, In.Normal); 
     float4 sunLightColor = float4(sunLight, sunLight, sunLight, 1); // Den Alphakanal setzen
     sunLightColor *= LightColor; // Die Lichtfarbe anbringen
     sunLightColor = saturate(sunLightColor); // Die Farbwerte auf [0..1] beschneiden
     // Die Texturfarbe an der zu zeichnenden Stelle abholen. Um die Interpolation der Texturkoordinaten 
     // brauchen wir uns nicht zu kümmern, das übernehmen Hardware und Compiler. 
     float4 baseColor = Tex0.Sample(DefaultSampler, In.TexCoords);
     float4 brightnessColor = baseColor*(sunLightColor + Ambient); // Helligkeit und Kontrast einrechnen
     brightnessColor = (brightnessColor + OffsetBrightness) * (1.0 + OffsetContrast);
     return brightnessColor;
 }

Geometrie-Shader

Die Implementierung eines Geometry-Shaders ist optional und ermöglicht es, ein Primitiv auf 0 bis n neue Primitive abzubilden. Die Art der Ausgabe-Primitive sowie die Maximalanzahl der produzierten Vertices muss allerdings zur Übersetzungszeit bekanntgegeben werden. Die Implementierung erfolgt hier prozedural und verwendet eigens dafür eingeführte Datenstrukturen (PointStream<T>, LineStream<T> und TriangleStream<T>).

Weiter besteht die Möglichkeit, auch auf die benachbarten Dreiecke und Linien zuzugreifen. Dies kann mit Hilfe der Input-Modifier trianglead und lineadj erreicht werden. Typische Anwendungen für Geometry-Shader sind die Generierung von Point-Sprites und das Rendern in CubeMap-Texturen. Hier ein einfacher Geometry-Shader, der jedes Dreieck, auf das er angewandt wird, zu seinen Schwerpunkt hin verkleinert: 

 [maxvertexcount(3)]
 void GS(triangle MyShaderOut[3] input, inout TriangleStream<MyShaderOut> OutputStream)
 {
     MyShaderOut point;
     float4 centroid = (input[0].Position + input[1].Position + input[2].Position) / 3.0;
     point = input[0];
     point.Position = lerp(centroid, input[0].Position, 0.9);
     OutputStream.Append(point);

     point = input[1];
     point.Position = lerp(centroid, input[1].Position, 0.9);
     OutputStream.Append(point);

     point = input[2];
     point.Position = lerp(centroid, input[2].Position, 0.9);
     OutputStream.Append(point);

     OutputStream.RestartStrip();
 }

Techniken

Zuletzt müssen die definierten Methoden in Form von Techniken und Durchläufen zugeordnet werden, damit sie vom Compiler entsprechend umgesetzt werden. Die Syntax der Shader hat sich mit DirectX 10 geringfügig geändert, daher wird die Zielversion auch bei der Technik nochmal explizit angegeben. 

 technique10 MyTechnique // Für DirectX 10+
 {
     pass Pass0
     {
         VertexShader = compile vs_4_0 MyVertexShader();
         PixelShader = compile ps_4_0 MyPixelShader();
     }
 }

Alternativen

Abgerufen von „https://de.wikiup.org/index.php?title=High_Level_Shading_Language&oldid=222105362“