Le multitexturing

Le multitexturing est le processus qui permet le mélange contrôlé de plusieurs textures sur une même surface 3D. Direct3D permet de mélanger jusqu’à huit étapes (ou étage/stage) correspondant à 8 textures superposées. Chacune correspond à un processus de texture blending qui détermine la couleur d’un pixel en mélangeant les couleurs de la texture de l’étape courante aux couleurs de l’étape précédente.


Quelque soit le stage sur lequel il s’effectue, le blend est une opération qui prend en entrée 8 paramètres :


  • Trois arguments pour le calcul de la couleur RGB.
  • Trois arguments pour le calcul de la composante Alpha,
  • Une opération pour calculer la couleur RGB
  • Une opération pour la composante alpha.
     

En résultat on obtient deux valeurs :


  • Une couleur RGB.
  • Une composante alpha (transparence).

Les arguments appartiennent à l’énumération TextureArgument, les opérations à TextureOperation. Ses membres les plus courants sont :


Subtract : Soustrait les données graphiques du second argument au premier argument.


SRGBA = Arg1 – Arg2


Lerp : Réalise une interpolation linéaire entre le second et le troisième argument suivant une proportion décrite dans le premier argument.


RGBA = (Arg1) * Arg2 + (1- Arg1) * Arg3.


MultiplyAdd : Réalise une multiplication de deux derniers arguments sur 3 trois donnés à laquelle on additionne le premier argument pour créer la sortie.


SRGBA = Arg1 + Arg2 *Arg3


DotProduct3 : Multiplie chaque composante RGB des deux arguments et les additionne entre eux.


SRGBA = (Arg1R * Arg2R + Arg1G * Arg2G + Arg1B * Arg2B)


BlendTextureAlpha : Réalise un mélange linéaire des composantes alpha de l’étage courant avec le résultat des étapes supérieures.


RGBA = Arg1 * (Alpha) + Arg2 * (1 – Alpha)


BlendDiffuseAlpha : Réalise un mélange linéaire entre l’étage supérieur et l’étage courant.


RGBA = Arg1 * (Alpha) + Arg2 * (1 – Alpha)


AddSmooth : Additionne les arguments 1 et 2 puis soustrait leur produit pour donner la sortie.


RGBA = Arg1 + Arg2 – Arg1 * Arg2


AddSigned2X : Additionne les texels des de l’étage supérieur avec l’étage courant pour la sortie avec une correction de 0.5 et un décalage de bits de 1 vers la gauche (multiplication par 2).


RGBA = (Arg1 + Arg2 – 0.5) << 1


AddSigned : Additionne les texels des de l’étage supérieur avec l’étage courant pour la sortie avec une correction de 0.5.


RGBA = Arg1 + Arg2 -0.5


Add : Additionne les texels des de l’étage supérieur avec l’étage courant pour la sortie. RGBA = Arg1 + Arg2


Modulate4X : Multiplie les texels des de l’étage supérieur avec l’étage courant puis décale les bits de 2 vers la gauche (provoquant une multiplication par 4) pour la sortie.


RGBA = (Arg1 * Arg2) << 2


Modulate2X :  Multiplie les texels des de l’étage supérieur avec l’étage courant puis décale les bits de 1 vers la gauche (provoquant une multiplication par 2) pour la sortie.


RGBA = (Arg1 * Arg2) << 1


Modulate : Multiplie les texels des de l’étage supérieur avec l’étage courant pour créer la sortie. RGBA = Arg1 * Arg2


SelectArg2 : Prend en compte le second argument de l’étage courant portent sur la couleur ou la composante alpha pour créer la sortie. RGBA = Arg2


SelectArg1 : Prend en compte le premier argument de l’étage courant portent sur la couleur ou la composante alpha pour créer la sortie. RGBA = Arg1


Disable : Désactive la sortie de l’étage courant et de tous les étages d’un niveau supérieur. Pour désactivier le mapping de texture, il suffit de donner ce drapeau pour l’étage 0. Les opération sur la composante alpha ne peut être désactivée lorsque les opérations sur les couleurs sont activée.


Reportez vous à l’aide du SDK pour les autres membres non explicités ici. Les membres les plus courants de TextureOperation sont :


TextureColor : Contient les couleurs de l’étage courant.


Current : Renvoie l’élément de l’étage precedent (si un seul étage dans le multitexturing, l’argument est equivalent à Diffuse).


Diffuse : Pixels dont la valeur est obtenue via une interpolation bilinéaire des sommets de la primitive en gouraud.


Reportez vous à l’aide du SDK pour les autres membres non explicités ici. Les possibilités de calculs et de mélange sont donc infinies, la difficulté de comprend les possibilités des calculs est importante. Là encore, comme pour l’usage des filtres, on peut s’en sortir facilement au départ en tâtonnant jusqu’à obtenir l’effet souhaité. Avec le temps, les mécanismes suivront. Plutôt que de s’engager dans une pléthore d’exemples pour les mettre en valeur, j’ai développé un petit programme fort utile qui permet, via une interface Windows très simple de s’amuser en testant toutes les opérations avec tous les arguments possibles pour déterminer quel résultat cela pouvait avoir à l’écran.


