Skuggning med variabel hastighet (VRS)

Motivationen för VRS

På grund av prestandabegränsningar har en grafikåtergivning inte alltid råd att leverera samma kvalitetsnivå till varje del av utdatabilden. Skuggning med variabel hastighet – eller grov pixelskuggning – är en mekanism som gör att du kan allokera renderingsprestanda/effekt med hastigheter som varierar mellan dina renderade bilder.

I vissa fall kan skuggningsfrekvensen minskas med liten eller ingen minskning av märkbar utdatakvalitet; vilket leder till en prestandaförbättring som i stort sett är kostnadsfri.

Utan VRS – flerexempel på antialias med supersampling

Utan skuggning med variabel frekvens är det enda sättet att kontrollera skuggningshastigheten med flera exempel på antialias (MSAA) med exempelbaserad körning (även kallat supersampling).

MSAA är en mekanism för att minska geometriska alias och förbättra återgivningskvaliteten för en bild jämfört med att inte använda MSAA. MSAA-exempelantalet, som kan vara 1x, 2x, 4x, 8x eller 16x, styr antalet tilldelade exempel per målpixel för återgivning. MSAA-exempelantalet måste vara känt i förväg när målet allokeras och det kan inte ändras därefter.

Supersampling gör att pixelskuggningen anropas en gång per exempel, med högre kvalitet men också högre prestandakostnad jämfört med körning per bildpunkt.

Ditt program kan styra skuggningshastigheten genom att välja mellan per pixelbaserad körning eller MSAA-with-supersampling. Dessa två alternativ ger inte mycket bra kontroll. Du kanske också vill ha en lägre skuggningshastighet för en viss klass av objekt jämfört med resten av bilden. Sådana objekt kan innehålla ett objekt bakom ett HUD-element eller en genomskinlighet, en oskärpa (djup-of-field, rörelse osv.) eller en optisk förvrängning på grund av VR-optik. Men det skulle inte vara möjligt, eftersom skuggningskvaliteten och kostnaderna är fasta över hela bilden.

Med skuggning med variabel hastighet (VRS)

Vrs-modellen (variable-rate shading) utökar supersampling-with-MSAA i motsatt riktning, "grov pixel", genom att lägga till begreppet grov skuggning. Det är här skuggning kan utföras med en frekvens som är mer grov än en pixel. Med andra ord kan en grupp bildpunkter skuggas som en enda enhet och resultatet skickas sedan till alla exempel i gruppen.

Med ett api för grov skuggning kan ditt program ange antalet pixlar som tillhör en skuggad grupp, eller grov pixel. Du kan variera den grova pixelstorleken när du har allokerat återgivningsmålet. Därför kan olika delar av skärmen eller olika dragningspass ha olika skuggningshastigheter.

Följande är en tabell som beskriver vilken MSAA-nivå som stöds med vilken grov pixelstorlek, för plattformar som stöder grov skuggning:

• För celler som är markerade Yaktiveras den kombinationen.
• För celler som har markerats Capär den kombinationen villkorligt aktiverad baserat på ett tak (AdditionalShadingRatesSupported).
• För celler som är tomma stöds inte den kombinationen.
• För celler som är halvtonskuggade stöds inte den kombinationen, och den omfattar spårning av fler än 16 exempel per pixelskuggning. För spårning av fler än 16 exempel finns det ytterligare maskinvarujusteringsbarriärer att stödja, jämfört med de andra fallen.

Funktionsnivåer

Det finns två nivåer för VRS-implementeringen och två funktioner som du kan fråga efter. Varje nivå beskrivs mer detaljerat efter tabellen.

Nivå 1

• Skuggningshastighet kan endast anges per dragningsbasis. inte mer detaljerat än så.
• Skuggningshastigheten gäller enhetligt för det som ritas oberoende av var det ligger inom återgivningsmålet.

Nivå 2

• Skuggningshastighet kan anges per dragning, som i Nivå 1. Det kan också anges med en kombination av per dragningsbas och av:
  • Semantisk från varje provocerande hörn, och
  • en skärmutrymmesbild.
