Ombrage à taux variable (VRS)

La motivation de VRS

En raison de contraintes de performances, un renderer graphique ne peut pas toujours se permettre de fournir le même niveau de qualité à chaque partie de son image de sortie. L’ombrage à taux variable (ou trame de pixels grossière) est un mécanisme qui vous permet d’allouer des performances de rendu/de la puissance à des taux qui varient selon votre image rendue.

Dans certains cas, le taux d’ombrage peut être réduit avec peu ou pas de réduction de la qualité de production perceptible ; menant à une amélioration des performances qui est essentiellement gratuite.

Sans VRS : anticrénelage multi-échantillon avec supersampling

Sans ombrage à taux variable, le seul moyen de contrôler le taux d’ombrage est avec l’anti-aliasing multi-échantillon (MSAA) avec l’exécution basée sur l’échantillon (également appelée supersampling).

MSAA est un mécanisme permettant de réduire l’alias géométrique et d’améliorer la qualité de rendu d’une image par rapport à l’utilisation de MSAA. Le nombre d’exemples MSAA, qui peut être 1x, 2x, 4x, 8x ou 16x, régit le nombre d’échantillons alloués par pixel cible de rendu. Le nombre d’exemples MSAA doit être connu avant l’allocation de la cible et ne peut pas être modifié par la suite.

Le super-échantillonnage entraîne l’appel du nuanceur de pixels une fois par échantillon, à une qualité plus élevée, mais aussi un coût de performances plus élevé par rapport à l’exécution par pixel.

Votre application peut contrôler son taux d’ombrage en choisissant entre l’exécution par pixel ou msAA-with-supersampling. Ces deux options ne fournissent pas de contrôle très précis. En outre, vous souhaiterez peut-être un taux d’ombrage inférieur pour une certaine classe d’objets par rapport au reste de l’image. Ces objets peuvent inclure un objet derrière un élément HUD ou une transparence, un flou (profondeur de champ, mouvement, etc.) ou une distorsion optique due à l’optique VR. Mais cela ne serait pas possible, car la qualité et les coûts d’ombrage sont fixes sur l’ensemble de l’image.

Avec l’ombrage à taux variable (VRS)

Le modèle d’ombrage à taux variable (VRS) étend l’échantillonnage avec MSAA dans le sens inverse, « pixel grossière », direction, en ajoutant le concept d’ombrage grossière. C’est là que l’ombrage peut être effectué à une fréquence plus grossière qu’un pixel. En d’autres termes, un groupe de pixels peut être ombré sous forme d’unité unique, et le résultat est ensuite diffusé dans tous les exemples du groupe.

Une API d’ombrage grossière permet à votre application de spécifier le nombre de pixels appartenant à un groupe ombré, ou pixels grossières. Vous pouvez varier la taille de pixels grossière après avoir alloué la cible de rendu. Ainsi, différentes parties de l’écran ou différentes passes de dessin peuvent avoir des taux d’ombrage différents.

Voici un tableau décrivant le niveau MSAA pris en charge avec la taille grossière des pixels, pour les plateformes qui prennent en charge l’ombrage grossière :

• Pour les cellules marquées Y, cette combinaison est activée.
• Pour les cellules marquées cap, cette combinaison est activée de manière conditionnelle en fonction d’une limite (AdditionalShadingRatesSupported).
• Pour les cellules vides, cette combinaison n’est pas prise en charge.
• Pour les cellules ombrées demi-teintes, cette combinaison n’est pas prise en charge, et il implique le suivi de plus de 16 échantillons par appel de nuanceur de pixels. Pour le suivi de plus de 16 échantillons, il existe des barrières d’alignement matérielle supplémentaires à prendre en charge, par rapport aux autres cas.

Niveaux de fonctionnalité

Il existe deux niveaux d’implémentation VRS, et deux fonctionnalités que vous pouvez rechercher. Chaque niveau est décrit plus en détail après le tableau.

Niveau 1

