Animated sprite extension for Delta Engine.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using DeltaEngine.Core;
using DeltaEngine.Datatypes;
using DeltaEngine.Graphics;
using DeltaEngine.Rendering;

namespace DeltaExtensions
{
    public class AnimatedSprite : Sprite
    {
        private readonly Image _image; //the sprite sheet

        private readonly int _height; //height of one sprite in the sprite sheet
        private readonly int _width; //width of one sprite in the sprite sheet

        private readonly Point[] _frames;
        private float _currentFrameDelta;
        private int _currentFrameNumber;
        private readonly int _targetFps;
        private readonly float _frameLength;

        /// <summary>
        ///
        /// </summary>
        /// <param name="image"></param>
        /// <param name="initalDrawArea"></param>
        /// <param name="color"></param>
        /// <param name="height"></param>
        /// <param name="width"></param>
        /// <param name="targetFps"></param>
        /// <param name="frames"></param>
        public AnimatedSprite(Image image, Rectangle initalDrawArea, Color color, int width, int height, int targetFps, Point[] frames)
            : base(image, initalDrawArea, color)
        {
            _image = image;
            _height = height;
            _width = width;
            _targetFps = targetFps;
            _frameLength = (1 / (float)_targetFps);
            _frames = frames;
        }

        protected override void Render(Renderer renderer, Time time)
        {
            DrawImage(time, renderer.Screen);
        }

        private Point GetCurrentFrame(Time time)
        {
            _currentFrameDelta += time.CurrentDelta;
            if (_currentFrameDelta > _frameLength)
            {
                _currentFrameNumber = (_currentFrameNumber + 1) % _frames.Length;
                _currentFrameDelta = 0;
            }
            return _frames[_currentFrameNumber];
        }

        private void DrawImage(Time time, ScreenSpace screen)
        {
            var currentImage = GetCurrentFrame(time);
            var heightPercentage = 1 / _image.PixelSize.Height * _height;
            var widthPercentage = 1 / _image.PixelSize.Width * _width;

            var topLeft = new Point(currentImage.X * widthPercentage, currentImage.Y * heightPercentage);
            var topRight = new Point((currentImage.X+1) * widthPercentage, currentImage.Y * heightPercentage);
            var botLeft = new Point(currentImage.X * widthPercentage, (currentImage.Y + 1) * heightPercentage);
            var botRight = new Point((currentImage.X + 1) * widthPercentage, (currentImage.Y + 1) * heightPercentage);

            var vertices = new[]
            {
                GetVertex(DrawArea.TopLeft, topLeft, screen),
                GetVertex(DrawArea.TopRight, topRight, screen),
                GetVertex(DrawArea.BottomRight, botRight, screen),
                GetVertex(DrawArea.BottomLeft, botLeft, screen)
            };
            _image.Draw(vertices);
        }

        private VertexPositionColorTextured GetVertex(Point position, Point uv, ScreenSpace screen)
        {
            if (Flip == FlipMode.Horizontal)
                uv.X = 1.0f - uv.X;
            if (Flip == FlipMode.Vertical)
                uv.Y = 1.0f - uv.Y;
            return new VertexPositionColorTextured(screen.ToPixelSpaceRounded(position), Color, uv);
        }
    }
}