• Skuggningshastigheter från de tre källorna kombineras med hjälp av en uppsättning kombinationer.
• Skärmutrymmets bildpanelstorlek är 16 x 16 eller mindre.
• Skuggningsfrekvensen som begärs av ditt program kommer garanterat att levereras exakt (för precision för tidsmässiga och andra rekonstruktionsfilter).
• SV_ShadingRate PS-indata stöds.
• Skuggningsfrekvensen per provoking-vertex (kallas även per primitiv) är giltig när en visningsport används och SV_ViewportArrayIndex inte skrivs till.
• Per-provoking-vertex-frekvensen kan användas med mer än ett visningsområde om funktionen SupportsPerVertexShadingRateWithMultipleViewports är inställd på true. I så fall kan dessutom den kursen användas när SV_ViewportArrayIndex skrivs till.

Lista över funktioner

• AdditionalShadingRatesSupported
  • Boolesk typ.
  • Anger om storlekarna 2x4, 4x2 och 4x4 grova bildpunkter stöds för en samplad återgivning. och om grov pixelstorlek 2x4 stöds för 2x MSAA.
• SupportsPerVertexShadingRateWithMultipleViewports
  • Boolesk typ.
  • Anger om fler än ett visningsområde kan användas med per hörn (kallas även per primitiv) skuggningshastighet.

Ange skuggningshastighet

För flexibilitet i program finns det en mängd olika mekanismer för att styra skuggningshastigheten. Olika mekanismer är tillgängliga beroende på maskinvarufunktionsnivån.

Kommandolista

Det här är den enklaste mekanismen för att ställa in skuggningshastigheten. Den är tillgänglig på alla nivåer.

Ditt program kan ange en grov pixelstorlek med hjälp av metoden ID3D12GraphicsCommandList5::RSSetShadingRate-metoden. Api:et tar ett enda uppräkningsargument. API:et ger en övergripande kontroll över kvalitetsnivån för återgivning – möjligheten att ställa in skuggningshastigheten per dragning.

Värden för det här tillståndet uttrycks via D3D12_SHADING_RATE uppräkning.

Stöd för grov pixelstorlek

Skuggningshastigheterna 1x1, 1x2, 2x1 och 2x2 stöds på alla nivåer.

Det finns en funktion, AdditionalShadingRatesSupported, för att ange om 2x4, 4x2 och 4x4 stöds på enheten.

Skärmutrymmesbild (bildbaserad)

På nivå 2 och högre kan du ange pixelskuggningshastigheten med en skärmutrymmesbild.

Med skärmutrymmesbilden kan ditt program skapa en lod-mask (level-of-detail) som anger regioner av varierande kvalitet, till exempel områden som kommer att täckas av rörelseoskärpa, djup-of-field-oskärpa, transparenta objekt eller HUD-gränssnittselement. Bildens upplösning finns i makroblock. Det finns inte i upplösningen för återgivningsmålet. Med andra ord anges skuggningshastighetsdata med en kornighet på 8 x 8 eller 16 x 16 bildpunkter, vilket anges av VRS-panelens storlek.

Panelstorlek

Ditt program kan köra frågor mot ett API för att hämta den VRS-panelstorlek som stöds för enheten.

Paneler är kvadratiska och storleken refererar till panelens bredd eller höjd i texels.

Om maskinvaran inte stöder nivå 2-skuggning med variabel hastighet returnerar funktionsfrågan för panelstorleken 0.

Om maskinvaran stöder nivå 2-skuggning med variabel hastighet är panelstorleken ett av dessa värden.

• 8
• 16
• 32

Bildstorlek för skärmutrymme

För ett återgivningsmål med storleken {rtWidth, rtHeight}, med en angiven panelstorlek med namnet VRSTileSize, är skärmutrymmesbilden som täcker den av dessa dimensioner.

{ ceil((float)rtWidth / VRSTileSize), ceil((float)rtHeight / VRSTileSize) }

Skärmutrymmesbildens övre vänstra del (0, 0) är låst till återgivningsmålets övre vänstra sida (0, 0).

Om du vill slå upp koordinaten (x,y) för en panel som motsvarar en viss plats i återgivningsmålet delar du upp koordinaterna för fönsterutrymmet (x, y) med panelstorleken och ignorerar bråkbitar.

Om skärmutrymmesbilden är större än den behöver vara för ett givet återgivningsmål används inte de extra delarna till höger och/eller längst ned.

