/// <summary> /// Affiche à l'écran la partie de la mappe monde visible par la caméra. /// </summary> /// <param name="camera">Caméra à exploiter pour l'affichage.</param> /// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param> protected void Draw(Camera camera, SpriteBatch spriteBatch) { // Initialiser le rectangle de destination aux dimensions d'une image. Rectangle destRect = new Rectangle(0, 0, this.LargeurImage, this.HauteurImage); // Afficher une rangée à la fois. for (int row = 0; row < this.Textures.GetLength(0); row++) { for (int col = 0; col < this.Textures.GetLength(1); col++) { // Calculer la position de l'image à l'écran. destRect.X = col * this.LargeurImage; destRect.Y = row * this.HauteurImage; // Afficher l'image si elle est visible dans la caméra. if (camera == null || camera.EstVisible(destRect)) { // Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect // de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran). if (camera != null) { camera.Monde2Camera(ref destRect); } // Afficher l'image courante. spriteBatch.Draw(this.Textures[row, col], destinationRectangle: destRect); // afficher la tuile } } } }
/// <summary> /// Affiche à l'écran la particule (si elle est visible). /// </summary> /// <param name="camera">Caméra indiquant la partie du monde présentement visible à l'écran (peut être nulle).</param> /// <param name="spriteBatch">Tampon d'affichage de sprites.</param> public override void Draw(float angle, Camera camera, SpriteBatch spriteBatch, SpriteEffects effects = SpriteEffects.None) { if (this.Visible) { // Calculer le canal alpha à appliquer à la texture (permet à Update() de faire // graduellement diaparaître l'image à l'écran (fade out). Color fadeColor = new Color(255, 255, 255, (byte)MathHelper.Clamp(this.fadeAlpha, 0, 255)); // Corriger la position d'affichage de la texture en fonction de l'expansion occasionnée // par l'explosion. Vector2 pos = new Vector2(this.Position.X + this.dispersionDelta.X, this.Position.Y + this.dispersionDelta.Y); // On doit travailler avec une copie de PositionRect car on va mapper ses coordonnées // en celles du monde si on nous a fourni une caméra. Rectangle destRect = this.PositionRect; // Si une caméra est fournie, on s'assure que le sprite y est visible. if (camera == null || camera.EstVisible(destRect)) { // Décaler la destination en fonction de la caméra avant de dessiner. if (camera != null) { camera.Monde2Camera(ref destRect); } spriteBatch.Draw(this.Texture, pos, null, fadeColor, this.rotation, new Vector2(this.Texture.Width / 2, this.Texture.Height / 2), this.echelle, effects, 1); } } }
/// <summary> /// Affiche à l'écran le sprite en fonction de la position de la camera. L'affichage est /// déléguée à palette afin d'afficher la tuile courante d'animation. /// </summary> /// <param name="camera">Caméra à exploiter pour l'affichage.</param> /// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param> public override void Draw(float angle, Camera camera, SpriteBatch spriteBatch, SpriteEffects effects = SpriteEffects.None) { // Calculer les coordonnées du sprite dans le monde. Rectangle destRect = new Rectangle(0, 0, this.Width, this.Height); destRect.X = (int)Position.X - (this.Width / 2); destRect.Y = (int)Position.Y - (this.Height / 2); // Si une caméra est fournie, on s'assure que le sprite y est visible. if (camera == null || camera.EstVisible(destRect)) { // Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect // de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran). camera.Monde2Camera(ref destRect); // Afficher la tuile courante this.PaletteAnimation.Draw(angle, this.IndexTuile, destRect, spriteBatch, effects); } }
/// <summary> /// Fonction membre à surcharger pour dessiner le sprite. Par défaut la this.texture est /// affichée à sa position. /// </summary> /// <param name="camera">Caméra indiquant la partie du monde présentement visible à l'écran (peut être nulle).</param> /// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param> public virtual void Draw(Camera camera, SpriteBatch spriteBatch) { // On doit travailler avec une copie de PositionRect car on va mapper ses coordonnées // en celles du monde si on nous a fourni une caméra. Rectangle destRect = this.PositionRect; // Si une caméra est fournie, on s'assure que le sprite y est visible. if (camera == null || camera.EstVisible(destRect)) { // Décaler la destination en fonction de la caméra avant de dessiner. if (camera != null) { camera.Monde2Camera(ref destRect); } // Afficher le sprite. spriteBatch.Draw(this.Texture, destinationRectangle: destRect); } }
/// <summary> /// Affiche à l'écran le sprite en fonction de la position de la camera. L'affichage est /// déléguée à palette afin d'afficher la tuile courante d'animation. /// </summary> /// <param name="camera">Caméra à exploiter pour l'affichage.</param> /// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param> public override void Draw(Camera camera, SpriteBatch spriteBatch) { // Comme l'attribut _position contient la position centrée du sprite mais // que Draw() considère la position fournie comme celle de l'origine du // sprite, il faut décaler _position en conséquence avant d'invoquer Draw(). this.ForcerPosition(Position.X - (this.Width / 2), Position.Y - (this.Height / 2)); // Créer destRect aux coordonnées du sprite dans le monde. À noter que // les dimensions de destRect sont constantes. Rectangle destRect = new Rectangle((int)Position.X, (int)Position.Y, this.Width, this.Height); // Afficher le sprite s'il est visible. if (camera == null) { // Afficher la tuile courante. this.Palette.Draw((int)this.IndexTuile, destRect, spriteBatch); } else if (camera.EstVisible(destRect)) { // Puisque le sprite est visible, déléguer à la palette de tuiles la tâche d'afficher // la tuile courante. // Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect // de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran). camera.Monde2Camera(ref destRect); // Afficher la tuile courante. this.Palette.Draw((int)this.IndexTuile, destRect, spriteBatch); } // Remettre _position au centre du sprite. this.ForcerPosition(Position.X + (this.Width / 2), Position.Y + (this.Height / 2)); }
/// <summary> /// Affiche à l'écran la partie de la mappe monde visible par la caméra. /// </summary> /// <param name="camera">Caméra à exploiter pour l'affichage.</param> /// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param> public override void Draw(Camera camera, SpriteBatch spriteBatch) { // Initialiser le rectangle de destination aux dimensions d'une image. Rectangle destRect = new Rectangle(0, 0, this.LargeurImage, this.HauteurImage); // Afficher une rangée à la fois. for (int row = 0; row < this.Textures.GetLength(0); row++) { for (int col = 0; col < this.Textures.GetLength(1); col++) { // Calculer la position de l'image à l'écran. destRect.X = col * this.LargeurImage; destRect.Y = row * this.HauteurImage; // Afficher l'image si elle est visible dans la caméra. if (camera.EstVisible(destRect)) { // Puisque l'image est visible, l'afficher. // Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect // de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran). camera.Monde2Camera(ref destRect); // Afficher l'image courante. spriteBatch.Draw(this.Textures[row, col], destRect, null, Color.White); // afficher la tuile } } } }
/// <summary> /// Affiche à l'écran la partie de la mappe monde visible par la camera. /// </summary> /// <param name="camera">Caméra à exploiter pour l'affichage.</param> /// <param name="spriteBatch">Gestionnaire d'affichage en batch aux périphériques.</param> public override void Draw(Camera camera, SpriteBatch spriteBatch) { // Initialiser le rectangle de destination aux dimensions d'une tuile Rectangle destRect = new Rectangle(0, 0, this.Palette.LargeurTuile, this.Palette.HauteurTuile); // Afficher une rangée à la fois for (int row = 0; row < this.MappeMonde.GetLength(0); row++) { for (int col = 0; col < this.MappeMonde.GetLength(1); col++) { // Calculer la position de la tuile à l'écran destRect.X = col * this.Palette.LargeurTuile; destRect.Y = row * this.Palette.HauteurTuile; // Afficher la tuile si elle est visible par la caméra if (camera.EstVisible(destRect)) { // Puisque le sprite est visible, déléguer à la palette de tuiles la tâche d'afficher // la tuile courante. // Décaler la destination en fonction de la caméra. Ceci correspond à transformer destRect // de coordonnées logiques (i.e. du monde) à des coordonnées physiques (i.e. de l'écran). camera.Monde2Camera(ref destRect); // Afficher la tuile courante this.Palette.Draw(this.MappeMonde[row, col], destRect, spriteBatch); } } } }