DrawLight2Creature

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

//ハイライトを検出してドローできます
//部屋を暗くして、懐中電灯であそんでね。

package  
{
    
    import flash.display.*;
    import flash.events.Event;
    import flash.filters.BlurFilter;
    import flash.geom.Point;
    import flash.geom.Rectangle;
    import flash.media.*;

    [SWF (width=1200, height= 900)]
    public class DrawLight2Creature extends Sprite 
    {
        private const SCALE:Number = 2
        
        private var container:Sprite
        private var canvas:Sprite
        private var camera:Camera;
        private var video:Video;
        private var srcBmd:BitmapData
        private var w:Number;
        private var h:Number;
        private var r:Rectangle;
        private var p:Point
        private var g:Graphics;

        private var posints:Vector.<Vector.<Number>>
        private var sX:Number;
        private var sY:Number;
        private var mX:Number;
        private var mY:Number;
        private var eX:Number;
        private var eY:Number;
        private var drawingEnable:Boolean = false;
        private var blurBmd:BitmapData;
        private var bm:Bitmap;

        public function DrawLight2Creature() 
        {
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.align = StageAlign.TOP_LEFT;
            
            container = addChild(new Sprite()) as Sprite;
            
            //setup web-cam
            if (!initCam()) return;
            
            //bitmap analyze
            srcBmd = new BitmapData(w, h, false, 0xFF000000);
            var bmp:DisplayObject = addChild(new Bitmap(srcBmd))
            bmp.scaleX = bmp.scaleY = 2
            bmp.y = 10+h*SCALE;
            container.addChild(video);
            
            //drawing
            //canvas = container.addChild(new Sprite()) as Sprite;
            canvas = new Sprite();
            canvas.scaleX = canvas.scaleY = SCALE
            g = canvas.graphics;
            mX = mY = 0;
            
            //blur effect
            blurBmd = new BitmapData(w, h,true,0x00000000);
            container.addChild(new Bitmap(blurBmd));
            
            container.scaleX = container.scaleY = SCALE
            
            addEventListener(Event.ENTER_FRAME, drawDitection)
            addEventListener(Event.ENTER_FRAME, addBlur)

        }
        
        private function initCam():Boolean
        {
            if (!(camera = Camera.getCamera())) return false;
            w = camera.width;
            h = camera.height;
            r = new Rectangle(0, 0, w, h);
            p = new Point()
            video = new Video(w, h);
            video.attachCamera(camera);
            
            return true;
        }
        
        private function addBlur(e:Event = null):void
        {
            //bmd.colorTransform(bmd.rect, new ColorTransform(1, 1, 1, 1, 0x11, 0x11, 0x11, 0));
            blurBmd.draw(canvas);
            blurBmd.applyFilter(blurBmd, blurBmd.rect, p, new BlurFilter());
        }
        
        private function drawDitection(e:Event = null):void
        {
            var threshold:uint = 0xFFAAAAAA
            srcBmd.unlock();
            srcBmd.lock();
            srcBmd.draw(video);
            srcBmd.threshold(srcBmd, r, p, ">", threshold, 0xFFFFFFFF, 0xFFFFFFFF);
            srcBmd.threshold(srcBmd, r, p, "<", threshold, 0x00000000, 0xFFFFFFFF);
            
            var rec:Rectangle = srcBmd.getColorBoundsRect(0xFFFFFF, 0xFFFFFF)
            var w:Number = rec.width;
            var h:Number = rec.height;
            var x:Number = rec.x;
            var y:Number = rec.y;
            x = x + (w) * .5;
            y = y + (h) * .5;
            
            if (w == 0 && drawingEnable)      stopDraw()
            else if (w > 0 && !drawingEnable) startDraw(x,y) 
            else if (w > 0 && drawingEnable)  draw(x,y)
        }
        
        private function draw(x:Number,y:Number):void
        {
            var dX:Number = (x-mX)
            var dY:Number = (y-mY)
            var distance:Number = Math.sqrt(dX*dX+dY*dY)
            
            if (distance < 10) return;
            
            var point:Vector.<Number> = new Vector.<Number>(2)
            point[0] = mX
            point[1] = mY
            posints.push(point);
            g.moveTo(mX, mY);
            g.lineTo(x,  y);
            
            mX = x;
            mY = y;
        }
        private function stopDraw():void
        {
            drawingEnable = false
            
            var point:Vector.<Number> = new Vector.<Number>(2)
            point[0] = mX
            point[1] = mY
            posints.push(point);
            
            g.clear()
            
            if (posints.length < 2) return;
            canvas.addChild(new Creature(posints))

        }
        private function startDraw(x:Number,y:Number):void
        {
            drawingEnable = true;
            g.beginFill(0xFF0000);
            g.lineStyle(1, 0xFF0000);
            
            
            sX = mX = x;
            sY = mY = y;
            posints = new Vector.<Vector.<Number>>() 
            
        }
    }   
}

import flash.display.*
import flash.events.Event;
class Creature extends Sprite
{
    public var points:Vector.<Vector.<Number>>
    private var g:Graphics
    public function Creature(points:Vector.<Vector.<Number>>)
    {
        this.points = points
        g = this.graphics
        g.beginFill(0x00FF00)
        //g.lineStyle(1,0x00FF00)
        addEventListener(Event.ENTER_FRAME,onEnterFrame)
        
        draw()
    }
    
    private function draw():void
    {
        g.clear()
        g.beginFill(0x00FF00)
        //g.lineStyle(1,0x00FF00)
        g.moveTo(points[0][0],points[0][1])
        var n:int = points.length
        for (var i:int = 1; i < n; i++) 
        {
            g.lineTo(points[i][0],points[i][1])
        }
        g.lineTo(points[0][0],points[0][1])

    }
    
    private function transformPoint():void
    {
        var n:int = points.length
        for (var i:int = 0; i < n; i++) 
        {
            points[i][0] += -2.5+Math.random()*5
            points[i][1] += -2+Math.random()*5
        }
    }
    private function kill():void
    {
        
    }
    
    private function onEnterFrame(e:Event):void 
    {
        if (Math.random() > .5) return;
        transformPoint()
        draw()
    }
}