粒子算法：烟花、喷泉、爆炸

参考：https://www.codeproject.com/articles/10003/a-basic-particles-system

如果需要实现一个喷泉粒子系统：

1）需要先定义每个粒子元素Particle类：它应包含有运动方向和速度，初始化位置（及运动一个生命值后的位置），生命值，粒子渲染的颜色，及一个生命值增加一个单位后对应的粒子属性变化。

Vector.cs--存储粒子位置信息

/// <summary>
    /// 向量
    /// </summary>
    public class Vector
    {
        #region Private members
        /// <summary>
        /// X Coorination of the vector
        /// </summary>
        private float m_Xcoord;
        /// <summary>
        /// Y Coorination of the vector
        /// </summary>
        private float m_Ycoord;
        /// <summary>
        /// Z Coorination of the vector
        /// </summary>
        private float m_Zcoord;
        #endregion

        #region Constructors
        /// <summary>
        /// Default constructor. Initiate vector at the (0,0,0) location
        /// </summary>
        public Vector()
        { }

        /// <summary>
        /// Initiate vector with given parameters
        /// </summary>
        /// <param name="inX">X coordination of vector</param>
        /// <param name="inY">Y coordination of vector</param>
        /// <param name="inZ">Z coordination of vector</param>
        public Vector(float inX, float inY, float inZ)
        {
            m_Xcoord = inX;
            m_Ycoord = inY;
            m_Zcoord = inZ;
        }

        /// <summary>
        /// Initiate vector with given parameters
        /// </summary>
        /// <param name="coordination">Vector's coordinations as an array</param>
        public Vector(float[] coordination)
        {
            m_Xcoord = coordination[0];
            m_Ycoord = coordination[1];
            m_Zcoord = coordination[2];
        }

        /// <summary>
        /// Initiate vector with same values as given Vector
        /// </summary>
        /// <param name="v">Vector to copy coordinations</param>
        public Vector(Vector vector)
        {
            m_Xcoord = vector.X;
            m_Ycoord = vector.Y;
            m_Zcoord = vector.Z;
        }
        #endregion

        #region Public properties
        /// <summary>
        /// X Coordination of vector
        /// </summary>
        public float X
        {
            get { return m_Xcoord; }
            set { m_Xcoord = value; }
        }
        /// <summary>
        /// Y Coordination of vector
        /// </summary>
        public float Y
        {
            get { return m_Ycoord; }
            set { m_Ycoord = value; }
        }
        /// <summary>
        /// Z Coordination of vector
        /// </summary>
        public float Z
        {
            get { return m_Zcoord; }
            set { m_Zcoord = value; }
        }
        #endregion

        #region Methods

        /// <summary>
        /// Add 2 vectors and create a new one.
        /// </summary>
        /// <param name="vector1">First vector</param>
        /// <param name="vector2">Second vector</param>
        /// <returns>New vector that is the sum of the 2 vectors</returns>
        public static Vector Add(Vector vector1, Vector vector2)
        {
            if (((Object)vector1 == null) || ((Object)vector2 == null))
                return null;
            return new Vector(vector1.X + vector2.X, vector1.Y + vector2.Y, vector1.Z + vector2.Z);
        }
        /// <summary>
        /// Substract 2 vectors and create a new one.
        /// </summary>
        /// <param name="vector1">First vector</param>
        /// <param name="vector2">Second vector</param>
        /// <returns>New vector that is the difference of the 2 vectors</returns>
        public static Vector Subtract(Vector vector1, Vector vector2)
        {
            if (((Object)vector1 == null) || ((Object)vector2 == null))
                return null;
            return new Vector(vector1.X - vector2.X, vector1.Y - vector2.Y, vector1.Z - vector2.Z);
        }
        /// <summary>
        /// Return a new vector with negative values.
        /// </summary>
        /// <param name="v">Original vector</param>
        /// <returns>New vector that is the inversion of the original vector</returns>
        public static Vector Neg(Vector vector)
        {
            if ((Object)vector == null)
                return null;
            return new Vector(-vector.X, -vector.Y, -vector.Z);
        }
        /// <summary>
        /// Multiply a vector with a scalar
        /// </summary>
        /// <param name="vector">Vector to be multiplied</param>
        /// <param name="val">Scalar to multiply vector</param>
        /// <returns>New vector that is the multiplication of the vector with the scalar</returns>
        public static Vector Multiply(Vector vector, float val)
        {
            if ((Object)vector == null)
                return null;
            return new Vector(vector.X * val, vector.Y * val, vector.Z * val);
        }
        #endregion

        #region Operators

        /// <summary>
        /// Check equality of two vectors
        /// </summary>
        /// <param name="vector1">First vector</param>
        /// <param name="vector2">Second vector</param>
        /// <returns>True - if he 2 vectors are equal.
        /// False - otherwise</returns>
        public static bool operator ==(Vector vector1, Vector vector2)
        {
            if (((Object)vector1 == null) || ((Object)vector2 == null))
                return false;
            return ((vector1.X.Equals(vector2.X))
                && (vector1.Y.Equals(vector2.Y))
                && (vector1.Z.Equals(vector2.Z)));
        }

        /// <summary>
        /// Check inequality of two vectors
        /// </summary>
        /// <param name="vector1">First vector</param>
        /// <param name="vector2">Second vector</param>
        /// <returns>True - if he 2 vectors are not equal.
        /// False - otherwise</returns>
        public static bool operator !=(Vector vector1, Vector vector2)
        {
            if (((Object)vector1 == null) || ((Object)vector2 == null))
                return false;
            return ((!vector1.X.Equals(vector2.X))
                && (!vector1.Y.Equals(vector2.Y))
                && (!vector1.Z.Equals(vector2.Z)));
        }

        /// <summary>
        /// Calculate the sum of 2 vectors.
        /// </summary>
        /// <param name="vector1">First vector</param>
        /// <param name="vector2">Second vector</param>
        /// <returns>New vector that is the sum of the 2 vectors</returns>
        public static Vector operator +(Vector vector1, Vector vector2)
        {
            if (((Object)vector1 == null) || ((Object)vector2 == null))
                return null;
            return Vector.Add(vector1, vector2);
        }
        /// <summary>
        /// Calculate the substraction of 2 vectors
        /// </summary>
        /// <param name="vector1">First vector</param>
        /// <param name="vector2">Second vector</param>
        /// <returns>New vector that is the difference of the 2 vectors</returns>
        public static Vector operator -(Vector vector1, Vector vector2)
        {
            if (((Object)vector1 == null) || ((Object)vector2 == null))
                return null;
            return Vector.Subtract(vector1, vector2);
        }
        /// <summary>
        /// Calculate the negative (inverted) vector
        /// </summary>
        /// <param name="v">Original vector</param>
        /// <returns>New vector that is the invertion of the original vector</returns>
        public static Vector operator -(Vector vector)
        {
            if ((Object)vector == null)
                return null;
            return Vector.Neg(vector);
        }
        /// <summary>
        /// Calculate the multiplication of a vector with a scalar
        /// </summary>
        /// <param name="vector">Vector to be multiplied</param>
        /// <param name="val">Scalar to multiply vector</param>
        /// <returns>New vector that is the multiplication of the vector and the scalar</returns>
        public static Vector operator *(Vector vector, float val)
        {
            if ((Object)vector == null)
                return null;
            return Vector.Multiply(vector, val);
        }
        /// <summary>
        /// Calculate the multiplication of a vector with a scalar
        /// </summary>
        /// <param name="val">Scalar to multiply vecto</param>
        /// <param name="vector">Vector to be multiplied</param>
        /// <returns>New vector that is the multiplication of the vector and the scalar</returns>
        public static Vector operator *(float val, Vector vector)
        {
            if ((Object)vector == null)
                return null;
            return Vector.Multiply(vector, val);
        }

        #endregion

        #region Constants
        /// <summary>
        /// Standard (0,0,0) vector
        /// </summary>
        public static Vector Zero
        {
            get { return new Vector(0.0f, 0.0f, 0.0f); }
        }
        /// <summary>
        /// Standard (1,0,0) vector
        /// </summary>
        public static Vector XAxis
        {
            get { return new Vector(1.0f, 0.0f, 0.0f); }
        }
        /// <summary>
        /// Standard (0,1,0) vector
        /// </summary>
        public static Vector YAxis
        {
            get { return new Vector(0.0f, 1.0f, 0.0f); }
        }
        /// <summary>
        /// Standard (0,0,1) vector
        /// </summary>
        public static Vector ZAxis
        {
            get { return new Vector(0.0f, 0.0f, 1.0f); }
        }
        #endregion

        #region Overides
        public override bool Equals(object obj)
        {
            Vector vector = obj as Vector;
            if ((Object)vector != null)
                return (m_Xcoord.Equals(vector.X))
                    && (m_Ycoord.Equals(vector.Y))
                    && (m_Zcoord.Equals(vector.Z));
            return false;
        }

        public override string ToString()
        {
            return string.Format(CultureInfo.InvariantCulture, "({0}, {1}, {2})", m_Xcoord, m_Ycoord, m_Zcoord);
        }
        public override int GetHashCode()
        {
            return m_Xcoord.GetHashCode() ^ m_Ycoord.GetHashCode() ^ m_Zcoord.GetHashCode();
        }
        #endregion
    }

