Das offizielle Minecraft Wiki twittert hier: Wiki-Twitter   Noch keinen Server gefunden? Es gibt einen Wiki-Server

Shaderdaten

Aus Minecraft Wiki
Wechseln zu: Navigation, Suche

Shaderdaten sind Textdateien mit Anweisungen für spezielle Grafikeffekte, die das komplette Bild im Spiel verändern (siehe Wikipedia-Erklärung zu Shader). Beispielsweise kann ein Shader das Spiel in schwarz/weiß anzeigen.

Arten[Bearbeiten | Quelltext bearbeiten]

  • Vertexshader: Ein Vertex ist ein Eckpunkt, d.h. ein Punkt, an dem sich Linien des Konstruktionsmodells treffen. Beispiel: Ein normaler Minecraft-Block ist ein Würfel. Dessen Konstruktionsmodell enthält acht Vertices (vier Eckpunkte oben, vier unten), die durch zwölf Linien miteinander verbunden werden. Ein Vertexshader ist ein Programmteil, der auf alle Vertices eines Bildes wirkt und sie verändern kann. Er fügt jedoch keine neuen hinzu oder entfernt welche. Vielmehr verändert ein Vertexshader die Eigenschaften eines Vertex, vor allem seine Koordinaten. Dadurch ändert sich die Geometrie der dreidimensionalen Elemente des Bildes (Blöcke, Kreaturen, etc.), was wiederum Einfluss auf die Beleuchtung hat. Beispielsweise kann durch einen Vertexshader ein Fischaugen-Effekt erzeugt werden, d.h. das gesamte Bild erscheint gewölbt. Neben den Positionskoordinaten kann ein Vertex weitere Eigenschaften wie z.B. Transparenz haben, die auch durch einen Vertexshader geändert werden können.
  • Fragmentshader: Ein Fragment ist der kleinste Teil eines Bildes. Das ist normalerweise ein Pixel, aber da sich beim Einsatz von Transparenz Pixel überlagern können (z.B. überlagern die Pixel der halb-transparenten Wolken die Pixel der Landschaft) ist "Fragment" der treffendere Begriff. Ein Fragmentshader kann alle Eigenschaften eines Fragments verändern, vor allem seine Farbe. Durch Abdunkeln und Aufhellen der Farbe können z.B. Schattierungen erreicht werden, um realistische Oberflächeneffekte für eigentlich flache Grafikelemente zu simulieren. Aber auch die eingangs erwähnte schwarz/weiß-Darstellung wird durch Fragmentshader erreicht.

Weiterführende Infos finden sich z.B. im OpenGL Wiki.

Herkunft[Bearbeiten | Quelltext bearbeiten]


  •  minecraft.jar: Die Original-Shaderdaten stehen in minecraft.jar.

    •  assets: Die Standard-Ressourcen.

      •  minecraft: Die Minecraft-Standard-Ressourcen.

        •  shaders: Die Shaderdaten.

          •  programm: Die Vertexshader (Dateityp ".vsh"), Fragmentshader (Dateityp ".fsh") und zugehörige Pass-Dateien (Dateityp ".json"). Alle Dateien sind lesbare Textdateien.

          •  post: Die Effekt-Dateien (Dateityp ".json"), die mehrere Programm-Shader zu einem bestimmten Grafikeffekt kombinieren (engl. post = nachgeordnet).

Änderbarkeit[Bearbeiten | Quelltext bearbeiten]

Die Shaderdaten sind Teil der Standard-Ressourcen und können mit Ressourcenpaketen geändert werden. Die Vertexshader sind vom Dateityp .vsh, die Fragmentshader vom Dateityp .fsh und die zugehörigen Pass-Dateien vom Dateityp .json. Alle Dateien sind aber lesbare Textdateien.

Um eine Datei auszutauschen, legt man ein Ressourcenpaket an und platziert die entsprechende Datei mit dem richtigen Namen im richtigen Ordner (siehe Ressourcenpaket-Aufbau). Das bedeutet, man muss nicht alle Shaderdaten in ein Ressourcenpaket stellen, sondern nur die, die man verändert hat. Im Minimalfall ist das nur eine einzige. Neue Shader hinzufügen kann man derzeit nicht.

Einige Shader werden im Spiel im Zuschauermodus eingesetzt.

Funktionsweise[Bearbeiten | Quelltext bearbeiten]

Ein Shader gibt Anweisungen an die Hardware, d.h. an den Grafikprozessor oder die Grafikarte des Computers. In Minecraft wird für einen standardisierten Zugriff auf die unterschiedlichen Hardwareprodukte die Funktionenbibliothek OpenGL (Open Graphics Library = Offene Grafikbibliothek) verwendet. OpenGL bietet mit GLSL (OpenGL Shading Language) eine Programmiersprache speziell für Shader.

Die Anwendung von Shadern ist Teil des Rendering-Prozesses. Dabei werden nacheinander verschiedene Grafikfunktionen angwendet, um das fertige Bild zu erzeugen. Jede Anwendung eines Shaders wird Pass (= Durchgang) genannt, wobei auch mehrere Shader-Durchgänge auf ein Bild angewendet werden können.

In Minecraft gibt es folgende Arten von Shader-Dateien:

  • Vertexshader (Dateityp ".vsh") und Fragmentshader (Dateityp ".fsh") sind in GLSL (OpenGL Shading Language) programmiert. Eine Einführung dazu findet man hier. Die Shader stehen im Shader-Ordner /program.
  • Pass-Dateien (Dateityp ".json") beschreiben jeweils einen Shader-Durchgang (engl. pass), der aus dem Aufruf eines Vertexshaders und eines Fragmentshaders besteht. Die Pass-Dateien stehen zusammen mit den Shadern im Shader-Ordner /program.
  • Effekte (Dateityp ".json") kombinieren mehrere Programm-Shader zu einem bestimmten Grafikeffekt. Die Effektdateien stehen im Shader-Ordner /post. Da sie von den Pass-Dateien getrennt sind, können sie denselben Namen haben.