• Le taux d’ombrage ne peut être spécifié que sur une base par tirage ; pas plus granulaire que cela.
• Le taux d’ombrage s’applique uniformément à ce qui est dessiné indépendamment de l’emplacement où il se trouve dans la cible de rendu.

Niveau 2

• Le taux d’ombrage peut être spécifié sur une base par tirage, comme dans le niveau 1. Il peut également être spécifié par une combinaison de base par tirage et de :
  • Sémantique de chaque vertex provoquant, et
  • image d’espace d’écran.
• Les taux d’ombrage des trois sources sont combinés à l’aide d’un ensemble de combiners.
• La taille de la vignette de l’image d’espace écran est de 16 x 16 ou plus petite.
• Le taux d’ombrage demandé par votre application est garanti pour être livré exactement (pour une précision de filtres temporels et d’autres filtres de reconstruction).
• SV_ShadingRate entrée PS est prise en charge.
• Le taux d’ombrage par vertex (également appelé taux par primitive) est valide lorsqu’une fenêtre d’affichage est utilisée et SV_ViewportArrayIndex n’est pas écrite.
• Le taux de vertex par provocation peut être utilisé avec plusieurs fenêtres d’affichage si la SupportsPerVertexShadingRateWithMultipleViewports est définie sur true. En outre, dans ce cas, ce taux peut être utilisé lorsque SV_ViewportArrayIndex est écrit.

Liste des fonctionnalités

• additionalShadingRatesSupported
  • Type booléen.
  • Indique si les tailles de pixels 2x4, 4 x 2 et 4 x 4 sont prises en charge pour le rendu à échantillon unique ; et si la taille de pixels grossière 2x4 est prise en charge pour 2 x MSAA.
• SupportsPerVertexShadingRateWithMultipleViewports
  • Type booléen.
  • Indique si plusieurs fenêtres d’affichage peuvent être utilisées avec le taux d’ombrage par vertex (également appelé par primitive).

Spécification du taux d’ombrage

Pour la flexibilité des applications, il existe divers mécanismes fournis pour contrôler le taux d’ombrage. Différents mécanismes sont disponibles en fonction du niveau de fonctionnalité matérielle.

Liste de commandes

Il s’agit du mécanisme le plus simple pour définir le taux d’ombrage. Il est disponible sur tous les niveaux.

Votre application peut spécifier une taille de pixel grossière à l’aide de la méthode ID3D12GraphicsCommandList5 ::RSSetShadingRate méthode. Cette API prend un seul argument d’énumération. L’API fournit un contrôle global du niveau de qualité pour le rendu, la possibilité de définir le taux d’ombrage par dessin.

Les valeurs de cet état sont exprimées par l’énumération D3D12_SHADING_RATE.

Prise en charge des tailles de pixels grossières

Les taux d’ombrage 1x1, 1x2, 2x1 et 2x2 sont pris en charge sur tous les niveaux.

Il existe une fonctionnalité, AdditionalShadingRatesSupported, pour indiquer si 2x4, 4x2 et 4x4 sont pris en charge sur l’appareil.

Image d’espace d’écran (basée sur l’image)

Sur le niveau 2 et supérieur, vous pouvez spécifier le taux d’ombrage de pixels avec une image d’espace d’écran.

L’image de l’espace écran permet à votre application de créer une image « masque de niveau de détail (LOD) » indiquant des régions de qualité variable, telles que les zones couvertes par le flou de mouvement, le flou de profondeur de champ, les objets transparents ou les éléments d’interface utilisateur HUD. La résolution de l’image se trouve dans des macroblocks ; ce n’est pas dans la résolution de la cible de rendu. En d’autres termes, les données de débit de trame de fond sont spécifiées à une granularité de 8 x 8 ou 16 x 16 pixels, comme indiqué par la taille de la vignette VRS.

Taille des vignettes

Votre application peut interroger une API pour récupérer la taille de vignette VRS prise en charge pour son appareil.

Les vignettes sont carrées et la taille fait référence à la largeur ou à la hauteur de la vignette dans les texels.

