Forked from:: Murai's 2009 07 22 ECLIPSE!!!! forked from: Flickr Tricks ..

2009 07 22 ECLIPSE!!!! に勝手にコメントをつけてみた

Happy Eclipse! を勝手に解説する
ソースが長いので途中で力尽きたけど、だいたいの雰囲気は分かるはず。
下記コメントの「@see http://www.flickr.com/photos/auroracrowley/」
は Fork 元「Flickr Tricks For Aurora Crowley!!」の参照ページの
模様です。
Fork 元：
- http://wonderfl.net/code/448a0195da618461603cb61f9172fc6aff8420cf
以下、オリジナルのソースコードのはじまりはじまり。
Happy Eclipse!!
ActionScript3 Thread library のサンプルになれば幸いです :-)
*
* @see http://www.flickr.com/photos/auroracrowley/
* @see http://www.libspark.org/htdocs/as3/thread-files/document/

nitoyon

forked:2
favorite:10
lines:613
license : MIT License
modified : 2009-07-25 18:02:32

Embed: Tweet

// Happy Eclipse! を勝手に解説する
// ソースが長いので途中で力尽きたけど、だいたいの雰囲気は分かるはず。
//
// 下記コメントの「@see http://www.flickr.com/photos/auroracrowley/」
// は Fork 元「Flickr Tricks For Aurora Crowley!!」の参照ページの
// 模様です。
//
// Fork 元：
//  - http://wonderfl.net/code/448a0195da618461603cb61f9172fc6aff8420cf
//
// 以下、オリジナルのソースコードのはじまりはじまり。

//Happy Eclipse!!

// forked from soundkitchen's Flickr Tricks For Aurora Crowley!!
/**
 *  ActionScript3 Thread library のサンプルになれば幸いです :-)
 *
 *  @see    http://www.flickr.com/photos/auroracrowley/
 *  @see    http://www.libspark.org/htdocs/as3/thread-files/document/
 */

package
{
    import flash.display.Sprite;
    import flash.display.StageAlign;
    import flash.display.StageQuality;
    import flash.display.StageScaleMode;
    import flash.display.StageDisplayState;
    import flash.events.Event;
    import flash.events.MouseEvent;
    import flash.geom.Rectangle;
    import org.libspark.thread.EnterFrameThreadExecutor;
    import org.libspark.thread.Thread;

[SWF(frameRate=60, width=465, height=465, backgroundColor=0x000000)]
    // ドキュメントクラス
    public class Eclipse extends Sprite
    {
        // コンストラクタ
        public function Eclipse()
        {
            // ステージの設定
            stage.align = StageAlign.TOP_LEFT;
            stage.quality = StageQuality.HIGH;
            stage.scaleMode = StageScaleMode.NO_SCALE;
            stage.fullScreenSourceRect = new Rectangle(0, 0, 465 , 465);

// クリック時にはフルスクリーンに
            stage.addEventListener(MouseEvent.CLICK,function(e:Event):void{
                stage.displayState = (StageDisplayState.FULL_SCREEN==stage.displayState)?StageDisplayState.NORMAL:StageDisplayState.FULL_SCREEN
            })

// ステージに追加完了時に initialize 関数を呼ぶ
            addEventListener(Event.ADDED_TO_STAGE, initialize);
        }

private function initialize(evt:Event):void
        {
            // 即座に removeEventListener する。素敵な癖ですね。
            removeEventListener(Event.ADDED_TO_STAGE, initialize);

// そうめん 初期化
            if (!Thread.isReady)
            {
                Thread.initialize(new EnterFrameThreadExecutor());
            }

// MainThread を開始する
            new MainThread(this).start();
        }
    }
}