Beispiel: Vertexshader "flip.vsh"[Bearbeiten | Quelltext bearbeiten]

 #version 120
 attribute vec4 Position;
 uniform mat4 ProjMat;
 uniform vec2 InSize;
 uniform vec2 OutSize;
 uniform vec2 ScreenSize;
 varying vec2 texCoord;
 void main()
 {
   vec4 outPos = ProjMat * vec4(Position.xy, 0.0, 1.0);
   gl_Position = vec4(outPos.xy, 0.2, 1.0);
   vec2 inOutRatio = OutSize / InSize;
   vec2 inScreenRatio = ScreenSize / InSize;
   texCoord = Position.xy / OutSize;
   texCoord.x = texCoord.x * inOutRatio.x;
   texCoord.y = texCoord.y * inOutRatio.y;
   texCoord.y -= 1.0 - inScreenRatio.y;
 }

Der Vertexshader "flip.vsh" erwartet als Attribut ("attribute") eine Vertexposition sowie vier Eingabevariablen ("uniform"). Die Variable "texCoord" reicht er an den Fragmentshader weiter ("varying"), sie muss dort ebenfalls definiert sein. Die Hauptfunktion ("main") wird gestartet, wenn der Shader aufgerufen wird.

Beispiel: Fragmentshader "blit.fsh"[Bearbeiten | Quelltext bearbeiten]

 #version 120
 uniform sampler2D DiffuseSampler;
 varying vec2 texCoord;
 varying vec2 oneTexel;
 uniform vec2 InSize;
 uniform float Resolution = 4.0;
 uniform float Saturation = 1.5;
 uniform float MosaicSize = 8.0;
 void main()
 {
   vec2 mosaicInSize = InSize / MosaicSize;
   vec2 fractPix = fract(texCoord * mosaicInSize) / mosaicInSize;
   vec4 baseTexel = texture2D(DiffuseSampler, texCoord - fractPix);
   baseTexel = baseTexel - fract(baseTexel * Resolution) / Resolution;
   float luma = dot(baseTexel.rgb, vec3(0.3, 0.59, 0.11));
   vec3 chroma = (baseTexel.rgb - luma) * Saturation;
   baseTexel = vec4(luma + chroma, baseTexel.a);
   gl_FragColor = baseTexel;
 }

Der Fragmentshader "blit.fsh" erwartet als Eingabevariable ("uniform") eine Vorlage ("sampler2D"), die die weiteren Eingabevariablen versorgt. Die Variable "texCoord" ("varying") erhält er vom Fragmentshader, die restlichen Eingabevariablen über die Vorlage. Die Hauptfunktion ("main") wird gestartet, wenn der Shader aufgerufen wird.

Beispiel: Pass-Datei "flip.json"[Bearbeiten | Quelltext bearbeiten]

 {
   blend: 
   {
     func:add,
     srcrgb:one,
     dstrgb:zero
   },
   vertex:flip,
   fragment:blit,
   attributes:[Position],
   samplers:[{name:DiffuseSampler}],
   uniforms:
   [
     {name:ProjMat, type:matrix4x4, count:16, values:[1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 1.0]},
     {name:InSize, type:float, count:2, values:[1.0, 1.0]},
     {name:OutSize, type:float, count:2, values:[1.0, 1.0]},
     {name:ScreenSize, type:float, count:2, values:[1.0, 1.0]},
     {name:ColorModulate, type:float, count:4, values:[1.0, 1.0, 1.0, 1.0]}
   ]
 }

In der Pass-Datei "flip.json" werden zuerst die Werte für die Blending-Funktion angegeben, die zum Mischen von überlagerten Pixeln dient (Beispiel: die Pixel einer halbtransparenten Wolke überlagern die Pixel der Landschaft). Dann folgen die Namen des Vertexshaders (flip.vsh) und des Fragmentshaders (blit.fsh). Der flip-Shader erwartet als Attribut ("attribute") die Position des Vertex, die ihm hier durchgereicht wird und folgende Eingabewerte ("uniform"), die ihm hier übergeben werden: "ProjMat", "InSize", "OutSize" und "ScreenSize". Der blit-Shader erwartet auch einige Eingabewerte, die aber nicht in "flip.json" stehen, sondern in der Vorlage (Sampler) "DiffuseSampler". Die Eingabewerte "ColorModulate" scheinen zur Zeit nicht benötigt zu werden, aber sie stören auch nicht.

Beispiel: Effektdatei "flip.json"[Bearbeiten | Quelltext bearbeiten]

 {
   targets:
   [
     swap
   ],
   passes:
   [
     {
       name:flip,
       intarget:"minecraft:main",
       outtarget:swap
     },
     {
       name:blit,
       intarget:swap,
       outtarget:"minecraft:main"
     }
   ]
 }

In der Effektdatei flip.json (nicht zu verwechseln mit der gleichnamigen Pass-Datei) wird zuerst ein Zwischenschritt definiert, der "swap" genannt wird. Dann werden die Durchgänge ("passes") festgelegt:

  • Im ersten Durchgang wird das Ausgangbild "minecraft:main" durch den Programm-Shader "flip" zum Zwischenschritt "swap" verändert.
  • Im zweiten Durchgang wird der Zwischenschritt "swap" durch den Programm-Shader "blit" zum fertigen Bild "minecraft:main".

Geschichte[Bearbeiten | Quelltext bearbeiten]