/// <summary>
        /// Processes the specified Particle.
        /// </summary>
        /// <param name="dt">Elapsed time in whole and fractional seconds.</param>
        /// <param name="particle">The particle to be processed.</param>
        /// <param name="tag">The tag which has been attached to the Particle (or null).</param>
        public override unsafe void Process(float dt, Particle* particle, object tag)
        {
            float a = particle->Age * 0.07f,
                  aInv = 1f - a;

            particle->Scale = (particle->Scale * aInv) + (this.MergeScale * a);
        }

		protected override void ProcessLinear(float bias, float scale, float deltaTime, Particle[] particles, int begin, int end)
		{
			for (int i = begin; i < end; ++i)
			{
				particles[i].m_rotation = bias + scale * particles[i].m_age / particles[i].m_life;
			}
		}

        /// <summary>
        /// Processes the particles.
        /// </summary>
        /// <param name="dt">Elapsed time in whole and fractional seconds.</param>
        /// <param name="particleArray">A pointer to an array of particles.</param>
        /// <param name="count">The number of particles which need to be processed.</param>
        protected internal override unsafe void Process(float dt, Particle* particleArray, int count)
        {
            this.TotalSeconds += dt;

            float deltaAmp = this.Amplitude * dt;

            for (int i = 0; i < count; i++)
            {
                Particle* particle = (particleArray + i);

                float secondsAlive = this.TotalSeconds - particle->Inception;

                float sin = Calculator.Cos(secondsAlive * this.Frequency);

                Vector2 force = new Vector2(sin, 0f);

                force.X = ((force.X * this.AngleCos) + (force.Y * -this.AngleSin));
                force.Y = ((force.X * this.AngleSin) + (force.Y * this.AngleCos));

                force.X *= deltaAmp;
                force.Y *= deltaAmp;

                particle->Velocity.X += force.X;
                particle->Velocity.Y += force.Y;
            }
        }

            public void IteratesOverEachParticle()
            {
                var buffer = new Particle
                {
                    Age = new float[100],
                    R = new float[100],
                    G = new float[100],
                    B = new float[100]
                };

                for (var i = 0; i < buffer.Age.Length; i++)
                    buffer.Age[i] = 1.0f;

                var subject = new ColourInterpolator2
                {
                    InitialColour = new Colour(1f, 0f, 0f),
                    FinalColour = new Colour(0f, 0f, 1f)
                };

                subject.Update(0.1666666f, ref buffer, buffer.Age.Length);

                for (int i = 0; i < buffer.Age.Length; i++)
                {
                    buffer.B[0].Should().BeApproximately(1f, 0.000001f);
                }
            }

        protected internal override void Update(float elapsedSeconds, ref Particle particle, int count)
        {
            fixed (float* agePtr = particle.Age)
            fixed (float* rPtr = particle.R)
            fixed (float* gPtr = particle.G)
            fixed (float* bPtr = particle.B)
            fixed (float* aPtr = particle.Opacity)
            {
                var ageDataPtr = agePtr;
                var rDataPtr = rPtr;
                var gDataPtr = gPtr;
                var bDataPtr = bPtr;
                var aDataPtr = aPtr;

                for (var j = 0; j < count; j++)
                {
                    var age = *(ageDataPtr + j);
                    var inverseAge = 1.0f - age;
                    var alpha = InitialColour.A * age;
                    *(aDataPtr + j) = alpha;
                    *(rDataPtr + j) = InitialColour.H * inverseAge;
                    *(gDataPtr + j) = InitialColour.S * inverseAge;
                    *(bDataPtr + j) = InitialColour.L * inverseAge;
                }
            }
        }

        /// <summary>
        /// Processes the particles.
        /// </summary>
        /// <param name="elapsedSeconds">Elapsed time in whole and fractional seconds.</param>
        /// <param name="particle">A pointer to the first item in an array of particles.</param>
        /// <param name="count">The number of particles which need to be processed.</param>
        protected internal override unsafe void Process(float elapsedSeconds, Particle* particle, int count)
        {
            particle->Colour.X = (this.InitialColour.X + ((this.UltimateColour.X - this.InitialColour.X) * particle->Age));
            particle->Colour.Y = (this.InitialColour.Y + ((this.UltimateColour.Y - this.InitialColour.Y) * particle->Age));
            particle->Colour.Z = (this.InitialColour.Z + ((this.UltimateColour.Z - this.InitialColour.Z) * particle->Age));

            Particle* previousParticle = particle;

            particle++;

            for (int i = 1; i < count; i++)
            {
                if (particle->Age < previousParticle->Age)
                {
                    particle->Colour.X = (this.InitialColour.X + ((this.UltimateColour.X - this.InitialColour.X) * particle->Age));
                    particle->Colour.Y = (this.InitialColour.Y + ((this.UltimateColour.Y - this.InitialColour.Y) * particle->Age));
                    particle->Colour.Z = (this.InitialColour.Z + ((this.UltimateColour.Z - this.InitialColour.Z) * particle->Age));
                }
                else
                {
                    particle->Colour.X = previousParticle->Colour.X;
                    particle->Colour.Y = previousParticle->Colour.Y;
                    particle->Colour.Z = previousParticle->Colour.Z;
                }

                previousParticle++;
                particle++;
            }
        }

    void Start()
    {
        // Calculate the number of warp needed to handle all the particles
        if (particleCount <= 0)
            particleCount = 1;
        mWarpCount = Mathf.CeilToInt((float)particleCount / WARP_SIZE);

        // Initialize the Particle at the start
        Particle[] particleArray = new Particle[particleCount];
        for (int i = 0; i < particleCount; ++i)
        {
            particleArray[i].position.x = Random.value * 2 - 1.0f;
            particleArray[i].position.y = Random.value * 2 - 1.0f;
            particleArray[i].position.z = 0;

            particleArray[i].velocity.x = 0;
            particleArray[i].velocity.y = 0;
            particleArray[i].velocity.z = 0;
        }

        // Create the ComputeBuffer holding the Particles
        particleBuffer = new ComputeBuffer(particleCount, SIZE_PARTICLE);
        particleBuffer.SetData(particleArray);

        // Find the id of the kernel
        mComputeShaderKernelID = computeShader.FindKernel("CSMain");

        // Bind the ComputeBuffer to the shader and the compute shader
        computeShader.SetBuffer(mComputeShaderKernelID, "particleBuffer", particleBuffer);
        material.SetBuffer("particleBuffer", particleBuffer);
    }

        /// <summary>
        /// Processes the particles.
        /// </summary>
        /// <param name="dt">Elapsed time in whole and fractional seconds.</param>
        /// <param name="particle">A pointer to an array of particles.</param>
        /// <param name="count">The number of particles which need to be processed.</param>
        protected internal override unsafe void Process(float dt, Particle* particle, int count)
        {
            for (int i = 0; i < count; i++)
            {
                Particle* previousParticle = particle - 1;

                if (particle->Momentum == previousParticle->Momentum)
                {
                    particle->Rotation = previousParticle->Rotation;

                    continue;
                }

                float rads = Calculator.Atan2(particle->Momentum.Y, particle->Momentum.X);

                particle->Rotation = (rads + this.RotationOffset);

                if (particle->Rotation > Calculator.Pi)
                    particle->Rotation -= Calculator.TwoPi;

                else if (particle->Rotation < -Calculator.Pi)
                    particle->Rotation += Calculator.TwoPi;

                particle++;
            }
        }

		public ParticleSpring(Particle particle, Particle other, float springConstant, float restLength) 
			: base(particle)
		{
			_other = other;
			_springConstant = springConstant;
			_restLength = restLength;
		}

        public ParticleSystem(int maxParticles)
        {
            MAX_PARTICLES = maxParticles;

            random = new Random();
            _textures = new Texture2D[MAX_TEXTURES];
            _particles = new Particle[MAX_PARTICLES];

            for (int i = 0; i < MAX_PARTICLES; ++i)
            {
                _particles[i] = new Particle(null, _ttl, 0, 0, 0, 0, 0, 0);
                _particles[i]._exists = false;
            }

            _spawnBox.X = 0;
            _spawnBox.Y = 0;
            _minRotSpeed = 0;
            _maxRotSpeed = 0;
            _minRotInit = 0;
            _maxRotInit = 0;
            Angle = 0;
            _spawnCone = (float)Math.PI * 2f;
            _minSpeed = 10;
            _maxSpeed = 10;

            _alphaDecrement = 0.2f;
            _decrementTick = 5;

            _alphaIncrement = 0.2f;
            _incrementTick = 5;

            _isOn = true;
        }

		public ParticleAnchoredSpring(Particle particle, Point3D anchor, float springConstant, float restLength)
			: base(particle)
		{
			Anchor = anchor;
			SpringConstant = springConstant;
			RestLength = restLength;
		}

        public override void UpdateParticle(GameTime time, Particle spawn)
        {
            _momentum.X = (float)Math.Cos(spawn.Orientation) * spawn.Speed;
            _momentum.Y = (float)Math.Sin(spawn.Orientation) * spawn.Speed;

            if (spawn.Position.X < (float)_rect.X)
            {
                spawn.Position.X = (float)_rect.X;
                _momentum.X *= -1f; _momentum.X *= _bounce;
            }
            else if (spawn.Position.X > (float)_rect.Width)
            {
                spawn.Position.X = (float)_rect.Width;
                _momentum.X *= -1f; _momentum.X *= _bounce;
            }

            if (spawn.Position.Y < (float)_rect.Y)
            {
                spawn.Position.Y = (float)_rect.Y;
                _momentum.Y *= -1f; _momentum.Y *= _bounce;
            }
            else if (spawn.Position.Y > (float)_rect.Height)
            {
                spawn.Position.Y = (float)_rect.Height;
                _momentum.Y *= -1f; _momentum.Y *= _bounce;
            }

            spawn.Orientation = (float)Math.Atan2(_momentum.Y, _momentum.X);
            spawn.Speed = _momentum.Length();
        }

		public void Construction_CanCreateAParticleWithAnInitialPositionAndVelocity_AndItsPositionAndVelocityAreInitialised()
		{
			var particle = new Particle(TestPosition, TestVelocity);

			Assert.IsTrue(particle.Position.Equals(TestPosition));
			Assert.IsTrue(particle.Velocity.Equals(TestVelocity));
		}

		public void Construction_CanCreateAParticleWithAnInitialPosition_AndItsPositionIsInitialised()
		{
			var particle = new Particle(TestPosition);

			Assert.IsTrue(particle.Position.Equals(TestPosition));
			Assert.IsTrue(particle.Velocity.Equals(Vector3.ZeroVector));
		}

        protected internal unsafe override void Update(float elapsedSeconds, ref Particle particle, int count)
        {
            _totalSeconds += elapsedSeconds;

            fixed (float* agePtr = particle.Age)
            fixed (float* inceptionPtr = particle.Inception)
            {
                var ageDataPtr = agePtr;
                var inceptionDataPtr = inceptionPtr;
                var term = _term;
                var totalSeconds = _totalSeconds;

                for (var j = 0; j < count; j++)
                {
                    var age = (totalSeconds - *(inceptionDataPtr + j)) / term;

                    // TODO: There is a fairly systemic bug in the emitter code right now that means that the inception time
                    // of a particle can be later than the total elapsed time in here. It happens because the modifiers are
                    // not necessarily updated every frame, while the emitter is.
                    if (age < 0)
                        age = 0;
                    if (age > 1)
                        age = 1;

                    *(ageDataPtr + j) = age;
                }
            }
        }

        public AddParticleDlg(Particle copy)
        {
            InitializeComponent();

            /* Add relevant info to fields.. */
            txtName.Text = copy.Name;
            txtAlphaStart.Text = copy.StartAlpha.ToString();
            txtEndAlpha.Text = copy.EndAlpha.ToString();

            txtRot.Text = copy.Rotation.ToString();
            txtDeltaRot.Text = copy.RotationSpeed.ToString();
            txtScale.Text = copy.ScaleStart.ToString();
            txtScaleEnd.Text = copy.ScaleEnd.ToString();

            txtMinLife.Text = copy.MinLife.ToString();
            txtMaxLife.Text = copy.MaxLife.ToString();

            txtTexturePath.Text = copy.TextureName;

            System.Drawing.Color color;
            color = System.Drawing.Color.FromArgb(copy.StartColor.R, copy.StartColor.G, copy.StartColor.B);
            pctStartColor.BackColor = color;
            pctEndColor.BackColor = System.Drawing.Color.FromArgb(copy.EndColor.R, copy.EndColor.G, copy.EndColor.B);
            StartColor = copy.StartColor;
            EndColor = copy.EndColor;

            EditedParticle = true;
        }

        /// <summary>
        /// Processes the particles.
        /// </summary>
        /// <param name="dt">Elapsed time in whole and fractional seconds.</param>
        /// <param name="particleArray">A pointer to an array of particles.</param>
        /// <param name="count">The number of particles which need to be processed.</param>
        protected internal override unsafe void Process(float dt, Particle* particleArray, int count)
        {
            Vector2 distance;

            float strengthDelta = this.Strength * dt;

            float deltaForceX = this.Force.X * strengthDelta;
            float deltaForceY = this.Force.Y * strengthDelta;

            for (int i = 0; i < count; i++)
            {
                Particle* particle = (particleArray + i);

                // Calculate the distance between the Particle and the center of the force...
                distance.X = this.Position.X - particle->Position.X;
                distance.Y = this.Position.Y - particle->Position.Y;

                float squareDistance = ((distance.X * distance.X) + (distance.Y * distance.Y));

                // Check to see if the Particle is within range of the force...
                if (squareDistance < this.SquareRadius)
                {
                    // Adjust the force vector based on the strength of the force and the time delta...
                    particle->Velocity.X += deltaForceX;
                    particle->Velocity.Y += deltaForceY;
                }
            }
        }

 /// <summary>
 /// Modifies a single Particle.
 /// </summary>
 /// <param name="time">Game timing information.</param>
 /// <param name="particle">Particle to modify.</param>
 public override void ProcessActiveParticle(GameTime time, Particle particle)
 {
     //particle.Momentum += (_gravity * (float)time.ElapsedGameTime.TotalSeconds);
     Vector2 dtGrav;
     Vector2.Multiply(ref _gravity, (float)time.ElapsedGameTime.TotalSeconds, out dtGrav);
     Vector2.Add(ref particle.Momentum, ref dtGrav, out particle.Momentum);
 }

        public override void Update(Particle part)
        {
            //phaseTarget = phaseTarget % 1f;
            phase += phaseSpeed * Global.Speed * mult;
            phase = MathHelper.Clamp(phase, 0, 1);
            double pow = 1.5;

            float value = phase;

            value = (float)(Math.Pow(value, pow));

            value = 1 - (float)Math.Pow(1 - value, pow);
            if (phase >= 1)
            {
                mult = -1;
            }
            else if (phase <= 0)
            {
                mult = 1;
            }
            
            Vector2 val = MyMath.Between(startScale, endScale, value);
            part.Scale = val;
            base.Update(part);
        }

 public XnaRect ResolveUVBounds(string uvBoundsName, Particle.ParticleSystem system)
 {
     uvBoundsName = uvBoundsName ?? "{Whole}";
     if (uvBoundsName == "{Whole}")
     {
         return system != null && system.TextureObject != null
                ? new XnaRect(0, 0, system.TextureObject.Width, system.TextureObject.Height)
                : XnaRect.Empty;
     }
     else if (uvBoundsName.StartsWith("{") && uvBoundsName.EndsWith("}"))
     {
         string[][] tokens = uvBoundsName.Substring(1, uvBoundsName.Length - 2)
                             .Split(new char[] { ' ' }, StringSplitOptions.RemoveEmptyEntries)
                             .Select(t => t.Split(new char[] { ':' }, StringSplitOptions.RemoveEmptyEntries)).ToArray();
         int x, y, w, h;
         if (tokens.Length != 4 || tokens.Any(t => t.Length != 2)
             || tokens[0][0] != "x" || !int.TryParse(tokens[0][1], out x)
             || tokens[1][0] != "y" || !int.TryParse(tokens[1][1], out y)
             || (tokens[2][0] != "width" && tokens[2][0] != "w") || !int.TryParse(tokens[2][1], out w)
             || (tokens[3][0] != "height" && tokens[3][0] != "h") || !int.TryParse(tokens[3][1], out h))
         {
             throw new FormatException(String.Format("Cannot convert '{0}' to a rectangle.", uvBoundsName));
         }
         return new XnaRect(x, y, w, h);
     }
     else
     {
         return XnaRect.Empty;
     }
 }