// import いっぱい！
// まずは flash.***
import flash.display.Bitmap;
import flash.display.BitmapData;
import flash.display.BlendMode;
import flash.display.DisplayObject;
import flash.display.DisplayObjectContainer;
import flash.display.Stage;
import flash.events.MouseEvent;
import flash.events.TimerEvent;
import flash.filters.BitmapFilter;
import flash.filters.BitmapFilterQuality;
import flash.filters.BlurFilter;
import flash.geom.ColorTransform;
import flash.geom.Point;
import flash.net.URLRequest;
import flash.net.URLVariables;
import flash.system.LoaderContext;
import flash.text.TextField;
import flash.text.TextFieldAutoSize;
import flash.text.TextFormat;
import flash.ui.Mouse;
import flash.utils.Timer;

// JSON シリアライズ用のライブラリ（as3corelibより）
import com.adobe.serialization.json.JSON;

// そうめん
import org.libspark.thread.Thread;
import org.libspark.thread.threads.display.LoaderThread;
import org.libspark.thread.threads.net.URLLoaderThread;
import org.libspark.thread.utils.IProgress;
import org.libspark.thread.utils.IProgressNotifier;
import org.libspark.thread.utils.MultiProgress;
import org.libspark.thread.utils.ParallelExecutor;
import org.libspark.thread.utils.SerialExecutor;

// フィルタエフェクト
internal var FILTER_BLUR:BlurFilter = new BlurFilter(4, 4, BitmapFilterQuality.MEDIUM);
// 高速化用の(0,0)を指す Point オブジェクト
internal var POINT_ZERO:Point = new Point();

import flash.display.Shape;

// メインの処理を実行するスレッド
// 実行順は次の通り：
//   1. run() メソッド
//      WaitAnimationThread を実行・待機
//   2. loadImage() メソッド
//      LoadImageThread, LoadImageProgressThread を実行・待機
//   3. loadComplete() メソッド
//      画像表示用の canvas を準備
//   4. changeImage() メソッド
//      HandleImageThread を実行・待機
//      その後、再び changeImage() メソッドを実行
internal class MainThread extends Thread
{
    private var layer:DisplayObjectContainer;
    private var imageLoader:LoadImageThread;
    private var contents:Array;
    private var canvas:Bitmap;
    private var currentIndex:uint;

// コンストラクタ
    // DocumentRoot を layter に記録しておく
    public function MainThread(layer:DisplayObjectContainer)
    {
        this.layer = layer;
    }

// スレッドのエントリポイント
    override protected function run():void
    {
        var t:Thread;

// ローディングを開始して、終了まで待機する
        t = new WaitAnimationThread(layer);
        t.start();
        t.join();

// WaitAnimationThread が終了したら、loadImage を呼ぶ
        next(loadImage);
    }

// 画像をロードする
    private function loadImage():void
    {
        // 並列実行を行う
        var executor:ParallelExecutor;
        executor = new ParallelExecutor();

// 画像ロード用のスレッドを追加
        imageLoader = new LoadImageThread();
        executor.addThread(imageLoader);

// ロード状況を表示するスレッドを追加
        executor.addThread(new LoadImageProgressThread(layer, imageLoader.progress));

// 両方が終了するまで待機
        executor.start();
        executor.join();

// 終了後は loadComplete を実行する
        next(loadComplete);
    }

// ロード完了時の処理
    private function loadComplete():void
    {
        var s:Stage,
            data:BitmapData;

contents = imageLoader.contents.concat();
        imageLoader.contents.length = 0;
        imageLoader.contents = null;

currentIndex = 0;

s = layer.stage;
        data = new BitmapData(450, 450, true, 0);
        canvas = new Bitmap(data);
        canvas.x = (s.stageWidth - canvas.width) / 2;
        canvas.y = (s.stageHeight - canvas.height) / 2;
        layer.addChild(canvas);

next(changeImage);
    }

// 表示する画像を変更する
    private function changeImage():void
    {
        if (currentIndex >= contents.length)
        {
            currentIndex = 0;
        }

var image:Bitmap,
            th:Thread;

// イメージ表示のスレッドを準備する
        image = contents[currentIndex++] as Bitmap;
        th = new HandleImageThread(image, canvas);

// 終了まで待機する
        th.start();
        th.join();

// 次は再びこのメソッド
        next(changeImage);
    }

// 終了時の処理
    override protected function finalize():void
    {
        layer = null;
        imageLoader = null;
    }
}

