Condividi tramite

Fasi tassellatura

  • Articolo

Il runtime Direct3D 11 supporta tre nuove fasi che implementano la tassellatura, che converte le superfici di suddivisione con dettaglio basso in primitive con dettaglio superiore nella GPU. Riquadri a mosaico (o suddivide) superfici ad alto ordine in strutture adatte per il rendering.

Implementando la tassellatura nell'hardware, una pipeline grafica può valutare i modelli di dettaglio inferiore (numero di poligoni inferiori) ed eseguire il rendering in dettaglio più alto. Anche se la tassellatura software può essere eseguita, la tassellatura implementata dall'hardware può generare un'incredibile quantità di dettagli visivi (incluso il supporto per il mapping di spostamento) senza aggiungere i dettagli visivi alle dimensioni del modello e paralizzando le frequenze di aggiornamento.

Vantaggi della tassellatura

Tessellazione:

  • Consente di risparmiare molta memoria e larghezza di banda, che consente a un'applicazione di eseguire il rendering di superfici più dettagliate da modelli a bassa risoluzione. La tecnica a mosaico implementata nella pipeline Direct3D 11 supporta anche il mapping di spostamento, che può produrre quantità straordinarie di dettagli sulla superficie.
  • Supporta tecniche di rendering scalabili, ad esempio livelli di dettaglio dipendenti continui o di visualizzazione, che possono essere calcolati in tempo reale.
  • Migliora le prestazioni eseguendo calcoli costosi a una frequenza inferiore (eseguendo calcoli su un modello con dettaglio inferiore). Questo potrebbe includere calcoli di fusione usando forme di fusione o destinazioni morph per animazioni realistiche o calcoli di fisica per il rilevamento delle collisioni o le dinamiche del corpo morbido.

La pipeline Direct3D 11 implementa la tassellatura nell'hardware, che carica il lavoro dalla CPU alla GPU. Ciò può portare a miglioramenti delle prestazioni molto elevati se un'applicazione implementa un numero elevato di destinazioni morphing e/o modelli di pelle/deformazione più sofisticati. Per accedere alle nuove funzionalità a mosaico, è necessario conoscere alcune nuove fasi della pipeline.

Nuove fasi della pipeline

La tassellatura usa la GPU per calcolare una superficie più dettagliata da una superficie costruita da patch quad, patch di triangolo o isoline. Per approssimare la superficie ordinata, ogni patch viene suddivisa in triangoli, punti o linee usando fattori di tassellatura. La pipeline Direct3D 11 implementa la tassellatura usando tre nuove fasi della pipeline:

  • Hull-Shader stage: fase programmabile dello shader che produce una patch geometrica (e costanti patch) che corrispondono a ogni patch di input (quad, triangolo o linea).
  • fase tessellator: fase della pipeline a funzione fissa che crea un modello di campionamento del dominio che rappresenta la patch geometrica e genera un set di oggetti più piccoli (triangoli, punti o linee) che collegano questi esempi.
  • Domain-Shader Fase: fase programmabile dello shader che calcola la posizione del vertice corrispondente a ogni esempio di dominio.

Il diagramma seguente evidenzia le nuove fasi della pipeline Direct3D 11.

diagramma della pipeline direct3d 11 che evidenzia le fasi hull-shader, tessellator e domain-shader

Il diagramma seguente illustra la progressione attraverso le fasi a mosaico. La progressione inizia con la superficie di suddivisione a dettaglio ridotto. La progressione evidenzia quindi la patch di input con la patch geometry, i campioni di dominio e i triangoli corrispondenti che connettono questi esempi. La progressione evidenzia infine i vertici che corrispondono a questi campioni.

diagramma della progressione a mosaico

fase Hull-Shader

Uno hull shader, richiamato una volta per patch, trasforma i punti di controllo di input che definiscono una superficie di ordine inferiore in punti di controllo che costituiscono una patch. Esegue anche alcuni calcoli per patch per fornire dati per la fase a mosaico e la fase del dominio. A livello di scatola nera più semplice, la fase hull-shader sarà simile al diagramma seguente.

