Vertex Shader: ce este, sarcini și principiul de funcționare

Ce este Vertex Shader?

Vertex Shader este o etapă programabilă a pipeline-ului grafic (graphics pipeline) care procesează fiecare vârf al modelului tridimensional individual. Vârful (vertex) este un punct în spațiul tridimensional care conține atribute: coordonate xyz, normale, culoare și coordonate de textură UV.

Spre deosebire de pipeline-ul cu funcții fixe (fixed-function pipeline), unde transformările erau executate după un algoritm rigid, Vertex Shader oferă programatorului control complet asupra transformării vârfurilor. Acest lucru permite implementarea animației procedurale, deformarea modelelor, skinning-ul scheletal și orice transformări matematice pe partea GPU.

Locul Vertex Shader în pipeline-ul grafic

Pipeline-ul grafic OpenGL ES include o succesiune de etape de la datele de intrare până la imaginea finală. Vertex Shader se află după etapa de asamblare a vârfurilor (vertex assembly) și înainte de etapa de rasterizare. Fiecare vârf transmis de CPU prin buffer-ul de vârfuri trece prin Vertex Shader exact o dată, iar rezultatul este transmis la următoarea etapă pentru asamblarea primitivelor.

Cum funcționează Vertex Shader?

Vertex Shader primește la intrare atributele vârfului din buffer-ul de vârfuri (VBO) prin pointeri de atribute (vertex attribute pointers) configurați în codul CPU. Programatorul scrie codul shader-ului în GLSL (OpenGL Shading Language) sau un limbaj similar, care este compilat de driver-ul GPU în instrucțiuni mașină pentru cipul specific.

Procesul de procesare a vârfului

Pentru fiecare vârf, Vertex Shader execută secvențial trei operații: citirea atributelor de intrare — aplicarea transformărilor definite de programator — scrierea rezultatelor în variabilele de ieșire. Ieșirea minimă obligatorie este poziția vârfului în spațiul de tăiere (gl_Position). Toate celelalte date de ieșire (culoare, normale, coordonate de textură) sunt interpolate și transmise la următoarea etapă — 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;
}

Sarcinile principale ale Vertex Shader

Vertex Shader rezolvă o gamă largă de sarcini ale pipeline-ului grafic legate de transformarea geometriei. Fiecare sarcină este realizată prin operații matematice asupra vectorilor și matricelor, executate paralel pentru mii de vârfuri simultan.

Transformarea coordonatelor prin MVP

Sarcina de bază și cea mai răspândită este înmulțirea coordonatelor vârfurilor cu matricele model, view și projection (MVP). Matricea MVP transformă vârful din spațiul local al modelului în spațiul de tăiere (clip space), care apoi este normalizat și transformat în coordonate ecran în etapele automate ale pipeline-ului.

Animația scheletală (Skinning)

Pentru personaje animate, Vertex Shader implementează animația scheletală (skinning). Fiecare vârf este legat de mai multe oase cu greutăți specifice. Vertex blending — suma ponderată a transformărilor de la oasele legate — permite deformarea lină a pielii personajului la mișcarea scheletului.

Deformarea procedurală a geometriei

Vertex Shader poate modifica geometria pe baza timpului sau a altor parametri uniform fără participarea CPU. Wave deformation, deplasări de zgomot bazate pe zgomotul Perlin și efecte de undă pe apă — toate aceste efecte sunt implementate în shader-ul de vârfuri fără reîncărcarea geometriei din memoria RAM.

Vertex Shader vs Fragment Shader: diferențe

Deși ambele tipuri de shader-e sunt etape programabile ale pipeline-ului grafic, Vertex Shader și Fragment Shader rezolvă sarcini fundamental diferite și lucrează în stadii diferite ale procesării imaginii.

Diferența cheie este frecvența apelurilor. Vertex Shader este apelat o dată pe vârf, în timp ce Fragment Shader — pentru fiecare fragment (pixel). Într-o scenă cu rezoluție înaltă, numărul de apeluri ale Fragment Shader depășește numărul de apeluri ale Vertex Shader de mii de ori, ceea ce face optimizarea shader-elor de pixeli și mai critică.

Performanța și optimizarea Vertex Shader

Performanța Vertex Shader este critică pentru aplicațiile în timp real, în special în dezvoltarea mobilă cu consum limitat de energie. Principalii factori de performanță — numărul de vârfuri, complexitatea codului shader-ului și lățimea de bandă a memoriei GPU.

Factori care influențează performanța

• Vertex count — numărul de vârfuri transmise la GPU per cadru. Modelele cu milioane de poligoane creează o sarcină mare pe shader-ul de vârfuri.
• Shader complexity — numărul de instrucțiuni în shader. Buclele imbricate și salturile condiționate (divergence) reduc performanța paralelă a blocurilor SIMD.
• Bandwidth — viteza de citire a datelor vârfurilor din memoria video. Formatul atributelor (float32, float16, întreg normalizat) influențează direct lățimea de bandă.

Metode de optimizare a shader-elor de vârfuri

Pentru reducerea sarcinii Vertex Shader se aplică următoarele abordări. Level of Detail (LOD) — comutarea la versiuni simplificate ale modelelor la îndepărtarea camerei de obiect. Instancing — desenarea multiplă a aceleiași geometrii cu matrice de transformare diferite într-un singur apel de desenare (draw call).

// Vertex Shader cu suport pentru instanțiere
in vec3 aPosition;
in mat4 aInstanceMatrix;
uniform mat4 uViewProjection;

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

Exemple de cod Vertex Shader

Vertex Shader în diferite API-uri grafice are o logică similară, dar sintaxă și convenții de denumire diferite. Să examinăm implementarea unui shader de vârfuri de bază în GLSL pentru OpenGL ES 3.0 și în Metal Shading Language pentru iOS și macOS.

Exemplu în GLSL pentru 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;
}

Exemplu în 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;
}