// 開始時の表示を行うスレッドクラス
// クラス名に「Animation」と入っているが、実際にはアニメーションは
// 行わず、文字を表示後、即座に終了する。
internal class WaitAnimationThread extends Thread
{
    private var layer:DisplayObjectContainer;
    private var message:Bitmap;

// コンストラクタ
    // layer はドキュメントクラスのインスタンス
    public function WaitAnimationThread(layer:DisplayObjectContainer)
    {
        this.layer = layer;
    }

// スレッドのエントリポイント
    override protected function run():void
    {
        var s:Stage,
            txt:TextField,
            fmt:TextFormat,
            bmd:BitmapData;

// ステージ
        s = layer.stage;

// 文字列を準備
        fmt = new TextFormat();
        fmt.color = 0xFFFFFF;
        fmt.size = 24;
        fmt.font = 'Trebuchet MS';
        txt = new TextField();
        txt.autoSize = TextFieldAutoSize.LEFT;
        txt.defaultTextFormat = fmt;
        txt.text = '2009 07 22 ECLIPSE PHOTO STREAM.';

// BitmapData に文字列を描画
        bmd = new BitmapData(txt.textWidth, txt.textHeight, true, 0);
        bmd.draw(txt);

// ビットマップを作成し、ステージの真ん中に配置
        message = new Bitmap(bmd);
        message.blendMode = BlendMode.INVERT;
        message.x = (s.stageWidth - message.width) / 2;
        message.y = (s.stageHeight - message.height) / 2;

// ドキュメントクラスのインスタンスに追加する
        layer.addChild(message);

// next() がないのでスレッドは終了する
    }

// 終了処理
    // message の参照は切るが、テキストは表示されたまま
    override protected function finalize():void
    {
        layer = null;
        message = null;
    }
}

// 画像をロードするスレッド
// 「進捗通知機構」を備えるために IProgressNotifier を実装している
// 進捗状況は LoadImageProgressThread に伝えられる
internal class LoadImageThread extends Thread
implements IProgressNotifier
{
    public var contents:Array;
    private var mainProgress:MultiProgress;
    private var subProgress:MultiProgress;
    private var jsonLoader:URLLoaderThread;
    private var imageLoader:SerialExecutor;

// IProgressNotifier で実装すべき唯一のメソッド
    public function get progress():IProgress
    {
        return mainProgress;
    }

// コンストラクタ
    public function LoadImageThread()
    {
        var req:URLRequest,
            data:URLVariables;

// 写真検索の URLRequest を準備する
        // (YQL を利用して Flickr の写真を検索する)
        req = new URLRequest('http://query.yahooapis.com/v1/public/yql');
        data = new URLVariables();
        data['q'] = "select * from flickr.photos.search where text='eclipse or 日食' and max_taken_date='2009-07-22'";
        data['format'] = 'json';
        req.data = data;

// Loader 用のスレッドを準備しておく
        jsonLoader = new URLLoaderThread(req);
        mainProgress = new MultiProgress();
        subProgress = new MultiProgress();

mainProgress.addProgress(jsonLoader.progress, 0.1);
        mainProgress.addProgress(subProgress);
    }

// スレッドのエントリポイント
    override protected function run():void
    {
        // 写真検索を実施して、完了を待機する
        jsonLoader.start();
        jsonLoader.join();

// ロードが完了したら loadDataComplete を呼び出す
        next(loadDataComplete);
    }

// 写真検索完了時の処理
    private function loadDataComplete():void
    {
        var json:Object,
            row:Object,
            th:LoaderThread,
            req:URLRequest,
            ctx:LoaderContext,
            flickr:FlickrPhoto;

json = JSON.decode(jsonLoader.loader.data);
        ctx = new LoaderContext(true);

// 順次実行のスレッドを作成する
        imageLoader = new SerialExecutor();

// 順次実行スレッドに画像ロードのスレッドを追加していく
        for each (row in json.query.results.photo)
        {
            flickr = new FlickrPhoto(row);
            req = new URLRequest(flickr.thumbnailURL);
            th = new LoaderThread(req, ctx);
            imageLoader.addThread(th);
            subProgress.addProgress(th.progress);
        }

// 画像ロード処理を開始
        imageLoader.start();
        imageLoader.join();

// 全部終わったら loadImageComplete を呼び出す
        next(loadImageComplete);
    }

// 全ての画像のロードが完了したときの処理
    private function loadImageComplete():void
    {
        var i:uint,
            l:uint,
            th:LoaderThread;

contents = [];
        l = imageLoader.numThreads;
        for (i=0; i<l; i++)
        {
            th = imageLoader.getThreadAt(i) as LoaderThread;
            contents.push(th.loader.content);
        }
    }

override protected function finalize():void
    {
        jsonLoader = null;
        imageLoader = null;
    }
}