diagramma della fase hull-shader

Uno hull shader viene implementato con una funzione HLSL e ha le proprietà seguenti:

  • L'input dello shader è compreso tra 1 e 32 punti di controllo.
  • L'output dello shader è compreso tra 1 e 32 punti di controllo, indipendentemente dal numero di fattori di tassellatura. L'output dei punti di controllo di uno hull shader può essere utilizzato dalla fase domain-shader. I dati costanti patch possono essere utilizzati da uno shader di dominio; I fattori di tassellatura possono essere utilizzati dallo shader del dominio e dalla fase a mosaico.
  • I fattori di tassellatura determinano quanto suddividere ogni patch.
  • Lo shader dichiara lo stato richiesto dalla fase del tassellatore. Sono incluse informazioni quali il numero di punti di controllo, il tipo di viso di patch e il tipo di partizionamento da usare durante il tassellamento. Queste informazioni vengono visualizzate come dichiarazioni in genere nella parte anteriore del codice dello shader.
  • Se la fase hull-shader imposta qualsiasi fattore di tassellatura del bordo su = 0 o NaN, la patch verrà ignorata. Di conseguenza, la fase del tassellatore può o meno essere eseguita, lo shader di dominio non verrà eseguito e non verrà generato alcun output visibile per tale patch.

A un livello più profondo, un hull-shader opera effettivamente in due fasi: una fase del punto di controllo e una fase costante della patch, che vengono eseguite in parallelo dall'hardware. Il compilatore HLSL estrae il parallelismo in uno hull shader e lo codifica in bytecode che guida l'hardware.

  • La fase del punto di controllo funziona una sola volta per ogni punto di controllo, la lettura dei punti di controllo per una patch e la generazione di un punto di controllo di output (identificato da un ControlPointID).
  • La fase patch-constant funziona una volta per patch per generare fattori di tassellatura perimetrale e altre costanti per patch. Internamente, molte fasi costanti patch possono essere eseguite contemporaneamente. La fase patch-constant ha accesso in sola lettura a tutti i punti di controllo di input e output.

Ecco un esempio di hull shader:

[patchsize(12)]
[patchconstantfunc(MyPatchConstantFunc)]
MyOutPoint main(uint Id : SV_ControlPointID,
     InputPatch<MyInPoint, 12> InPts)
{
     MyOutPoint result;
     
     ...
     
     result = TransformControlPoint( InPts[Id] );

     return result;
}

Per un esempio che crea uno hull shader, vedere Procedura: Creare uno hull shader.

Fase tassellatore

Il tassellatore è una fase a funzione fissa inizializzata associando uno hull shader alla pipeline (vedere Procedura: Inizializzare la fase tassellatore). Lo scopo della fase a mosaico è suddividere un dominio (quad, tri o linea) in molti oggetti più piccoli (triangoli, punti o linee). Il tassellatore riquadri un dominio canonico in un sistema di coordinate normalizzato (da zero a uno). Ad esempio, un dominio quad viene tassellato in un quadrato unitario.

