package

{

        import flash.display.Bitmap;

        import flash.display.BitmapData;

        import flash.display.Sprite;

        import flash.events.Event;

        import flash.events.MouseEvent;

 

        [SWF( backgroundColor='0x121212', frameRate='35', width='256', height='256')]

 

        public class Main extends Sprite

        {

                [Embed(source='pattern.gif' )] private const Pattern: Class;

                public var ripple:Ripple;

 

                public function Main()

                {

                        graphics.beginBitmapFill( Bitmap( new Pattern() ).bitmapData );

                        graphics.drawRect( 0, 0, 256, 256 );

                        graphics.endFill();

                        ripple = new Ripple(500, 500);

                        this.addEventListener(MouseEvent.MOUSE_MOVE, mouseMove)

                        this.addEventListener(Event.ENTER_FRAME, onEnterFrame)

                }

                private function mouseMove (_e:MouseEvent):void

                {

                        ripple.wobbleXY(this.mouseX, this.mouseY, 1);

                }

                private function onEnterFrame(_e:Event):void

                {

                        //пересчитываем карту смещений в Ripple

                        ripple.render();

                        //применяем фильтр

                        this.filters = [ripple.filter];

                }

        }        

}

package

{

        import flash.display.BitmapData;

        import flash.display.BlendMode;

        import flash.filters.ConvolutionFilter;

        import flash.filters.DisplacementMapFilter;

        import flash.filters.DisplacementMapFilterMode;

        import flash.geom.ColorTransform;

        import flash.geom.Matrix;

        import flash.geom.Point;

        import flash.geom.Rectangle;

 

        public class Ripple 

        {

                private var _filter:DisplacementMapFilter;

 

                private var mapBMP: BitmapData;

                private var resBMP : BitmapData;

 

                private var bufBMP : BitmapData;

                private var mtrx1 : Matrix;

                private var mtrx2 : Matrix;

                private var wave : ConvolutionFilter;

                private var damp : ColorTransform;

 

                private var width:Number;

                private var height:Number;

 

                private var quartRect:Rectangle;

 

                public function Ripple(w:Number, h:Number) 

                {

                        width = w;

                        height = h;

                        quartRect = new Rectangle(0, 0, width/2,height/2);

                        mtrx1 = new Matrix();

                        mtrx2 = new Matrix(2, 0, 0, 2);

 

                        mapBMP = new BitmapData(width, height, false, 128);

                        resBMP = new BitmapData(width, height, false, 128);

                        bufBMP = new BitmapData(width, height, false, 128);

 

                        wave = new ConvolutionFilter(3, 3, [1, 1, 1, 1, 1, 1, 1, 1, 1], 9, 0);

                        damp = new ColorTransform(0, 0, 0.99609374, 1, 0, 0, 2, 0);

 

                        _filter = new DisplacementMapFilter (new BitmapData(width, height, false, 128), new Point(), 4, 4, 32, 32, DisplacementMapFilterMode.IGNORE);

 

                }

 

                public function render():void

                {

                        resBMP.applyFilter (mapBMP, quartRect, new Point(), wave);

                        resBMP.draw(resBMP,mtrx1,null, BlendMode.ADD);

                        resBMP.draw (bufBMP, mtrx1, null, BlendMode.DIFFERENCE);

                        resBMP.draw (resBMP, mtrx1, damp);

 

                        _filter.mapBitmap.draw(resBMP, mtrx2, null, null, null, true);

                        bufBMP = mapBMP;

                        mapBMP = resBMP.clone();

                } 

 

                public function clear():void 

                {

 

                        resBMP = new BitmapData (width, height, false, 128);

                        mapBMP = new BitmapData (width, height, false, 128);

                        bufBMP = new BitmapData (width, height, false, 128);

                        wave = new ConvolutionFilter (3, 3, [1, 1, 1, 1, 1, 1, 1, 1, 1] , 9, 0);

                        damp = new ColorTransform (0, 0, 0.99609374, 1, 0, 0, 2, 0);

 

                        _filter.mapBitmap = new BitmapData(width, height, false, 128);

 

                }

 

                public function wobbleXY (x : Number, y : Number, d:Number):void 

                {

                        if (!d) d = 1;

                        var dx:Number = Math.round(x / 2);

                        var dy:Number = Math.round(y / 2);

 

                        mapBMP.setPixel (dx + d, dy, 0xFFFFFF);

                        mapBMP.setPixel (dx - d, dy, 0xFFFFFF);

                        mapBMP.setPixel (dx, dy + d, 0xFFFFFF);

                        mapBMP.setPixel (dx, dy - d, 0xFFFFFF);

                        mapBMP.setPixel (dx, dy, 0xFFFFFF);

                }

 

                public function wobble (n : Number):void 

                {

                        if (!n) n = 32;

                        for (var i:Number = 0; i < n; i++) {

                                wobbleXY (width*Math.random() , height*Math.random(), 1);

                        }

                }

 

                public function get filter():DisplacementMapFilter { return _filter; }

 

        }

}