// LoadImageThread の進捗情報に基づいて画面描画を行うスレッド
// 実際にはローディング表示は何もやっていないが、雛形だけは用意されている。
internal class LoadImageProgressThread extends Thread
{
    private var progress:IProgress;
    private var layer:DisplayObjectContainer;
    private var indicator:HandleIndicatorThread;

// コンストラクタ
    // progress 経由で LoadImageThread の進捗状況を取得できる
    public function LoadImageProgressThread(layer:DisplayObjectContainer, progress:IProgress)
    {
        this.layer = layer;
        this.progress = progress;
    }

// スレッドのエントリポイント
    override protected function run():void
    {
        indicator = new HandleIndicatorThread(layer);
        indicator.start();

next(step);
    }

private function step():void
    {
        if (progress.isCompleted||progress.isFailed||progress.isCanceled)
        {
            next(shutDown);

return;
        }

// Loading の進捗状況を取得できる
        //  TODO: なにかしらやる。
        var percent:Number = progress.percent;

// Loading 完了したら shutDown に移る
        // 完了しない限りは繰り返し step を実行する
        if (percent >= 1)
        {
            next(shutDown);
        }
        else
        {
            next(step);
        }
    }

private function shutDown():void
    {
        // HandleIndicatorThread に停止するよう要請する
        // 実際に停止するかどうかは HandleIndicatorThread の実装に依存する
        indicator.interrupt();
    }

override protected function finalize():void
    {
        progress = null;
        layer = null;
        indicator = null;
    }
}