Si le matériel ne prend pas en charge l’ombrage de taux variable de niveau 2, la requête de fonctionnalité pour la taille de vignette retourne 0.

Si le matériel ne prend en charge l’ombrage de niveau 2 variable, la taille de la vignette est l’une de ces valeurs.

• 8
• 16
• 32

Taille de l’image d’espace écran

Pour une cible de rendu de taille {rtWidth, rtHeight}, à l’aide d’une taille de vignette donnée nommée VRSTileSize, l’image d’espace d’écran qui la couvrira est de ces dimensions.

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

L’image d’espace d’écran située en haut à gauche (0, 0) est verrouillée en haut à gauche de la cible de rendu (0, 0).

Pour rechercher la coordonnée (x,y) d’une vignette qui correspond à un emplacement particulier dans la cible de rendu, divisez les coordonnées de l’espace fenêtre de (x, y) par la taille de la vignette, ignorant les bits fractionnels.

Si l’image de l’espace écran est supérieure à celle d’une cible de rendu donnée, les parties supplémentaires situées à droite et/ou en bas ne sont pas utilisées.

Si l’image de l’espace écran est trop petite pour une cible de rendu donnée, toute tentative de lecture de l’image au-delà de ses étendues réelles génère un taux d’ombrage par défaut de 1x1. Cela est dû au fait que l’image d’espace d’écran située en haut à gauche (0, 0) est verrouillée dans la partie supérieure gauche de la cible de rendu (0, 0) et « lecture au-delà des étendues de la cible de rendu » signifie lire trop de valeurs pour x et y.

Format, disposition, propriétés de ressource

Le format de cette surface est une surface 8 bits à canal unique (DXGI_FORMAT_R8_UINT).

La ressource est TEXTURE2Ddimension .

Elle ne peut pas être matricielle ou mipée. Il doit avoir explicitement un niveau mip.

Il a le nombre d’échantillons 1 et la qualité de l’échantillon 0.

Il a une disposition de texture UNKNOWN. Elle ne peut pas être implicitement une disposition principale de ligne, car l’adaptateur croisé n’est pas autorisé.

La façon attendue pour laquelle les données d’image d’espace d’écran sont remplies consiste à

1. Écrire les données à l’aide d’un nuanceur de calcul ; l’image d’espace d’écran est liée en tant qu’UAV ou
2. Copiez les données dans l’image d’espace d’écran.

Lors de la création de l’image d’espace d’écran, ces indicateurs sont autorisés.

• AUCUN
• ALLOW_UNORDERED_ACCESS
• DENY_SHADER_RESOURCE

Ces indicateurs ne sont pas autorisés.

• ALLOW_RENDER_TARGET
• ALLOW_DEPTH_STENCIL
• ALLOW_CROSS_ADAPTER
• ALLOW_SIMULTANEOUS_ACCESS
• VIDEO_DECODE_REFERENCE_ONLY

Le type de tas de la ressource ne peut pas être UPLOAD ni READBACK.

La ressource ne peut pas être SIMULTANEOUS_ACCESS. La ressource n’est pas autorisée à être inter-adaptateur.

Données

Chaque octet de l’image d’espace d’écran correspond à une valeur de l’énumération D3D12_SHADING_RATE.

État de la ressource

Une ressource doit être transférée dans un état en lecture seule lorsqu’elle est utilisée comme image d’espace d’écran. Un état en lecture seule, D3D12_RESOURCE_STATE_SHADING_RATE_SOURCE, est défini à cet effet.

La ressource d’image est transférée de cet état pour redevenir accessible en écriture.

Définition de l’image

L’image d’espace d’écran permettant de spécifier le taux de nuanceur est définie dans la liste de commandes.

Une ressource qui a été définie comme source de taux d’ombrage ne peut pas être lue ou écrite à partir d’une étape de nuanceur.

Une image d’espace d’écran null peut être définie pour spécifier le taux de nuanceur. Cela a l’effet de 1x1 utilisé de manière cohérente comme contribution de l’image d’espace écran. L’image d’espace d’écran peut initialement être considérée comme définie sur null.

