Partager via

Utilisation de nuanceurs dans Direct3D 9

  • Article

Compilation d’un nuanceur pour un matériel spécifique

Les nuanceurs ont été ajoutés pour la première fois à Microsoft DirectX dans DirectX 8.0. À cette époque, plusieurs machines de nuanceur virtuelles ont été définies, chacune correspondant à peu près à un processeur graphique particulier produit par les principaux fournisseurs de graphiques 3D. Pour chacune de ces machines de nuanceur virtuel, un langage d’assembly a été conçu. Les programmes écrits sur les modèles de nuanceur (noms vs_1_1 et ps_1_1 - ps_1_4) étaient relativement courts et étaient généralement écrits par les développeurs directement dans le langage d’assembly approprié. L’application passerait ce code de langage d’assembly lisible par l’homme à la bibliothèque D3DX à l’aide de D3DXAssembleShader et récupérerait une représentation binaire du nuanceur qui serait à son tour passée à l’aide de CreateVertexShader ou CreatePixelShader. Pour plus d’informations, consultez le Kit de développement logiciel (SDK).

La situation dans Direct3D 9 est similaire. Une application transmet un nuanceur HLSL à D3DX à l’aide de D3DXCompileShader et obtient une représentation binaire du nuanceur compilé qui, à son tour, est passée à Microsoft Direct3D à l’aide de CreatePixelShader ou CreateVertexShader. Le runtime ne connaît rien au sujet de HLSL, uniquement les modèles de nuanceur d’assembly binaire. C’est bien, car cela signifie que le compilateur HLSL peut être mis à jour indépendamment du runtime Direct3D. Vous pouvez également compiler des nuanceurs hors connexion à l’aide de fxc.

En plus du développement du compilateur HLSL, Direct3D 9 a également introduit les modèles de nuanceur au niveau de l’assembly pour exposer les fonctionnalités de la dernière génération de matériel graphique. Les développeurs d’applications peuvent travailler en assembly pour ces nouveaux modèles (vs_2_0, vs_3_0, ps_2_0, ps_3_0), mais nous nous attendons à ce que la plupart des développeurs passent à HLSL pour le développement de nuanceurs.

Bien entendu, la possibilité d’écrire un programme HLSL pour exprimer un algorithme d’ombrage particulier ne lui permet pas automatiquement de s’exécuter sur un matériel donné. Une application appelle D3DX pour compiler un nuanceur en code d’assembly binaire avec D3DXCompileShader. L’une des limitations de ce point d’entrée est un paramètre qui définit les modèles de niveau assembly (ou cibles de compilation) que le compilateur HLSL doit utiliser pour exprimer le code de nuanceur final. Si une application effectue une compilation de nuanceur HLSL au moment de l’exécution (par opposition au moment de la compilation ou hors connexion), l’application peut examiner les fonctionnalités de l’appareil Direct3D et sélectionner la cible de compilation à mettre en correspondance. Si l’algorithme exprimé dans le nuanceur HLSL est trop complexe pour s’exécuter sur la cible de compilation sélectionnée, la compilation échoue. Cela signifie que bien que HLSL soit un avantage énorme pour le développement de nuanceurs, il ne libère pas les développeurs des réalités de l’expédition de jeux à un public cible avec des périphériques graphiques de différentes fonctionnalités. En tant que développeur de jeux, vous devez toujours gérer une approche hiérarchisé de vos visuels ; Cela signifie écrire de meilleurs nuanceurs pour des cartes graphiques plus compatibles et écrire des versions plus basiques pour les cartes plus anciennes. Avec HLSL bien écrit, toutefois, cette charge peut être considérablement allégé.

Au lieu de compiler des nuanceurs HLSL à l’aide de D3DX sur l’ordinateur du client au moment du chargement de l’application ou lors de la première utilisation, de nombreux développeurs choisissent de compiler leur nuanceur de HLSL en code d’assembly binaire avant même leur expédition. Cela permet de garder le code source HLSL à l’abri des regards indiscrets et de garantir que tous les nuanceurs que leur application exécutera ont subi leur processus d’assurance qualité interne. Fxc est un utilitaire pratique pour compiler des nuanceurs hors connexion. Cet outil dispose d’un certain nombre d’options que vous pouvez utiliser pour compiler du code pour la cible de compilation spécifiée. L’étude de la sortie désassemblé peut être très pédagogique pendant le développement si vous souhaitez optimiser vos nuanceurs ou simplement connaître les fonctionnalités de la machine de nuanceur virtuel à un niveau plus détaillé. Ces options sont résumées ci-dessous :

Initialisation des constantes du nuanceur

Les constantes du nuanceur sont contenues dans la table constante. Cela est accessible avec l’interface ID3DXConstantTable . Les variables du nuanceur global peuvent être initialisées dans le code du nuanceur. Celles-ci sont initialisées au moment de l’exécution en appelant SetDefaults.

Liaison d’un paramètre nuanceur à un registre particulier

Le compilateur attribue automatiquement des registres à des variables globales. Le compilateur affecterait Environment au registre de l’échantillonneur s0, SparkleNoise au registre de l’échantillonneur s1 et k_s au registre constant c0 (en supposant qu’aucun autre échantillonneur ou registre de constante n’a déjà été affecté) pour les trois variables globales suivantes :

sampler Environment;
sampler SparkleNoise;
float4 k_s;

Il est également possible de lier des variables à un registre spécifique. Pour forcer le compilateur à affecter à un registre particulier, utilisez la syntaxe suivante :

register(RegisterName)

où RegisterName est le nom du registre spécifique. Les exemples suivants illustrent la syntaxe d’affectation de registre spécifique, où l’environnement de l’échantillonneur est lié à sampler register s1, SparkleNoise est lié à sampler register s0 et k_s est lié à la constante register c12 :

sampler Environment : register(s1);
sampler SparkleNoise : register(s0);
float4 k_s : register(c12);

Rendu d’un nuanceur programmable

Un nuanceur est rendu en définissant le nuanceur actuel dans l’appareil, en initialisant les constantes du nuanceur, en indiquant à l’appareil d’où proviennent les différentes données d’entrée, puis en montrant les primitives. Chacune de ces opérations peut être effectuée en appelant les méthodes suivantes respectivement :

Débogage des nuanceurs

L’extension DirectX pour Microsoft Visual Studio .NET fournit un débogueur HLSL entièrement intégré dans l’environnement de développement intégré (IDE) Visual Studio .NET. Pour préparer le débogage du nuanceur, vous devez installer les outils appropriés sur votre ordinateur (consultez Débogage des nuanceurs dans Visual Studio (Direct3D 9)).

Guide de programmation pour HLSL