// 画像の処理を行うスレッド
internal class HandleImageThread extends Thread
{
    public static const PARTICLE_MARGIN:Number = 2;

private var original:Bitmap;
    private var destination:Bitmap;
    private var showParticles:Vector.<ShowImageParticle>;
    private var hideParticles:Vector.<HideImageParticle>;

// コンストラクタ
    public function HandleImageThread(original:Bitmap, destination:Bitmap)
    {
        this.original = original;
        this.destination = destination;
        this.showParticles = new Vector.<ShowImageParticle>();
        this.hideParticles = new Vector.<HideImageParticle>();
    }

// エントリポイント
    override protected function run():void
    {
        var w:Number, h:Number, c:uint,
            tx:Number, ty:Number,
            sx:Number, sy:Number,
            cx:Number, cy:Number,
            angle:Number,
            i:uint, j:uint,
            s:Stage,
            data:BitmapData;

// 画像の情報を取得する
        s = destination.stage;
        data = original.bitmapData;
        w = data.width;
        h = data.height;
        cx = s.stageWidth / 2;
        cy = s.stageHeight / 2;

// それぞれの座標について処理を行う
        for (i=0; i<w; i+=2)
        {
            for (j=0; j<h; j+=2)
            {
                // 色を取得する
                c = data.getPixel32(i, j);

// 真っ黒なら何もしない
                if (!c) continue;

// スタート地点はランダムな角度に 500px 移動させる
                angle = Math.random() * Math.PI * 2;
                sx = Math.cos(angle) * 500 + cx;
                sy = Math.sin(angle) * 500 + cy;

// 終了地点は PARTICLE_MARGIN 倍した場所
                tx = i * PARTICLE_MARGIN;
                ty = j * PARTICLE_MARGIN;

// 開始と終了のパーティクルを準備
                showParticles.push(new ShowImageParticle(sx, sy, tx, ty, c));
                hideParticles.push(new HideImageParticle(tx, ty, sx, sy, c, s.frameRate));
            }
        }

// 次は showStep
        next(showStep);
    }

// パーティクルが集まってくる処理
    private function showStep():void
    {
        var i:uint,
            l:uint,
            c:uint,
            a:Number,
            f:Boolean,
            p:ShowImageParticle,
            data:BitmapData;

data = destination.bitmapData;
        data.lock();

// ぼかしつつ
        data.applyFilter(data, data.rect, POINT_ZERO, FILTER_BLUR);

// 座標を更新する
        l = showParticles.length;
        f = false;
        for (i=0; i<l; i++)
        {
            p = showParticles[i];

if (p.isAlive)
            {
                f = true;
                p.update();
            }
            data.setPixel32(p.x, p.y, p.color);
        }
        data.unlock();

// 全ての移動が完了すれば fixedImage へ
        if (!f)
        {
            next(fixedImage);
        }
        // そうでなければ再度 showStep へ
        else
        {
            next(showStep);
        }
    }

// 非表示にしていく処理
    private function hideStep():void
    {
        var i:uint,
            l:uint,
            c:uint,
            a:Number,
            f:Boolean,
            p:HideImageParticle,
            data:BitmapData;

data = destination.bitmapData;
        data.lock();

// 透明にしつつ、ぼかしつつ
        data.colorTransform(data.rect, new ColorTransform(1, 1, 1, .97, 0, 0, 0, 0));
        data.applyFilter(data, data.rect, POINT_ZERO, FILTER_BLUR);

l = hideParticles.length;
        for (i=0; i<l; i++)
        {
            p = hideParticles[i];
            p.update();
            data.setPixel32(p.x, p.y, p.color);

// 画面外に移動したら消す
            if (!data.rect.contains(p.x, p.y))
            {
                hideParticles.splice(i, 1);
                i--;
                l = hideParticles.length;
            }
        }
        data.unlock();
        //trace(p.x, p.y);

// 全部消えない限りは hideStep を繰り返す
        if (l) next(hideStep);
    }

// 固定のままの状態
    // 3秒待機して hideStep へ
    private function fixedImage():void
    {
        sleep(3000);

next(hideStep);
    }

// 終了処理
    override protected function finalize():void
    {
        original = null;
        destination = null;
        showParticles.length = 0;
        showParticles = null;
        hideParticles.length = 0;
        hideParticles = null;
    }
}

internal class HandleIndicatorThread extends Thread
{
    private var layer:DisplayObjectContainer;
    private var indicator:DisplayObject;

public function HandleIndicatorThread(layer:DisplayObjectContainer)
    {
        this.layer = layer;
    }

override protected function run():void
    {
        Mouse.hide();

layer.stage.mouseChildren = false;

indicator = new Indicator();
        indicator.x = layer.mouseX;
        indicator.y = layer.mouseY;

layer.addChild(indicator);

next(step);
    }

private function step():void
    {
        if (checkInterrupted()) return;

indicator.rotation = (indicator.rotation + 360 / indicator.stage.frameRate) % 360;
        indicator.x = layer.mouseX;
        indicator.y = layer.mouseY;

next(step);
    }

override protected function finalize():void
    {
        Mouse.show();

layer.stage.mouseChildren = true;
        layer.removeChild(indicator);
        layer = null;
        indicator = null;
    }
}