Promotion et dégradation

Une ressource d’image d’espace d’écran n’a pas d’implications particulières en ce qui concerne la promotion ou la dégradation.

Attribut par primitive

Un attribut par primitive ajoute la possibilité de spécifier un terme de taux d’ombrage en tant qu’attribut d’un sommet provoquant. Cet attribut est à nuanceur plat, c’est-à-dire propagé à tous les pixels du triangle ou de la primitive de trait actuel. L’utilisation d’un attribut par primitive peut permettre un contrôle plus précis de la qualité de l’image par rapport aux autres spécificateurs de taux d’ombrage.

L’attribut par primitive est une sémantique settable nommée SV_ShadingRate. SV_ShadingRate existe dans modèle de nuanceur HLSL 6.4.

Si un VS ou GS définit SV_ShadingRate, mais que VRS n’est pas activé, le paramètre sémantique n’a aucun effet. Si aucune valeur de SV_ShadingRate n’est spécifiée par primitive, une valeur de taux d’ombrage de 1x1 est considérée comme la contribution par primitive.

Combinaison de facteurs de taux d’ombrage

Les différentes sources de taux d’ombrage sont appliquées en séquence à l’aide de ce diagramme.

Chaque paire de A et B est combinée à l’aide d’un combineur.

* Lors de la spécification d’un taux de nuanceur par attribut de vertex.

• Si un nuanceur de géométrie est utilisé, le taux d’ombrage peut être spécifié à travers cela.
• Si un nuanceur géométrique n’est pas utilisé, le taux d’ombrage est spécifié par le vertex provoquant.

Liste des combiners

Les combiners suivants sont pris en charge. Utilisation d’un combineur (C) et de deux entrées (A et B).

• passthrough. C.xy = A.xy.
• remplacer. C.xy = B.xy.
• qualité supérieure. C.xy = min(A.xy, B.xy).
• de qualité inférieure. C.xy = max(A.xy, B.xy).
• Appliquer le coût B par rapport à un. C.xy = min(maxRate, A.xy + B.xy).

où maxRate est la plus grande dimension autorisée de pixels grossières sur l’appareil. Ce serait

• D3D12_AXIS_SHADING_RATE_2X (autrement dit, valeur 1), si AdditionalShadingRatesSupported est false.
• D3D12_AXIS_SHADING_RATE_4X (autrement dit, valeur 2), si AdditionalShadingRatesSupported est true.

Le choix du combineur pour l’ombrage à taux variable est défini sur la liste de commandes via ID3D12GraphicsCommandList5 ::RSSetShadingRate.

Si aucun combineur n’est jamais défini, il reste à la valeur par défaut, qui est PASSTHROUGH.

Si la source d’un combineur est une D3D12_AXIS_SHADING_RATE, qui n’est pas autorisée dans la table de prise en charge, l’entrée est nettoyée à un taux d’ombrage qui est pris en charge.

Si la sortie d’un combineur ne correspond pas à un taux d’ombrage pris en charge sur la plateforme, le résultat est nettoyé à un taux d’ombrage qui est pris en charge.

État par défaut et effacement de l’état

Toutes les sources de taux d’ombrage, à savoir

• taux spécifié par l’état du pipeline (spécifié dans la liste de commandes),
• taux spécifié par l’image d’écran et
• l’attribut par primitive

ont une valeur par défaut de D3D12_SHADING_RATE_1X1. Les combiners par défaut sont {PASSTHROUGH, PASSTHROUGH}.

Si aucune image d’espace d’écran n’est spécifiée, un taux d’ombrage de 1x1 est déduit de cette source.

Si aucun attribut par primitive n’est spécifié, un taux d’ombrage de 1x1 est déduit de cette source.

ID3D12CommandList ::ClearState réinitialise le taux spécifié par l’état du pipeline à la valeur par défaut, et la sélection de l’image d’espace d’écran sur la valeur par défaut « aucune image d’espace écran ».

Interrogation du taux d’ombrage à l’aide de SV_ShadingRate

