Circle Pixelate

/**
 * Copyright bongiovi015 ( http://wonderfl.net/user/bongiovi015 )
 * MIT License ( http://www.opensource.org/licenses/mit-license.php )
 * Downloaded from: http://wonderfl.net/c/696H
 */

package
{
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.Loader;
    import flash.display.Shader;
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.filters.ShaderFilter;
    import flash.geom.Point;
    import flash.net.URLLoader;
    import flash.net.URLLoaderDataFormat;
    import flash.net.URLRequest;
    import flash.system.LoaderContext;
    import flash.utils.ByteArray;

    public class WonderCircle3 extends Sprite
    {
        public var loaderImage : Loader = new Loader;
        public var loaderShader : URLLoader = new URLLoader;
        public var bmp : Bitmap;
        public var shader : Shader = new Shader;
        public var seed : int = Math.floor(Math.random()*0xFFFF);
        public var offset : Array = [new Point, new Point];
        public var bmpdPerlin : BitmapData;
        public var center:Point;
    
        
        public function WonderCircle3(){
            graphics.beginFill(0x222222, 1);
            graphics.drawRect(0, 0, 465, 465);
            graphics.endFill();
            
            loaderImage.contentLoaderInfo.addEventListener(Event.COMPLETE, imgLoaded);
            loaderImage.load(new URLRequest("http://www.bongiovi.tw/wonderfl/mood.jpg"), new LoaderContext(true));
            
            center = new Point(465/2, 465/2);
        }
        
        
        private function imgLoaded(e:Event) : void {
            bmp = Bitmap(loaderImage.content);
            addChild(bmp).y = ( 465 - bmp.height ) * .5;
            loaderShader.addEventListener(Event.COMPLETE, shaderLoaded);
            loaderShader.dataFormat = URLLoaderDataFormat.BINARY;
            loaderShader.load(new URLRequest("http://www.bongiovi.tw/wonderfl/Circle3.pbj"));
        }
        
        
        private function shaderLoaded(e:Event) : void {
            shader.byteCode = ByteArray(loaderShader.data);
            bmpdPerlin = new BitmapData(bmp.width*.5, bmp.height*.5);
            addEventListener(Event.ENTER_FRAME, render);
            addEventListener(MouseEvent.CLICK, onClick);
        }
        
        private function onClick(event:MouseEvent):void {
            center.x = stage.mouseX;
            center.y = stage.mouseY;
        }        
        
        public function render(e:Event) : void {
            const SPEED : int = 2;
            bmpdPerlin.perlinNoise(bmp.width*.5, bmp.height*.5, 3, seed, false, true, 1, false, offset);
            offset[0].x += SPEED;
            offset[1].y += SPEED;
            shader.data.size.value = [stage.mouseX / stage.stageWidth * 15 + 10];
            shader.data.sizeCircle.value = [stage.mouseY / stage.stageHeight * 15 + 10];
            shader.data.center.value = [center.x, center.y];
            
            shader.data.srcPerlin.input = bmpdPerlin;
            bmp.filters = [new ShaderFilter(shader)];
        }
    }
}



/*


<languageVersion : 1.0;>

kernel CircleEffect
<   namespace : "bongiovi.tw";
    vendor : "bongiovi";
    version : 1;
    description : "Circle Effect";
>
{
    input image4 src;  
    input image4 srcPerlin;
    output pixel4 dst;  


    parameter float2 center
    <
        minValue:float2(0.0, 0.0);
        maxValue:float2(2000.0, 2000.0);
        defaultValue:float2(300.0, 200.0);
    >;  
    
    
    parameter float offset
    <
        minValue:0.0;
        maxValue:10.0;
        defaultValue:0.5;
    >;
                    
    
    parameter float size
    <
        minValue:1.0;
        maxValue:100.0;
        defaultValue:10.0;
    >;    
    
    
    parameter float sizeCircle
    <
        minValue:1.0;
        maxValue:100.0;
        defaultValue:20.0;
    >;
    
    
    const float PI = 3.1415926;
    const float TWO_PI = 6.2831852;
    
    void
    evaluatePixel()
    {
        float2 pos = outCoord();
        float radius = distance(pos, center);
        radius = (floor(radius/size/2.0) + offset )* size*2.0;
        float numCircles = floor(TWO_PI * radius / size / 2.0); 
        float angle = atan(pos.y - center.y, pos.x - center.x);
        float angleBase = TWO_PI / numCircles;                 
        angle =    (floor(angle/angleBase) + offset) * angleBase;
        float2 endPos = float2(cos(angle) * radius, sin(angle) * radius) + center;
        dst = sampleLinear(src, endPos);          
        float4 perlin = sampleLinear(srcPerlin, endPos*.5);
        dst.a = 1.0 - step(distance(endPos, pos), sizeCircle*perlin.r);
        
    }
}


*/