Les lutins sont positionnés sur l'écran à l'aide de coordonnées. La largeur et la hauteur de l'écran sont les mêmes que le tampon arrière. L'axe x représente la largeur de l'écran et l'axe y représente la hauteur de l'écran. L'axe y est mesuré à partir du dessus de l'écran et augmente à mesure que vous vous déplacez vers le bas et l'axe x est mesuré de gauche à droite. Par exemple, lorsque le tampon arrière graphique est 800×600, 0,0 est le coin supérieur gauche de l'écran, et 800,600 est le coin inférieur droit de l'écran (voir illustration 1).

Figure 1.  L'emplacement d'un lutin dans les coordonnées de l'écran (axe x 400, axe y 200)

Pour dessiner un lutin, créez un objet SpriteBatch , initialisez-le en appelant Begin, est appelez ensuite Draw pour chaque lutin. Les données de topogramme binaire pour un lutin sont prises à partir d'un objet Texture2D . La texture peut contenir des informations de canal alpha pour faire partie de la texture transparente ou semi-transparente. Vous pouvez colorer, faire pivoter ou mettre les lutins à l'échelle en utilisant Draw. Cette méthode vous donne l'option de dessiner uniquement une partie de la texture sur l'écran. Après avoir dessiné un lutin, appelez End avant d'appeler Present.

Lorsque vous dessinez un lutin, l'origine des lutins est un concept important. L'origine est un point spécifique sur le lutin, qui est par défaut le coin supérieur gauche du lutin, ou (0,0). Draw dessine l'origine du lutin à l'emplacement de l'écran que vous spécifiez. Par exemple si vous dessinez un lutin de 50×50 pixels à l'emplacement (400,200) sans spécifier une origine, le coin supérieur gauche du lutin sera en pixels (400,200). Si vous utilisez le centre du lutin 50×50 comme l'origine (25,25), pour dessiner le lutin dans la même position, vous devez ajouter les coordonnées de l'origine à la position. Dans ce cas, la position est (425,225) et l'origine est (25,25), comme cela est présenté à l'illustration 2.

Figure 2.  Le point bleu indique le centre de la coordonnée du lutin.

Lorsque vous faites pivoter un lutin, la méthode utilise l'origine comme le centre de la rotation. Dans ces cas, il est ordinaire d'utiliser le centre du lutin comme l'origine lorsque vous calculez l'endroit où vous devez dessiner le lutin sur l'écran.

Les lutins ont également un concept de profondeur qui est un numéro de point de flottement situé entre 0 et 1. Les lutins dessinés à une profondeur de 0 sont dessinés en face des lutins qui ont une profondeur supérieure à 0 ; les lutins dessinés à une profondeur de 1 sont couverts par des lutins dessinés à une profondeur inférieure à 1.

Un lutin est basé sur un objet Texture2D —en d'autres termes, un topogramme binaire. Utilisez Draw pour dessiner toute la texture ou une portion de la texture. Pour dessiner une portion de la texture, utilisez le paramètre sourceRectangle pour spécifier quels texels, ou pixel de texture dessiner. Une texture 32×32 a 1024 texels, spécifiés comme des valeurs X et Y similaires à la manière dont les coordonnées de l'écran sont spécifiées. La spécification d'un sourceRectangle de (0, 0, 16, 16) sélectionnerait le cadran supérieur gauche d'une texture 32×32 .

Draw fournit trois options pour la mise à l'échelle d'un lutin : l'utilisation d'un paramètre de mise à l'échelle uniforme, d'un paramètre de mise à l'échelle non uniforme ou d'un rectangle source et d'un rectangle de destination. Le paramètre de mise à l'échelle uniforme est un nombr de point de flottement qui multiplie la taille du lutin par l'intermédiaire des axes X et Y. Cela rétrécira ou élargira de manière égale le lutin le long de chaque axe, en maintenant le ratio original entre la largeur et la hauteur du lutin.

Pour mettre à l'échelle les axes X et Y de manière indépendante, Draw accepte une valeur Vector2 comme un scalaire. Ce Vector2 spécifie une mise à l'échelle non uniforme : les axes X et Y sont mis à l'échelle de manière indépendante conformément aux champs X et Y duVector2.

Draw accepte également un rectangle source et un rectangle de destination. Le rectangle de destination est spécifié dans les coordonnées de l'écran, alors que le rectangle source est spécifié en texels. Draw prend les pixels sur la texture spécifiée dans sourceRectangle et les met à l'échelle d'une manière indépendante le long des axes X et Y jusqu'à ce qu'ils correspondent aux coordonnées de l'écran spécifiées par destinationRectangle.

Vous pouvez également spécifier une matrice de transformation que le lot peut appliquer à chaque lutin avant de les dessiner. La matrice de transformation peut être toute combinaison de matrices de traduction, de rotation ou de mise à l'échelle multipliées ensemble dans une seule matrice. Cette matrice est combinée avec les paramètres de position, de rotation, de mise à l'échelle et de profondeur du lutin fournis à Draw. Étant donné que la matrice s'applique également à la profondeur, toute transformation de coordonnée Z qui rend la profondeur du lutin supérieure à 1.0 ou inférieure à 0.0 fera disparaître le lutin.

Voir Rotation d'un groupe de sprites pour un exemple de rotation de matrice et Mise à l'échelle de sprites en fonction de la taille de l'écran pour un exemple de mise à l'échelle de matrice.

Utilisez un SpriteBatch pour dessiner du texte. La méthode DrawString dessinera du texte sur l'écran avec une position, une couleur, une rotation, une origine et une mise à l'échelle. DrawString nécessite également un type spécial de texture encapsulé par la classe SpriteFont . UneSpriteFont est créée par l'architecture pipeline de contenu lorsque vous ajoutez un fichier de polices de lutin à votre projet. Le fichier de polices de lutins a des informations telles que le nom et la taille en point de la police, et quels caractères Unicode inclure dans la texture SpriteFont. Au moment de l'exécution, une SpriteFont est chargée avec ContentManager.Load tout comme un objet Texture2D .

Voir Référence du schéma XML des polices sprite pour une liste de tags de polices de lutins. Vous pouvez utiliser l'architecture pipeline de contenu pour déterminer automatiquement vos régions de caractères. Pour de plus amples informations, voir Procédure : Étendre le processeur de descriptions de police pour prendre en charge des caractères supplémentaires.

Dans un dessin normal, l'objet SpriteBatch ne modifie pas un état de rendu ou ne dessine pas de lutin jusqu'à ce que vous appeliez End. C'est connu sous le nom de mode Différé . Dans le mode différé, SpriteBatch sauvegarde les informations à partir de chaque appel Draw jusqu'à ce que vous appeliez End.

Si vous appelez Begin, en spécifiant SpriteSortMode.Immediate, il clignote en mode Immédiat . En mode immédiat, le SpriteBatch change automatiquement les états de rendu du périphérique graphique pour commencer à dessiner des lutins. Par la suite, chaque appel à Draw dessine immédiatement le lutin en utilisant les paramètres du périphérique actuel.

En mode immédiat, dès que vous appelez Begin sur une instance SpriteBatch , ne l'appelez pas sur toute autre instance SpriteBatch jusqu'à ce que vous appeliez End pour le premier SpriteBatch.

Le mode différé est plus lent que le mode immédiat, mais il permet à plusieurs instances de SpriteBatch d'accepter les appels Begin et Draw sans interférer les unes avec les autres.