Il est utile de savoir quel taux d’ombrage a été sélectionné par le matériel à n’importe quel appel de nuanceur de pixels donné. Cela peut permettre une variété d’optimisations dans votre code PS. Une variable système PS uniquement, SV_ShadingRate, fournit des informations sur le taux d’ombrage.

Type

Le type de cette sémantique est uint.

Interprétation des données

Les données sont interprétées comme une valeur de l’énumération D3D12_SHADING_RATE.

Si VRS n’est pas utilisé

Si l’ombrage de pixels grossière n’est pas utilisé, SV_ShadingRate est lu en arrière comme valeur de 1x1, indiquant des pixels fins.

Comportement sous exécution basée sur des exemples

Un nuanceur de pixels échoue si elle entre SV_ShadingRate et utilise également l’exécution basée sur des exemples, par exemple en plaçant SV_SampleIndexou en utilisant l’exemple de mot clé d’interpolation.

Remarques sur l’ombrage différé

Les passes d’éclairage d’une application de trame différée peuvent avoir besoin de savoir quel taux d’ombrage a été utilisé pour quelle zone de l’écran. C’est ainsi que les distributions de passe d’éclairage peuvent se lancer à un rythme plus grosseur. La variable SV_ShadingRate peut être utilisée pour effectuer cette opération si elle est écrite dans le gbuffer.

Profondeur et gabarit

Lorsque l’ombrage de pixels grossière est utilisé, la profondeur et le gabarit et la couverture sont toujours calculés et émis à la résolution complète de l’exemple.

Utilisation du taux d’ombrage demandé

Pour tous les niveaux, il est prévu que si un taux d’ombrage est demandé et qu’il est pris en charge sur la combinaison de niveau appareil-et-MSAA, c’est-à-dire le taux d’ombrage fourni par le matériel.

Un taux d’ombrage demandé signifie qu’un taux d’ombrage est calculé en tant que sortie des combiners (consultez la combinaison de facteurs de taux d’ombrage section de cette rubrique).

Un taux d’ombrage pris en charge est 1x1, 1x2, 2x1 ou 2x2 dans une opération de rendu où le nombre d’échantillons est inférieur ou égal à quatre. Si la fonctionnalité AdditionalShadingRatesSupported est true, 2x4, 4x2 et 4x4 sont également prises en charge pour certains exemples de comptage (consultez le tableau dans la section With variable-rate shading (VRS) section de cette rubrique).

Dérivés de l’espace écran

Les calculs de dégradés de pixels à adjacents sont affectés par l’ombrage de pixels grossières. Par exemple, lorsque des pixels grossières 2x2 sont utilisés, un dégradé est deux fois plus de taille que lorsque les pixels grossières ne sont pas utilisés. Votre application souhaite peut-être ajuster les nuanceurs pour compenser cela , ou non, en fonction des fonctionnalités souhaitées.

Étant donné que les mips sont choisies en fonction d’un dérivé de l’espace d’écran, l’utilisation de l’ombrage de pixels grossières affecte la sélection de mip. L’utilisation de l’ombrage de pixels grossières entraîne la sélection de mips moins détaillée par rapport au moment où les pixels grossières ne sont pas utilisés.

Interpolation d’attribut

Les entrées d’un nuanceur de pixels peuvent être interpolées en fonction de leurs sommets sources. Étant donné que l’ombrage à taux variable affecte les zones de la cible écrites par chaque appel du nuanceur de pixels, elle interagit avec l’interpolation d’attribut. Les trois types d’interpolation sont centre, centroïde et échantillon.

Centre

L’emplacement d’interpolation centrale d’un pixel grossière est le centre géométrique de la zone de pixels grossière. SV_Position est toujours interpolé au centre de la région de pixels grossières.

Centroïde