Il tassellatore funziona una volta per patch usando i fattori di tassellatura (che specificano la precisione del dominio verrà tassellato) e il tipo di partizionamento (che specifica l'algoritmo usato per suddividere una patch) che vengono passati dalla fase hull-shader. Il tassellatore restituisce le coordinate uv (e facoltativamente w) e la topologia della superficie nella fase domain-shader.

Internamente, il tassellatore opera in due fasi:

  • La prima fase elabora i fattori a mosaico, risolvendo i problemi di arrotondamento, gestendo fattori molto piccoli, riducendo e combinando i fattori, usando l'aritmetica a virgola mobile a 32 bit.
  • La seconda fase genera elenchi di punti o topologie in base al tipo di partizionamento selezionato. Questa è l'attività principale della fase a mosaico e usa frazioni a 16 bit con aritmetica a virgola fissa. L'aritmetica a virgola fissa consente l'accelerazione hardware mantenendo la precisione accettabile. Ad esempio, data una patch larga 64 metri, questa precisione può posizionare punti a una risoluzione di 2 mm.
Tipo di partizionamento Gamma
fractional_odd [1...63]
fractional_even Intervallo TessFactor: [2...64]
numero intero Intervallo TessFactor: [1..64]
pow2 Intervallo TessFactor: [1..64]

fase Domain-Shader

Un domain shader calcola la posizione del vertice di un punto suddiviso nella patch di output. Un domain shader viene eseguito una volta per ogni punto di output della fase a mosaico e ha accesso in sola lettura alle coordinate UV della fase a mosaico, alla patch di output dello hull shader e alle costanti della patch di output dello hull shader, come illustrato nel diagramma seguente.

diagramma della fase domain-shader

Le proprietà dello shader di dominio includono:

  • Un domain shader viene richiamato una volta per ogni coordinata di output dalla fase del tassellatore.
  • Uno shader di dominio utilizza i punti di controllo di output dalla fase hull-shader.
  • Un domain shader restituisce la posizione di un vertice.
  • Gli input sono gli output dello hull shader, inclusi i punti di controllo, i dati costanti patch e i fattori di tassellatura. I fattori a mosaico possono includere i valori utilizzati dal tassellatore a funzione fissa, nonché i valori non elaborati (prima dell'arrotondamento per tassellatura integer, ad esempio), che facilita la geomorfia, ad esempio.

Al termine dello shader del dominio, la tassellatura viene completata e i dati della pipeline continuano alla fase successiva della pipeline (geometry shader, pixel shader e così via). Un geometry shader che prevede primitive con adiacenza (ad esempio, 6 vertici per triangolo) non è valido quando la tassellatura è attiva (questo comporta un comportamento non definito, che il livello di debug si lamenta).

Di seguito è riportato un esempio di domain shader:

void main( out    MyDSOutput result, 
           float2 myInputUV : SV_DomainPoint, 
           MyDSInput DSInputs,
           OutputPatch<MyOutPoint, 12> ControlPts, 
           MyTessFactors tessFactors)
{
     ...

     result.Position = EvaluateSurfaceUV(ControlPoints, myInputUV);
}

API per l'inizializzazione delle fasi di tassellatura

La tassellatura viene implementata con due nuove fasi programmabili dello shader: uno hull shader e uno shader di dominio. Queste nuove fasi dello shader sono programmate con codice HLSL definito nel modello di shader 5. Le nuove destinazioni shader sono: hs_5_0 e ds_5_0. Analogamente a tutte le fasi programmabili dello shader, il codice per l'hardware viene estratto dagli shader compilati passati al runtime quando gli shader vengono associati alla pipeline usando API come DSSetShader e HSSetShader. Prima di tutto, lo shader deve essere creato usando API come CreateHullShader e CreateDomainShader.

Abilitare la tassellatura creando uno hull shader e associandolo alla fase hull-shader (in questo modo viene impostata automaticamente la fase del tassellatore). Per generare le posizioni dei vertici finali dalle patch a mosaico, è anche necessario creare uno shader di dominio e associarlo alla fase domain-shader. Una volta abilitata la tassellatura, l'input dei dati nella fase input-assembler deve essere dati patch. Ovvero, la topologia dell'assembler di input deve essere una topologia costante patch da D3D11_PRIMITIVE_TOPOLOGY impostata con IASetPrimitiveTopology.

Per disabilitare la tassellatura, impostare hull shader e domain shader su NULL. Né la fase geometry-shader né la fase di output del flusso possono leggere i punti di controllo di output dello hull-shader o i dati delle patch.

Procedura:

La documentazione contiene anche esempi per l'inizializzazione delle fasi a mosaico.

Articolo Descrizione
Procedura: Creare un hull shader
 Creare uno hull shader.
Procedura: Progettare un hull shader
 Progettare uno hull shader.
Procedura: Inizializzare la fase di tassellatore
 Inizializzare la fase a mosaico.
Procedura: Creare un di domain shader
 Creare uno shader di dominio.
Procedura: Progettare un di domain shader
 Creare uno shader di dominio.

pipeline grafica