Vertex Shader: cos'è, compiti e principio di funzionamento

Cos'è Vertex Shader?

Vertex Shader è una fase programmabile del pipeline grafico che elabora ogni vertice di un modello 3D individualmente. Un vertice è un punto nello spazio tridimensionale contenente attributi: coordinate xyz, normali, colore e coordinate di texture UV.

A differenza del pipeline a funzione fissa (fixed-function pipeline) dove le trasformazioni venivano eseguite secondo un algoritmo rigido, Vertex Shader dà allo sviluppatore il controllo completo sulla trasformazione dei vertici. Ciò consente di implementare animazione procedurale, deformazione di modelli, skinning scheletrico e qualsiasi trasformazione matematica lato GPU.

Posizione di Vertex Shader nel pipeline grafico

Il pipeline grafico OpenGL ES include una sequenza di fasi dai dati di input all'immagine finale. Vertex Shader si trova dopo la fase di assemblaggio dei vertici e prima della fase di rasterizzazione. Ogni vertice inviato dalla CPU attraverso un buffer di vertici passa attraverso Vertex Shader esattamente una volta, e il risultato viene inoltrato alla fase successiva per l'assemblaggio delle primitive.

Come funziona Vertex Shader?

Vertex Shader riceve gli attributi dei vertici dal buffer di vertici (VBO) attraverso puntatori di attributi di vertice configurati nel codice CPU. Lo sviluppatore scrive il codice dello shader in GLSL (OpenGL Shading Language) o un linguaggio equivalente, che il driver della GPU compila in istruzioni macchina per il chip specifico.

Flusso di elaborazione dei vertici

Per ogni vertice, Vertex Shader esegue sequenzialmente tre operazioni: lettura degli attributi di input — applicazione delle trasformazioni definite dallo sviluppatore — scrittura dei risultati in variabili di output. L'output minimo richiesto è la posizione del vertice nello spazio di clipping (gl_Position). Tutti gli altri dati di output (colore, normali, coordinate di texture) vengono interpolati e passati alla fase successiva — 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;
}

Compiti principali di Vertex Shader

Vertex Shader risolve un'ampia gamma di compiti del pipeline grafico relativi alla trasformazione della geometria. Ogni compito viene implementato tramite operazioni matematiche su vettori e matrici, eseguite in parallelo per migliaia di vertici simultaneamente.

Trasformazione delle coordinate tramite MVP

Il compito base e più comune è moltiplicare le coordinate dei vertici per le matrici model, view e projection (MVP). La matrice MVP trasforma un vertice dallo spazio locale del modello allo spazio di clipping (clip space), che viene poi normalizzato e convertito in coordinate dello schermo nelle fasi automatiche del pipeline.

Animazione scheletrica (Skinning)

Per i personaggi animati, Vertex Shader implementa l'animazione scheletrica (skinning). Ogni vertice è legato a più ossa con pesi specifici. Vertex blending — una somma ponderata delle trasformazioni delle ossa legate — consente di deformare uniformemente la pelle del personaggio quando lo scheletro si muove.

Deformazione procedurale della geometria

Vertex Shader può modificare la geometria in base al tempo o ad altri parametri uniform senza coinvolgimento della CPU. Wave deformation, spostamento per rumore Perlin ed effetti di increspatura dell'acqua — tutti questi effetti vengono implementati nello shader di vertici senza ricaricare la geometria dalla RAM.

Vertex Shader vs Fragment Shader: differenze

Sebbene entrambi i tipi di shader siano fasi programmabili del pipeline grafico, Vertex Shader e Fragment Shader risolvono compiti fondamentalmente diversi e operano in fasi diverse dell'elaborazione dell'immagine.

La differenza chiave è la frequenza di chiamata. Vertex Shader viene chiamato una volta per vertice, mentre Fragment Shader viene chiamato per ogni frammento (pixel). In una scena ad alta risoluzione, il numero di chiamate di Fragment Shader supera il numero di chiamate di Vertex Shader di migliaia di volte, rendendo l'ottimizzazione degli shader di pixel ancora più critica.

Prestazioni e ottimizzazione di Vertex Shader

Le prestazioni di Vertex Shader sono criticamente importanti per le applicazioni in tempo reale, specialmente nello sviluppo mobile con consumo energetico limitato. I principali fattori di prestazione sono il numero di vertici, la complessità del codice dello shader e la larghezza di banda della memoria GPU.

Fattori che influenzano le prestazioni

• Numero di vertici — il numero di vertici inviati alla GPU per frame. I modelli con milioni di poligoni creano un carico elevato sullo shader di vertici.
• Complessità dello shader — il numero di istruzioni nello shader. Cicli annidati e ramificazioni condizionali (divergenza) riducono le prestazioni parallele delle unità SIMD.
• Larghezza di banda — la velocità di lettura dei dati dei vertici dalla memoria video. Il formato degli attributi (float32, float16, intero normalizzato) influisce direttamente sulla produttività.

Metodi di ottimizzazione degli shader di vertici

Per ridurre il carico su Vertex Shader, vengono utilizzati i seguenti approcci. Level of Detail (LOD) — passaggio a versioni semplificate dei modelli quando la telecamera si allontana dall'oggetto. Instancing — disegno ripetuto della stessa geometria con diverse matrici di trasformazione in un'unica chiamata di disegno (draw call).

// Vertex Shader con supporto instancing
in vec3 aPosition;
in mat4 aInstanceMatrix;
uniform mat4 uViewProjection;

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

Esempi di codice Vertex Shader

Vertex Shader su diverse API grafiche ha logica simile, ma sintassi e convenzioni di denominazione diverse. Esaminiamo l'implementazione di uno shader di vertici di base in GLSL per OpenGL ES 3.0 e in Metal Shading Language per iOS e macOS.

Esempio in GLSL per 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;
}

Esempio in 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;
}