Particle.cs---粒子属性类

    /// <summary>
    /// 粒子
    /// </summary>
    public class Particle
    {
        /// <summary>
        /// 当前粒子所在的位置信息
        /// </summary>
        private Vector position;
        /// <summary>
        /// 当前粒子运行的方向和速度
        /// </summary>
        private Vector velocity;
        /// <summary>
        /// 当前离子的生命值
        /// </summary>
        private int life;
        /// <summary>
        /// 当前离子渲染的颜色
        /// </summary>
        private Color color;

        public Particle() : this(Vector.Zero, Vector.Zero, Color.Black, 0) { }

        public Particle(Vector position, Vector velocity, Color color, int life)
        {
            this.position = position;
            this.velocity = velocity;
            this.color = color;
            if (life > 0)
            {
                this.life = life;
            }
        }

        public virtual void Update()
        {
            // Update particle's movement according to environment
            this.velocity = this.velocity - NativeEnvironment.GetInstance().Gravity
                                    + NativeEnvironment.GetInstance().Wind;
            // Update particle's position according to movement
            this.position = this.position + this.velocity;
            // Update particle's age
            this.life++;
        }

        /// <summary>
        /// 获取 当前粒子的位置信息
        /// </summary>
        public Vector Position
        {
            get { return position; }
        }

        /// <summary>
        /// 获取 当前粒子的运行方向和速度
        /// </summary>
        public Vector Velocity
        {
            get { return velocity; }
        }

        /// <summary>
        /// 获取 当前粒子的生命值
        /// </summary>
        public int Life
        {
            get { return life; }
        }

        /// <summary>
        /// 获取 当前离子渲染的颜色
        /// </summary>
        public Color Color
        {
            get { return color; }
        }
    }

