Exporter (0) Imprimer
Développer tout

Utilisation de l'infrastructure Effects

Dave Aronson et Kris Gray
Microsoft Corporation

Résumé : Dans cet article, Dave Aronson et Kris Gray traitent de l'infrastructure Effects dans D3DX, composant intégral de D3DX qui offre aux développeurs de nombreux avantages en regroupant les jeux d'effets visuels.

Présentation

Suite à la série d'articles concernant l'utilisation de Microsoft® Direct3DX (D3DX), nous allons ce mois-ci couvrir l'infrastructure Effects. Cette dernière vous permet de créer un jeu d'effets visuels qui peuvent être regroupés au sein d'une unité logique. Les fichiers Effects comportent l'extension .fx et sont communément appelés fichiers fx. La structure d'un fichier Effect suit la forme suivante :

Structure de l'infrastructure Effects

Figure 1. Structure de l'infrastructure Effects

L'infrastructure Effects permet aux vendeurs de logiciel indépendants (ISV) de regrouper des techniques graphiques similaires au sein d'un fichier unique afin de décrire la façon dont un matériel donné sera dessiné. Ces méthodes peuvent être choisies en fonction des critères du vendeur de logiciel indépendant, par exemple, en fonction des performances et des capacités matérielles. Ceci permet aux créateurs de contenu de créer un seul jeu de contenu qui fonctionnera sur de nombreuses configurations PC, tout en conservant un aspect et un comportement cohérents. Les techniques peuvent varier, des nuanceurs haut niveau aux nuanceurs bas niveau, en passant par le pipeline à fonction fixe.

Étant donné que ce système fonctionne séparément de la géométrie, il est possible de programmer un effet parallèlement au contenu, sans que le créateur ne se retrouve bloqué. Lors de l'utilisation d'un fichier d'effet avec de multiples techniques, celles-ci peuvent être validées pour garantir que le fichier d'effet fonctionnera sur la configuration matérielle en cours sur la machine de l'utilisateur. Vous pouvez même choisir un effet moindre en fonction des résultats de la validation. Vous pouvez choisir un effet moindre en fonction de votre propre métrique, par exemple la distance par rapport à l'origine, ou encore en fonction d'un test de performances.

Le traitement pixel et vertex peut être effectué par le pipeline à fonction fixe ou implémenté à l'aide de nuanceurs programmables. La tessallation des données d'entrée, le traitement primitif et les sorties de données sont contrôlés par l'état du pipeline. L'infrastructure Effects encapsule la totalité de cet état. Elle fixe l'état qui contrôle le mode de fonctionnement du pipeline. Elle peut appeler un traitement à fonction fixe ou un traitement par nuanceur programmable ou bien les deux.

Voici quelques fonctions de l'infrastructure Effects :

  • Effects contient des variables globales. Ces variables peuvent être définies par l'effet lui-même ou par l'application.
  • Effects gère l'état du pipeline. Ceci comprend les états concernant le paramétrage des transformations, de la lumière, des matériaux et des options de rendu.
  • Effects gère l'état de la texture et celui de l'échantillonneur. Ceci comprend la spécification des fichiers de texture, l'initialisation des étapes de texture, la création d'objets d'échantillonneur et le paramétrage de l'état de l'échantillonneur.
  • Effects gère l'état du nuanceur. Ceci comprend la création et la suppression des nuanceurs, le paramétrage des constantes de nuanceur, celui de l'état du nuanceur et le rendu avec les nuanceurs.
  • Effects contient de nombreuses options de rendu, appelées techniques. Chaque technique encapsule des variables globales, l'état du pipeline, l'état de la texture et de l'échantillonneur, ainsi que celui du nuanceur. Un seul style est implémenté dans une pass de rendu. Une ou plusieurs pass peuvent être encapsulées dans une technique. Toutes ces pass et techniques peuvent être validées pour voir si le code d'effet fonctionne sur le matériel.
  • Effects peut enregistrer et restaurer l'état, laissant l'équipement dans le même état qu'avant le lancement de l'effet.

