Vertex Shader: vad är det, uppgifter och funktionsprincip

Vad är Vertex Shader?

Vertex Shader är ett programmerbart steg i grafikpipelinen (graphics pipeline) som bearbetar varje vertex i en tredimensionell modell individuellt. En vertex är en punkt i tredimensionellt utrymme som innehåller attribut: xyz-koordinater, normaler, färg och UV-texturkoordinater.

Till skillnad från fixed-function pipeline, där transformationer utfördes enligt en fast algoritm, ger Vertex Shader utvecklaren full kontroll över vertexomvandling. Detta möjliggör implementering av procedurell animation, modelldeformation, skeletalskinning och alla matematiska transformationer på GPU-sidan.

Vertex Shaders plats i grafikpipelinen

OpenGL ES grafikpipeline omfattar en sekvens av steg från indata till slutlig bild. Vertex Shader finns efter steget för vertexmontering (vertex assembly) och före rasteriseringssteget. Varje vertex som skickas från CPU:n via vertexbufferten passerar genom Vertex Shader exakt en gång, och resultatet skickas vidare till nästa steg för montering av primitiver.

Hur fungerar Vertex Shader?

Vertex Shader tar emot vertexattribut från vertexbufferten (VBO) via vertexattributpekare (vertex attribute pointers) konfigurerade i CPU-koden. Utvecklaren skriver shaderkod i GLSL (OpenGL Shading Language) eller liknande språk, som kompileras av GPU-drivrutinen till maskininstruktioner för det specifika chipet.

Process för vertexbearbetning

För varje vertex utför Vertex Shader sekventiellt tre operationer: läsning av indataattribut — tillämpning av transformationer definierade av utvecklaren — skrivning av resultat till utdatavariabler. Minsta obligatoriska utdata är vertexens position i klipprymden (gl_Position). Alla andra utdata (färg, normaler, texturkoordinater) interpoleras och skickas vidare till nästa steg — Fragment Shader.

#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;
}

Vertex Shaders huvuduppgifter

Vertex Shader löser ett brett spektrum av grafikpipelinsuppgifter relaterade till geometriomvandling. Varje uppgift implementeras genom matematiska operationer på vektorer och matriser, som utförs parallellt för tusentals vertex samtidigt.

Koordinatomvandling via MVP

Den grundläggande och vanligaste uppgiften är multiplikation av vertexkoordinater med model-, view- och projectionsmatriser (MVP). MVP-matrisen omvandlar vertex från modellens lokala rymd till klipprymden (clip space), som sedan normaliseras och omvandlas till skärmkoordinater i automatiska pipelinsteg.

Skelettanimation (Skinning)

För animerade karaktärer implementerar Vertex Shader skelettanimation (skinning). Varje vertex är bunden till flera ben med specifika vikter. Vertex blending — den viktade summan av transformationer från bundna ben — möjliggör smidig deformation av karaktärens hud när skelettet rör sig.

Procedurell deformation av geometri

Vertex Shader kan modifiera geometri baserat på tid eller andra uniform-parametrar utan CPU-deltagande. Wave deformation, brusförskjutningar baserade på Perlin-brus och vattenkrusningseffekter — alla dessa effekter implementeras i vertex shadern utan att ladda om geometri från RAM.

Vertex Shader vs Fragment Shader: skillnader

Även om båda shadertyperna är programmerbara steg i grafikpipelinen, löser Vertex Shader och Fragment Shader fundamentalt olika uppgifter och arbetar i olika stadier av bildbearbetning.

Den viktigaste skillnaden är anropsfrekvensen. Vertex Shader anropas en gång per vertex, medan Fragment Shader anropas för varje fragment (pixel). I en scen med hög upplösning överstiger antalet Fragment Shader-anrop antalet Vertex Shader-anrop tusentals gånger, vilket gör optimering av pixel shaders ännu mer kritisk.

Vertex Shader prestanda och optimering

Vertex Shader-prestanda är kritisk för realtidsapplikationer, särskilt inom mobilutveckling med begränsad energiförbrukning. De viktigaste prestandafaktorerna är antalet vertex, shaderkodens komplexitet och GPU-minnets bandbredd.

Faktorer som påverkar prestanda

• Vertex count — antalet vertex som skickas till GPU:n per bildruta. Modeller med miljontals polygoner skapar hög belastning på vertex shadern.
• Shader complexity — antalet instruktioner i shadern. Nästlade loopar och villkorliga hopp (divergence) minskar parallell prestanda hos SIMD-block.
• Bandwidth — hastigheten för läsning av vertexdata från videominnet. Attributformatet (float32, float16, normaliserat heltal) påverkar direkt bandbredden.

Optimeringsmetoder för vertex shaders

För att minska belastningen på Vertex Shader tillämpas följande tillvägagångssätt. Level of Detail (LOD) — växla till förenklade versioner av modeller när kameran rör sig bort från objektet. Instancing — upprepad ritning av samma geometri med olika transformationsmatriser i ett enda ritningsanrop (draw call).

// Vertex Shader med instansieringsstöd
in vec3 aPosition;
in mat4 aInstanceMatrix;
uniform mat4 uViewProjection;

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

Exempel på Vertex Shader-kod

Vertex Shader i olika grafik-API:er har liknande logik men olika syntax och namngivningskonventioner. Låt oss titta på implementeringen av en grundläggande vertex shader i GLSL för OpenGL ES 3.0 och i Metal Shading Language för iOS och macOS.

Exempel i GLSL 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;
}

Exempel i Metal Shading Language

#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;
}