Étapes de pavage

Le runtime Direct3D 11 prend en charge trois nouvelles étapes qui implémentent la mise en place d’un pavage, qui convertit les surfaces de subdivision à faible détail en primitives plus détaillées sur le GPU. Les mosaïques de pavage (ou décomposent) les surfaces d’ordre élevé en structures appropriées pour le rendu.

En implémentant la mise en forme dans le matériel, un pipeline graphique peut évaluer les modèles de détails inférieurs (nombre de polygones inférieur) et le rendu en détail. Bien que la mise en place des logiciels puisse être effectuée, la mise en œuvre par le matériel peut générer une quantité incroyable de détails visuels (y compris la prise en charge du mappage des déplacements) sans ajouter les détails visuels aux tailles de modèle et paralyser les taux d’actualisation.

• Avantages de la pavage
• Nouvelles étapes de pipeline
  • Étape hull-shader
  • Étape Tessellator
  • Étape du nuanceur de domaine
• API pour initialiser les étapes de tssellation
• Guide pratique pour :
• Rubriques connexes

Avantages de la pavage

Pavage :

• Économise beaucoup de mémoire et de bande passante, ce qui permet à une application de restituer des surfaces détaillées plus élevées à partir de modèles basse résolution. La technique de pavage implémentée dans le pipeline Direct3D 11 prend également en charge le mappage de déplacement, qui peut produire des quantités étonnantes de détails de surface.
• Prend en charge les techniques de rendu évolutif, telles que les niveaux de détail continus ou dépendants de la vue, qui peuvent être calculés à la volée.
• Améliore les performances en effectuant des calculs coûteux à des fréquences plus faibles (en effectuant des calculs sur un modèle de moindre détail). Cela peut inclure la fusion de calculs à l’aide de formes de fusion ou de cibles de morphes pour des calculs réalistes d’animation ou de physique pour la détection de collision ou la dynamique du corps mou.

Le pipeline Direct3D 11 implémente la liaison dans le matériel, ce qui décharge le travail de l’UC vers le GPU. Cela peut entraîner des améliorations très importantes des performances si une application implémente un grand nombre de cibles de transformation et/ou des modèles d’apparence/déformation plus sophistiqués. Pour accéder aux nouvelles fonctionnalités de pavage, vous devez en savoir plus sur les nouvelles étapes de pipeline.

Nouvelles étapes de pipeline

La mise en forme utilise le GPU pour calculer une surface plus détaillée à partir d’une surface construite à partir de quatre correctifs, de correctifs de triangle ou d’isolines. Pour se rapprocher de la surface ordonnée, chaque patch est subdivisé en triangles, points ou lignes à l’aide de facteurs de tssellation. Le pipeline Direct3D 11 implémente l’entassement à l’aide de trois nouvelles étapes de pipeline :

• Étape hull-shader : étape de nuanceur programmable qui produit un patch géométrique (et des constantes de patch) qui correspondent à chaque correctif d’entrée (quad, triangle ou trait).
• Étape Tessellator : étape de pipeline de fonction fixe qui crée un modèle d’échantillonnage du domaine qui représente le correctif géométrique et génère un ensemble d’objets plus petits (triangles, points ou lignes) qui relient ces exemples.
• Étape de nuanceur de domaine : étape de nuanceur programmable qui calcule la position de vertex qui correspond à chaque exemple de domaine.

Le diagramme suivant met en évidence les nouvelles étapes du pipeline Direct3D 11.

Le diagramme suivant montre la progression à travers les phases de pavage. La progression commence par la surface de subdivision à faible détail. La progression suivante met en évidence le correctif d’entrée avec le correctif de géométrie, les exemples de domaine et les triangles correspondants qui relient ces exemples. La progression met enfin en évidence les sommets qui correspondent à ces exemples.

Hull-Shader Étape

Un nuanceur de coque, appelé une fois par correctif, transforme les points de contrôle d’entrée qui définissent une surface de faible ordre en points de contrôle qui constituent un correctif. Il effectue également certains calculs par correctif pour fournir des données pour la phase de pavage et la phase de domaine. Au niveau de la boîte noire la plus simple, l’étape hull-shader ressemblerait au diagramme suivant.