2）需要考虑自然环境因素NativeEnvironment，并设定以下两个属性：重力、风速。

NativeEnvironment.cs--自然环境因素

    /// <summary>
    /// 自然环境条件信息
    /// </summary>
    public class NativeEnvironment
    {
        /// <summary>
        /// 重力
        /// </summary>
        private Vector gravity = Vector.Zero;
        /// <summary>
        /// 风速
        /// </summary>
        private Vector wind = Vector.Zero;

        /// <summary>
        /// 单例实体对象
        /// </summary>
        private static NativeEnvironment instance = null;

        private NativeEnvironment() { }

        /// <summary>
        /// 获取 自然条件信息对象实例
        /// </summary>
        public static NativeEnvironment GetInstance()
        {
            if (instance == null)
            {
                instance = new NativeEnvironment();
            }
            return instance;
        }

        /// <summary>
        /// 获取或设置 重力
        /// </summary>
        public Vector Gravity
        {
            get { return gravity; }
            set { gravity = value; }
        }

        /// <summary>
        /// 获取或设置 风速
        /// </summary>
        public Vector Wind
        {
            get { return wind; }
            set { wind = value; }
        }
    }

3）定义一个喷泉粒子系统.类,它应该包含以下属性：存储当前粒子系统中所有粒子的集合容器、初始化系统时所有粒子的起始位置、最大生命值、粒子渲染的颜色、最大粒子个数，还应该包含以下几个方法：新增粒子，一个生命值单位变化后批量修改所有粒子的方法。

Particles.cs --- 粒子系统抽象类

    /// <summary>
    /// 粒子系统
    /// </summary>
    public abstract class Particles
    {
        /// <summary>
        /// 当前粒子系统内所有的粒子元素存储集合
        /// </summary>
        protected List<Particle> particles = new List<Particle>();
        /// <summary>
        /// 粒子系统的中心位置
        /// </summary>
        protected Vector position;
        /// <summary>
        /// 默认粒子的最大生命值
        /// </summary>
        protected int maxLife = 150;
        /// <summary>
        /// 默认粒子的渲染颜色
        /// </summary>
        protected Color color;

        /// <summary>
        /// 生成（新增）粒子到粒子系统中
        /// </summary>
        /// <returns></returns>
        protected abstract Particle Create();

        /// <summary>
        /// 修改粒子系统中所有粒子的状态位置等信息
        /// </summary>
        /// <returns></returns>
        public abstract bool Update();

        public virtual void Draw(Graphics g)
        {
            Pen pen;
            int intense;
            Particle part;

            for (int i = 0; i < this.particles.Count; i++)
            {
                part = this[i];
                // Calculate particle intensity
                intense = (int)((float)part.Life / this.MaxLife);
                // Generate pen for the particle
                pen = new Pen(Color.FromArgb(intense * this.color.R,
                                             intense * this.color.G,
                                             intense * this.color.B));
                // Draw particle
                g.DrawEllipse(pen, part.Position.X, part.Position.Y,
                    Math.Max(1, 4 * part.Life / this.MaxLife),
                    Math.Max(1, 4 * part.Life / this.MaxLife));
                pen.Dispose();
            }
        }

        /// <summary>
        /// 根据ｉｎｄｅｘ访问系统中某个粒子对象
        /// </summary>
        /// <param name="index"></param>
        /// <returns></returns>
        public Particle this[int index]
        {
            get { return (Particle)this.particles[index]; }
        }

        /// <summary>
        /// 返回系统中所有粒子个数
        /// </summary>
        public int Count
        {
            get { return this.particles.Count; }
        }

        /// <summary>
        /// 返回系统中粒子最大生命值
        /// </summary>
        public int MaxLife
        {
            get { return this.maxLife; }
        }

    }

