root/as3/Astro/ShaderFilter/Mudflow/ScratchCanvas.as

package
{
        import flash.display.*;
        import flash.geom.*;
        import flash.filters.DisplacementMapFilter;

        public class ScratchCanvas extends Sprite implements ILineCanvas
        {
                private var mBitmapData:BitmapData;
                private var mOffscreen:BitmapData;
                private var mNoiseBitmapData:BitmapData;
                private var mOfsSprite:Sprite;
                private var mBitmap:Bitmap;
                private var mClearRect:Rectangle;
                private var mDFilter:DisplacementMapFilter;

                function ScratchCanvas(w:int, h:int)
                {
                        setupFilter(w, h);
                        mBitmapData = new BitmapData(w, h, true, 0);
                        mOffscreen = new BitmapData(w, h, true, 0);
                        mBitmap = new Bitmap(mBitmapData);
                        mOfsSprite = new Sprite();

                        mClearRect = new Rectangle(0, 0, w, h);

                        addChild(mBitmap);
                }

                private function setupFilter(w:int, h:int):void
                {
                        mNoiseBitmapData = new BitmapData(w, h, true);
                        mNoiseBitmapData.perlinNoise(2,
                                                                                2,
                                                                                19,
                                                                                1,
                                                                                false,
                                                                                true);

                        mDFilter = new DisplacementMapFilter(mNoiseBitmapData,
                                new Point(0, 0),
                                2,
                                1,
                                4,
                                4);

                        //mNoiseBitmapData.dispose();
                }

                public function drawLine(x1:Number, y1:Number, x2:Number, y2:Number, c:uint):void
                {
                        var i:int;
                        mOffscreen.fillRect(mClearRect, 0);
                        var g:Graphics = mOfsSprite.graphics;

                        for (i = 0;i < 8;i++)
                        {
                                g.clear();
                                g.lineStyle(1, c, 0.1);
                                g.moveTo(x1 + Math.random()*5-2, y1 + Math.random()*5-2);
                                g.lineTo(x2 + Math.random()*5-2, y2 + Math.random()*5-2);
        
                                mOffscreen.draw(mOfsSprite);
                                mOffscreen.applyFilter(mOffscreen, mClearRect, new Point(0,0), mDFilter);
                                mBitmapData.draw(mOffscreen);
                        }
                }
        }
}