Un nuanceur de coque est implémenté avec une fonction HLSL et possède les propriétés suivantes :

• L’entrée du nuanceur est comprise entre 1 et 32 points de contrôle.
• La sortie du nuanceur est comprise entre 1 et 32 points de contrôle, quel que soit le nombre de facteurs de pavage. La sortie des points de contrôle d’un nuanceur de coque peut être consommée par la phase de nuanceur de domaine. Les données de constante corrective peuvent être consommées par un nuanceur de domaine ; Les facteurs de tssellation peuvent être consommés par le nuanceur de domaine et la phase de pavage.
• Les facteurs de tssellation déterminent la quantité à subdiviser chaque patch.
• Le nuanceur déclare l’état requis par la phase tessellator. Cela inclut des informations telles que le nombre de points de contrôle, le type de face de correctif et le type de partitionnement à utiliser lors de la tessellating. Ces informations apparaissent généralement sous forme de déclarations à l’avant du code du nuanceur.
• Si l’étape de nuanceur de coque définit un facteur de pavage de bord sur = 0 ou NaN, le patch est supprimé. Par conséquent, la phase tessellator peut ou non s’exécuter, le nuanceur de domaine ne s’exécutera pas et aucune sortie visible ne sera produite pour ce correctif.

À un niveau plus profond, un nuanceur de coque fonctionne en fait en deux phases : une phase de point de contrôle et une phase de constante corrective, qui sont exécutées en parallèle par le matériel. Le compilateur HLSL extrait le parallélisme dans un nuanceur de coque et l’encode dans un bytecode qui pilote le matériel.

• La phase de point de contrôle fonctionne une fois pour chaque point de contrôle, en lisant les points de contrôle d’un correctif et en générant un point de contrôle de sortie (identifié par un ControlPointID).
• La phase de constante de correctif fonctionne une fois par correctif pour générer des facteurs de pavage de bord et d’autres constantes par patch. En interne, de nombreuses phases de constante de correctif peuvent s’exécuter en même temps. La phase de constante corrective dispose d’un accès en lecture seule à tous les points de contrôle d’entrée et de sortie.

Voici un exemple de nuanceur de coque :

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

     return result;
}

Pour obtenir un exemple qui crée un nuanceur de coque, consultez Guide pratique pour créer un nuanceur de coque.

Étape Tessellator

Le tessellator est une étape à fonction fixe initialisée en liant un nuanceur de coque au pipeline (voir How To: Initialize the Tessellator Stage). L’objectif de la phase tessellateur est de subdiviser un domaine (quad, tri ou trait) en de nombreux objets plus petits (triangles, points ou lignes). Le tessellateur mosaïque un domaine canonique dans un système de coordonnées normalisé (zéro à un). Par exemple, un domaine quad est tessellé à un carré d’unité.

Le tessellateur fonctionne une fois par correctif à l’aide des facteurs de tssellation (qui spécifient la façon dont le domaine sera composé) et du type de partitionnement (qui spécifie l’algorithme utilisé pour découper un correctif) qui sont passés à partir de l’étape hull-shader. Le tessellateur génère les coordonnées uv (et éventuellement w) et la topologie de surface à l’étape de nuanceur de domaine.

En interne, le tessellateur fonctionne en deux phases :

• La première phase traite les facteurs de pavage, en corrigeant les problèmes d’arrondi, en gérant de très petits facteurs, en réduisant et en combinant des facteurs, en utilisant l’arithmétique à virgule flottante 32 bits.
• La deuxième phase génère des listes de points ou de topologie en fonction du type de partitionnement sélectionné. Il s’agit de la tâche principale de la phase tessellator et utilise des fractions 16 bits avec une arithmétique à point fixe. L’arithmétique à point fixe permet l’accélération matérielle tout en conservant une précision acceptable. Par exemple, avec un patch de 64 mètres de large, cette précision peut placer des points à une résolution de 2 mm.

Domain-Shader Étape

Un nuanceur de domaine calcule la position de vertex d’un point subdivisé dans le correctif de sortie. Un nuanceur de domaine est exécuté une fois par point de sortie de l’étape tessellator et dispose d’un accès en lecture seule aux coordonnées UV de sortie de l’étape du tessellateur, au patch de sortie du nuanceur de coque et aux constantes de patch de sortie du nuanceur de coque, comme le montre le diagramme suivant.

