Ombreggiatura a frequenza variabile (VRS)
La motivazione per vrs
A causa dei vincoli di prestazioni, un renderer di grafica non può sempre permettersi di offrire lo stesso livello di qualità a ogni parte dell'immagine di output. L'ombreggiatura a frequenza variabile, o l'ombreggiatura in pixel grossolana, è un meccanismo che consente di allocare prestazioni/potenza di rendering a velocità che variano in base all'immagine di cui è stato eseguito il rendering.
In alcuni casi, la velocità di ombreggiatura può essere ridotta con una riduzione ridotta della qualità dell'output percepibile; che comporta un miglioramento delle prestazioni essenzialmente gratuito.
Senza VRS: anti-aliasing multicampionamento con supercampionamento
Senza ombreggiatura a frequenza variabile, l'unico mezzo per controllare la frequenza di ombreggiatura è con l'anti-aliasing multicampionamento (MSAA) con l'esecuzione basata su campione (nota anche come supercampionamento).
MSAA è un meccanismo per ridurre l'aliasing geometrico e migliorare la qualità di rendering di un'immagine rispetto all'uso di MSAA. Il numero di campioni MSAA, che può essere 1x, 2x, 4x, 8x o 16x, determina il numero di campioni allocati per ogni pixel di destinazione di rendering. Il conteggio degli esempi MSAA deve essere noto in anticipo quando viene allocata la destinazione e non può essere modificato in seguito.
Il supercampionamento fa sì che il pixel shader venga richiamato una volta per campione, con una qualità superiore, ma anche un costo di prestazioni superiore rispetto all'esecuzione per pixel.
L'applicazione può controllare la frequenza di ombreggiatura scegliendo tra esecuzione basata su pixel o MSAA-with-supercampionamento. Queste due opzioni non forniscono un controllo molto fine. Inoltre, si potrebbe volere una frequenza di ombreggiatura inferiore per una determinata classe di oggetti rispetto al resto dell'immagine. Tali oggetti possono includere un oggetto dietro un elemento HUD o una trasparenza, una sfocatura (profondità di campo, movimento e così via) o una distorsione ottica dovuta all'ottica VR. Ma questo non sarebbe possibile, perché la qualità e i costi dell'ombreggiatura sono fissi sull'intera immagine.
Con ombreggiatura a frequenza variabile (VRS)
Il modello di ombreggiatura a frequenza variabile estende il supercampionamento con MSAA nella direzione opposta, "grossolana pixel", aggiungendo il concetto di ombreggiatura grossolana. In questo caso l'ombreggiatura può essere eseguita a una frequenza più grossolana di un pixel. In altre parole, un gruppo di pixel può essere ombreggiato come una singola unità e il risultato viene quindi trasmesso a tutti i campioni nel gruppo.
Un'API di ombreggiatura grossolana consente all'applicazione di specificare il numero di pixel appartenenti a un gruppo ombreggiato o un pixel grossolano. È possibile variare le dimensioni dei pixel grossolani dopo aver allocato la destinazione di rendering. Quindi, parti diverse dello schermo o passaggi di disegno diversi possono avere frequenze di ombreggiatura diverse.
Di seguito è riportata una tabella che descrive il livello MSAA supportato con le dimensioni in pixel grossolane per le piattaforme che supportano l'ombreggiatura grossolana:
- Per le celle contrassegnate con Y, tale combinazione è abilitata.
- Per le celle contrassegnate con cap, tale combinazione viene abilitata in modo condizionale in base a un limite (AdditionalShadingRatesSupported).
- Per le celle vuote, tale combinazione non è supportata.
- Per le celle ombreggiate da halftone, tale combinazione non è supportata e prevede il rilevamento di più di 16 campioni per chiamata al pixel shader. Per tenere traccia di più di 16 campioni esistono ulteriori barriere di allineamento hardware da supportare, rispetto agli altri casi.
Livelli di funzionalità
Esistono due livelli per l'implementazione vrs e due funzionalità per cui è possibile eseguire query. Ogni livello viene descritto in modo più dettagliato dopo la tabella.
Livello 1
- La frequenza di ombreggiatura può essere specificata solo per ogni disegno; non più granulare di questo.
- La velocità di ombreggiatura si applica in modo uniforme a ciò che viene disegnato indipendentemente dalla posizione all'interno della destinazione di rendering.
Livello 2
- La frequenza di ombreggiatura può essere specificata in base al disegno, come nel livello 1. Può anche essere specificato da una combinazione di base per disegno e di:
- Semantica da ogni vertice provocatore e
- un'immagine dello spazio sullo schermo.
- Le frequenze di ombreggiatura delle tre origini vengono combinate usando un set di combinatori.
- Le dimensioni del riquadro dell'immagine dello spazio dello schermo sono pari a 16x16 o inferiori.
- La frequenza di ombreggiatura richiesta dall'applicazione è garantita esattamente (per la precisione dei filtri temporali e di altri filtri di ricostruzione).
- SV_ShadingRate l'input PS è supportato.
- La frequenza di ombreggiatura per ogni vertice provocante (nota anche come per primitiva) è valida quando viene usato un viewport e
SV_ViewportArrayIndexnon viene scritto in . - La frequenza per ogni vertice può essere usata con più viewport se la funzionalità SupportsPerVertexShadingRateWithMultipleViewports è impostata su
true. Inoltre, in tal caso, tale frequenza può essere usata quandoSV_ViewportArrayIndexviene scritta in .
Elenco di funzionalità
-
AdditionalShadingRatesSupported
- Tipo booleano.
- Indica se sono supportate dimensioni di pixel 2x4, 4x2 e 4x4 grossolane per il rendering a campionamento singolo; e se le dimensioni del pixel grossolano 2x4 sono supportate per 2x MSAA.
-
SupportsPerVertexShadingRateWithMultipleViewports
- Tipo booleano.
- Indica se è possibile usare più viewport con la frequenza di ombreggiatura per vertice (nota anche come per primitiva).
Specifica della frequenza di ombreggiatura
Per la flessibilità nelle applicazioni, sono disponibili diversi meccanismi per controllare la frequenza di ombreggiatura. Sono disponibili meccanismi diversi a seconda del livello di funzionalità hardware.
Elenco di comandi
Questo è il meccanismo più semplice per impostare la frequenza di ombreggiatura. È disponibile in tutti i livelli.
L'applicazione può specificare una dimensione di pixel grossolana usando il metodo ID3D12GraphicsCommandList5::RSSetShadingRate. Tale API accetta un singolo argomento di enumerazione. L'API fornisce un controllo generale del livello di qualità per il rendering, ovvero la possibilità di impostare la frequenza di ombreggiatura in base al disegno.
I valori per questo stato vengono espressi tramite l'enumerazione D3D12_SHADING_RATE .
Supporto delle dimensioni dei pixel grossolane
Le frequenze di ombreggiatura 1x1, 1x2, 2x1 e 2x2 sono supportate in tutti i livelli.
È disponibile una funzionalità AdditionalShadingRatesSupported per indicare se nel dispositivo sono supportati 2x4, 4x2 e 4x4.
Immagine dello spazio sullo schermo (basata su immagine)
Nel livello 2 e superiore è possibile specificare la frequenza di ombreggiatura in pixel con un'immagine dello spazio dello schermo.
L'immagine dello spazio dello schermo consente all'applicazione di creare un'immagine "livello di dettaglio (LOD) che indica le aree di qualità variabili, ad esempio le aree coperte da sfocatura del movimento, sfocatura profondità di campo, oggetti trasparenti o elementi dell'interfaccia utente HUD. La risoluzione dell'immagine è in macroblocks; non è nella risoluzione della destinazione di rendering. In altre parole, i dati della frequenza di ombreggiatura vengono specificati con una granularità di 8 riquadri pixel 8x8 o 16x16, come indicato dalle dimensioni del riquadro VRS.
Dimensioni del riquadro
L'applicazione può eseguire query su un'API per recuperare le dimensioni del riquadro VRS supportate per il dispositivo.
I riquadri sono quadrati e la dimensione fa riferimento alla larghezza o all'altezza del riquadro in texel.
Se l'hardware non supporta l'ombreggiatura a velocità variabile di livello 2, la query di funzionalità per le dimensioni del riquadro restituisce 0.
Se l'hardware supporta l'ombreggiatura a velocità variabile di livello 2, le dimensioni del riquadro sono uno di questi valori.
- 8
- 16
- 32
Dimensioni dell'immagine dello spazio dello schermo
Per una destinazione di rendering di dimensioni {rtWidth, rtHeight}, usando una determinata dimensione di riquadro denominata VRSTileSize, l'immagine dello spazio dello schermo che lo coprirà è di queste dimensioni.
{ ceil((float)rtWidth / VRSTileSize), ceil((float)rtHeight / VRSTileSize) }
L'immagine dello spazio dello schermo in alto a sinistra (0, 0) è bloccata nella parte superiore sinistra della destinazione di rendering (0, 0).
Per cercare la coordinata (x,y) di un riquadro che corrisponde a una posizione specifica nella destinazione di rendering, dividere le coordinate dello spazio della finestra di (x, y) in base alle dimensioni del riquadro, ignorando i bit frazionari.
Se l'immagine dello spazio dello schermo è maggiore di quella necessaria per una determinata destinazione di rendering, le parti aggiuntive a destra e/o inferiore non vengono usate.
Se l'immagine dello spazio dello schermo è troppo piccola per una determinata destinazione di rendering, qualsiasi tentativo di lettura dall'immagine oltre gli extent effettivi restituisce una velocità di ombreggiatura predefinita pari a 1x1. Ciò è dovuto al fatto che l'immagine dello spazio dello schermo in alto a sinistra (0, 0) è bloccata nella parte superiore sinistra della destinazione di rendering (0, 0) e la "lettura oltre gli extent della destinazione di rendering" significa leggere valori troppo elevati per x e y.
Formato, layout, proprietà delle risorse
Il formato di questa superficie è una superficie a 8 bit a canale singolo (DXGI_FORMAT_R8_UINT).
La risorsa è la dimensione TEXTURE2D.
Non può essere matriceta o ignorata. Deve avere un livello mip in modo esplicito.
Ha il numero di campioni 1 e la qualità del campione 0.
Ha layout di trama UNKNOWN. Non può essere in modo implicito il layout principale della riga, perché l'adattatore incrociato non è consentito.
Il modo previsto in cui vengono popolati i dati dell'immagine dello spazio dello schermo è
- Scrivere i dati usando un compute shader; l'immagine dello spazio dello schermo è associata come UAV o
- Copiare i dati nell'immagine dello spazio dello schermo.
Quando si crea l'immagine dello spazio dello schermo, questi flag sono consentiti.
- NONE
- ALLOW_UNORDERED_ACCESS
- DENY_SHADER_RESOURCE
Questi flag non sono consentiti.
- ALLOW_RENDER_TARGET
- ALLOW_DEPTH_STENCIL
- ALLOW_CROSS_ADAPTER
- ALLOW_SIMULTANEOUS_ACCESS
- VIDEO_DECODE_REFERENCE_ONLY
Il tipo heap della risorsa non può essere UPLOAD né READBACK.
La risorsa non può essere SIMULTANEOUS_ACCESS. La risorsa non può essere inter-adapter.
Dati
Ogni byte dell'immagine dello spazio dello schermo corrisponde a un valore dell'enumerazione D3D12_SHADING_RATE .
Stato della risorsa
Una risorsa deve essere sottoposta a transizione in uno stato di sola lettura quando viene usata come immagine dello spazio dello schermo. A questo scopo viene definito uno stato di sola lettura, D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE.
La risorsa immagine viene passata da tale stato per diventare nuovamente scrivibile.
Impostazione dell'immagine
L'immagine dello spazio dello schermo per specificare la frequenza dello shader è impostata nell'elenco dei comandi.
Una risorsa impostata come origine della frequenza di ombreggiatura non può essere letta o scritta da qualsiasi fase dello shader.
È possibile impostare un'immagine null dello spazio sullo schermo per specificare la frequenza dello shader. Questo ha l'effetto di usare 1x1 in modo coerente come contributo dell'immagine dello spazio dello schermo. L'immagine dello spazio dello schermo può essere inizialmente considerata impostata su null.
Promozione e decadimento
Una risorsa immagine dello spazio sullo schermo non ha implicazioni speciali per quanto riguarda la promozione o il decadimento.
Attributo per primitiva
Un attributo per primitivo aggiunge la possibilità di specificare un termine di frequenza di ombreggiatura come attributo da un vertice che provoca. Questo attributo è ombreggiato in modo flat, ovvero viene propagato a tutti i pixel nel triangolo o nella primitiva linea corrente. L'uso di un attributo per primitivo può abilitare un controllo più granulare della qualità dell'immagine rispetto agli altri identificatori di frequenza di ombreggiatura.
L'attributo per primitivo è una semantica impostabile denominata SV_ShadingRate.
SV_ShadingRate esiste come parte del modello HLSL Shader 6.4.
Se visual studio o GS imposta SV_ShadingRate, ma VRS non è abilitato, l'impostazione semantica non ha alcun effetto. Se non viene specificato alcun valore per SV_ShadingRate primitiva, viene considerato come contributo per primitivo un valore di frequenza di ombreggiatura pari a 1x1.
Combinazione dei fattori di frequenza di ombreggiatura
Le varie origini della frequenza di ombreggiatura vengono applicate in sequenza usando questo diagramma.
Ogni coppia di A e B viene combinata usando un combinatore.
* Quando si specifica una frequenza dello shader in base all'attributo vertex.
- Se viene usato uno shader geometry, è possibile specificare la frequenza di ombreggiatura.
- Se non viene usato uno shader geometry, la frequenza di ombreggiatura viene specificata dal vertice che provoca.
Elenco di combinatori
Sono supportati i combinatori seguenti. Uso di un combinatore (C) e di due input (A e B).
- Pass-through. C.xy = A.xy.
- Eseguire l'override. C.xy = B.xy.
- Maggiore qualità. C.xy = min(A.xy, B.xy).
- Qualità inferiore. C.xy = max(A.xy, B.xy).
- Applicare il costo B rispetto a A. C.xy = min(maxRate, A.xy + B.xy).
dove maxRate è la dimensione massima consentita di pixel grossolani nel dispositivo. Questo sarebbe
-
D3D12_AXIS_SHADING_RATE_2X (ovvero un valore pari a 1), se AdditionalShadingRatesSupported è
false. -
D3D12_AXIS_SHADING_RATE_4X (ovvero un valore pari a 2), se AdditionalShadingRatesSupported è
true.
La scelta del combinatore per l'ombreggiatura a velocità variabile viene impostata nell'elenco dei comandi tramite ID3D12GraphicsCommandList5::RSSetShadingRate.
Se non vengono mai impostati combinatori, rimangono all'impostazione predefinita, ovvero PASSTHROUGH.
Se l'origine di un combinatore è un D3D12_AXIS_SHADING_RATE, che non è consentito nella tabella di supporto, l'input viene sanificato in base a una frequenza di ombreggiatura supportata.
Se l'output di un combinatore non corrisponde a una frequenza di ombreggiatura supportata nella piattaforma, il risultato viene filtrato in base a una frequenza di ombreggiatura supportata.
Stato predefinito e cancellazione dello stato
Tutte le origini della frequenza di ombreggiatura, ovvero
- frequenza specificata dallo stato della pipeline (specificata nell'elenco di comandi),
- frequenza specificata dall'immagine dello spazio dello schermo e
- attributo per primitiva
il valore predefinito è D3D12_SHADING_RATE_1X1. I combinatori predefiniti sono {PASSTHROUGH, PASSTHROUGH}.
Se non viene specificata alcuna immagine dello spazio dello schermo, viene dedotta una frequenza di ombreggiatura pari a 1x1 da tale origine.
Se non viene specificato alcun attributo per primitiva, viene dedotto da tale origine una frequenza di ombreggiatura pari a 1x1.
ID3D12CommandList::ClearState reimposta la velocità specificata dallo stato della pipeline sul valore predefinito e la selezione dell'immagine dello spazio dello schermo sul valore predefinito "nessuna immagine dello spazio dello schermo".
Esecuzione di query sulla frequenza di ombreggiatura tramite SV_ShadingRate
È utile sapere quale frequenza di ombreggiatura è stata selezionata dall'hardware in qualsiasi chiamata al pixel shader specificato. Ciò potrebbe consentire un'ampia gamma di ottimizzazioni nel codice PS. Una variabile di sistema solo PS, SV_ShadingRate, fornisce informazioni sulla frequenza di ombreggiatura.
Tipo
Il tipo di questa semantica è uint.
Interpretazione dei dati
I dati vengono interpretati come valore dell'enumerazione D3D12_SHADING_RATE .
Se vrs non viene usato
Se l'ombreggiatura in pixel grossolana non viene usata, SV_ShadingRate viene rilette come valore 1x1, che indica i pixel sottili.
Comportamento nell'esecuzione basata su esempio
Una compilazione pixel shader non riesce se inserisce SV_ShadingRate e usa anche l'esecuzione basata su campioni, ad esempio immettendo SV_SampleIndexo usando la parola chiave di interpolazione di esempio.
Osservazioni sull'ombreggiatura posticipata
I passaggi di illuminazione di un'applicazione ombreggiatura posticipata potrebbero dover sapere quale frequenza di ombreggiatura è stata usata per quale area dello schermo. Questo è in modo che i messaggi di illuminazione pass possono essere lanciati a una velocità grossolana. La
SV_ShadingRatevariabile può essere usata per eseguire questa operazione se viene scritta nel gbuffer.
Profondità e stencil
Quando si usa l'ombreggiatura in pixel grossolana, la profondità e lo stencil e la copertura vengono sempre calcolate e generate alla risoluzione completa del campione.
Utilizzo della frequenza di ombreggiatura richiesta
Per tutti i livelli, è previsto che se è richiesta una frequenza di ombreggiatura ed è supportata nella combinazione di livello device-and-MSAA, questa è la velocità di ombreggiatura fornita dall'hardware.
Una frequenza di ombreggiatura richiesta indica una frequenza di ombreggiatura calcolata come output dei combinatori (vedere la sezione Combinazione dei fattori di frequenza di ombreggiatura in questo argomento).
Una frequenza di ombreggiatura supportata è 1x1, 1x2, 2x1 o 2x2 in un'operazione di rendering in cui il conteggio dei campioni è minore o uguale a quattro. Se la funzionalità AdditionalShadingRatesSupported è true, anche 2x4, 4x2 e 4x4 sono supportate le frequenze di ombreggiatura per alcuni conteggi dei campioni (vedere la tabella nella sezione With variable-rate shading (VRS) in questo argomento.
Derivati dello spazio sullo schermo
I calcoli delle sfumature da pixel a pixel adiacenti sono influenzati dall'ombreggiatura in pixel grossolana. Ad esempio, quando vengono usati 2x2 pixel grossolani, una sfumatura sarà due volte la dimensione rispetto a quando i pixel grossolani non vengono usati. L'applicazione potrebbe voler regolare gli shader per compensare questo problema, o meno, a seconda delle funzionalità desiderate.
Poiché gli mips vengono scelti in base a uno spazio dello schermo derivato, l'utilizzo dell'ombreggiatura pixel grossolana influisce sulla selezione mip. L'utilizzo dell'ombreggiatura dei pixel grossolani causa la selezione di mips meno dettagliati rispetto a quando i pixel grossolani non vengono usati.
Interpolazione degli attributi
Gli input a un pixel shader possono essere interpolati in base ai vertici di origine. Poiché l'ombreggiatura a frequenza variabile influisce sulle aree della destinazione scritte da ogni chiamata del pixel shader, interagisce con l'interpolazione degli attributi. I tre tipi di interpolazione sono centro, centroide e campione.
Center
La posizione di interpolazione centrale per un pixel grossolano è il centro geometrico dell'area di pixel grossolana completa.
SV_Position viene sempre interpolata al centro dell'area pixel grossolana.
Baricentro
Quando l'ombreggiatura in pixel grossolana viene usata con MSAA, per ogni pixel fine ci saranno comunque scritture nel numero completo di campioni allocati per il livello MSAA della destinazione. Quindi, la posizione di interpolazione centroide considererà tutti i campioni per i pixel fine all'interno di pixel grossolani. Detto questo, la posizione di interpolazione centroide è definita come il primo campione coperto, in ordine crescente di indice campione. La copertura effettiva dell'esempio è AND-ed con il bit corrispondente dello stato di rasterizer SampleMask.
Nota
Quando l'ombreggiatura in pixel grossolana viene usata nel livello 1, SampleMask è sempre una maschera completa. Se SampleMask è configurato per non essere una maschera completa, l'ombreggiatura in pixel grossolana è disabilitata nel livello 1.
Esecuzione basata su esempio
L'esecuzione basata su campioni o il supercampionamento, causato dall'uso della funzionalità di interpolazione del campione, può essere usata con ombreggiatura pixel grossolana e fa sì che il pixel shader venga richiamato per campione. Per le destinazioni del numero di campioni N, il pixel shader viene richiamato N volte per pixel fine.
EvaluateAttributeSnapped
Gli intrinseci del modello pull non sono compatibili con l'ombreggiatura in pixel grossolana nel livello 1. Se si tenta di usare oggetti intrinseci del modello pull con ombreggiatura pixel grossolana al livello 1, l'ombreggiatura dei pixel grossolani viene disabilitata automaticamente.
L'intrinseco EvaluateAttributeSnapped può essere usato con ombreggiatura pixel grossolana nel livello 2. La sua sintassi è la stessa di sempre.
numeric EvaluateAttributeSnapped(
in attrib numeric value,
in int2 offset);
Per il contesto, EvaluateAttributeSnapped ha un parametro di offset con due campi. Se usato senza ombreggiatura in pixel grossolana, vengono usati solo quattro bit inferiori all'esterno dei trentadue. Questi quattro bit rappresentano l'intervallo [-8, 7]. Questo intervallo si estende su una griglia di 16x16 all'interno di un pixel. L'intervallo è tale che i bordi superiore e sinistro del pixel sono inclusi e i bordi inferiore e destro non sono. L'offset (-8, -8) si trova nell'angolo superiore sinistro e l'offset (7, 7) si trova nell'angolo inferiore destro. Offset (0, 0) è il centro del pixel.
Se usato con ombreggiatura pixel grossolana, EvaluateAttributeSnappedil parametro offset di è in grado di specificare una gamma più ampia di posizioni. Il parametro offset seleziona una griglia 16x16 per ogni pixel fine e sono presenti più pixel sottili. L'intervallo expressible e il conseguente numero di bit usati dipendono dalle dimensioni del pixel grossolano. I bordi superiore e sinistro del pixel grossolano sono inclusi e i bordi inferiore e destro non sono.
La tabella seguente descrive l'interpretazione del parametro offset di EvaluateAttributeSnappedper ogni dimensione di pixel grossolana.
Intervallo di offset evaluateAttributeSnapped
| Dimensioni pixel grossolane | Intervallo indicizzabile | Dimensioni dell'intervallo rappresentabili | Numero di bit necessari {x, y} | Maschera binaria di bit utilizzabili |
|---|---|---|---|---|
| 1x1 (fine) | {[-8, 7], [-8, 7]} | {16, 16} | {4, 4} | {000000000000xxxx, 00000000000xxxx} |
| 1x2 | {[-8, 7], [-16, 15]} | {16, 32} | {4, 5} | {000000000000xxxx, 00000000000xxxxx} |
| 2x1 | {[-16, 15], [-8, 7]} | {32, 16} | {5, 4} | {00000000000xxxxx, 00000000000xxxx} |
| 2x2 | {[-16, 15], [-16, 15]} | {32, 32} | {5, 5} | {00000000000xxxxx, 00000000000xxxxx} |
| 2x4 | {[-16, 15], [-32, 31]} | {32, 64} | {5, 6} | {00000000000xxxxx, 000000000xxxxxx} |
| 4x2 | {[-32, 31], [-16, 15]} | {64, 32} | {6, 5} | {0000000000xxxxxx, 00000000000xxxxx} |
| 4x4 | {[-32, 31], [-32, 31]} | {64, 64} | {6, 6} | {0000000000xxxxxx, 000000000xxxxxx} |
Le tabelle seguenti sono una guida per la conversione da una rappresentazione decimale a decimale e frazionaria. Il primo bit utilizzabile nella maschera binaria è il bit del segno e il resto della maschera binaria comprende la parte numerica.
Lo schema numerico per i valori a quattro bit passato a EvaluateAttributeSnapped non è specifico dell'ombreggiatura a velocità variabile. È sottolineato qui per completezza.
Per i valori a quattro bit.
| Valore binario | Decimal | Precisione |
|---|---|---|
| 1000 | -0.5f | -8 / 16 |
| 1001 | -0.4375f | -7 / 16 |
| 1010 | -0.375f | -6 / 16 |
| 1011 | -0.3125f | -5 / 16 |
| 1100 | -0.25f | -4 / 16 |
| 1101 | -0.1875f | -3 / 16 |
| 1110 | -0.125f | -2 / 16 |
| 1111 | -0.0625f | -1 /16 |
| 0000 | 0,0f | 0 / 16 |
| 0001 | -0.0625f | 1 / 16 |
| 0010 | -0.125f | 2 / 16 |
| 0011 | -0.1875f | 3 / 16 |
| 0100 | -0.25f | 4 / 16 |
| 0101 | -0.3125f | 5 / 16 |
| 0110 | -0.375f | 6 / 16 |
| 0111 | -0.4375f | 7 / 16 |
Per i valori a cinque bit.
| Valore binario | Decimal | Precisione |
|---|---|---|
| 10000 | -1 | -16 / 16 |
| 10001 | -0.9375 | -15 / 16 |
| 10010 | -0.875 | -14 / 16 |
| 10011 | -0.8125 | -13 / 16 |
| 10100 | -0.75 | -12 / 16 |
| 10101 | -0.6875 | -11 / 16 |
| 10110 | -0.625 | -10 / 16 |
| 10111 | -0.5625 | -9 / 16 |
| 11000 | -0.5 | -8 / 16 |
| 11001 | -0.4375 | -7 / 16 |
| 11010 | -0.375 | -6 / 16 |
| 11011 | -0.3125 | -5 / 16 |
| 11100 | -0.25 | -4 / 16 |
| 11101 | -0.1875 | -3 / 16 |
| 11110 | -0.125 | -2 / 16 |
| 11111 | -0.0625 | -1 / 16 |
| 00000 | 0 | 0 / 16 |
| 00001 | 0.0625 | 1 / 16 |
| 00010 | 0,125 | 2 / 16 |
| 00011 | 0.1875 | 3 / 16 |
| 00100 | 0,25 | 4 / 16 |
| 00101 | 0.3125 | 5 / 16 |
| 00110 | 0.375 | 6 / 16 |
| 00111 | 0.4375 | 7 / 16 |
| 01000 | 0.5 | 8 / 16 |
| 01001 | 0.5625 | 9 / 16 |
| 01010 | 0.625 | 10 / 16 |
| 01011 | 0.6875 | 11 / 16 |
| 01100 | 0,75 | 12 / 16 |
| 01101 | 0.8125 | 13 / 16 |
| 01110 | 0.875 | 14 / 16 |
| 01111 | 0.9375 | 15 / 16 |
Per valori a sei bit.
| Valore binario | Decimal | Precisione |
|---|---|---|
| 100000 | -2 | -32 / 16 |
| 100001 | -1.9375 | -31 / 16 |
| 100010 | -1.875 | -30 / 16 |
| 100011 | -1.8125 | -29 / 16 |
| 100100 | -1.75 | -28 / 16 |
| 100101 | -1.6875 | -27 / 16 |
| 100110 | -1.625 | -26 / 16 |
| 100111 | -1.5625 | -25 / 16 |
| 101000 | -1.5 | -24 / 16 |
| 101001 | -1.4375 | -23 / 16 |
| 101010 | -1.375 | -22 / 16 |
| 101011 | -1.3125 | -21 / 16 |
| 101100 | -1.25 | -20 / 16 |
| 101101 | -1.1875 | -19 / 16 |
| 101110 | -1.125 | -18 / 16 |
| 101111 | -1.0625 | -17 / 16 |
| 110000 | -1 | -16 / 16 |
| 110001 | -0.9375 | -15 / 16 |
| 110010 | -0.875 | -14 / 16 |
| 110011 | -0.8125 | -13 / 16 |
| 110100 | -0.75 | -12 / 16 |
| 110101 | -0.6875 | -11 / 16 |
| 110110 | -0.625 | -10 / 16 |
| 110111 | -0.5625 | -9 / 16 |
| 111000 | -0.5 | -8 / 16 |
| 111001 | -0.4375 | -7 / 16 |
| 111010 | -0.375 | -6 / 16 |
| 111011 | -0.3125 | -5 / 16 |
| 111100 | -0.25 | -4 / 16 |
| 111101 | -0.1875 | -3 / 16 |
| 111110 | -0.125 | -2 / 16 |
| 111111 | -0.0625 | -1 / 16 |
| 000000 | 0 | 0 / 16 |
| 000001 | 0.0625 | 1 / 16 |
| 000010 | 0,125 | 2 / 16 |
| 000011 | 0.1875 | 3 / 16 |
| 000100 | 0,25 | 4 / 16 |
| 000101 | 0.3125 | 5 / 16 |
| 000110 | 0.375 | 6 / 16 |
| 000111 | 0.4375 | 7 / 16 |
| 001000 | 0.5 | 8 / 16 |
| 001001 | 0.5625 | 9 / 16 |
| 001010 | 0.625 | 10 / 16 |
| 001011 | 0.6875 | 11 / 16 |
| 001100 | 0,75 | 12 / 16 |
| 001101 | 0.8125 | 13 / 16 |
| 001110 | 0.875 | 14 / 16 |
| 001111 | 0.9375 | 15 / 16 |
| 010000 | 1 | 16 / 16 |
| 010001 | 1.0625 | 17 / 16 |
| 010010 | 1,125 | 18 / 16 |
| 010011 | 1.1875 | 19 / 16 |
| 010100 | 1,25 | 20 / 16 |
| 010101 | 1.3125 | 21 / 16 |
| 010110 | 1.375 | 22 / 16 |
| 010111 | 1.4375 | 23 / 16 |
| 011000 | 1.5 | 24 / 16 |
| 011001 | 1.5625 | 25 / 16 |
| 011010 | 1,625 | 26 / 16 |
| 011011 | 1.6875 | 27 / 16 |
| 011100 | 1,75 | 28 / 16 |
| 011101 | 1.8125 | 29 / 16 |
| 011110 | 1.875 | 30 / 16 |
| 011111 | 1.9375 | 31 / 16 |
Allo stesso modo di con pixel fine, EvaluateAttributeSnappedla griglia delle posizioni valutabili viene centrata al centro dei pixel grossolani quando si usa l'ombreggiatura dei pixel grossolana.
SetSamplePositions
Quando l'ID API ID3D12GraphicsCommandList1::SetSamplePositions viene usato con ombreggiatura grossolana, l'API imposta le posizioni di esempio per i pixel fine.
SV_Coverage
Se SV_Coverage viene dichiarato come input o output shader nel livello 1, l'ombreggiatura dei pixel grossolana è disabilitata.
È possibile usare la SV_Coverage semantica con ombreggiatura dei pixel grossolani nel livello 2 e riflette quali esempi di una destinazione MSAA vengono scritti.
Quando viene usata l'ombreggiatura dei pixel grossolani, consentendo a più pixel di origine di includere un riquadro, la maschera di copertura rappresenta tutti gli esempi provenienti da tale riquadro.
Data la compatibilità con l'ombreggiatura dei pixel grossolani con MSAA, il numero di bit di copertura necessari per essere specificato può variare. Ad esempio, con una risorsa MSAA 4x usando D3D12_SHADING_RATE_2x2, ogni pixel grossolano scrive in quattro pixel fine e ogni pixel fine ha quattro esempi. Ciò significa che ogni pixel grossolano scrive in un totale di 4 * 4 = 16 campioni.
Numero di bit di copertura necessari
La tabella seguente indica il numero di bit di copertura necessari per ogni combinazione di dimensioni di pixel grossolane e livello MSAA.
Come indicato nella tabella, non è possibile usare pixel grossolani per scrivere in più di 16 esempi alla volta usando la funzionalità di ombreggiatura a velocità variabile esposta tramite Direct3D 12. Questa restrizione è dovuta ai vincoli di Direct3D 12 relativi ai livelli MSAA consentiti con le dimensioni grossolane dei pixel (vedere la tabella nella sezione With variable-rate shading (VRS) in questo argomento.
Ordinamento e formato di bit nella maschera di copertura
I bit della maschera di copertura rispettano un ordine ben definito. La maschera è costituita da copertura da pixel da sinistra a destra, quindi dall'alto verso il basso (colonna-principale) ordine. I bit di copertura sono i bit a basso ordine della semantica di copertura e vengono raggruppati in modo denso.
La tabella seguente mostra il formato della maschera di copertura per le combinazioni supportate di dimensioni di pixel grossolane e livello MSAA.
La tabella seguente illustra 2x MSAA pixel, in cui ogni pixel ha due esempi di indici 0 e 1.
La posizione delle etichette di campioni sui pixel è per scopi illustrativi e non trasmette necessariamente le posizioni spaziali di {X, Y} su tale pixel; soprattutto dato che le posizioni di esempio possono essere modificate a livello di codice. Gli esempi vengono definiti dall'indice basato su 0.
La tabella seguente mostra 4x MSAA pixel, in cui ogni pixel ha quattro esempi di indici 0, 1, 2 e 3.
Discard
Quando la semantica discard HLSL viene usata con ombreggiatura di pixel grossolana, i pixel grossolani vengono eliminati.
Rasterizzazione indipendente dalla destinazione (TIR)
IL TIR non è supportato quando viene utilizzata l'ombreggiatura dei pixel grossolana.
Visualizzazioni degli ordini raster (ROV)
Gli interlock ROV vengono specificati come operativi in corrispondenza della granularità dei pixel fine. Se l'ombreggiatura viene eseguita per esempio, gli interlock vengono operativi in corrispondenza della granularità di esempio.
Rasterizzazione conservativa
È possibile usare la rasterizzazione conservativa con ombreggiatura a frequenza variabile. Quando la rasterizzazione conservativa viene usata con ombreggiatura di pixel grossolani, i pixel fine all'interno di pixel grossolani vengono rasterizzati in modo conservativo fornendo una copertura completa.
Copertura
Quando viene usata la rasterizzazione conservativa, la semantica di copertura contiene maschere complete per i pixel fine coperti e 0 per i pixel fine non coperti.
Pacchetti
È possibile chiamare API di ombreggiatura a frequenza variabile in un bundle.
Passaggio di rendering
È possibile chiamare API di ombreggiatura a frequenza variabile in un passaggio di rendering.
Chiamata alle API VRS
Questa sezione successiva descrive il modo in cui l'ombreggiatura a frequenza variabile è accessibile all'applicazione tramite Direct3D 12.
Query sulle funzionalità
Per eseguire una query sulla funzionalità di ombreggiatura a frequenza variabile dell'adattatore, chiamare ID3D12Device::CheckFeatureSupport con D3D12_FEATURE::D 3D12_FEATURE_D3D12_OPTIONS6 e fornire una struttura D3D12_FEATURE_DATA_D3D12_OPTIONS6 per la funzione da compilare. La struttura D3D12_FEATURE_DATA_D3D12_OPTIONS6 contiene diversi membri, tra cui uno del tipo enumerato D3D12_VARIABLE_SHADING_RATE_TIER (D3D12_FEATURE_DATA_D3D12_OPTIONS6 ::VariableShadingRateTier) e uno che indica se l'elaborazione in background è supportata (D3D12_FEATURE_DATA_D3D12_OPTIONS6::BackgroundProcessingSupported).
Per eseguire una query sulla funzionalità livello 1, ad esempio, è possibile eseguire questa operazione.
D3D12_FEATURE_DATA_D3D12_OPTIONS6 options;
return
SUCCEEDED(m_device->CheckFeatureSupport(
D3D12_FEATURE_D3D12_OPTIONS6,
&options,
sizeof(options))) &&
options.ShadingRateTier == D3D12_VARIABLE_SHADING_RATE_TIER_1;
Tassi di ombreggiatura
I valori dell'enumerazione D3D12_SHADING_RATE sono organizzati in modo che le frequenze di ombreggiatura siano facilmente decomposbili in due assi, in cui i valori di ogni asse vengono rappresentati in modo compatto nello spazio logaritmico in base all'enumerazione D3D12_AXIS_SHADING_RATE.
È possibile creare una macro per comporre due tassi di ombreggiatura dell'asse in una frequenza di ombreggiatura simile a questa.
#define D3D12_MAKE_COARSE_SHADING_RATE(x,y) ((x) << 2 | (y))
D3D12_MAKE_COARSE_SHADING_RATE(
D3D12_AXIS_SHADING_RATE_2X,
D3D12_AXIS_SHADING_RATE_1X)
La piattaforma fornisce anche queste macro, definite in d3d12.h.
#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(x) ((x) >> 2 )
#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(y) ((y) & 3 )
Tali elementi possono essere usati per analizzare e comprendere SV_ShaderRate.
Nota
Questa interpretazione dei dati è orientata alla descrizione dell'immagine dello spazio dello schermo, che può essere modificata dagli shader. Questo argomento è illustrato ulteriormente nelle sezioni precedenti. Ma non c'è motivo di avere una definizione coerente delle dimensioni dei pixel grossolane da usare ovunque, tra cui quando si imposta la frequenza di ombreggiatura a livello di comando.
Impostazione della frequenza di ombreggiatura a livello di comando e dei combinatori
La frequenza di ombreggiatura e, facoltativamente, i combinatori vengono specificati tramite il metodo ID3D12GraphicsCommandList5::RSSetShadingRate . Si passa un valore D3D12_SHADING_RATE per la frequenza di ombreggiatura di base e una matrice facoltativa di valori D3D12_SHADING_RATE_COMBINER .
Preparazione dell'immagine dello spazio dello schermo
Lo stato della risorsa di sola lettura che designa un'immagine di frequenza di ombreggiatura utilizzabile è definita come D3D12_RESOURCE_STATES::D 3D12_RESOURCE_STATE_SHADING_RATE_SOURCE.
Impostazione dell'immagine dello spazio dello schermo
Specificare l'immagine dello spazio dello schermo tramite il metodo ID3D12GraphicsCommandList5::RSSetShadingRateImage .
m_commandList->RSSetShadingRateImage(screenSpaceImage);
Esecuzione di query sulle dimensioni del riquadro
È possibile eseguire una query sulle dimensioni del riquadro dal membro D3D12_FEATURE_DATA_D3D12_OPTIONS6::ShadingRateImageTileSize . Vedere Query sulle funzionalità precedenti.
Viene recuperata una dimensione, poiché le dimensioni orizzontali e verticali sono sempre uguali. Se la funzionalità del sistema è D3D12_SHADING_RATE_TIER_NOT_SUPPORTED, la dimensione del riquadro restituita è 0.