Particles Benchmark Test

This work was inspired and is related to article "HTML5" versus Flash: Animation Benchmarking. The article compares four web technologies by speed of animation (framerate). Since Silverlight was not included, we decided to add it.
The algorithm for particle animation was taken from the HTML5 page and rewritten for Silverlight. The result is here:

http://silverlightonly.com/v/misc/particDemo.htm

You can define your own number of particles by adding a parameter:
http://silverlightonly.com/v/misc/particDemo.htm?particles=250
http://silverlightonly.com/v/misc/particDemo.htm?particles=500
http://silverlightonly.com/v/misc/particDemo.htm?particles=1000

And here is the Silverlight code:

// partic.xaml
<navigation:Page x:Class="benchm.partic" 
           xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
           xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
           xmlns:navigation="clr-namespace:System.Windows.Controls;assembly=System.Windows.Controls.Navigation"
           Title="particles Page">
    <Canvas x:Name="LayoutRoot">
        <Grid Name="Grid1">
        <TextBlock Name="txtCntp" Text="Silverlight" FontSize="16" HorizontalAlignment="Left" VerticalAlignment="Bottom" Margin="5" />
        <TextBlock Name="txtFps" Text="FPS" FontSize="24" HorizontalAlignment="Right" VerticalAlignment="Bottom" Margin="5" />
        </Grid>
    </Canvas>
</navigation:Page>

// partic.xaml.cs
using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Media;
using System.Windows.Media.Animation;
using System.Windows.Shapes;
using System.Windows.Browser;

namespace benchm
{
    public partial class partic : Page
    {   //original idea & code from http://www.themaninblue.com/writing/perspective/2010/03/22/
        static int MAX_PARTICLES = 500;
        static int MAX_VELOCITY = 500;
        static int PARTICLE_RADIUS = 6;
        static int STAGE_WIDTH = 1024;
        static int STAGE_HEIGHT = 768;
        static string[] COLORS = { "#FFcc0000", "#FFffcc00", "#FFaaff00", "#FF0099cc", "#FF194c99", "#FF661999" };
        DateTime _dtLastFPS = DateTime.Now;
        int _fps;
        Ellipse[] particles;
        static Random Rnd = new Random();
        const double PId2 = Math.PI / 2;
        
        public partic()
        {
            InitializeComponent();

if (HtmlPage.Document.QueryString.ContainsKey("particles"))
                int.TryParse(HtmlPage.Document.QueryString["particles"], out MAX_PARTICLES);
            MAX_PARTICLES = Math.Min(MAX_PARTICLES, 10000);
            txtCntp.Text = MAX_PARTICLES.ToString() + " particles in Silverlight";
            particles = new Ellipse[MAX_PARTICLES];

STAGE_WIDTH = (int)Application.Current.Host.Content.ActualWidth;
	        STAGE_HEIGHT = (int)Application.Current.Host.Content.ActualHeight;
            Grid1.Width = STAGE_WIDTH;
            Grid1.Height = STAGE_HEIGHT;
    		
	        // Create the particles
	        for (var i = 0; i < MAX_PARTICLES; i++)
	        {
		        particles[i] = new Ellipse();
                particles[i].Width = PARTICLE_RADIUS * 2;
                particles[i].Height = PARTICLE_RADIUS * 2;
                double x = STAGE_WIDTH / 2 - PARTICLE_RADIUS;
                double y = STAGE_HEIGHT / 2 - PARTICLE_RADIUS;

// Set element colour
                particles[i].Fill = new SolidColorBrush(GetColorFromHexa(COLORS[(int)Math.Floor(Rnd.NextDouble() * COLORS.Length)]));

// Create visual element for the particle
                particles[i].SetValue(Canvas.LeftProperty, x);
                particles[i].SetValue(Canvas.TopProperty, y);
                LayoutRoot.Children.Add(particles[i]);
    		}
            System.Threading.Thread.Sleep(500);

// Start the animation
            CompositionTarget.Rendering += new EventHandler(CompositionTarget_Rendering);
        }

private Color GetColorFromHexa(string hexaColor)
        {
            return Color.FromArgb(
                    Convert.ToByte(hexaColor.Substring(1, 2), 16),
                    Convert.ToByte(hexaColor.Substring(3, 2), 16),
                    Convert.ToByte(hexaColor.Substring(5, 2), 16),
                    Convert.ToByte(hexaColor.Substring(7, 2), 16));
        }

void CompositionTarget_Rendering(object sender, EventArgs e)
        {   //process each frame
            if (_dtLastFPS.AddSeconds(1) < DateTime.Now)
            {
                txtFps.Text = _fps.ToString() + " FPS";
                _fps = 0;
                _dtLastFPS = DateTime.Now;
            }
            else
                _fps++;

// Calculate the framerate based upon the difference between the absolute times of the oldest and newest frames, subdivided by how many frames were drawn inbetween
            TimeSpan timeDelta = DateTime.Now - _dtLastFPS;

// Redraw each particle
            for (var i=0; i<particles.Length; i++)
                Draw(i, timeDelta.TotalMilliseconds);
        }

void Draw(int k, double timeDelta)
        {   //redraw the k ellipse
            double x = (double)particles[k].GetValue(Canvas.LeftProperty);
            double y = (double)particles[k].GetValue(Canvas.TopProperty);

double angle = Math.PI * 2 * Rnd.NextDouble();
            var velocity = MAX_VELOCITY / 8 * 7 * Rnd.NextDouble() + MAX_VELOCITY / 8;

// Calculate next position of particle
            double nextX = x + Math.Cos(angle) * velocity *(timeDelta * 0.001);
            double nextY = y + Math.Sin(angle) * velocity *(timeDelta * 0.001);

// If particle is going to move off right side of screen
            if (nextX + PARTICLE_RADIUS * 2 > STAGE_WIDTH)
            {
                // If angle is between 3 o'clock and 6 o'clock
                if ((angle >= 0 && angle < PId2))
                {
                    angle = Math.PI - angle;
                }
                // If angle is between 12 o'clock and 3 o'clock
                else if (angle > PId2 * 3)
                {
                    angle = angle - (angle - PId2 * 3) * 2;
                }
            }

// If particle is going to move off left side of screen
            if (nextX < 0)
            {
                // If angle is between 6 o'clock and 9 o'clock
                if ((angle > PId2 && angle < Math.PI))
                {
                    angle = Math.PI - angle;
                }
                // If angle is between 9 o'clock and 12 o'clock
                else if (angle > Math.PI && angle < PId2 * 3)
                {
                    angle = angle + (PId2 * 3 - angle) * 2;
                }
            }

// If particle is going to move off bottom side of screen
            if (nextY + PARTICLE_RADIUS * 2 > STAGE_HEIGHT)
            {
                // If angle is between 3 o'clock and 9 o'clock
                if ((angle > 0 && angle < Math.PI))
                {
                    angle = Math.PI * 2 - angle;
                }
            }

// If particle is going to move off top side of screen
            if (nextY < 0)
            {
                // If angle is between 9 o'clock and 3 o'clock
                if ((angle > Math.PI && angle < Math.PI * 2))
                {
                    angle = angle - (angle - Math.PI) * 2;
                }
            }

// Fix next position of particle
            nextX = x + Math.Cos(angle) * velocity * (timeDelta * 0.001);
            nextY = y + Math.Sin(angle) * velocity * (timeDelta * 0.001);

particles[k].SetValue(Canvas.LeftProperty, nextX);
            particles[k].SetValue(Canvas.TopProperty, nextY);
        }
    }
}