Om skärmutrymmesbilden är för liten för ett givet återgivningsmål ger alla försök att läsa från bilden utöver dess faktiska omfattning en standard skuggningshastighet på 1x1. Det beror på att skärmutrymmesbildens övre vänstra del (0, 0) är låst till återgivningsmålets övre vänstra sida (0, 0) och "läsning utöver render-mål-omfattningen" innebär att läsa för stora värden för x och y.

Format, layout, resursegenskaper

Formatet på den här ytan är en 8-bitars yta med en kanal (DXGI_FORMAT_R8_UINT).

Resursen är dimensionen TEXTURE2D.

Det kan inte vara matriserat eller mippat. Den måste uttryckligen ha en mip-nivå.

Den har exempelantal 1 och exempelkvalitet 0.

Den har texturlayout OKÄND. Det kan implicit inte vara rad-större layout, eftersom korsadapter inte tillåts.

Det förväntade sättet på vilket skärmutrymmesbilddata fylls i är att antingen

1. Skriv data med hjälp av en beräkningsskuggare. skärmutrymmesbilden är bunden som en UAV, eller
2. Kopiera data till skärmutrymmesbilden.

När du skapar skärmutrymmesbilden tillåts dessa flaggor.

• INGEN
• ALLOW_UNORDERED_ACCESS
• DENY_SHADER_RESOURCE

Dessa flaggor är inte tillåtna.

• ALLOW_RENDER_TARGET
• ALLOW_DEPTH_STENCIL
• ALLOW_CROSS_ADAPTER
• ALLOW_SIMULTANEOUS_ACCESS
• VIDEO_DECODE_REFERENCE_ONLY

Resursens heaptyp kan inte vara UPLOAD eller READBACK.

Resursen kan inte SIMULTANEOUS_ACCESS. Resursen får inte vara korskort.

Data

Varje byte av skärmutrymmesbilden motsvarar ett värde för D3D12_SHADING_RATE uppräkning.

Resurstillstånd

En resurs måste övergå till ett skrivskyddat tillstånd när den används som en skärmutrymmesbild. Ett skrivskyddat tillstånd, D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE, definieras för detta ändamål.

Avbildningsresursen övergår från det tillståndet för att bli skrivbar igen.

Ställa in bilden

Skärmutrymmesbilden för att ange skuggningshastigheten anges i kommandolistan.

En resurs som har angetts som en skuggningsfrekvenskälla kan inte läsas eller skrivas från någon skuggningsfas.

Du kan ange en null skärmutrymmesbild för att ange skuggningshastigheten. Detta innebär att 1x1 används konsekvent som bidrag från skärmutrymmesbilden. Skärmutrymmesbilden kan ursprungligen anses vara inställd på null.

Befordran och förfall

En skärmutrymmesbildresurs har inga särskilda konsekvenser för befordran eller förfall.

Per primitivt attribut

Ett per primitivt attribut lägger till möjligheten att ange en skuggningsfrekvensterm som ett attribut från ett utlösande hörn. Det här attributet är platt skuggat, det vill sa att det sprids till alla bildpunkter i den aktuella triangeln eller linjens primitiva. Användning av ett per primitivt attribut kan möjliggöra finare kontroll av bildkvaliteten jämfört med andra skuggningsfrekvenssspecificerare.

Attributet per primitiv är en semantik som kan anges med namnet SV_ShadingRate. SV_ShadingRate finns som en del av HLSL Shader Model 6.4.

Om en VS- eller GS-uppsättningar SV_ShadingRate, men VRS inte är aktiverat, har semantikinställningen ingen effekt. Om inget värde för SV_ShadingRate anges per primitiv antas ett skuggningsfrekvensvärde på 1x1 som det per primitiva bidraget.

Kombinera skuggningshastighetsfaktorer

De olika skuggningskällorna tillämpas i följd med hjälp av det här diagrammet.

Varje par av A och B kombineras med en kombination.

* När du anger en skuggningshastighet per hörnattribut.

• Om en geometriskuggning används kan skuggningshastighet anges genom detta.
• Om en geometrisk skuggning inte används anges skuggningshastigheten av det utlösande hörnet.

Lista över kombinationer

Följande kombinationer stöds. Använda en Combiner (C) och två indata (A och B).

