In case Flash no longer exists; a copy of this site is included in the Flashpoint archive's "ultimate" collection.

Dead Code Preservation :: Archived AS3 works from wonderfl.net

forked from: forked from: muraken effect test

@autoher : muraken (undefined Inc.)
Get Adobe Flash player
by hacker_tmbt9fl2 23 Jun 2010
    Embed
// forked from hacker_f7l4m6a's forked from: muraken effect test
// forked from nitoyon's muraken effect test
// forked from muraken's camera of undefined
// @autoher : muraken (undefined Inc.)

package {
    import flash.display.Bitmap;
    import flash.display.BitmapData;
    import flash.display.BitmapDataChannel;
    import flash.display.DisplayObject;
    import flash.display.Sprite;
    import flash.display.*;
    import flash.events.Event;
    import flash.geom.Matrix;
    import flash.geom.Point;
    import flash.geom.Rectangle;
    import flash.media.Camera;
    import flash.media.Video;
    
    [SWF(width="465", height="465", backgroundColor="0xffffff", frameRate="40")]
    public class NoiseDisplay extends Sprite {
        private var bmp:Bitmap;
        private const BMD_WIDTH:int = 240;
        private const BMD_HEIGHT:int = 240;
        private var baseColor:uint = 0xFFFFFF;
        private var baseBmd:BitmapData;
        private var editBmd:BitmapData;
        private var noiseBmd:BitmapData;
        private var sandstormBmd:BitmapData;
        private var sorce:DisplayObject;
        private var baseMatrix:Matrix;
        private var pointArray:Array;
        private var randArray1:Array;
        private var randArray2:Array;
        private var randNum1:Number;
        private var bmdUpNum:Number;
        private var video:Video;
        private var _bmp:Bitmap;
        private var camera_width:int;
        private var camera_height:int;
        //丸たちを作る
        private var sprite:Sprite;
        private var g:Graphics;
        
        /*コンストラクタ*/
        public function NoiseDisplay():void {
            //丸たちを作る
            sprite = new Sprite();
            makeCircle(sprite);
            
            //ビットマップ画像作成
            bmp = new Bitmap();
            //下地 w,h,透過,塗り
            baseBmd = new BitmapData(BMD_WIDTH, BMD_HEIGHT, false,baseColor);
            //ノイズ初期設定
            noiseInit(bmp,baseBmd);
            
            //サイズの変換行列
            baseMatrix = new Matrix();
            
            //R,G,Bの各座標
            pointArray = new Array(new Point(0, 0), new Point(0, 0), new Point(0, 0));
            
            //二種類のrandArrayは細かなぶれの表現?
            //R,G,B 1~1.999...
            randArray1 = new Array(Math.random() + 1, Math.random() + 1, Math.random() + 1);
            randArray2 = new Array(0, 0, 0);
            
            randNum1 =0.5;
            bmdUpNum = 0;
            
            //ノイズを一時的に見えなくする
            bmp.visible = false;
            
            //ステージの寸法が変わったら、_onResize
            stage.addEventListener(Event.RESIZE,  _onResize);
            
            //初めにリサイズ
            _onResize(null);
            
            //自分が毎フレームupDate
            addEventListener(Event.ENTER_FRAME, upDate);
            
            //ノイズ表示
            bmp.visible = true;
            
            //丸たちを見えなくする
            sorce.visible = false;
        }
        private function makeCircle(_sprite:Sprite):void{
            
            g=_sprite.graphics;
            
            //赤丸
            g.beginFill(0xff0000);
            g.drawCircle(200, 150, 45);
            g.endFill();
            
            //青丸
            g.beginFill(0x0000ff);
            g.drawCircle(250, 200, 45);
            g.endFill();
            
            //丸たちをソースとする
            sorce = _sprite;
        }
        private function noiseInit(_bmp:Bitmap,_baseBmd:BitmapData):void{
            //ビットマップ画像表示
            addChild(_bmp);

            //編集用複製
            editBmd = _baseBmd.clone();
            
             //ノイズ用複製
            noiseBmd = _baseBmd.clone();
            
             //砂嵐用複製
            sandstormBmd = _baseBmd.clone();
            
            //ビットマップ画像のビットマップデータにノイズ用を設定
            _bmp.bitmapData = noiseBmd;
            
            //ノイズ拡大縮小されたらスムージング・アンチエイリアスかける
            _bmp.smoothing = true;
        }
        /**
        *リサイズ関数
        */
        private function _onResize(e:Event):void {
            
            //ステージの幅・高さを取得
            var W:Number = stage.stageWidth;
            var H:Number = stage.stageHeight;
            
            //拡大・縮小用行列
            baseMatrix = new Matrix();
            
            //全体に対するノイズ画像の寸法の比率を、行列要素の拡大・縮小に適用
            baseMatrix.scale(BMD_WIDTH/W, BMD_HEIGHT/H);
            
            //ノイズ画像の寸法をステージの寸法にあわせる
            bmp.scaleX = W/BMD_WIDTH;
            bmp.scaleY = H/BMD_HEIGHT;
            
            //ノイズ画像を左上に整頓
            bmp.x = bmp.y = 0;
        }
        /**
        *毎フレーム行うアップデート関数
        */
        //移動量に関わる変数
        private var _keyCnt:Number = 0;
        
        //一時変数
        private var sin:Number;
        private var bdc:Object=BitmapDataChannel;
        private var copy_bmd:BitmapData;
        private var keyNum:Number;
        private var sandNum:Number;
        private function upDate(e:Event):void {
            
            //ノイズをコピー
             copy_bmd= baseBmd.clone();
            
            //ノイズに丸たちを拡大・縮小を適用して描画
            copy_bmd.draw(sorce, baseMatrix);
            
            //それを編集用にコピー
            editBmd = copy_bmd.clone();
            
            //ぶれを生成
            makeShake();
            
            //ぶれを適用
            applicationShake();
            
            //ノイズを作って適用
            makeAppNoise();
            
        }//end upDate
        
        /*
        *ぶれを生成
        */
        private function makeShake():void{
            
            //0,1,2 (R,G,B)について
            for (var i:uint = 0; i < 3; i++) {
                
                //G,Bなら
                if (randArray1[i] >= 1){
                    
                    //1減らす(二種類のrandArrayは細かなぶれの表現?)
                    --randArray1[i];
                    
                    //ぶれの大きさ
                    randArray2[i] = Math.random() / 4 + .03;  //0.03~0.28
                    
                } //end if
                
                //減ったり増えたり
                randArray1[i] += randArray2[i];
                
                //移動量に関わる変数 0から48に近づいていく。イーズアウト。 0で静止
                _keyCnt +=.25* (48-_keyCnt);
                
                //ぶれさせる素。減ったり増えたりでいったりきたり。 -1~1
                sin=Math.sin(randArray1[i] * (2*Math.PI));
                
                //x方向の移動
                pointArray[i].x =  (sin * randArray2[i] * _keyCnt * 2 )>>0;
                
                //y方向の移動
                pointArray[i].y = 0;
                
            }//end for
            
            //ぶれ (R+G+B+8)/4
            keyNum = 1*(
                Math.abs(pointArray[0].x) + 
                Math.abs(pointArray[1].x) + 
                Math.abs(pointArray[2].x) + 
                8
            ) / 4;
            
        }//end makeShake
        
        /**
        *ぶれを適用
        */
        private function applicationShake():void{
            
            var i:Number = BMD_HEIGHT;
            //BMDの上から下まで
            while (i--){
                
                //-1~1
                sin=Math.sin(i / BMD_HEIGHT * (Math.random() / 8 + 1)* randNum1 * Math.PI * 2);
                var offset:Number =  sin* 0.8 * keyNum * keyNum;
                
                //ノイズ画像BDの座標(0,i)に、copy_bmdの(offset, i, BMD_WIDTH - offset, 1)をコピー
                editBmd.copyPixels(
                    copy_bmd, 
                    new Rectangle(offset, i, BMD_WIDTH - offset, 1), 
                    new Point(0, i)
                );
            }//end while
            
        }//end applicationShake
        
        /**
        *ノイズを作って適用
        */
        private function makeAppNoise():void{
            
            //砂嵐画像をノイズで塗る
            sandstormBmd.noise(int(Math.random() * 1000));
            
            //各チャンネルにどれだけ乗算するか(0~256)
            sandNum = 0.25*256; //25%
            
            //ノイズに砂嵐画像をチャンネルごとにブレンド(乗算)
            editBmd.merge(
                sandstormBmd, 
                editBmd.rect, 
                new Point(0,0),  //生成イメージの配置は左上
                sandNum, //red
                sandNum, //green
                sandNum, //blue
                0 //alpha
            );
            //その赤チャンネルデータの座標pointArray[0]をノイズ画像の赤チャにコピー
            noiseBmd.copyChannel(
                editBmd, 
                noiseBmd.rect, 
                pointArray[0], 
                bdc.RED, 
                bdc.RED
            );
            //その緑チャンネルデータの座標pointArray[1]をノイズ画像の緑チャにコピー
            noiseBmd.copyChannel(
                editBmd, 
                noiseBmd.rect, 
                pointArray[1], 
                bdc.GREEN, 
                bdc.GREEN
            );
            //その青チャンネルデータの座標pointArray[2]をノイズ画像の青チャにコピー
            noiseBmd.copyChannel(
                editBmd, 
                noiseBmd.rect, 
                pointArray[2], 
                bdc.BLUE, 
                bdc.BLUE
            );
        }//end makeAppNoise
           
    }
}