Fragment Shader — vad det är, uppgifter och funktionsprincip

Vad är Fragment Shader?

Fragment Shader (fragment- eller pixelshader) — är ett programmerbart steg i grafikkedjan som beräknar den slutgiltiga färgen för varje fragment i bilden. Ett fragment är en potentiell pixel som, efter att ha passerat djup- och stenciltester, blir en synlig pixel på skärmen.

Fragment Shader exekveras efter rasterisering, när tredimensionella primitiver (trianglar) redan har omvandlats till en uppsättning fragment. Shadern tar emot på ingången interpolerade attribut — texturkoordinater, normaler, färger som beräknades i Vertex Shader för triangelns hörn och linjärt interpolerades för varje pixel inuti den.

Historia om Fragment Shaders utveckling

Före uppkomsten av programmerbara shaders (före DirectX 8 / OpenGL 2.0) utfördes beräkningen av pixelfärgen av en fast pipeline med en begränsad uppsättning operationer. Programmerbar Fragment Shader dök upp år 2001 och utökade radikalt grafikkapaciteten: utvecklare fick full kontroll över färgen på varje pixel, vilket möjliggjorde fotorealistisk belysning, komplexa material och post-effekter.

Hur fungerar Fragment Shader?

Fragment Shader startas av GPU för varje fragment som genereras av rasteriseraren. Varje shader-anrop bearbetar ett fragment, läser dess indata, exekverar användarkoden och skriver utdatavärdet — fragmentets färg i RGBA-format.

Indata och utdata

Fragment Shaders indata inkluderar interpolerade attribut från Vertex Shader (texturkoordinater, normaler, färger), uniforma variabler (ljuskällor, matriser) och textursamplers. Utdatat — färgvektor (gl_FragColor i OpenGL ES 2.0 eller användarvariabel i ES 3.0) som skrivs till färgbufferten.

#version 300 es
precision mediump float;

in vec2 vTexCoord;
uniform sampler2D uTexture;
out vec4 fragColor;

void main() {
    fragColor = texture(uTexture, vTexCoord);
}

Huvuduppgifter för Fragment Shader

Fragment Shader ansvarar för bildens visuella kvalitet. Alla effekter som användaren ser på skärmen — färg, skuggor, reflektioner, transparens — beräknas precis i detta steg av grafikkedjan.

Texturering

Den vanligaste operationen — att hämta färg från en textur baserat på interpolerade UV-koordinater. Sampler2D och funktionen texture() gör det möjligt att få pixelns färg från en texturatlas. Filtrering (bilinjär, trilinejär, anisotropisk) styrs via samplerparametrar och påverkar skärpan i bilden vid olika betraktningsvinklar.

Phong-belysning

Phong-belysningsmodellen (Phong shading) beräknas i Fragment Shader för varje pixel, vilket ger jämnare högdagrar än vertexbelysning (Gouraud shading). Phong lighting inkluderar tre komponenter: ambient (omgivningsljus), diffuse (diffust) och specular (spegelreflexion).

// Fragment shader med Phong-belysning
in vec3 vNormal;
in vec3 vPosition;
uniform vec3 uLightDir;
uniform vec3 uLightColor;

void main() {
    vec3 norm = normalize(vNormal);
    float diff = max(dot(norm, uLightDir), 0.0);
    fragColor = vec4(uLightColor * diff, 1.0);
}

Post-effekter och blending

Fragment Shader gör det möjligt att applicera efterbehandling: färgkorrigering via LUT-tabeller, oskärpa (blur), glödeffekt (bloom) och tonemapping för HDR-rendering. Alla dessa effekter fungerar på pixelnivå och exekveras i realtid.

Prestanda för Fragment Shader och optimering

Prestanda för Fragment Shader — den huvudsakliga faktorn som begränsar FPS i moderna mobila spel. Eftersom shadern anropas för varje pixel, kan även en liten ökning av kodkomplexiteten leda till en märkbar minskning av bildhastigheten.

Huvudsakliga prestandaproblem

• Overdraw — omritning av samma pixel på grund av överlappande objekt. Särskilt kritiskt för halvgenomskinliga objekt.
• Villkorliga förgreningar — förgreningar i Fragment Shader minskar effektiviteten av SIMD-exekvering, eftersom GPU måste exekvera båda grenarna.
• Texturuppslag — varje texturuppslag (texture lookup) har en fördröjning på tiotals GPU-cykler. Minimering av antalet samplers snabbar upp shadern.

Optimeringsmetoder för Fragment Shader

För mobila GPU:er (Qualcomm Adreno, ARM Mali) rekommenderas: använd mediump precision för float-variabler, kombinera texturuppslag, tillämpa early-z-tester för att avvisa osynliga fragment före shader-exekvering.

Fragment Shader vs Vertex Shader: jämförelse

Båda typerna av shaders programmeras av utvecklaren, men de arbetar i olika steg av pipeline och löser olika uppgifter. Fragment Shader är betydligt mer resurskrävande på grund av antalet anrop.

Exempel på Fragment Shader-kod

Fragment Shader kan vara enkel (texturuppslag) eller komplex (flerskiktsbelysning). Låt oss titta på två praktiska exempel: grundläggande texturering och en gradienteffekt med hjälp av tid.

Grundläggande texturering i GLSL

#version 300 es
precision mediump float;
in vec2 vTexCoord;
in vec3 vColor;
uniform sampler2D uDiffuseMap;
out vec4 fragColor;

void main() {
    vec4 texColor = texture(uDiffuseMap, vTexCoord);
    fragColor = texColor * vec4(vColor, 1.0);
}

Exempel i Metal Shading Language

#include <metal_stdlib>
using namespace metal;

struct FragmentIn {
    float2 texCoord;
    float3 normal;
};

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