• Genomströmning. C.xy = A.xy.
• åsidosätt. C.xy = B.xy.
• Högre kvalitet. C.xy = min(A.xy, B.xy).
• Lägre kvalitet. C.xy = max(A.xy, B.xy).
• Använd kostnad B i förhållande till A. C.xy = min(maxRate, A.xy + B.xy).

där maxRate är den största tillåtna dimensionen av grov pixel på enheten. Detta skulle vara

• D3D12_AXIS_SHADING_RATE_2X (dvs. värdet 1) om AdditionalShadingRatesSupported är false.
• D3D12_AXIS_SHADING_RATE_4X (dvs. värdet 2) om AdditionalShadingRatesSupported är true.

Valet av kombinationsprogram för skuggning med variabel frekvens anges i kommandolistan via ID3D12GraphicsCommandList5::RSSetShadingRate.

Om inga kombinationer någonsin har angetts förblir de som standard, vilket är PASSTHROUGH.

Om källan till en kombination är en D3D12_AXIS_SHADING_RATE, som inte tillåts i supporttabellen, rensas indata till en skuggningshastighet som stöds.

Om utdata från en kombinationsfunktion inte motsvarar en skuggningsfrekvens som stöds på plattformen, rensas resultatet till en skuggningshastighet som stöds.

Standardtillstånd och tillståndsrensning

Alla skuggningsfrekvenskällor, nämligen

• pipelinens tillståndsangivna hastighet (anges i kommandolistan).
• bild angiven hastighet för skärmutrymme och
• attributet per primitiv

har standardvärdet D3D12_SHADING_RATE_1X1. Standard kombinerarna är {PASSTHROUGH, PASSTHROUGH}.

Om ingen skärmutrymmesbild har angetts härleds en skuggningshastighet på 1x1 från den källan.

Om inget per primitivt attribut anges härleds en skuggningshastighet på 1x1 från den källan.

ID3D12CommandList::ClearState återställer den angivna pipeline-tillståndsfrekvensen till standardvärdet och valet av skärmutrymmesbild till standardvärdet "ingen skärmutrymmesbild".

Köra frågor mot skuggningsfrekvensen med hjälp av SV_ShadingRate

Det är användbart att veta vilken skuggningsfrekvens som har valts av maskinvaran vid ett visst pixelskuggningsanrop. Detta kan möjliggöra en mängd olika optimeringar i PS-koden. En ps-systemvariabel, SV_ShadingRate, innehåller information om skuggningshastigheten.

Typ

Typen av den här semantiken är uint.

Datatolkning

Data tolkas som ett värde för D3D12_SHADING_RATE uppräkning.

Om VRS inte används

Om grov pixelskuggning inte används, läss SV_ShadingRate tillbaka som ett värde på 1x1, vilket indikerar fina bildpunkter.

Beteende under exempelbaserad körning

En pixelskuggning misslyckas med kompileringen om den matar in SV_ShadingRate och även använder exempelbaserad körning, till exempel genom att ange SV_SampleIndexeller med hjälp av nyckelordet för exempelinterpolation.

Kommentarer om uppskjuten skuggning

Ett uppskjutet skuggningsprograms belysningspass kan behöva veta vilken skuggningshastighet som användes för vilket område på skärmen. Detta är så att belysningspasssändningar kan starta i en grovare takt. Variabeln SV_ShadingRate kan användas för att åstadkomma detta om den skrivs ut till gbuffern.

Djup och stencil

När grov pixelskuggning används beräknas djup och stencil och täckning alltid och genereras med den fullständiga exempelupplösningen.

Använda den begärda skuggningsfrekvensen

För alla nivåer är det förväntat att om en skuggningsfrekvens begärs och stöds på kombinationen enhet-och-MSAA-nivå, så är det den skuggningshastighet som levereras av maskinvaran.

En begärd skuggningsfrekvens innebär en skuggningshastighet som beräknas som utdata från kombinationerna (se avsnittet Kombinera skuggningshastighetsfaktorer i det här avsnittet).

En skuggningsfrekvens som stöds är 1x1, 1x2, 2x1 eller 2x2 i en återgivningsåtgärd där urvalsantalet är mindre än eller lika med fyra. Om funktionen AdditionalShadingRatesSupported är true, stöds även 2x4, 4x2 och 4x4 skuggningsfrekvenser för vissa exempelantal (se tabellen i Med vrs(variable-rate shading) i det här avsnittet).

