C# Winform 水波纹效果

//添加自定义控件
using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Drawing.Imaging;

namespace My.UControl
{
    public partial class WaveControl : Panel// Control
    {
        public WaveControl()
        {
            InitializeComponent();
            this.Effect.Tick += new EventHandler(Effect_Tick);
            this.Paint += new PaintEventHandler(WavesControl_Paint);
            this.MouseMove += new MouseEventHandler(WavesControl_MouseMove);

            this.Effect.Enabled = true;
            this.Effect.Interval = ;
            SetStyle(ControlStyles.UserPaint, true);
            SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            SetStyle(ControlStyles.DoubleBuffer, true);
            this.BackColor = Color.White;
        }
        public WaveControl(Bitmap bmp)
            : this()
        {
            this.bmpImage = bmp;
        }
        #region Fields or Properties
        private int scale = ;
        /// <summary>
        /// The scale of the wave matrix compared to the size of the image.
        /// Use it for large images to reduce processor load.
        ///
        /// 0 : wave resolution is the same than image resolution
        /// 1 : wave resolution is half the image resolution
        /// ...and so on
        /// </summary>
        public int Scale
        {
            get { return scale; }
            set { scale = value; }
        }
        private Bitmap bmpImage;
        /// <summary>
        /// Background image
        /// </summary>
        public Bitmap BmpImage
        {
            get { return bmpImage; }
            set
            {
                if (value == null)
                    return;
                bmpImage = value;
                bmpHeight = bmpImage.Height;
                bmpWidth = bmpImage.Width;
                waveHeight = bmpHeight >> scale;
                waveWidth = bmpWidth >> scale;

                waves = new short[waveWidth, waveHeight, ];

                bmpBytes = new byte[bmpWidth * bmpHeight * ];

                bmpBitmapData = bmpImage.LockBits(new Rectangle(, , bmpWidth, bmpHeight),
                    System.Drawing.Imaging.ImageLockMode.ReadWrite,
                    System.Drawing.Imaging.PixelFormat.Format32bppArgb);
                Marshal.Copy(bmpBitmapData.Scan0, bmpBytes, , bmpWidth * bmpHeight * );
            }
        }

        private int bmpHeight { get; set; }
        private int bmpWidth { get; set; }

        private int waveWidth { get; set; }
        private int waveHeight { get; set; }

        private short[, ,] waves { get; set; }
        private byte[] bmpBytes { get; set; }

        private System.Drawing.Imaging.BitmapData bmpBitmapData { get; set; }
        private bool IsWaves = false;

        private int activedBuf = ;
        #endregion