Lorsque l’ombrage de pixels grossière est utilisé avec MSAA, pour chaque pixel fin, il y aura toujours des écritures dans le nombre total d’échantillons alloués pour le niveau MSAA de la cible. Par conséquent, l’emplacement d’interpolation centroïde prend en compte tous les exemples de pixels fins au sein de pixels grossières. Cela étant dit, l’emplacement d’interpolation centroïde est défini comme premier échantillon couvert, dans l’ordre croissant de l’index de l’échantillon. La couverture effective de l’échantillon est and-ed avec le bit correspondant de l’état de rastériseur SampleMask.

Exécution basée sur des exemples

L’exécution basée sur des exemples ou supersampling( qui est causée par l’utilisation de l’exemple de fonctionnalité d’interpolation) peut être utilisée avec l’ombrage de pixels grossière et entraîne l’appel du nuanceur de pixels par exemple. Pour les cibles du nombre d’échantillons N, le nuanceur de pixels est appelé N fois par pixel fin.

EvaluateAttributeSnapped

Les intrinsèques du modèle d’extraction ne sont pas compatibles avec l’ombrage de pixels grossières sur le niveau 1. S’il existe une tentative d’utilisation d’intrinsèques de modèle d’extraction avec trame de pixels grossières sur le niveau 1, l’ombrage de pixels grossière est automatiquement désactivé.

La EvaluateAttributeSnapped intrinsèque est autorisée à être utilisée avec l’ombrage de pixels grossières sur le niveau 2. Sa syntaxe est identique à celle qu’elle a toujours été.

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

Pour le contexte, EvaluateAttributeSnapped a un paramètre de décalage avec deux champs. Lorsqu’il est utilisé sans trame de pixels grossières, seuls les quatre bits de l’ordre inférieur des trente-deux sont utilisés. Ces quatre bits représentent la plage [-8, 7]. Cette plage s’étend sur une grille de 16 x 16 dans un pixel. La plage est telle que les bords supérieur et gauche du pixel sont inclus, et les bords inférieur et droit ne sont pas. Le décalage (-8, -8) se trouve en haut à gauche et le décalage (7, 7) est situé en bas à droite. Le décalage (0, 0) est le centre du pixel.

Lorsqu’il est utilisé avec l’ombrage de pixels grossières, EvaluateAttributeSnappedparamètre de décalage est capable de spécifier une plus grande plage d’emplacements. Le paramètre de décalage sélectionne une grille de 16 x 16 pour chaque pixel fin, et il existe plusieurs pixels fins. La plage expressible et le nombre de bits utilisé dépendent de la taille grossière des pixels. Les bords supérieur et gauche du pixel grossière sont inclus, et les bords inférieur et droit ne sont pas.

Le tableau ci-dessous décrit l’interprétation du paramètre de décalage de EvaluateAttributeSnappedpour chaque taille de pixels grossière.

Plage de décalage d’EvaluateAttributeSnapped

Taille de pixels grossières	Plage indexable	Taille de plage représentée	Nombre de bits nécessaires {x, y}	Masque binaire des bits utilisables
1x1 (fine)	{[-8, 7], [-8, 7]}	{16, 16}	{4, 4}	{0000000000xxxx, 00000000000xxxx}
1x2	{[-8, 7], [-16, 15]}	{16, 32}	{4, 5}	{0000000000xxxx, 000000000000xxxxx}
2x1	{[-16, 15], [-8, 7]}	{32, 16}	{5, 4}	{0000000000xxxxx, 0000000000xxxx}
2x2	{[-16, 15], [-16, 15]}	{32, 32}	{5, 5}	{0000000000xxxxx, 0000000000xxxxx}
2x4	{[-16, 15], [-32, 31]}	{32, 64}	{5, 6}	{0000000000xxxxx, 000000000xxxx}
4x2	{[-32, 31], [-16, 15]}	{64, 32}	{6, 5}	{00000000xx, 00000000000xxxxx}
4x4	{[-32, 31], [-32, 31]}	{64, 64}	{6, 6}	{000000000xxxxxx, 000000000xxxx}

Les tableaux ci-dessous constituent un guide pour la conversion vers le point fixe vers la représentation décimale et fractionnelle. Le premier bit utilisable dans le masque binaire est le bit de signe, et le reste du masque binaire comprend la partie numérique.