Skärmutrymmesderivat

Beräkningar av pixel-till-angränsande pixeltoningar påverkas av grov pixelskuggning. När till exempel 2x2 grova bildpunkter används blir en toning dubbelt så stor som när grova bildpunkter inte används. Ditt program kanske vill justera skuggningar för att kompensera för detta , eller inte, beroende på vilka funktioner du vill ha.

Eftersom mips väljs baserat på ett skärmutrymmesderivat påverkar användningen av grov pixelskuggning mip-markeringen. Användning av grov pixelskuggning gör att mindre detaljerade mips väljs jämfört med när grova bildpunkter inte används.

Attributinterpolation

Indata till en pixelskuggning kan interpoleras baserat på deras källhörn. Eftersom skuggning med variabel hastighet påverkar de områden i målet som skrivs av varje anrop av pixelskuggningen interagerar den med attributinterpolation. De tre typerna av interpolering är center, centroid och sample.

Centrum

Mitteninterpolationens plats för en grov pixel är den geometriska mitten av det fullständiga grova bildpunktsområdet. SV_Position interpoleras alltid i mitten av den grova pixelregionen.

Centroid

När grov pixelskuggning används med MSAA kommer det för varje fin pixel fortfarande att skrivas till det fullständiga antalet exempel som allokerats för målets MSAA-nivå. Centroidinterpolationens plats tar därför hänsyn till alla exempel på fina bildpunkter inom grova bildpunkter. Med detta sagt definieras centroidinterpolationens plats som det första täckta urvalet, i ökande ordning efter exempelindex. Exemplets effektiva täckning är AND-ed med motsvarande bit av rastreringstillståndet SampleMask.

Exempelbaserad körning

Exempelbaserad körning, eller supersampling– som orsakas av användning av exempelinterpoleringsfunktionen – kan användas med grov pixelskuggning och gör att pixelskuggningen anropas per exempel. För mål för exempelantalet N anropas pixelskuggaren N gånger per fin pixel.

EvaluateAttributeSnapped

Inbyggda pull-modeller är inte kompatibla med grov pixelskuggning på nivå 1. Om det görs ett försök att använda pull-model intrinsics med grov pixelskuggning på nivå 1 inaktiveras grov pixelskuggning automatiskt.

Den inbyggda EvaluateAttributeSnapped tillåts användas med grov pixelskuggning på nivå 2. Syntaxen är densamma som den alltid har varit.

numeric EvaluateAttributeSnapped(	
    in attrib numeric value, 
    in int2 offset);

För kontext har EvaluateAttributeSnapped en förskjutningsparameter med två fält. När de används utan grov pixelskuggning används bara fyra bitar i lägre ordning av hela trettiotvå. Dessa fyra bitar representerar intervallet [-8, 7]. Det här intervallet sträcker sig över ett 16x16-rutnät inom en pixel. Intervallet är sådant att pixelns övre och vänstra kanter ingår och att de nedre och högra kanterna inte är det. Offset (-8, -8) finns i det övre vänstra hörnet och förskjutningen (7, 7) är i det nedre högra hörnet. Offset (0, 0) är mitten av pixeln.

När den används med grov pixelskuggning kan EvaluateAttributeSnappedförskjutningsparameter ange ett bredare antal platser. Förskjutningsparametern väljer ett rutnät på 16 x 16 för varje fin pixel och det finns flera fina bildpunkter. Det uttrycksbara intervallet och det efterföljande antalet bitar som används beror på den grova pixelstorleken. De övre och vänstra kanterna på den grova pixeln ingår och de nedre och högra kanterna är inte det.

I tabellen nedan beskrivs tolkningen av EvaluateAttributeSnappedoffsetparameter för varje grov pixelstorlek.

EvaluateAttributeSnappeds förskjutningsintervall