        void WavesControl_MouseMove(object sender, MouseEventArgs e)
        {
            int realX = (int)((e.X / (double)this.ClientRectangle.Width) * waveWidth);
            int realY = (int)((e.Y / (double)this.ClientRectangle.Height) * waveHeight);
            this.PutDrop(realX, realY, );
        }
        /// <summary>
        /// This function is used to start a wave by simulating a round drop
        /// </summary>
        /// <param name="realX">x position of the drop</param>
        /// <param name="realY">y position of the drop</param>
        /// <param name="height">Height position of the drop</param>
        private void PutDrop(int realX, int realY, int height)
        {
            this.IsWaves = true;
            int radius =;
            double dist;
            for (int i = -radius; i <= radius; i++)
            {
                for (int j = -radius; j <= radius; j++)
                {
                    if (((realX + i >= ) && (realX + i < waveWidth - )) && ((realY + j >= ) && (realY + j < waveHeight - )))
                    {
                        dist = Math.Sqrt(i * i + j * j);
                        if (dist < radius)
                            waves[realX + i, realY + j, activedBuf] = (short)(Math.Cos(dist * Math.PI / radius) * height);
                    }
                }
            }
        }
        /// <summary>
        /// Paint handler
        /// Calculates the final effect-image out of
        /// </summary>
        /// <param name="sender"></param>
        /// <param name="e"></param>
        void WavesControl_Paint(object sender, PaintEventArgs e)
        {
            if (bmpImage == null) return;
            using (Bitmap tmpBmp = bmpImage.Clone() as Bitmap)
            {

                int xOffset, yOffset;
                byte alpha;
                if (IsWaves)
                {
                    BitmapData tmpBitmapData = tmpBmp.LockBits(new Rectangle(, , bmpWidth, bmpHeight),
                        ImageLockMode.ReadWrite, PixelFormat.Format32bppArgb);
                    byte[] tmpBytes = new byte[bmpWidth * bmpHeight * ];
                    Marshal.Copy(tmpBitmapData.Scan0, tmpBytes, , bmpWidth * bmpHeight * );
                    for (int x = ; x < bmpWidth - ; x++)
                    {
                        for (int y = ; y < bmpHeight - ; y++)
                        {
                            int waveX = (int)x >> scale;
                            int waveY = (int)y >> scale;
                            ///check bounds
                            waveX = waveX <=  ?  : waveX;
                            waveY = waveY <=  ?  : waveY;
                            waveX = waveX >= waveWidth -  ? waveWidth -  : waveX;
                            waveY = waveY >= waveHeight -  ? waveHeight -  : waveY;
                            ///this gives us the effect of water breaking the light
                            xOffset = (waves[waveX - , waveY, activedBuf] - waves[waveX + , waveY, activedBuf]) >> ;
                            yOffset = (waves[waveX, waveY - , activedBuf] - waves[waveX, waveY + , activedBuf]) >> ;

                            if ((xOffset != ) || (yOffset != ))
                            {
                                ///check bounds
                                if (x + xOffset >= bmpWidth - )
                                    xOffset = bmpWidth - x - ;
                                if (y + yOffset >= bmpHeight - )
                                    yOffset = bmpHeight - y - ;
                                if (x + xOffset < ) xOffset = -x;
                                if (y + yOffset < ) yOffset = -y;
                                ///generate alpha
                                alpha = (byte)( - xOffset);
                                if (alpha < ) alpha = ;
                                if (alpha > ) alpha = ;
                                ///set colors
                                tmpBytes[ * (x + y * bmpWidth)] = bmpBytes[ * (x + xOffset + (y + yOffset) * bmpWidth)];
                                tmpBytes[ * (x + y * bmpWidth) + ] = bmpBytes[ * (x + xOffset + (y + yOffset) * bmpWidth) + ];
                                tmpBytes[ * (x + y * bmpWidth) + ] = bmpBytes[ * (x + xOffset + (y + yOffset) * bmpWidth) + ];
                                tmpBytes[ * (x + y * bmpWidth) + ] = alpha;
                            }
                        }
                    }
                    ///copy data back
                    Marshal.Copy(tmpBytes, , tmpBitmapData.Scan0, bmpWidth * bmpHeight * );
                    tmpBmp.UnlockBits(tmpBitmapData);
                }
                e.Graphics.DrawImage(tmpBmp, , , this.ClientRectangle.Width, this.ClientRectangle.Height);
            }
        }

        /// <summary>
        /// This is the method that actually does move the waves around and simulates the
        /// behaviour of water.
        /// </summary>
        private void Waves()
        {
            int newBuf = this.activedBuf ==  ?  : ;
            bool wavesFound = false;
            for (int x = ; x < waveWidth - ; x++)
            {
                for (int y = ; y < waveHeight - ; y++)
                {
                    waves[x, y, newBuf] = (short)(((
                        waves[x - , y - , activedBuf] +
                        waves[x - , y, activedBuf] +
                        waves[x - , y + , activedBuf] +
                        waves[x, y - , activedBuf] +
                        waves[x, y + , activedBuf] +
                        waves[x + , y - , activedBuf] +
                        waves[x + , y, activedBuf] +
                        waves[x + , y + , activedBuf]) >> ) - waves[x, y, newBuf]);
                    ///damping
                    if (waves[x, y, newBuf] != )
                    {
                        waves[x, y, newBuf] -= (short)(waves[x, y, newBuf] >> );
                        wavesFound = true;
                    }
                }
            }
            IsWaves = wavesFound;
            activedBuf = newBuf;
        }

        void Effect_Tick(object sender, EventArgs e)
        {
            if (IsWaves)
            {
                Invalidate();
                Waves();
            }
        }
        //protected override void OnPaint(PaintEventArgs pe)
        //{
        //    base.OnPaint(pe);
        //}
    }
}

参考资料[含程序，源码，算法]

http://pan.baidu.com/s/1dD3s2xN

http://www.cnblogs.com/worldreason/archive/2008/05/09/1189648.html

http://www.codeproject.com/Articles/1073/Interactive-water-effect