FountainParticlesSystem.cs---喷泉粒子系统定义

    public class FountainParticlesSystem : Particles
    {
        private static readonly int DEFAULT_NUM_PARTICLES = 500;

        // Random numbers generator
        private Random m_rand = new Random();

        /// <summary>
        /// Default constructor
        /// </summary>
        public FountainParticlesSystem()
            : this(Vector.Zero, Color.Black)
        { }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="pos">Starting position of system</param>
        public FountainParticlesSystem(Vector pos)
            : this(pos, Color.Black)
        { }

        /// <summary>
        /// Constructor
        /// </summary>
        /// <param name="pos">Starting position of system</param>
        /// <param name="col">Color of the particles in the system</param>
        public FountainParticlesSystem(Vector pos, Color col)
        {
            // Set system's position at given position
            this.position = pos;
            // Set system color to given color
            this.color = col;
            // Create ONLY 5 particles
            for (int i = 0; i < 5; i++)
            {
                // Create particle, and add it to the list of particles
                this.particles.Add(Create());
            }
        }

        /// <summary>
        /// Generate a single particle in the system.
        /// This function is used when particles are first created, and when they are regenerated
        /// </summary>
        /// <returns>New particle</returns>
        protected override Particle Create()
        {
            // 生成随机方向和速度的新粒子
            // 在一个喷泉，粒子移动几乎直
            float rndX = 2.0f * ((float)m_rand.NextDouble() - 0.4f);
            float rndY = -1.0f - 1 * (float)m_rand.NextDouble();
            float rndZ = 1.5f * ((float)m_rand.NextDouble() - 0.4f);

            // Create new particle at system's starting position
            Particle part = new Particle(this.position,
                // With generated direction and speed
                new Vector(rndX, rndY, rndZ), this.color,
                // And a random starting life
                m_rand.Next(50));

            // Return newly created particle
            return part;
        }

        /// <summary>
        /// Update all the particles in the system
        /// </summary>
        /// <returns>False - if there are no more particles in system
        /// True - otherwise</returns>
        public override bool Update()
        {
            Particle part;
            int count = this.Count;

            // For each particle
            for (int i = 0; i < count; i++)
            {
                // Get particle from list
                part = (Particle)this.particles[i];
                // Update particle and check age
                part.Update();

                /*part.Life > this.maxLife && */
                if (part.Position.Y >= this.position.Y)
                {
                    // Remove old particles
                    this.particles.RemoveAt(i);
                    // Update counter and index
                    i--;
                    count = this.particles.Count;
                }
            }

            // If there aren't enough particles
            if (this.particles.Count < DEFAULT_NUM_PARTICLES)
            {
                // Add another particles
                this.particles.Add(Create());
            }

            // Always return true, since system is regenerating
            return true;
        }
    }

4）设定粒子一个生命值增长需要耗费的时间、一个用来渲染粒子系统当前生命时刻的画布。

    public partial class Main : Form
    {
        private static readonly Vector MIDDLE_OF_VIEW = new Vector(250, 250, 250);
        private Particles ps = null;

        public Main()
        {
            InitializeComponent();

            this.timer.Interval = 20;//ms

            NativeEnvironment.GetInstance().Gravity = new Vector(0.0f, -0.02f, 0.0f);
            NativeEnvironment.GetInstance().Wind = new Vector(0.0f, 0.0f, 0.0f);

            if (NativeEnvironment.GetInstance().Gravity == NativeEnvironment.GetInstance().Wind)
                return;
        }

        private void btnStart_Click(object sender, EventArgs e)
        {
            ps = new FountainParticlesSystem(MIDDLE_OF_VIEW, Color.FromArgb(0, 0, 255));
            this.timer.Enabled = true;
        }

        private void timer_Tick(object sender, System.EventArgs e)
        {
            if (!ps.Update())
            {
                picDisplay.Refresh();
                ps = null;
                this.timer.Enabled = false;
            }
            else
            {
                picDisplay.Refresh();
            }
        }

        private void picDisplay_Paint(object sender, System.Windows.Forms.PaintEventArgs e)
        {
            if (ps == null)
                return;
            ps.Draw(e.Graphics);
        }
    }

效果：

代码下载位置：http://pan.baidu.com/s/1gfaODF1