Grov pixelstorlek	Indexerbart intervall	Storlek på representerande intervall	Antal bitar som behövs {x, y}	Binär mask av användbara bitar
1x1 (böter)	{[-8, 7], [-8, 7]}	{16, 16}	{4, 4}	{0000000000000xxxx, 00000000000xxxx}
1x2	{[-8, 7], [-16, 15]}	{16, 32}	{4, 5}	{0000000000000xxxx, 0000000000xxxxx}
2x1	{[-16, 15], [-8, 7]}	{32, 16}	{5, 4}	{00000000000xxxxxxx, 00000000000xxxx}
2x2	{[-16, 15], [-16, 15]}	{32, 32}	{5, 5}	{000000000000xxxxxxx, 0000000000xxxxx}
2x4	{[-16, 15], [-32, 31]}	{32, 64}	{5, 6}	{000000000000xxxxxxx, 000000000xxxxxx}
4x2	{[-32, 31], [-16, 15]}	{64, 32}	{6, 5}	{00000000000xxxxxxxx, 0000000000xxxxx}
4x4	{[-32, 31], [-32, 31]}	{64, 64}	{6, 6}	{00000000000xxxxxx, 000000000xxxx}

Tabellerna nedan är en guide för konvertering till från fast punkt till decimal och bråkrepresentation. Den första användbara biten i den binära masken är teckenbiten och resten av den binära masken består av den numeriska delen.

Nummerschemat för fyra bitars värden som skickas till EvaluateAttributeSnapped är inte specifikt för skuggning med variabel hastighet. Det upprepas här för fullständighet.

För fyra bitars värden.

Binärt värde	Decimal	Fraktionerad
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

För fem bitars värden.

Binärt värde	Decimal	Fraktionerad
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

För sex bitars värden.

Binärt värde	Decimal	Fraktionerad
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

På samma sätt som med fina bildpunkter centreras EvaluateAttributeSnappedrutnät med utvärderade platser i det grova pixelcentret när du använder grov pixelskuggning.

SetSamplePositions

När API:et ID3D12GraphicsCommandList1::SetSamplePositions används med grov skuggning anger API:et exempelpositionerna för fina bildpunkter.

SV_Coverage

Om SV_Coverage deklareras som skuggningsindata eller utdata på nivå 1 inaktiveras grov pixelfyllning.

Du kan använda SV_Coverage semantik med grov pixelskuggning på nivå 2, och det visar vilka exempel på ett MSAA-mål som skrivs.

När grov pixelskuggning används – vilket gör att flera källpixlar kan utgöra en panel – representerar täckningsmasken alla exempel som kommer från panelen.

Med tanke på den grova pixelskuggningens kompatibilitet med MSAA kan antalet täckningsbitar som behövs anges variera. Till exempel med en 4x MSAA-resurs med D3D12_SHADING_RATE_2x2, skriver varje grov pixel till fyra fina bildpunkter och varje fin pixel har fyra exempel. Det innebär att varje grov pixel skriver till totalt 4 * 4 = 16 exempel.

Antal täckningsbitar som behövs

I följande tabell visas hur många täckningsbitar som behövs för varje kombination av grov pixelstorlek och MSAA-nivå.

Som anges i tabellen går det inte att använda grova bildpunkter för att skriva till fler än 16 exempel i taget med hjälp av funktionen för skuggning med variabel hastighet som exponeras via Direct3D 12. Den här begränsningen beror på Direct3D 12:s begränsningar för vilka MSAA-nivåer som tillåts med vilken grov pixelstorlek (se tabellen i Med vrs-skuggning (variable-rate shading) i det här avsnittet).

Ordning och format för bitar i täckningsmasken

Bitarna i täckningsmasken följer en väldefinierad ordning. Masken består av täckning från bildpunkter från vänster till höger och sedan uppifrån och ned (kolumn-större) ordning. Täckningsbitar är lågordningsbitarna i täckningssemantiken och är tätt packade tillsammans.

Tabellen nedan visar täckningsmaskformatet för kombinationer av grov pixelstorlek och MSAA-nivå som stöds.

I följande tabell visas 2x MSAA-pixlar, där varje pixel har två exempel på index 0 och 1.

Placeringen av etiketterna för exempel på bildpunkterna är för illustrativa ändamål och förmedlar inte nödvändigtvis de rumsliga {X, Y} platserna för exempel på den pixeln. särskilt med tanke på att exempelpositioner kan ändras programmatiskt. Exempel refereras till av deras 0-baserade index.

I följande tabell visas 4 x MSAA-pixlar, där varje pixel har fyra exempel på index 0, 1, 2 och 3.

