c# 图片带水纹波动

using System;
using System.Collections.Generic;
using System.ComponentModel;
using System.Data;
using System.Drawing;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
using System.Windows.Forms;
using System.Runtime.InteropServices;
using System.Drawing.Imaging;

namespace myControl
{
    public struct DropData
    {
        public int x;
        public int y;
        public int radius;
        public int height;
    }

    public partial class Form1 : Form
    {

        public Form1()
        {
            InitializeComponent();

            this.SetStyle(ControlStyles.AllPaintingInWmPaint, true);
            this.SetStyle(ControlStyles.DoubleBuffer, true);
            this.SetStyle(ControlStyles.ResizeRedraw, true);
            this.SetStyle(ControlStyles.Selectable, true);
            this.SetStyle(ControlStyles.SupportsTransparentBackColor, true);
            this.SetStyle(ControlStyles.UserPaint, true);

            Timer myWaterTimer = new Timer();
            myWaterTimer.Interval = ;
            myWaterTimer.Tick += new EventHandler(myWaterTimer_Tick);
            Timer myDropsTimer = new Timer();
            myDropsTimer.Interval = ;
            myDropsTimer.Tick += new EventHandler(myDropsTimer_Tick);
        }

        private void myDropsTimer_Tick(object sender, EventArgs e)
        {
            try
            {

                this.myDropsTimer.Enabled = false;
                int _percent = (int)(0.005 * (this.Width + this.Height));
                int _dropsNumber = r.Next(_percent);
                ;
                ; i < _dropsNumber; i++)
                {
                    _drop = r.Next(drops.Length);
                    DropWater(drops[_drop].x, drops[_drop].y, drops[_drop].radius, drops[_drop].height);
                }

                 * _percent) + ;
                this.myDropsTimer.Enabled = true;
            }
            catch { }
        }

        private void myWaterTimer_Tick(object sender, EventArgs e)
        {
            try
            {
                if (fastImage.IsLocked()) return;
                this.myWaterTimer.Stop();
                PaintWater();
                this.myWaterTimer.Start();
            }
            catch { }
        }

        ;
        ;
        ;
        private static DropData[] drops;
        private FastBitmap fastImage = null;
        private FastBitmap originalImage = null;
        ;
        ;
        private byte[] bitmapOriginalBytes;
        private Random r = new Random();
        private static int[][][] waveHeight;
        bool isLoaded = false;

        private Image image;
        private bool auto;
        private int number;

        private Timer myWaterTimer, myDropsTimer;

        /// <summary>
        /// 绘画的图片
        /// </summary>
        public Image Image
        {
            get { return image; }
            set { image = value; }
        }
        /// <summary>
        /// 自动产生
        /// </summary>
        public bool Auto
        {
            get { return auto; }
            set { auto = value; }
        }
        /// <summary>
        /// 源点数
        /// </summary>
        public int Number
        {
            get { return number; }
            set { number = value; }
        }

        public void load()
        {
            try
            {
                isLoaded = true;
                this.Width = image.Width;
                this.Height = image.Height;
                bitmapWidth = image.Width;
                bitmapHeight = image.Height;
                waveHeight = new int[bitmapWidth][][];
                ; i < bitmapWidth; i++)
                {
                    waveHeight[i] = new int[bitmapHeight][];
                    ; j < bitmapHeight; j++)
                    {
                        waveHeight[i][j] = ];
                    }
                }
                CreateBitmap();
                if (auto)
                {
                    CreateWaterDrops();
                    this.myWaterTimer.Enabled = true;
                    ;
                    this.myDropsTimer.Enabled = true;
                }
                else
                {
                    this.MouseMove += new MouseEventHandler(myWaterWave_MouseMove);
                }
            }
            catch { }

        }

        private void CreateBitmap()
        {
            originalImage = new FastBitmap((Bitmap)(image).Clone(), bits);
            originalImage.LockBits();
            fastImage = new FastBitmap((Bitmap)(image).Clone(), bits);
            bitmapOriginalBytes = new byte[bits * fastImage.Width() * fastImage.Height()];
            fastImage.LockBits();
            Marshal.Copy(fastImage.Data().Scan0, bitmapOriginalBytes, , bitmapOriginalBytes.Length);
            fastImage.Release();
        }

        private void DropWater(int x, int y, int radius, int height)
        {
            long _distance;
            int _x;
            int _y;
            Single _ratio;
            _ratio = (Single)((Math.PI / (Single)radius));

            for (int i = -radius; i <= radius; i++)
            {
                for (int j = -radius; j <= radius; j++)
                {
                    _x = x + i;
                    _y = y + j;
                    ) && (_x <= bitmapWidth - ) && (_y >= ) && (_y <= bitmapHeight - ))
                    {
                        _distance = (long)Math.Sqrt(i * i + j * j);
                        if (_distance <= radius)
                        {
                            waveHeight[_x][_y][currentHeightBuffer] = (int)(height * Math.Cos((Single)_distance * _ratio));
                        }
                    }
                }
            }
        }

        private void PaintWater()
        {
            newHeightBuffer = (currentHeightBuffer + ) % ;
            fastImage.LockBits();
            byte[] _bufferBits = new byte[bits * fastImage.Width() * fastImage.Height()];
            Marshal.Copy(fastImage.Data().Scan0, _bufferBits, , _bufferBits.Length);
            int _offX;
            int _offY;
            ; _x < bitmapWidth - ; _x++)
            {
                ; _y < bitmapHeight - ; _y++)
                {
                    unchecked
                    {
                        waveHeight[_x][_y][newHeightBuffer] = ((
                            waveHeight[_x - ][_y][currentHeightBuffer] +
                            waveHeight[_x - ][_y - ][currentHeightBuffer] +
                            waveHeight[_x][_y - ][currentHeightBuffer] +
                            waveHeight[_x + ][_y - ][currentHeightBuffer] +
                            waveHeight[_x + ][_y][currentHeightBuffer] +
                            waveHeight[_x + ][_y + ][currentHeightBuffer] +
                            waveHeight[_x][_y + ][currentHeightBuffer] +
                            waveHeight[_x - ][_y + ][currentHeightBuffer]) >> )
                        - waveHeight[_x][_y][newHeightBuffer];
                    }
                    waveHeight[_x][_y][newHeightBuffer] -= (waveHeight[_x][_y][newHeightBuffer] >> );
                    _offX = ((waveHeight[_x - ][_y][newHeightBuffer] - waveHeight[_x + ][_y][newHeightBuffer])) >> ;
                    _offY = ((waveHeight[_x][_y - ][newHeightBuffer] - waveHeight[_x][_y + ][newHeightBuffer])) >> ;
                    ) && (_offY == )) continue;
                    ) _offX = -_x;
                    ) _offX = bitmapWidth - _x - ;
                    ) _offY = -_y;
                    ) _offY = bitmapHeight - _y - ;
                    _bufferBits[bits * (_x + _y * bitmapWidth) + ] = bitmapOriginalBytes[bits * (_x + _offX + (_y + _offY) * bitmapWidth) + ];
                    _bufferBits[bits * (_x + _y * bitmapWidth) + ] = bitmapOriginalBytes[bits * (_x + _offX + (_y + _offY) * bitmapWidth) + ];
                    _bufferBits[bits * (_x + _y * bitmapWidth) + ] = bitmapOriginalBytes[bits * (_x + _offX + (_y + _offY) * bitmapWidth) + ];
                }
            }
            Marshal.Copy(_bufferBits, , fastImage.Data().Scan0, _bufferBits.Length);
            currentHeightBuffer = newHeightBuffer;
            this.Invalidate();
        }

        private void CreateWaterDrops()
        {
            int _dropX;
            int _dropY;
            int _dropRadius;
            int _height;

            int _percent = (int)(0.0015 * (this.Width + this.Height));
            drops = new DropData[number];

            ; i < drops.Length; i++)
            {
                _dropX = r.Next(bitmapWidth);
                _dropY = r.Next(bitmapHeight);
                _height = r.Next();
                _dropRadius = r.Next( * _percent);

                ) _dropRadius = ;

                drops[i].x = _dropX;
                drops[i].y = _dropY;
                drops[i].radius = _dropRadius;
                drops[i].height = _height;
            }
        }

        private void myWaterWave_Paint(object sender, PaintEventArgs e)
        {
            try
            {
                if (isLoaded)
                {
                    fastImage.Release();
                    e.Graphics.DrawImage(fastImage.Bitmap, , , fastImage.Width(), fastImage.Height());
                }
            }
            catch { }
        }

        private void myWaterWave_MouseMove(object sender, MouseEventArgs e)
        {
            int dropX;
            int dropY;
            int dropRadius;
            int height;
            int percent = (int)(0.0015 * (this.Width + this.Height));
            drops = ];
            dropX = e.X;
            dropY = e.Y;
            height = r.Next();
            dropRadius = r.Next( * percent);

            ) dropRadius = ;

            drops[].x = dropX;
            drops[].y = dropY;
            drops[].radius = dropRadius;
            drops[].height = height;
            this.myWaterTimer.Enabled = true;
            ;
            this.myDropsTimer.Enabled = true;
        }
        private void Form1_MouseLeave(object sender, EventArgs e)
        {
          this.myDropsTimer.Enabled = false;
        }

        private void Form1_Load(object sender, EventArgs e)
        {

        }
    }

    public unsafe class FastBitmap
    {

        public struct PixelData
        {
            public byte blue;
            public byte green;
            public byte red;
            public byte alpha;
        }

        Bitmap Subject;
        int SubjectWidth;
        BitmapData bitmapData = null;
        Byte* pBase = null;
        bool isLocked = false;
        ;

        public FastBitmap(Bitmap SubjectBitmap, int bits)
        {
            this.Subject = SubjectBitmap;
            _bits = bits;
            try
            {
                //LockBits();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public void Release()
        {
            try
            {
                UnlockBits();
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public Bitmap Bitmap
        {
            get
            {
                return Subject;
            }
        }

        public void SetPixel(int X, int Y, Color Colour)
        {
            try
            {
                PixelData* p = PixelAt(X, Y);
                p->red = Colour.R;
                p->green = Colour.G;
                p->blue = Colour.B;
            }
            catch (AccessViolationException ave)
            {
                throw (ave);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public Color GetPixel(int X, int Y)
        {
            try
            {
                PixelData* p = PixelAt(X, Y);
                return Color.FromArgb((int)p->red, (int)p->green, (int)p->blue);
            }
            catch (AccessViolationException ave)
            {
                throw (ave);
            }
            catch (Exception ex)
            {
                throw ex;
            }
        }

        public int Width() { return Subject.Width; }
        public int Height() { return Subject.Height; }
        public bool IsLocked() { return isLocked; }
        public BitmapData Data() { return bitmapData; }

        public void LockBits()
        {
            if (isLocked) return;
            try
            {
                GraphicsUnit unit = GraphicsUnit.Pixel;
                RectangleF boundsF = Subject.GetBounds(ref unit);
                Rectangle bounds = new Rectangle((int)boundsF.X,
                    (int)boundsF.Y,
                    (int)boundsF.Width,
                    (int)boundsF.Height);

                SubjectWidth = (int)boundsF.Width * sizeof(PixelData);
                )
                {
                    SubjectWidth = _bits * (SubjectWidth / _bits + );
                }
                )
                    bitmapData = Subject.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format24bppRgb);
                else
                    bitmapData = Subject.LockBits(bounds, ImageLockMode.ReadWrite, PixelFormat.Format32bppRgb);
                pBase = (Byte*)bitmapData.Scan0.ToPointer();
            }
            finally
            {
                isLocked = true;
            }
        }

        private PixelData* PixelAt(int x, int y)
        {
            return (PixelData*)(pBase + y * SubjectWidth + x * sizeof(PixelData));
        }

        private void UnlockBits()
        {
            if (bitmapData == null) return;
            Subject.UnlockBits(bitmapData);
            bitmapData = null;
            pBase = null;
            isLocked = false;
        }
    }
}