Une application qui simplifiait la vie
Figure 1


Cerise sur le gâteau, notre programme donne le code source à mettre dans son programme pour avoir un multitexturing paramétré. C’est une copie, en C# d’un utilitaire présent dans les précédentes versions du SDK DirectX qui a été curieusement supprimé aujourd’hui. Le gain de temps que ce logiciel procurait au développeur était faramineux : avant, il fallait sans arrêt compiler son programme après avoir modifié une étape du multitexturing pour observer le résultat à l’écran. On perdait beaucoup de temps. Avec lui, un simple click suffit pour tester.


 Le programme

Au lancement nous avons l’écran suivant :

 

...en C#
Figure 2 

 

Seules trois étages peuvent donc être paramétrées sur les 8 possibles. En fait 99% des multitexturing portent sur un nombre d’étages inférieur ou égal à 3. C’est donc bien suffisant.

 

On voit en faisant défiler le contenu du combo box ColorOP ou AlphaOP qu’il y’a 25 fonctions de mélange (énumération TextureOperation). Pour ces opérations de 1 à trois arguments doivent être fournis prenant une valeur parmi 10 choix possibles (TextureArgument). Tout ceci existe pour chaque étape du multitexturing. Les possibilités sont donc trop nombreuses pour pouvoir être toutes données dans ce tutorial. Nous ne verrons que quelques effets.

 

Pour reproduire l’effet lumineux d’un sport sur une texture, il faut charger en texture de stage 2 spolite.bmp du répertoire de l’exécutable et configurer le second stage comme ceci :

 

 Figure 3— les texels blancs du spot se superposent aux texels du mur et les eclaircissent : le mur semble éclairé !

 

En cliquant sur le bouton « View code » on obtient :

 

  

public void SetTexturesStages(Microsoft.DirectX.Direct3D.Device device)

{

     //texture stage : 0 Fichier image : env2.bmp

     /////////////////////

     device.TextureState[0].ColorOperation = TextureOperation.SelectArg1;

     device.TextureState[0].ColorArgument1 = TextureArgument.TextureColor;

 

     device.TextureState[0].AlphaOperation = TextureOperation.SelectArg1;

     device.TextureState[0].AlphaArgument1 = TextureArgument.TextureColor;

 

     device.TextureState[0].ResultArgument = TextureArgument.Current;

 

 

     //texture stage : 1 Fichier image : spotlite.bmp

     /////////////////////

     device.TextureState[1].ColorOperation = TextureOperation.Modulate;

     device.TextureState[1].ColorArgument1 = TextureArgument.TextureColor;

     device.TextureState[1].ColorArgument2 = TextureArgument.Current;

 

     device.TextureState[1].AlphaOperation = TextureOperation.Disable;

 

     device.TextureState[1].ResultArgument = TextureArgument.Current;

 

 

     //texture stage : 2 Fichier image : env3.bmp

     /////////////////////

     device.TextureState[2].ColorOperation = TextureOperation.Disable;

 

     device.TextureState[2].AlphaOperation = TextureOperation.Disable;

 

}

 

  

Il s’agit du code généré par l’application pour créer le multitexturing, visible dans l’utilitaire, à l’intérieur de nos programmes.  Nous spécifions l’étage pour lequel les arguments et opérations donnés sont destinés (ici donné sous la forme d’un index de tableau), l’opération (ColorOperation et AlphaOperation ) de type TextureOperation  et les arguments liés de type TextureArgument (voir la figure 3).

 

Pour reproduire une case de monde de Warcraft avec une portion de terre et une portion d’herbe au dessus comme ceci :

 

Trouver comme faire un tel affichage avec cette application est simple

 Figure 4

 

 On chargera en texture stage 2 :

 

On voit le résultat dynamiquement

 Figure 5 

 

  

Dans tous les cas pas d’inquiétudes face à toutes ses possibilités de calculs. Personne ne peut vraiment prétendre maîtriser toutes ces opérations ou les comprendre. Seul le temps peut permet de s’en sortir avec plus ou moins de facilité. Toujours se reporter aux exemples de code source trouvé sur Internet ou bien à l’utilitaire présenté ici pour trouver l’effet voulu.

 

Sample

 

telecharger Vous pouvez télécharger le Sample ici.

Conclusion

[Soon]

Valentin Billotte


Leave a Reply

Your email address will not be published. Required fields are marked *

You may use these HTML tags and attributes: <a href="" title=""> <abbr title=""> <acronym title=""> <b> <blockquote cite=""> <cite> <code> <del datetime=""> <em> <i> <q cite=""> <strike> <strong>