Ombrage à taux variable (VRS)
La motivation pour VRS
En raison de contraintes de performances, un convertisseur graphique ne peut pas toujours se permettre d’offrir le même niveau de qualité à chaque partie de son image de sortie. L’ombrage à débit variable, ou ombrage de pixels grossières, est un mécanisme qui vous permet d’allouer les performances/la puissance de rendu à des taux qui varient d’une image rendue à l’autre.
Dans certains cas, le taux d’ombrage peut être réduit avec peu ou pas de réduction de la qualité de la production perceptible; conduisant à une amélioration des performances essentiellement gratuite.
Sans VRS : anti-aliasing multi-exemples avec surséchantillonnage
Sans ombrage à débit variable, le seul moyen de contrôler le taux d’ombrage est d’utiliser l’anti-aliasing multi-échantillons (MSAA) avec une exécution basée sur l’exemple (également appelée super-échantillonnage).
MSAA est un mécanisme permettant de réduire l’aliasing 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 de 1x, 2x, 4x, 8x ou 16x, régit le nombre d’exemples alloués par pixel cible de rendu. Le nombre d’exemples MSAA doit être connu à l’avance lorsque la cible est allouée, et il ne peut pas être modifié par la suite.
Le suréchantillonnage entraîne l’appel du nuanceur de pixels une seule fois par échantillon, à une qualité supérieure, 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 le suréchantillonnage MSAA avec. Ces deux options ne fournissent pas un contrôle très fin. En outre, vous pouvez souhaiter 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é de la trame de fond et les coûts sont fixes sur l’ensemble de l’image.
Avec ombrage à taux variable (VRS)
Le modèle d’ombrage à taux variable (VRS) étend le suréchantillonnage avec MSAA dans la direction opposée, « pixel grossière », en ajoutant le concept de trame 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é en tant qu’unité unique, et le résultat est ensuite diffusé sur tous les exemples du groupe.
Une API de trame grossière permet à votre application de spécifier le nombre de pixels qui appartiennent à un groupe ombré ou à un pixel grosseur. Vous pouvez modifier la taille de pixels grossière une fois que vous avez 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 quelle taille de pixel grossière, 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 en demi-teintes, cette combinaison n’est pas prise en charge et implique le suivi de plus de 16 échantillons par appel de nuanceur de pixels. Pour le suivi de plus de 16 exemples, il existe des barrières d’alignement matérielles supplémentaires à prendre en charge, par rapport aux autres cas.
Niveaux de fonctionnalités
Il existe deux niveaux pour l’implémentation de VRS et deux fonctionnalités que vous pouvez rechercher. Chaque niveau est décrit plus en détail après la table.
Niveau 1
- Le taux d’ombrage ne peut être spécifié que par tirage; pas plus granulaire que ça.
- 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 de trame de fond peut être spécifié 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 sommet provoquant, et
- une image d’espace d’écran.
- Les taux d’ombrage des trois sources sont combinés à l’aide d’un ensemble de combinateurs.
- La taille des vignettes d’image d’espace d’écran est de 16 x 16 ou moins.
- Le taux de trame de fond demandé par votre application est garanti pour être fourni exactement (pour la précision des filtres temporels et d’autres filtres de reconstruction).
- SV_ShadingRate entrée PS est prise en charge.
- Le taux d’ombrage par vertex provocateur (également appelé par primitive) est valide lorsqu’une seule fenêtre d’affichage est utilisée et
SV_ViewportArrayIndexn’est pas écrite dans. - Le taux de vertex par provocation peut être utilisé avec plusieurs fenêtres d’affichage si la fonctionnalité SupportsPerVertexShadingRateWithMultipleViewports est définie sur
true. En outre, dans ce cas, ce taux peut être utilisé quandSV_ViewportArrayIndexest écrit dans.
Liste de fonctionnalités
- AdditionalShadingRatesSupported
- Type booléen.
- Indique si les tailles de pixels grossières 2x4, 4x2 et 4x4 sont prises en charge pour le rendu à échantillon unique ; et si la taille de pixels grossière 2x4 est prise en charge pour 2x MSAA.
- SupportsPerVertexShadingRateWithMultipleViewports
- Type booléen.
- Indique si plusieurs fenêtres d’affichage peuvent être utilisées avec le taux d’ombrage par sommet (également appelé par primitive).
Spécification du taux de trame de fond
Pour plus de flexibilité dans les applications, divers mécanismes sont fournis pour contrôler le taux d’ombrage. Différents mécanismes sont disponibles en fonction du niveau de fonctionnalité matériel.
Liste de commandes
Il s’agit du mécanisme le plus simple pour définir le taux d’ombrage. Il est disponible à tous les niveaux.
Votre application peut spécifier une taille de pixels grossière à l’aide de la méthode ID3D12GraphicsCommandList5::RSSetShadingRate. Cette API prend un argument d’énumération unique. L’API fournit un contrôle global du niveau de qualité pour le rendu, c’est-à-dire la possibilité de définir le taux d’ombrage par tirage.
Les valeurs de cet état sont exprimées via 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 à tous les niveaux.
Une fonctionnalité, AdditionalShadingRatesSupported, permet d’indiquer si 2x4, 4x2 et 4x4 sont pris en charge sur l’appareil.
Image d’espace d’écran (basée sur une image)
Au niveau 2 et supérieur, vous pouvez spécifier le taux d’ombrage de pixels avec une image d’espace d’écran.
L’image d’espace d’écran permet à votre application de créer une image de « masque de niveau de détail (LOD) » indiquant des régions de qualité variable, telles que les zones qui seront 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 est dans macroblocks ; il ne se trouve 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 8x8 ou 16x16 pixels, comme indiqué par la taille de la vignette VRS.
Taille de la vignette
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 à débit variable de niveau 2, la requête de capacité pour la taille de vignette retourne 0.
Si le matériel prend en charge l’ombrage à débit variable de niveau 2, la taille des vignettes est l’une de ces valeurs.
- 8
- 16
- 32
Taille de l’image d’espace d’é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) }
Le coin supérieur gauche de l’image d’espace d’écran (0, 0) est verrouillé 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 d’espace de fenêtre de (x, y) par la taille de vignette, en ignorant les bits fractionnaires.
Si l’image d’espace d’écran est plus grande que nécessaire pour une cible de rendu donnée, les parties supplémentaires situées à droite et/ou en bas ne sont pas utilisées.
Si l’espace d’écran de l’image est trop petit 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. En effet, la partie supérieure gauche de l’image d’espace d’écran (0, 0) est verrouillée dans le coin supérieur gauche de la cible de rendu (0, 0) et que « lire au-delà des étendues de la cible de rendu » signifie lire des valeurs trop grandes pour x et y.
Format, disposition, propriétés de ressource
Le format de cette surface est une surface 8 bits monocanal (DXGI_FORMAT_R8_UINT).
La ressource est de dimension TEXTURE2D.
Il ne peut pas être matriculé ou mipped. 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 INCONNUE. Il ne peut pas implicitement s’agir d’une disposition de ligne principale, car l’inter-adaptateur n’est pas autorisé.
La façon attendue dans laquelle les données d’image d’espace d’écran sont remplies est de
- É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
- 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.
- Aucune
- 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 transitionné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 sort 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 des commandes.
Une ressource qui a été définie en tant que source de taux d’ombrage ne peut pas être lue ou écrite à partir d’une étape de nuanceur.
Une null image d’espace d’écran peut être définie pour spécifier le taux de nuanceur. Cela a pour effet que 1x1 est systématiquement utilisé comme contribution de l’image d’espace d’écran. L’image d’espace d’écran peut initialement être considérée comme définie sur null.
Promotion et désintégration
Une ressource d’image d’espace d’écran n’a pas d’implications particulières en ce qui concerne la promotion ou la désintégration.
Attribut par primitive
Un attribut par primitive ajoute la possibilité de spécifier un terme de taux d’ombrage en tant qu’attribut à partir d’un vertex provoquant. Cet attribut est à nuance plate, c’est-à-dire qu’il est propagé à tous les pixels du triangle ou de la primitive de ligne 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 débit d’ombrage.
L’attribut par primitive est une sémantique settable nommée SV_ShadingRate. SV_ShadingRate existe dans le cadre du modèle HLSL Shader 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 pour SV_ShadingRate n’est spécifiée par primitive, une valeur de taux d’ombrage de 1x1 est supposée comme 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 combinateur.
* 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é par ce biais.
- Si aucun nuanceur de géométrie n’est utilisé, le taux d’ombrage est spécifié par le vertex provoquant.
Liste des combinateurs
Les combinateurs suivants sont pris en charge. Utilisation d’un combinateur (C) et de deux entrées (A et B).
- Passthrough. C.xy = A.xy.
- Remplacez. C.xy = B.xy.
- Qualité supérieure. C.xy = min(A.xy, B.xy).
- Qualité inférieure. C.xy = max(A.xy, B.xy).
- Appliquez le coût B par rapport à A. 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 (c’est-à-dire la valeur 1), si AdditionalShadingRatesSupported est
false. - D3D12_AXIS_SHADING_RATE_4X (c’est-à-dire la valeur 2), si AdditionalShadingRatesSupported est
true.
Le choix du combinateur pour l’ombrage à débit variable est défini sur la liste de commandes via ID3D12GraphicsCommandList5::RSSetShadingRate.
Si aucun combinateur n’est jamais défini, ils restent à la valeur par défaut, qui est PASSTHROUGH.
Si la source d’un combinateur est une D3D12_AXIS_SHADING_RATE, ce qui n’est pas autorisé dans la table de prise en charge, l’entrée est aseptisée à un taux d’ombrage pris en charge.
Si la sortie d’un combinateur ne correspond pas à un taux d’ombrage pris en charge sur la plateforme, le résultat est aseptisé à un taux d’ombrage pris en charge.
État par défaut et effacement de l’état
Toutes les sources de taux d’ombrage, à savoir
- le taux spécifié par l’état du pipeline (spécifié dans la liste de commandes),
- le taux spécifié par l’image d’espace d’écran, et
- attribut per-primitive
ont une valeur par défaut de D3D12_SHADING_RATE_1X1. Les combinateurs 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 à partir de cette source.
Si aucun attribut par primitive n’est spécifié, un taux de trame de fond de 1x1 est déduit à partir 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 à la valeur par défaut « aucune image d’espace d’écran ».
Interrogation du taux de trame de fond à l’aide de SV_ShadingRate
Il est utile de savoir quel taux d’ombrage a été sélectionné par le matériel lors d’un appel de nuanceur de pixels donné. Cela peut permettre diverses 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 la valeur 1x1 est lue en retour, ce qui indique les pixels fins.
Comportement sous l’exécution basée sur l’exemple
Un nuanceur de pixels échoue à la compilation s’il entre SV_ShadingRate et utilise également l’exécution basée sur un exemple, par exemple, en entrant SV_SampleIndexou en utilisant l’exemple d’interpolation mot clé.
Remarques sur l’ombrage différé
Les passes d’éclairage d’une application de trame de fond différée peuvent avoir besoin de savoir quelle vitesse d’ombrage a été utilisée pour quelle zone de l’écran. C’est pour que les distributions de passe d’éclairage puissent démarrer à un rythme plus grosseur. La
SV_ShadingRatevariable peut être utilisée pour ce faire si elle est écrite dans le gbuffer.
Profondeur et gabarit
Lorsque l’ombrage de pixels grossis est utilisé, la profondeur, 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 attendu que si un taux d’ombrage est demandé et qu’il est pris en charge sur la combinaison au niveau de l’appareil et du niveau MSAA, il s’agit du taux d’ombrage fourni par le matériel.
Un taux de trame de fond demandé désigne un taux de trame de fond calculé en tant que sortie des combinateurs (voir la section Combinaison des facteurs de taux de trame de fond de fond dans cette rubrique).
Un taux d’ombrage pris en charge est de 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, les taux d’ombrage 2x4, 4x2 et 4x4 sont également pris en charge pour certains nombres d’échantillons (voir le tableau de la section Avec un ombrage à taux variable (VRS) de cette rubrique).
Dérivés de l’espace d’écran
Les calculs des dégradés de pixels à pixels adjacents sont affectés par l’ombrage grossière des pixels. Par exemple, lorsque 2 x 2 pixels grossières sont utilisés, un dégradé est deux fois plus grand 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 de la fonctionnalité que vous souhaitez.
Étant donné que les mips sont choisis en fonction d’un dérivé de l’espace d’écran, l’utilisation d’une trame de pixels grossière 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és que lorsque 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 la trame de fond à 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 le centre, le centroïde et l’exemple.
Center
L’emplacement d’interpolation centrale d’un pixel grosseur est le centre géométrique de la zone de pixels grossière complète. 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 a toujours des écritures dans le nombre total d’exemples alloués pour le niveau MSAA de la cible. Par conséquent, l’emplacement d’interpolation centroïde prend en compte tous les exemples pour les pixels fins à l’intérieur de pixels grossières. Cela étant dit, l’emplacement d’interpolation centroïde est défini comme le premier échantillon couvert, dans l’ordre croissant de l’exemple d’index. La couverture effective de l’exemple est AND-ed avec le bit correspondant de l’état de rastériseur SampleMask.
Notes
Lorsque l’ombrage de pixels grossière est utilisé sur le niveau 1, SampleMask est toujours un masque complet. Si SampleMask est configuré pour ne pas être un masque complet, la trame de pixels grossière est désactivée au niveau 1.
Exécution basée sur des exemples
L’exécution basée sur un exemple, ou le suréchantillonnage, qui est dû à l’utilisation de la fonctionnalité d’interpolation de l’exemple, peut être utilisé avec un 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 pull ne sont pas compatibles avec l’ombrage de pixels grossières sur le niveau 1. S’il y a une tentative d’utilisation des intrinsèques de modèle de tirage avec ombrage de pixels grossières au niveau 1, l’ombrage de pixels grossières est automatiquement désactivé.
L’intrinsèque EvaluateAttributeSnapped est autorisée à être utilisée avec un ombrage de pixels grossière sur le niveau 2. Sa syntaxe est la même qu’elle a toujours été.
numeric EvaluateAttributeSnapped(
in attrib numeric value,
in int2 offset);
Pour le contexte, EvaluateAttributeSnapped a un paramètre offset avec deux champs. En cas d’utilisation sans ombrage de pixels grossières, seuls les quatre bits d’ordre inférieur sur les trente-deux complets sont utilisés. Ces quatre bits représentent la plage [-8, 7]. Cette plage s’étend sur une grille de 16 x 16 pixels. La plage est telle que les bords supérieur et gauche du pixel sont inclus, et les bords inférieur et droit ne le sont pas. Le décalage (-8, -8) se trouve dans le coin supérieur gauche et le décalage (7, 7) se trouve dans le coin inférieur droit. Le décalage (0, 0) est le centre du pixel.
Lorsqu’il est utilisé avec l’ombrage de pixels grossières, EvaluateAttributeSnappedle paramètre offset de est capable de spécifier une plage plus large d’emplacements. Le paramètre offset sélectionne une grille de 16 x 16 pour chaque pixel fin, et il existe plusieurs pixels fins. La plage expressible et le nombre conséquent de bits utilisés dépendent de la taille de pixels grossière. Les bords supérieur et gauche du pixel grosseur sont inclus, et les bords inférieur et droit ne le sont pas.
Le tableau ci-dessous décrit l’interprétation du EvaluateAttributeSnappedparamètre de décalage de chaque taille de pixel grossière.
Plage de décalages d’EvaluateAttributeSnapped
| Taille grossière des pixels | Plage indexable | Taille de plage représentable | Nombre de bits nécessaires {x, y} | Masque binaire des bits utilisables |
|---|---|---|---|---|
| 1x1 (fin) | {[-8, 7], [-8, 7]} | {16, 16} | {4, 4} | {0000000000xxxxxx, 00000000000xxxx} |
| 1x2 | {[-8, 7], [-16, 15]} | {16, 32} | {4, 5} | {00000000000xxxxxx, 0000000000xxxxx} |
| 2x1 | {[-16, 15], [-8, 7]} | {32, 16} | {5, 4} | {0000000000xxxxx, 00000000000xxxx} |
| 2x2 | {[-16, 15], [-16, 15]} | {32, 32} | {5, 5} | {0000000000xxxxx, 00000000000xxxxx} |
| 2x4 | {[-16, 15], [-32, 31]} | {32, 64} | {5, 6} | {00000000000xxxxx, 00000000xxxxxx} |
| 4x2 | {[-32, 31], [-16, 15]} | {64, 32} | {6, 5} | {0000000000xxxxxx, 0000000000xxxxx} |
| 4x4 | {[-32, 31], [-32, 31]} | {64, 64} | {6, 6} | {000000000xxxxxxxx, 00000000xxxxxx} |
Les tableaux ci-dessous sont un guide pour la conversion vers de la représentation de point fixe en représentation décimale et fractionnaire. 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 numérique pour les valeurs quatre bits passées à EvaluateAttributeSnapped n’est pas spécifique à l’ombrage à taux variable. Il est réitéré ici pour l’exhaustivité.
Pour les valeurs quatre bits.
| Valeur binaire | Decimal | Fraction |
|---|---|---|
| 1 000 | -0,5f | -8 / 16 |
| 1001 | -0,4375f | -7 / 16 |
| 1010 | -0,375f | -6 / 16 |
| 1010 | -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 cinq bits.
| Valeur binaire | Decimal | Fraction |
|---|---|---|
| 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 six bits.
| Valeur binaire | Decimal | Fraction |
|---|---|---|
| 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, EvaluateAttributeSnappedla grille des 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 un ombrage grossière, l’API définit les exemples de positions pour les pixels fins.
SV_Coverage
Si SV_Coverage est déclaré en tant qu’entrée ou sortie de nuanceur sur le niveau 1, la trame de pixel grossière est désactivée.
Vous pouvez utiliser la sémantique avec l’ombrage SV_Coverage de pixels grossière au 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 constituer une vignette, le masque de couverture représente tous les exemples qui proviennent de cette vignette.
Étant donné la compatibilité de la trame de pixels grossière avec MSAA, le nombre de bits de couverture à spécifier peut varier. Par exemple, avec une ressource MSAA 4x utilisant D3D12_SHADING_RATE_2x2, chaque pixel grossière écrit dans quatre pixels fins, et chaque pixel fin a quatre exemples. Cela signifie que chaque pixel grossière écrit dans un total de 4 * 4 = 16 exemples.
Nombre de bits de couverture nécessaires
Le tableau suivant indique le nombre de bits de couverture nécessaires pour chaque combinaison de taille 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 section Avec l’ombrage à débit variable (VRS) de cette rubrique).
Classement et format des bits dans le masque de couverture
Les bits du masque de couverture respectent un ordre bien défini. Le masque se compose de couvertures de pixels de gauche à droite, puis de haut en bas (colonne majeure). Les bits de couverture sont les bits de faible ordre de la sémantique de couverture et sont densément regroupés.
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 2x pixels MSAA, où chaque pixel a 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 ; d’autant plus que les exemples de positions peuvent être modifiés par programmation. Les exemples sont référencés par leur index de base 0.
Le tableau suivant montre 4x pixels MSAA, où chaque pixel a quatre exemples d’index 0, 1, 2 et 3.
Abandonner
Lorsque la sémantique discard 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 d’ordre raster (ROV)
Les verrous ROV sont spécifiés comme fonctionnant à une granularité de pixels fine. Si l’ombrage est effectué par exemple, les verrous fonctionnent à la granularité de l’exemple.
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 au sein de pixels grossières sont rastérisés de manière conservatrice en offrant une couverture complète.
Couverture
Lorsque la rastérisation conservatrice est utilisée, la sémantique de couverture contient des masques complets pour les pixels fins qui sont couverts, et 0 pour les pixels fins qui ne sont pas couverts.
Packs
Vous pouvez appeler des API d’ombrage à taux variable sur une offre groupée.
Passes de rendu
Vous pouvez appeler des API d’ombrage à débit variable dans une passe de rendu.
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 des fonctionnalités
Pour rechercher la fonctionnalité d’ombrage à débit variable de l’adaptateur, appelez ID3D12Device::CheckFeatureSupport avec D3D12_FEATURE::D 3D12_FEATURE_D3D12_OPTIONS6 et fournissez une structure D3D12_FEATURE_DATA_D3D12_OPTIONS6 que la fonction doit remplir pour vous. La structure D3D12_FEATURE_DATA_D3D12_OPTIONS6 contient plusieurs membres, dont un de type énuméré D3D12_VARIABLE_SHADING_RATE_TIER (D3D12_FEATURE_DATA_D3D12_OPTIONS6::VariableShadingRateTier) et un autre qui indique si le traitement en arrière-plan est pris en charge (D3D12_FEATURE_DATA_D3D12_OPTIONS6::BackgroundProcessingSupported).
Pour interroger 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 de manière à ce 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 un espace logarithmique en fonction de l’énumération D3D12_AXIS_SHADING_RATE.
Vous pouvez créer une macro pour composer des taux d’ombrage de deux axes en un taux de trame de fond 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 )
Vous pouvez les utiliser pour disséquer et comprendre SV_ShaderRate.
Notes
Cette interprétation des données est axée sur la description de l’image d’espace d’écran, qui peut être manipulée par des nuanceurs. Cela est décrit plus en détail dans les sections ci-dessus. Mais il n’y a aucune raison de ne pas avoir une définition cohérente des tailles de pixels grossières à utiliser partout, y compris lors de la définition du taux d’ombrage au niveau de la commande.
Définition du taux d’ombrage au niveau des commandes et des combinateurs
Le taux d’ombrage et, éventuellement, les combinateurs sont spécifiés par le biais de la méthode ID3D12GraphicsCommandList5::RSSetShadingRate . Vous transmettez une valeur D3D12_SHADING_RATE pour le taux de trame de base et un tableau facultatif de valeurs D3D12_SHADING_RATE_COMBINER .
Préparation de l’image d’espace d’écran
L’état de ressource en lecture seule désignant une image de taux de trame de fond 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 vignette
Vous pouvez interroger la taille de la vignette à partir du membre D3D12_FEATURE_DATA_D3D12_OPTIONS6::ShadingRateImageTileSize . Consultez Interrogation de capacité ci-dessus.
Une dimension est récupérée, car les dimensions horizontale et verticale sont toujours les mêmes. Si la fonctionnalité du système est D3D12_SHADING_RATE_TIER_NOT_SUPPORTED, la taille de vignette retournée est 0.
Commentaires
Bientôt disponible : Tout au long de 2024, nous allons supprimer progressivement GitHub Issues comme mécanisme de commentaires pour le contenu et le remplacer par un nouveau système de commentaires. Pour plus d’informations, consultez https://aka.ms/ContentUserFeedback.
Envoyer et afficher des commentaires pour