Les propriétés du nuanceur de domaine sont les suivantes :

• Un nuanceur de domaine est appelé une fois par coordonnée de sortie à partir de la phase tessellator.
• Un nuanceur de domaine consomme des points de contrôle de sortie à partir de la phase hull-shader.
• Un nuanceur de domaine génère la position d’un vertex.
• Les entrées sont les sorties du nuanceur de coque, y compris les points de contrôle, les données constantes correctives et les facteurs de pavage. Les facteurs de pavage peuvent inclure les valeurs utilisées par le tessellateur de fonction fixe, ainsi que les valeurs brutes (avant l’arrondi par la mise en forme d’entiers, par exemple), ce qui facilite la géomorphisation, par exemple.

Une fois le nuanceur de domaine terminé, la mise en forme est terminée et les données de pipeline passent à l’étape suivante du pipeline (nuanceur de géométrie, nuanceur de pixels, etc.). Un nuanceur de géométrie qui attend des primitives avec adjacence (par exemple, 6 sommets par triangle) n’est pas valide lorsque la mise en forme est active (il en résulte un comportement non défini, dont la couche de débogage se plaindra).

Voici un exemple de nuanceur de domaine :

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

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

API pour initialiser les étapes de tssellation

La mise en service est implémentée avec deux nouvelles phases de nuanceur programmables : un nuanceur de coque et un nuanceur de domaine. Ces nouvelles étapes de nuanceur sont programmées avec du code HLSL défini dans le modèle de nuanceur 5. Les nouvelles cibles du nuanceur sont les suivantes : hs_5_0 et ds_5_0. Comme toutes les étapes de nuanceur programmables, le code du matériel est extrait des nuanceurs compilés passés dans le runtime lorsque les nuanceurs sont liés au pipeline à l’aide d’API telles que DSSetShader et HSSetShader. Mais tout d’abord, le nuanceur doit être créé à l’aide d’API telles que CreateHullShader et CreateDomainShader.

Activez la mise en forme en créant un nuanceur de coque et en le liant à l’étape hull-shader (cela configure automatiquement l’étape tessellateur). Pour générer les positions de vertex finales à partir des correctifs tessellés, vous devez également créer un nuanceur de domaine et le lier à la phase de nuanceur de domaine. Une fois la liaison activée, l’entrée de données à la phase d’assembleur d’entrée doit être des données correctives. Autrement dit, la topologie de l’assembleur d’entrée doit être une topologie de constante de correctif de D3D11_PRIMITIVE_TOPOLOGY définie avec IASetPrimitiveTopology.

Pour désactiver la mise en forme, définissez le nuanceur de coque et le nuanceur de domaine sur NULL. Ni l’étape geometry-shader ni l’étape de sortie de flux ne peuvent lire les points de contrôle de sortie hull-shader ou corriger les données.

• Nouvelles topologies pour la phase d’assembleur d’entrée, qui sont des extensions de cette énumération.

  enum D3D11_PRIMITIVE_TOPOLOGY
  

  La topologie est définie sur la phase d’assembleur d’entrée à l’aide d’IASetPrimitiveTopology

• Bien sûr, les nouvelles étapes de nuanceur programmables nécessitent la définition d’un autre état, afin de lier des mémoires tampons, des exemples et des ressources de nuanceur constants aux étapes de pipeline appropriées. Ces nouvelles méthodes ID3D11Device sont implémentées pour définir cet état.

  • DSGetConstantBuffers
  • DSGetSamplers
  • DSGetShader
  • DSGetShaderResources
  • DSSetConstantBuffers
  • DSSetSamplers
  • DSSetShader
  • DSSetShaderResources
  • HSGetConstantBuffers
  • HSGetShaderResources
  • HSGetSamplers
  • HSGetShader
  • HSSetConstantBuffers
  • HSSetSamplers
  • HSSetShader
  • HSSetShaderResources

Guide pratique pour :

La documentation contient également des exemples d’initialisation des phases de pavage.

Rubriques connexes

Pipeline graphique