Dans cet article, nous allons utiliser l'échantillon appelé EffectEdit inclus dans le SDK Microsoft® DirectX® 9.0. EffectEdit est un très bon moyen pour visualiser et éditer instantanément un effet sur un objet. Une fois lancé, EffectEdit affiche le fichier d'effet dans le volet gauche (le volet 1 dans la capture d'écran ci-dessous). Le résultat généré pour ce fichier d'effet apparaît dans le volet supérieur droit (2). Le volet inférieur droit contient les options de rendu pour le fichier d'effet. Parmi les options, vous avez la possibilité de sélectionner la technique et la pass à dessiner (3). Si vous faites des erreurs en écrivant ou en modifiant un effet, celles-ci seront répertoriées dans le volet inférieur gauche (4) ; double-cliquez sur une erreur et vous serez conduit sur la ligne incorrecte du fichier d'effet.

La source de cette démonstration est fournie avec le SDK, ainsi vous pourrez voir comment les effets peuvent être utilisés dans une application.

Édition de l'effet avec Hemisphere.fx

Figure 2. Édition de l'effet avec Hemisphere.fx

Pour notre exemple, nous allons nous pencher sur l'exemple de fichier d'effet dans le SDK appelé hemisphere.fx. Ce fichier d'effet utilise le langage Microsoft HLSL (High Level Shading Language) pour démontrer la méthode de lumière hémisphérique présentée pour la première fois à la GDC 2002. Si nous commençons par étudier EffectEdit tout en éditant Hemisphere.fx, les premiers éléments qui apparaissent sont les variables globales de l'effet tout en haut du fichier.

Variables globales de l'effet

L'effet comporte plusieurs variables globales : XFile, BCLR, DirFromLight, DirFromSky, I_a, I_b, I_c, I_d, I_s, k_a, k_d, k_s, n, WorldView, Projection et VS_OUTPUT.

string XFile = "SkullOcc.x"; // model
int BCLR = 0xff202080; // background

XFile et BCLR sont des variables propres à EffectEdit. La variable XFile indique le modèle sur lequel afficher l'effet. (Pour obtenir davantage d'informations sur les fichiers X, consultez l' article de maillage D3DX précédent ( Lien externe au site MSDN France Site en anglais) dans Driving DirectX.) La variable BCLR est la couleur d'arrière-plan que l'application EffectEdit affichera dans la fenêtre d'affichage.

// light directions (view space)
float3 DirFromLight < string UIDirectional = "Light Direction"; > =
 {0.577, -0.577, 0.577};

// direction of light from sky (view space)
float3 DirFromSky < string UIDirectional = "Direction from Sky"; > = 
{ 0.0f, -1.0f, 0.0f }; 

Les variables DirFromLight et DirFromSky relient les variables à la valeur de vecteur indiquée à droite du signe d'égalité. Ces variables sont annotées par une valeur de chaîne reliée à l'annotation UIDirectional. L'application peut lire cette annotation pour récupérer la chaîne à afficher à côté de la lumière dans la fenêtre d'affichage. Les annotations sont des informations ajoutées par l'utilisateur. Ceci est décrit plus en détail ultérieurement dans cet article.

// light intensity
float4 I_a = { 0.5f, 0.5f, 0.5f, 1.0f }; // ambient
float4 I_b = { 0.1f, 0.0f, 0.0f, 1.0f }; // ground
float4 I_c = { 0.9f, 0.9f, 1.0f, 1.0f }; // sky
float4 I_d = { 1.0f, 0.9f, 0.8f, 1.0f }; // diffuse
float4 I_s = { 1.0f, 1.0f, 1.0f, 1.0f }; // specular

// material reflectivity
float4 k_a = { 0.8f, 0.8f, 0.8f, 1.0f }; // ambient
float4 k_d = { 0.4f, 0.4f, 0.4f, 1.0f }; // diffuse
float4 k_s = { 0.1f, 0.1f, 0.1f, 1.0f }; // specular
int n = 32; // power

Les variables ci-dessus sont des vecteurs simples et un nombre entier définis sur une valeur par défaut.

// transformations
float4x3 WorldView : WORLDVIEW;
float4x4 Projection : PROJECTION;

Les variables globales ci-dessus sont des matrices en virgule flottante (l'une est 4x3, l'autre 4x4). Si nous étudions la variable WorldView, cette matrice devra être réinitialisée pour la transformation composite WorldView. La matrice sera utilisée par le nuanceur vertex pour transformer les données de position de l'espace modèle en espace de visualisation. Une sémantique, appelée WORLDVIEW, lui est associée. Celle-ci peut être utilisée pour activer l'interface Effects afin de rechercher un paramètre d'effet donné. Certaines sémantiques sont prédéfinies. Ces états Effects sont répertoriés dans la documentation SDK DirectX. L'interface Effects peut utiliser une sémantique pour gérer un paramètre d'effet donné. Par exemple,

D3DHANDLE handle = 
 m_pEffect->GetParameterBySemantic(NULL, "WORLDVIEW");

renvoie la gestion de la matrice WorldView. Outre la recherche par nom de sémantique, l'interface Effects est dotée de nombreuses autres méthodes API pour rechercher des paramètres.

Voici le code du nuanceur vertex :

struct VS_OUTPUT
{
 float4 Pos : POSITION;
 float4 Diff : COLOR0;
 float4 Spec : COLOR1;
};

VS_OUTPUT VS(
 float3 Pos : POSITION, 
 float3 Norm : NORMAL, 
 float Occ : TEXCOORD0,
 uniform bool bHemi, 
 uniform bool bDiff,
 uniform bool bSpec)
{
 VS_OUTPUT Out = (VS_OUTPUT)0;

 // diffuse direction 
 float3 L = -DirFromLight;
 // hemisphere up axis 
 float3 Y = -DirFromSky; 
 // position (view space) 
 float3 P = mul(float4(Pos, 1), (float4x3)WorldView); 
 // normal (view space)
 float3 N = normalize(mul(Norm, (float3x3)WorldView)); 
 // reflection vector (view space)
 float3 R = normalize(2 * dot(N, L) * N - L); 
 // view direction (view space)
 float3 V = -normalize(P); 

 float4 Amb = k_a * I_a;
 float4 Hemi = k_a * lerp(I_b, I_c, (dot(N, Y) + 1) / 2) * 
(1 - Occ);
 float temp = 1 - max(0, dot(N, L));
 float4 Diff = k_d * I_d * (1 - temp * temp);
 float4 Spec = k_s * I_s * pow(max(0, dot(R, V)), n/4);
 float4 Zero = 0;

 Out.Pos = mul(float4(P, 1), Projection); // position (projected)
 Out.Diff = (bDiff ? Diff : 0)
 + (bHemi ? Hemi : Amb); // diffuse + ambient/hemisphere
 Out.Spec = (bSpec ? Spec : 0); // specular

 return Out;
}

Le code du nuanceur est écrit en langage HLSL et la mission du nuanceur est activée à l'aide d'un appel de compilation de nuanceur en ligne. Ce nuanceur vertex présente une structure contenant des membres des entrées et des sorties du nuanceur vertex, ainsi qu'une fonction, VS, qui sera compilée dans un nuanceur vertex. Les nuanceurs HLSL sont déclarés comme des définitions de fonctions en langage C. Pour obtenir davantage d'informations sur le langage HLSL, consultez la documentation SDK DirectX 9.0 et le livre à paraître, The DirectX 9 Programmable Graphics Pipeline (en anglais).

Étant donné que la fonction du nuanceur est déclarée en dehors d'une pass, voici comment définir la mission du nuanceur :

technique THemisphere
{
 pass P0
 {
 vertexShader = compile vs_1_1 VS(true, false, false);
 }
}

Cette mission du nuanceur vertex HLSL crée un objet de nuanceur vertex en ligne et l'affecte à l'état VertexShader. La déclaration de compilation se trouve dans la pass. Elle contient la cible de nuanceur vs_1_1, qui appelle le nuanceur vertex version 1_1. Cette déclaration contient le nom de la fonction du nuanceur, VS, qui sera compilé. Lors de la création de l'effet, le compilateur compile le nuanceur HLSL lorsqu'il lit la déclaration avec le mot-clé de compilation, puis affecte l'objet de nuanceur vertex à l'état de l'effet VertexShader.

technique TAmbientDiffuseSpecular
{
 pass P0
 {
 vertexShader = compile vs_1_1 VS(false, true, true);
 SpecularEnable = TRUE;
 }
}

Une deuxième technique, TAmbientDiffuseSpecular, diffère en deux points de la précédente. Tout d'abord, cette technique transmet différentes valeurs à la fonction HLSL, VS. Ensuite, elle définit l'état du rendu, SpecularEnable. Pour obtenir la liste des états disponibles, consultez la documentation SDK DirectX 9.0.

Ajout d'annotations aux informations de paramètres

Les annotations fournissent un mécanisme permettant d'ajouter des informations utilisateur aux paramètres d'effet. Les déclarations d'annotations sont délimitées par des crochets en chevron, <>. Une annotation contient :

  • Un type de données
  • Un nom de variable
  • Un signe d'égalité
  • La valeur de données
  • Un point-virgule final

L'exemple ci-dessus contient l'annotation suivante :

float3 DirFromLight < string UIDirectional = "Light Direction"; > =
 {0.577, -0.577, 0.577};

L'annotation est associée à la variable globale DirFromLight et spécifie le nom d'affichage du vecteur de lumière dans la fenêtre d'affichage pour l'édition de l'effet. L'annotation est tout simplement une information utilisateur associée à la variable. Une application peut lire l'annotation à l'aide de ID3DXEffect::GetAnnotation ou de ID3DXEffect::GetAnnotationByName pour renvoyer la chaîne Light Direction (sens de la lumière). L'application peut également ajouter des annotations.

Caractéristiques de Effects

Effects permet de simplifier la gestion de l'état du pipeline. Une fois que vous avez compris le fonctionnement d'Effects, vous pouvez réduire la charge de travail des applications générée par la gestion des changements d'état requis pour différentes techniques de rendu. Cette section souligne les caractéristiques d'Effects qui facilitent la gestion de l'état du pipeline.

Enregistrement et restauration de l'état

Comme vous l'avez appris au début de cet article, Effects permet de gérer les états. Le terme « état » est ici utilisé dans son sens large. Il couvre tous les types d'informations (tous les états) dont le pipeline a besoin pour spécifier les conditions du rendu. Ceci inclut presque tous les domaines fonctionnels du pipeline.

L'interface Effects gère l'ensemble du rendu au sein des méthodes ID3DXEffect::Begin et ID3DXEffect::End. Elle englobe toutes les informations de paramétrage des états dans chaque pass et, une fois la méthode ID3DXEffect::Pass appelée, le runtime applique tous les paramétrages des états. La fin du rendu est signalée par l'appel de End. N'oubliez pas d'inclure tous les appels concernant les dessins avant d'appeler End ; sinon, l'état risque d'être réinitialisé avant que le dessin ne soit terminé. Appeler End ne signifie par que le rendu est terminé, mais que l'application a soumis les informations de rendu au runtime.

Une fonction intéressante d'Effects concerne ce qui se passe lorsque End est appelé. Effects conserve une trace de tous les changements d'état et renvoie le pipeline à son état d'origine. (Ce comportement peut être modifié grâce aux indicateurs fournis avec Begin.)

Ainsi, Effects enregistre (l'état existant) lorsque Begin est appelé, puis restaure (l'état enregistré) une fois End appelé. Lors de la programmation de séquences de rendu à pass multiples, chacune requérant sa propre définition d'état, Effects peut réduire la charge de travail requise pour effectuer le suivi des changements d'état.

Notez qu'Effects rend une technique donnée, qui contient une ou plusieurs pass. L'état est restauré chaque fois que le rendu est terminé, c'est-à-dire chaque fois qu'une technique est terminée. Effects ne restaure pas l'état entre les pass.

De nombreux états contrôlent le pipeline. Pour permettre d'identifier les sous-ensembles susceptibles d'être intéressants, les états Effects peuvent être divisés en domaines fonctionnels suivants :

  • États de lumière
  • États du matériel
  • États du rendu
    • États du rendu du pipeline vertex
    • États du rendu du pipeline pixel
  • États de l'échantillonneur
  • États des étapes de l'échantillonneur
  • États du nuanceur
  • États constants du nuanceur
    • États constants du nuanceur vertex
    • États constants du nuanceur pixel
  • États de la texture
  • États des étapes de texture
  • États de transformation

Chacun de ces états est décrit dans la documentation SDK DirectX 9.0.

L'enregistrement et la restauration de l'état peut réduire la charge de travail de l'application qui doit effectuer le suivi des changements d'état entre les techniques. La section suivante aborde la disposition des techniques et des pass.

Partage des paramètres

Les paramètres Effects couvrent toutes les variables non statiques déclarées dans un effet. Ils incluent les variables globales et les annotations. Les paramètres Effects peuvent être partagés par différents effets s'ils sont déclarés avec le mot-clé partagé, puis si l'effet est créé avec un pool d'effets.

Un pool d'effets est un objet qui relie les paramètres d'effet partagés. Le pool est créé en appelant D3DXCreateEffectPool, qui renvoie une interface ID3DXEffectPool. L'interface sert d'entrée pour toute fonction D3DXCreateEffectxxx lorsqu'un effet est créé. Pour qu'un paramètre soit partagé par de nombreux effets, il doit comporter le même nom, le même type et la même sémantique pour chacun des effets partagés (la sémantique sera bientôt abordée).

Les effets partageant des paramètres doivent utiliser le même équipement. Ceci permet d'empêcher le partage des paramètres dépendants de l'équipement (tels que les nuanceurs ou les textures) entre différents équipements. Les paramètres sont supprimés du pool chaque fois que les effets contenant les paramètres partagés sont libérés. Si le partage des paramètres n'est pas nécessaire, NULL doit être indiqué pour le pool d'effets lorsqu'un effet est créé.

Les effets clonés utilisent le même pool d'effets que l'effet à partir duquel ils sont clonés. Le clonage d'un effet permet d'en obtenir une copie exacte, y compris celle des variables globales, des techniques, des pass et des annotations.

Utilisation de descripteurs pour obtenir et définir des paramètres

Les descripteurs sont un moyen efficace de référencer les paramètres, les techniques, les pass et les annotations des effets, grâce à ID3DXEffectCompiler ou ID3DXEffect. Ils sont générés dynamiquement lorsque vous appelez des fonctions de la forme Get[Parameter|Annotation|Function|Technique|Pass][ByName|BySemantic|Element].

Les descripteurs (qui sont de type D3DXHANDLE) sont des pointeurs de chaînes. Ceux qui sont transmis à des fonctions telles que GetParameter[ByName|Element|BySemantic] ou GetAnnotation[ByName] peuvent prendre l'une des trois formes suivantes :

  • Un descripteur renvoyé par une fonction telle que GetParameter[ByName|Element|BySemantic].
  • Une chaîne contenant le nom du paramètre, de la technique, de la pass ou de l'annotation.
  • Un descripteur défini sur NULL. Pour obtenir davantage d'informations à ce sujet, consultez Appendix Y: Effect Reference (en anglais).

Cet exemple renvoie un descripteur au paramètre associé à la sémantique WORLDVIEW :

D3DHANDLE handle = 
 m_pEffect->GetParameterBySemantic(NULL, "WORLDVIEW");

Construction d'un effet

Maintenant que vous êtes plus familier avec le contenu d'un effet, voyons comment utiliser l'API pour construire un effet, le valider et en obtenir un rendu.

Création d'un effet

Le code de création d'un effet provient de CMyD3DApplication::RestoreDeviceObjects:

LPD3DXBUFFER pShader = NULL;

 hr = D3DXCreateEffectFromFile(
 m_pd3dDevice,
 "hemisphere.fx",
 NULL, // CONST D3DXMACRO* pDefines, 
 NULL, // LPD3DXINCLUDE pInclude,
 D3DXSHADER_DEBUG,
 NULL,
 &m_pEffect,
 NULL);
 if(FAILED(hr))
 {
 return hr;
 }

Étant donné que l'effet est contenu dans le fichier d'effet hemisphere.fx, il sera créé à l'aide de D3DXCreateEffectFromFile. La création d'un effet requiert le jeu d'arguments suivant :

  • L'équipement.
  • Le nom du fichier d'effet.
  • Un pointeur vers une liste de #defines terminée par NULL, à utiliser lors de l'analyse du nuanceur.
  • Un pointeur facultatif vers un gestionnaire d'inclusions écrit par l'utilisateur. Le gestionnaire est appelé par le processeur, chaque fois qu'il doit résoudre un #include.
  • Un indicateur de compilation de nuanceur qui fournit au compilateur des indications concernant le mode d'utilisation du nuanceur. Les options incluent :
    • Validation ignorée, en cas de compilation de nuanceurs de bonne qualité.
    • Optimisation ignorée (parfois utilisée lorsque les optimisations rendent le débogage plus difficile).
    • Demande d'ajout des informations de débogage dans le nuanceur, afin de le déboguer.
  • Le pool d'effets. Le pool d'effets est un pointeur vers une interface de pool de mémoire créé à l'aide de D3DXCreateEffectPool. Si plusieurs effets utilisent le même pointeur de pool de mémoire, les variables globales dans les effets sont partagées. S'il n'est pas nécessaire de partager des variables d'effet, le pool de mémoire peut être défini sur NULL.
  • Un pointeur vers le nouvel effet.
  • Un pointeur vers un tampon vers lequel les erreurs de validation peuvent être envoyées. Dans cet exemple, le paramètre a été défini sur NULL et n'a donc pas été utilisé.

Le processus de création de l'effet simplifie le code de création de l'objet du nuanceur et de compilation du nuanceur :

LPDIRECT3DVERTEXSHADER9 m_pVSTexture = NULL;
 LPD3DXCONSTANTTABLE m_pTexture_ConstantTable = NULL;
 LPD3DXBUFFER l_pShader = NULL;

 hr = D3DXCompileShaderFromResource(
 NULL,
 MAKEINTRESOURCE(ID_HLSL_HEMISPHERE),
 NULL, // CONST D3DXMACRO* pDefines,
 NULL, // LPD3DXINCLUDE pInclude,
 "VSTexture", 
 "vs_1_1",
 D3DXSHADER_DEBUG,
 &l_pShader, 
 NULL, // error messages 
 &m_pTexture_ConstantTable );

 if(FAILED(hr))
 {
 return hr; 
 }
 
 // Create the vertex shader.
 hr = m_pd3dDevice->CreatevertexShader( 
 (DWORD*)l_pShader->GetBufferPointer(), 
&m_pVS_HLSL_Texture );

 if(FAILED(hr))
 {
 SAFE_RELEASE(l_pShader);
 SAFE_RELEASE(m_pTexture_ConstantTable); 
 }
 
 SAFE_RELEASE(l_pShader);

Lors de la création de ressources, les effets ne génèrent pas de pointeur de table constant pour définir les constantes du nuanceur. Au lieu de cela, les variables d'effet sont définies via l'interface ID3DXEffect. Les objets des nuanceurs vertex et pixel sont gérés de manière transparente par les effets et n'ont pas besoin d'être gérés par une application.

Validation d'un effet

Ce code récupère un descripteur de la technique et l'utilise pour valider la technique :

D3DXHANDLE hTech = m_pEffect->GetTechniqueByName("TvertexShaderOnly_Assy");
 m_pEffect->ValidateTechnique(hTech);

La validation d'une technique permet de vérifier que toutes les missions d'état des pass sont valides. Une fois qu'une technique a été validée, elle est disponible pour le rendu.

Lors de la validation, le code d'effet est validé ou testé par rapport au jeu de règles de validation. Ceci a pour objectif de repérer les erreurs, telles que les descripteurs manquants, les états définis de manière incorrecte, les objets d'effet initialisés de manière incorrecte et certaines erreurs concernant les cartes de cube et de volume.

Pour valider une technique, actualisez-la en appelant SetTechnique à l'aide d'un descripteur NULL.

Rendu d'un effet

Le code de rendu d'un effet est également plus simple qu'un même code de rendu sans effet. Voici le code de rendu avec effet :

// Begin the scene.
 if( SUCCEEDED( m_pd3dDevice->BeginScene() ) )
 {
 // Draw the mesh.
 if(m_pEffect)
 {
 D3DXMATRIXA16 matWorld;
 D3DXMatrixIdentity(&matWorld);
 D3DXMATRIX compMat; 
 D3DXMatrixMultiply(&compMat, &matWorld, &m_matView);
 D3DXMatrixMultiply(&compMat, &compMat, &m_matProj);
 m_pEffect->SetMatrix("matWorldView", compMat);
 m_pEffect->SetTechnique("TAmbientDiffuseSpecular"); 
 HRESULT hr;
 UINT numPasses, iPass;
 hr = m_pEffect->Begin( &numPasses, 0 );
 for( iPass = 0; iPass < numPasses; iPass ++ ) // all passes
 {
 hr = m_pEffect->Pass( iPass );
 // Render the tiger with a mesh drawing loop. 
 for( DWORD i=0; i < m_dwNumMaterials; i++ )
 {
 // Set the material and texture for this subset.
 m_pd3dDevice->SetMaterial( &m_pMeshMaterials[i] );
 m_pd3dDevice->SetTexture( 0, m_pMeshTextures[i] );
 
 // Draw the mesh subset.
 m_pMesh->DrawSubset( i );
 }
 
 }
 hr = m_pEffect->End();

 } 

 // End the scene.
 m_pd3dDevice->EndScene();
 }

Tout d'abord, l'interface d'effet appelle SetMatrix pour initialiser la matrice de l'effet. Ensuite, la technique de rendu est définie en appelant SetTechnique avec le nom de la technique.

L'ensemble du rendu d'un effet se trouve à l'intérieur d'une paire d'appels Begin/End. Les opérations de nuanceur réelles sont effectuées en réponse à l'appel Effect::Pass. Par conséquent, cette boucle de rendu consiste à interroger l'effet pour voir combien de pass il contient, puis à appeler toutes les pass pour une technique. Il serait possible d'agrandir la bouche de rendu afin qu'elle puisse appeler de nombreuses techniques, chacune comprenant de nombreuses pass.

Conclusion

Comme vous pouvez le voir, l'infrastructure Effects est assez puissante et peut être utilisée en combinaison avec un grand nombre d'équipements. Pour obtenir d'autres exemples de fichiers d'effet, consultez les exemples dans le SDK DirectX 9.0. Le mois prochain, nous verrons comment combiner l'utilisation de maillages (comme décrit dans l'article précédent Driving DirectX ( Lien externe au site MSDN France Site en anglais)), le nouveau langage de nuancement de haut niveau et l'infrastructure Effects.

 

Driving DirectX

Tous nos remerciements à Kris Gray. Certaines parties de cet article contiennent des informations qui sont incluses dans le livre à paraître, The DirectX 9 Programmable Graphics Pipeline (en anglais).

Dave Aronson travaille dans l'industrie infographique depuis plus de dix ans. Il est spécialisé dans les outils de graphie de jeux en 3 dimensions. Il est maintenant responsable des programmes de l'équipe D3DX, au sein de l'équipe Microsoft DirectX, et développe des outils et des technologies permettant la création facile et évolutive de jeux aux images très élaborées. La dernière création de cette équipe est le développement du langage de nuancement de niveau supérieur pour DirectX. Des articles à paraître prochainement vous en diront davantage sur l'utilisation de ce langage.



Dernière mise à jour le mardi 10 juin 2003



Pour en savoir plus
Afficher:
© 2014 Microsoft