Kasta bort

När HLSL-semantiska discard används med grov pixelskuggning ignoreras grova bildpunkter.

Måloberoende rastrering (TIR)

TIR stöds inte när grov pixelskuggning används.

Rasterordningsvyer (ROV: er)

ROV-interlock anges som fungerar med fin pixelkornighet. Om skuggning utförs per exempel fungerar sammankopplingar med granularitetsexempel.

Konservativ rastrering

Du kan använda konservativ rastrering med skuggning med variabel hastighet. När konservativ rasterisering används med grov pixelskuggning, rastreras fina pixlar inom grova bildpunkter konservativt genom att få full täckning.

Täckning

När konservativ rastrering används innehåller täckningssemantiken fullständiga masker för fina bildpunkter som täcks och 0 för fina bildpunkter som inte täcks.

Buntar

Du kan anropa API:er för skuggning med variabel frekvens i ett paket.

Återgivningspass

Du kan anropa API:er för skuggning med variabel hastighet i ett rendera pass.

Anropa VRS-API:erna

I nästa avsnitt beskrivs hur skuggning med variabel frekvens är tillgänglig för ditt program via Direct3D 12.

Frågor om kapacitet

Om du vill fråga efter kortets kapacitet för skuggning med variabel hastighet anropar du ID3D12Device::CheckFeatureSupport med D3D12_FEATURE::D 3D12_FEATURE_D3D12_OPTIONS6och tillhandahåller en D3D12_FEATURE_DATA_D3D12_OPTIONS6 struktur för funktionen som ska fyllas i åt dig. Den D3D12_FEATURE_DATA_D3D12_OPTIONS6 strukturen innehåller flera medlemmar, inklusive en som är av den uppräknade typen D3D12_VARIABLE_SHADING_RATE_TIER (D3D12_FEATURE_DATA_D3D12_OPTIONS6::VariableShadingRateTier) och en som anger om bakgrundsbearbetning stöds (D3D12_FEATURE_DATA_D3D12_OPTIONS6::BackgroundProcessingSupported).

Om du till exempel vill fråga efter kapacitet på nivå 1 kan du göra det.

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;

Skuggningshastigheter

Värdena i D3D12_SHADING_RATE uppräkning ordnas så att skuggningshastigheter enkelt kan delas upp i två axlar, där varje axels värden är kompakt representerade i logaritmiskt utrymme enligt D3D12_AXIS_SHADING_RATE uppräkning.

Du kan skapa ett makro för att skapa två axelskuggningshastigheter i en skuggningsfrekvens som den här.

#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)

Plattformen innehåller även dessa makron som definieras i d3d12.h.

#define D3D12_GET_COARSE_SHADING_RATE_X_AXIS(x) ((x) >> 2 )
#define D3D12_GET_COARSE_SHADING_RATE_Y_AXIS(y) ((y) & 3 )

De kan användas för att dissekera och förstå SV_ShaderRate.

Ange skuggningshastighet och kombinationer på kommandonivå

Skuggningshastigheten och, om du vill, kombinerare anges via metoden ID3D12GraphicsCommandList5::RSSetShadingRate. Du skickar ett D3D12_SHADING_RATE värde för basfyllningshastigheten och en valfri matris med D3D12_SHADING_RATE_COMBINER värden.

Förbereda skärmutrymmesbilden

Det skrivskyddade resurstillståndet som anger en användbar skuggningsfrekvensbild definieras som D3D12_RESOURCE_STATES::D 3D12_RESOURCE_STATE_SHADING_RATE_SOURCE.

Ställa in skärmutrymmesbilden

Du anger skärmutrymmesbilden via metoden ID3D12GraphicsCommandList5::RSSetShadingRateImage.

m_commandList->RSSetShadingRateImage(screenSpaceImage);

Köra frågor mot panelens storlek

Du kan fråga panelstorleken från D3D12_FEATURE_DATA_D3D12_OPTIONS6::ShadingRateImageTileSize medlem. Se Funktionsfråga ovan.

En dimension hämtas eftersom de vågräta och lodräta dimensionerna alltid är desamma. Om systemets funktion är D3D12_SHADING_RATE_TIER_NOT_SUPPORTEDär panelstorleken som returneras 0.