internal class HideMessageParticle
{
    public var x:Number;
    public var y:Number;
    public var ax:Number;
    public var ay:Number;
    public var vx:Number;
    public var vy:Number;
    public var color:uint;

public function HideMessageParticle(x:Number, y:Number, color:Number)
    {
        var len:Number,
            angle:Number;

len = Math.random() * 5;
        angle = Math.random() * Math.PI * 2;

this.ax = Math.cos(angle) * len;
        this.ay = Math.sin(angle) * len;
        this.x = x;
        this.y = y;
        this.color = color;
        this.vx = 0;
        this.vy = 0;
    }

public function update():void
    {
        vx += ax;
        vy += ay;
        x += vx;
        y += vy;
    }
}

import flash.geom.Point;

internal class ShowImageParticle
{
    public var x:Number;
    public var y:Number;
    public var color:uint;
    private var targetX:Number;
    private var targetY:Number;
    private var _isAlive:Boolean;

public function get isAlive():Boolean
    {
        return _isAlive;
    }

public function ShowImageParticle(x:Number, y:Number, targetX:Number, targetY:Number, color:uint)
    {
        this.x = x;
        this.y = y;
        this.color = color;
        this.targetX = targetX;
        this.targetY = targetY;
        this._isAlive = true;
    }

public function update():void
    {
        x += (targetX - x) * .05;
        y += (targetY - y) * .05;

if (Math.abs(targetX - x) < .5 && Math.abs(targetY - y) < .5)
        {
            x = targetX;
            y = targetY;
            _isAlive = false;
        }
    }
}

internal class HideImageParticle
{
    public var x:Number;
    public var y:Number;
    public var color:uint;
    private var vx:Number;
    private var vy:Number;
    private var ax:Number;
    private var ay:Number;
    private var rate:Number;

public function HideImageParticle(x:Number, y:Number, targetX:Number, targetY:Number, color:uint, rate:Number)
    {
        var dx:Number,
            dy:Number,
            len:Number,
            angle:Number;

dx = targetX - x;
        dy = targetY - y;
        len = 9.8;
        angle = Math.atan2(dy, dx);

this.x = x;
        this.y = y;
        this.vx = 0;
        this.vy = 0;
        this.ax = Math.cos(angle) * len;
        this.ay = Math.sin(angle) * len;
        this.color = color;
        this.rate = rate;
    }

public function update():void
    {
        vx += ax / rate;
        vy += ay / rate;
        x += vx;
        y += vy;
    }
}

internal class FlickrPhoto
{
    private var _id:String;
    public function get id():String
    {
        return _id;
    }

private var _secret:String;
    public function get secret():String
    {
        return _secret;
    }

private var _server:String;
    public function get server():String
    {
        return _server;
    }

private var _farm:String;
    public function get farm():String
    {
        return _farm;
    }

public function get thumbnailURL():String
    {
        return ['http://farm', farm, '.static.flickr.com/', server, '/', id, '_', secret, '_m.jpg'].join('');
    }

public function FlickrPhoto(data:Object)
    {
        this._id = data['id'] || '';
        this._secret = data['secret'] || '';
        this._server = data['server'] || '';
        this._farm = data['farm'] || '';
    }
}

// ローディング用のカーソル
internal class Indicator extends Shape
{
    public function Indicator()
    {
        var i:uint,
            cx:Number, cy:Number,
            numNeedles:uint = 12,
            innerR:Number = 7,
            outerR:Number = 5,
            cAngle:Number = -Math.PI / 2,
            nAngle:Number;

nAngle = Math.PI * 2 / numNeedles;
        for (i=0; i<numNeedles; i++)
        {
            cAngle += nAngle;
            cx = Math.cos(cAngle) * innerR;
            cy = Math.sin(cAngle) * innerR;
            graphics.moveTo(cx, cy);

cx = Math.cos(cAngle) * outerR;
            cy = Math.sin(cAngle) * outerR;
            graphics.lineStyle(2, 0xffffff, i/numNeedles);
            graphics.lineTo(cx, cy);
        }
    }
}

Code Fullscreen

Preview Fullscreen