Le schéma de nombre pour les valeurs quatre bits passées à EvaluateAttributeSnapped n’est pas spécifique à l’ombrage à taux variable. C’est répété ici pour l’exhaustivité.

Pour les valeurs à quatre bits.

Valeur binaire	Décimal	Fractionnaire
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

Pour les valeurs de cinq bits.

Valeur binaire	Décimal	Fractionnaire
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

Pour les valeurs de six bits.

Valeur binaire	Décimal	Fractionnaire
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

De la même manière qu’avec les pixels fins, EvaluateAttributeSnappedgrille d’emplacements pouvant être évalués est centrée au centre des pixels grossières lors de l’utilisation de l’ombrage de pixels grossières.

SetSamplePositions

Lorsque l’API ID3D12GraphicsCommandList1 ::SetSamplePositions est utilisée avec l’ombrage grossière, l’API définit les positions d’exemple pour les pixels fins.

SV_Coverage

Si SV_Coverage est déclaré en tant qu’entrée ou sortie du nuanceur au niveau 1, l’ombrage de pixels grossière est désactivé.

Vous pouvez utiliser la sémantique SV_Coverage avec une trame de pixels grossière sur le niveau 2, et elle reflète les exemples d’une cible MSAA en cours d’écriture.

Lorsque l’ombrage de pixels grossière est utilisé, ce qui permet à plusieurs pixels sources de composer une vignette, le masque de couverture représente tous les exemples provenant de cette vignette.

Étant donné la compatibilité de l’ombrage de pixels grossière avec MSAA, le nombre de bits de couverture nécessaires pour être spécifiés peut varier. Par exemple, avec une ressource MSAA 4x à l’aide de D3D12_SHADING_RATE_2x2, chaque pixel grossière écrit sur quatre pixels fins, et chaque pixel fin comporte quatre exemples. Cela signifie que chaque pixel grossière écrit dans un total de 4 * 4 = 16 échantillons.

Nombre de bits de couverture nécessaires

Le tableau suivant indique le nombre de bits de couverture nécessaires pour chaque combinaison de tailles de pixels grossières et de niveau MSAA.

Comme indiqué dans le tableau, il n’est pas possible d’utiliser des pixels grossières pour écrire dans plus de 16 échantillons à la fois à l’aide de la fonctionnalité d’ombrage à débit variable exposée via Direct3D 12. Cette restriction est due aux contraintes de Direct3D 12 concernant les niveaux MSAA autorisés avec la taille grossière des pixels (voir le tableau de la Avec ombrage à taux variable (VRS) section de cette rubrique).

Classement et format des bits dans le masque de couverture

Les bits du masque de couverture adhèrent à un ordre bien défini. Le masque se compose de couvertures de pixels de gauche à droite, puis de haut en bas (colonne principale). Les bits de couverture sont les bits de faible ordre de la sémantique de couverture et sont regroupés de manière dense.

Le tableau ci-dessous montre le format du masque de couverture pour les combinaisons prises en charge de taille de pixels grossières et de niveau MSAA.

Le tableau suivant présente 2 pixels MSAA, où chaque pixel contient deux exemples d’index 0 et 1.

Le positionnement des étiquettes d’échantillons sur les pixels est à des fins d’illustration et ne transmet pas nécessairement les emplacements spatiaux {X, Y} des échantillons sur ce pixel ; en particulier étant donné que les exemples de positions peuvent être modifiés par programmation. Les échantillons sont référencés par leur index basé sur 0.

Le tableau suivant montre 4 pixels MSAA, où chaque pixel comporte quatre exemples d’index 0, 1, 2 et 3.

Jeter

Lorsque l'discard sémantique HLSL est utilisée avec l’ombrage de pixels grossières, les pixels grossières sont ignorés.

Rastérisation indépendante de la cible (TIR)

TIR n’est pas pris en charge lorsque l’ombrage de pixels grossière est utilisé.

Affichages de l’ordre raster (ROV)

