Vertex Shader: mi ez, feladatok és működési elv

Mi az a Vertex Shader?

Vertex Shader a grafikus csővezeték (graphics pipeline) egy programozható szakasza, amely egy háromdimenziós modell minden egyes csúcspontját külön-külön dolgozza fel. A csúcspont (vertex) egy pont a háromdimenziós térben, amely attribútumokat tartalmaz: xyz koordinátákat, normálisokat, színt és UV textúra koordinátákat.

Ellentétben a rögzített funkciójú csővezetékkel (fixed-function pipeline), ahol a transzformációk egy mereven meghatározott algoritmus szerint történtek, a Vertex Shader teljes kontrollt ad a fejlesztőnek a csúcspontok transzformációja felett. Ez lehetővé teszi procedurális animáció, modellek deformálásának, csontváz skinningnek és bármilyen matematikai transzformációnak a GPU oldali megvalósítását.

A Vertex Shader helye a grafikus csővezetékben

Az OpenGL ES grafikus csővezetéke a bemeneti adatoktól a végső képig tartó szakaszok sorozatát foglalja magában. Vertex Shader a csúcspont összeállítás (vertex assembly) szakasza után és a raszterizációs szakasz előtt helyezkedik el. Minden, a CPU-ról a csúcspont bufferén keresztül küldött csúcspont pontosan egyszer halad át a Vertex Shaderen, és az eredmény a primitívek összeállításához a következő szakaszba kerül.

Hogyan működik a Vertex Shader?

Vertex Shader a csúcspont bufferből (VBO) a CPU kódban beállított attribútum mutatókon (vertex attribute pointers) keresztül fogadja a csúcspont attribútumait. A fejlesztő GLSL (OpenGL Shading Language) vagy hasonló nyelven írja a shader kódot, amelyet a GPU meghajtó fordíthat le gépi utasításokra az adott chip számára.

A csúcspont feldolgozásának folyamata

Minden csúcsponthoz a Vertex Shader három műveletet hajt végre egymás után: a bemeneti attribútumok beolvasása — a fejlesztő által meghatározott transzformációk alkalmazása — az eredmények kiírása a kimeneti változókba. A minimális kötelező kimenet a csúcspont pozíciója a vágási térben (gl_Position). Az összes többi kimeneti adat (szín, normálisok, textúra koordináták) interpolálódik és továbbításra kerül a következő szakaszba — a Fragment Shaderbe.

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

A Vertex Shader fő feladatai

Vertex Shader a geometria transzformációjával kapcsolatos grafikus csővezeték feladatok széles körét oldja meg. Minden feladat vektorokon és mátrixokon végzett matematikai műveleteken keresztül valósul meg, amelyek párhuzamosan futnak több ezer csúcspontra egyszerre.

Koordináta transzformáció MVP-n keresztül

Az alapvető és legelterjedtebb feladat a csúcspont koordináták szorzása a model, view és projection (MVP) mátrixokkal. MVP mátrix a csúcspontot a modell helyi teréből a vágási térbe (clip space) transzformálja, amely aztán normalizálódik és automatikus csővezeték szakaszokban képernyő koordinátákká alakul.

Csontváz animáció (Skinning)

Animált karakterekhez a Vertex Shader csontváz animációt (skinning) valósít meg. Minden csúcspont több csontboz van kötve meghatározott súlyokkal. Vertex blending — a kötött csontok transzformációinak súlyozott összege — lehetővé teszi a karakter bőrének sima deformálását a csontváz mozgása során.

Geometria procedurális deformációja

A Vertex Shader képes a geometriát idő vagy más uniform paraméterek alapján módosítani a CPU részvétele nélkül. Wave deformation, Perlin zajon alapuló zajeltolások és víz hullám effektusok — mindezek a hatások a vertex shaderben valósulnak meg a geometria RAM-ból történő újratöltése nélkül.

Vertex Shader vs Fragment Shader: különbségek

Bár mindkét shader típus a grafikus csővezeték programozható szakaszai, a Vertex Shader és a Fragment Shader alapvetően különböző feladatokat old meg és a képfeldolgozás különböző szakaszaiban dolgozik.

A legfontosabb különbség a hívások gyakorisága. A Vertex Shader egyszer hívódik meg csúcspontonként, míg a Fragment Shader minden fragmentumhoz (pixelhez). Egy nagy felbontású jelenetben a Fragment Shader hívások száma ezerszeresen meghaladja a Vertex Shader hívások számát, ami a pixel shaderek optimalizálását még kritikusabbá teszi.

Vertex Shader teljesítmény és optimalizálás

Vertex Shader teljesítménye kritikus fontosságú valós idejű alkalmazásokban, különösen a korlátozott energiafogyasztású mobilfejlesztésben. A fő teljesítménytényezők a csúcspontok száma, a shader kód összetettsége és a GPU memória sávszélessége.

A teljesítményt befolyásoló tényezők

• Vertex count — a GPU-ra küldött csúcspontok száma képkockánként. A többmillió poligonból álló modellek nagy terhelést rónak a vertex shaderre.
• Shader complexity — az utasítások száma a shaderben. Az egymásba ágyazott ciklusok és feltételes ugrások (divergence) csökkentik a SIMD blokkok párhuzamos teljesítményét.
• Bandwidth — a csúcspont adatok olvasásának sebessége a videó memóriából. Az attribútum formátuma (float32, float16, normalizált egész szám) közvetlenül befolyásolja a sávszélességet.

Vertex shaderek optimalizálási módszerei

A Vertex Shader terhelésének csökkentésére a következő megközelítések alkalmazhatók. Level of Detail (LOD) — a modellek egyszerűsített verzióira váltás, amikor a kamera távolodik az objektumtól. Instancing — ugyanazon geometria többszöri kirajzolása különböző transzformációs mátrixokkal egyetlen rajzolási hívásban (draw call).

// Vertex Shader példányosítási támogatással
in vec3 aPosition;
in mat4 aInstanceMatrix;
uniform mat4 uViewProjection;

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

Vertex Shader kód példák

Vertex Shader a különböző grafikus API-kban hasonló logikával, de eltérő szintaxissal és névkonvenciókkal rendelkezik. Tekintsük át egy alap vertex shader megvalósítását GLSL-ben OpenGL ES 3.0-hoz és Metal Shading Language-ben iOS és macOS rendszerekhez.

Példa GLSL-ben OpenGL ES 3.0-hoz

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

Példa Metal Shading Language-ben

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