Les interblocages ROV sont spécifiés comme fonctionnant à une granularité fine des pixels. Si l’ombrage est effectué par échantillon, les interblocages fonctionnent à la granularité de l’échantillon.

Rastérisation conservatrice

Vous pouvez utiliser la rastérisation conservatrice avec l’ombrage à taux variable. Lorsque la rastérisation conservatrice est utilisée avec l’ombrage de pixels grossières, les pixels fins dans les pixels grossièrement ratérisés en étant entièrement couverts.

Couverture

Lorsque la rastérisation conservatrice est utilisée, la sémantique de couverture contient des masques complets pour les pixels fins couverts et 0 pour les pixels fins qui ne sont pas couverts.

Paquets

Vous pouvez appeler des API d’ombrage à débit variable sur un bundle.

Passes de rendu

Vous pouvez appeler des API d’ombrage à débit variable dans un transmettre.

Appel des API VRS

Cette section suivante décrit la façon dont l’ombrage à débit variable est accessible à votre application via Direct3D 12.

Interrogation de fonctionnalités

Pour rechercher la fonctionnalité d’ombrage à taux variable de l’adaptateur, appelez ID3D12Device ::CheckFeatureSupport avec D3D12_FEATURE ::D 3D12_FEATURE_D3D12_OPTIONS6et fournissez une structure D3D12_FEATURE_DATA_D3D12_OPTIONS6 pour la fonction à remplir pour vous. La structure D3D12_FEATURE_DATA_D3D12_OPTIONS6 contient plusieurs membres, notamment l’un du type énuméré D3D12_VARIABLE_SHADING_RATE_TIER (D3D12_FEATURE_DATA_D3D12_OPTIONS6 ::VariableShadingRateTier), et un qui indique si le traitement en arrière-plan est pris en charge (D3D12_FEATURE_DATA_D3D12_OPTIONS6 ::BackgroundProcessingSupported).

Pour rechercher la fonctionnalité de niveau 1, par exemple, vous pouvez effectuer cette opération.

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;

Taux d’ombrage

Les valeurs de l’énumération D3D12_SHADING_RATE sont organisées afin que les taux d’ombrage soient facilement décomposables en deux axes, où les valeurs de chaque axe sont représentées de manière compacte dans l’espace logarithmique conformément à l’énumération D3D12_AXIS_SHADING_RATE.

Vous pouvez créer une macro pour composer deux taux d’ombrage d’axe dans un taux d’ombrage comme celui-ci.

#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 plateforme fournit également ces macros, définies dans d3d12.h.

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

Ceux-ci peuvent être utilisés pour dissecter et comprendre SV_ShaderRate.

Définition du taux d’ombrage au niveau de la commande et des combiners

Le taux d’ombrage et, éventuellement, les combiners sont spécifiés via la méthode ID3D12GraphicsCommandList5 ::RSSetShadingRate. Vous transmettez une valeur D3D12_SHADING_RATE pour le taux d’ombrage de base et un tableau facultatif de valeurs de D3D12_SHADING_RATE_COMBINER.

Préparation de l’image d’espace écran

L’état de ressource en lecture seule désignant une image de taux d’ombrage utilisable est défini comme D3D12_RESOURCE_STATES ::D 3D12_RESOURCE_STATE_SHADING_RATE_SOURCE.

Définition de l’image d’espace d’écran

Vous spécifiez l’image d’espace d’écran via la méthode ID3D12GraphicsCommandList5 ::RSSetShadingRateImage.

m_commandList->RSSetShadingRateImage(screenSpaceImage);

Interrogation de la taille de la vignette

Vous pouvez interroger la taille de la vignette à partir du membre D3D12_FEATURE_DATA_D3D12_OPTIONS6 ::ShadingRateImageTileSize membre. Consultez fonctionnalité d’interrogation ci-dessus.

Une dimension est récupérée, car les dimensions horizontales et verticales sont toujours identiques. Si la fonctionnalité du système est D3D12_SHADING_RATE_TIER_NOT_SUPPORTED, la taille de la vignette retournée est 0.