[AS3.0] DotLight [Color]

光るドットの表現をAS3.0で! :boy:

dotLightColor

:caution: 要 Flash Player 11.8 以上

This movie requires Flash Player 11.8.0

DotLight.as (effects.DotLight.as)
package effects {

  import flash.display.Sprite;
  import flash.display.Bitmap;
  import flash.display.BitmapData;
  import flash.display.PixelSnapping;
  import flash.display.BlendMode;
  import flash.geom.Matrix;
  import flash.geom.Rectangle;
  import flash.geom.Point;
  import flash.geom.ColorTransform;
  import flash.filters.BlurFilter;
  import flash.events.Event;

  import flash.utils.getTimer;
  import effects.DotEmit;

  public class DotLight extends Sprite {
    // プロパティ
    private var rect:Rectangle;
    private var area:Rectangle;
    private var canvas:BitmapData;
    private var map:BitmapData;
    private var sparkle:BitmapData;
    private var afterglow:BitmapData;
    private static var scale:uint = 4;
    private var aMatrix:Matrix;
    private var colorTrans:ColorTransform;
    private var blur:BlurFilter;
    private var sMatrix:Matrix;
    private var offsets:Array;
    private var seed:uint;
    private var light:DotEmit;

    // コンストラクタ
    public function DotLight(r:Rectangle, a:Rectangle) {
      rect = r;
      area = a;
      init();
    }

    // メソッド
    private function init():void {
      afterglow = new BitmapData(rect.width*2/scale, rect.height*2/scale, true, 0x00000000);
      var aBitmap:Bitmap = new Bitmap(afterglow, PixelSnapping.AUTO, true);

      aBitmap.scaleX = aBitmap.scaleY = scale/2;
      addChild(aBitmap);
      canvas = new BitmapData(rect.width, rect.height, true, 0x00000000);
      var cBitmap:Bitmap = new Bitmap(canvas);

      cBitmap.blendMode = BlendMode.ADD;
      addChild(cBitmap);
      map = new BitmapData(rect.width/scale, rect.height/scale, true, 0x00000000);
      offsets = [new Point(), new Point()];
      seed = Math.floor(Math.random()*1000);
      sparkle = new BitmapData(rect.width/scale, rect.height/scale, true, 0x00000000);
      var sBitmap:Bitmap = new Bitmap(sparkle);

      sBitmap.smoothing = true;
      sBitmap.blendMode = BlendMode.ADD;
      sBitmap.scaleX = sBitmap.scaleY = scale;

      addChild(sBitmap);
      aMatrix = new Matrix(2/scale, 0, 0, 2/scale, 0, 0);
      colorTrans = new ColorTransform(1, 1, 1, 0.16);
      blur = new BlurFilter(2, 2, 3);
      sMatrix = new Matrix(1/scale, 0, 0, 1/scale, 0, 0);
      light = new DotEmit(canvas, area, map, scale);
    }
    public function start():void {
      addEventListener(Event.ENTER_FRAME, update, false, 0, true);
    }
    public function stop():void {
      removeEventListener(Event.ENTER_FRAME, update);
    }
    private function update(evt:Event):void {
      var offset:Number = getTimer()*0.05;
      offsets[0].x = offsets[1].y = offset;
      map.perlinNoise(rect.width/scale, rect.height/scale, 2, seed, true, true, 1, false, offsets);
      light.create(10);
      canvas.lock();
      canvas.fillRect(canvas.rect, 0x00000000);
      light.emit();
      canvas.unlock();
      sparkle.lock();
      sparkle.fillRect(sparkle.rect, 0x00000000);
      sparkle.draw(canvas, sMatrix);
      sparkle.unlock();
      afterglow.lock();
      afterglow.draw(canvas, aMatrix, colorTrans, BlendMode.ADD);
      afterglow.applyFilter(afterglow, afterglow.rect, new Point(), blur);

      afterglow.unlock();
    }

  }

}

DotEmit.as (effects.DotEmit.as)
package effects {

  import flash.display.BitmapData;
  import flash.geom.Rectangle;

  import frocessing.color.ColorHSV;
  import geom.Bresenham;
  import particle.Dot;


  public class DotEmit {
    // プロパティ
    private var canvas:BitmapData;
    private var map:BitmapData;
    private var rect:Rectangle;
    private var scale:uint;
    private var cx:uint;
    private var cy:uint;
    private var radius:uint;
    private static var yScale:Number = 0.25;
    private var dots:Array;
    private static var acceleration:Number = 0.01;
    private static var gravity:Number = 0.03;
    private static var deceleration:Number = 0.01;
    private var color:ColorHSV;
    private static var length:Number = 3;
    private var manager:Bresenham;
    private static var createId:uint = 0;

    // コンストラクタ
    public function DotEmit(c:BitmapData, r:Rectangle, m:BitmapData, s:uint) {
      canvas = c;
      map = m;
      rect = r;
      scale = s;
      cx = rect.x + rect.width*0.5;
      cy = rect.y + rect.height*0.85;
      radius = rect.width*0.4;
      init();
    }

    // メソッド
    private function init():void {
      dots = new Array();
      color = new ColorHSV(0, 0.6);
      manager = new Bresenham(canvas);

    }
    public function create(max:uint, time:uint):void {
      for (var n:uint = 0; n < max; n++) {
        var angle:Number = Math.random()*360;
        var power:Number = Math.random() + 0.5;
        var dot:Dot = new Dot(px, py, angle, power);
        dot.x = cx + Math.cos(angle*Math.PI/180)*radius;
        dot.y = cy + Math.sin(angle*Math.PI/180)*radius*yScale;
        dot.px = dot.x;
        dot.py = dot.y;
        dot.hue = createId;
        color.h = dot.hue;

        dot.rgb = color.value;
        dots.push(dot);
      }
    }
    public function emit():void {
      for (var n:uint = 0; n < dots.length; n++) {
        var dot:Dot = dots[n];
        var c:uint = map.getPixel(dot.x/scale, dot.y/scale);
        dot.cx += ((((c >> 16) & 0xFF) - 0x80) / 0x80)*5;
        dot.vy += gravity*dot.power;
        dot.vy *= 0.99;
        dot.vx += acceleration;
        dot.angle += dot.vx;
        dot.cy -= dot.vy;
        var px:Number = Math.cos(dot.angle*Math.PI/180)*radius;
        var py:Number = Math.sin(dot.angle*Math.PI/180)*radius*yScale;
        dot.x = dot.cx + px*(dot.energy*0.4 + 0.2);
        dot.y = dot.cy + py*(dot.energy*0.4 + 0.2);
        dot.energy -= deceleration;
        var x0:int = dot.x;
        var y0:int = dot.y;
        var x1:int = dot.x - (dot.x - dot.px)*length;
        var y1:int = dot.y - (dot.y - dot.py)*length;
        dot.hue += 2.5;
        color.h = dot.hue;

        dot.rgb = color.value;
        manager.draw(x0, y0, x1, y1, dot.rgb, dot.energy*0.5);
        dot.px = dot.x;
        dot.py = dot.y;
        if (dot.energy < 0) {
          dots.splice(n, 1);
          dot = null;
        }
      }
    }

  }

}

Bresenham.as (geom.Bresenham.as)
package geom {

  import flash.display.BitmapData;

  public class Bresenham {
    // プロパティ
    private var canvas:BitmapData;

    // コンストラクタ
    public function Bresenham(c:BitmapData) {
      canvas = c;
    }

    // メソッド
    public function draw(x0:int, y0:int, x1:int, y1:int, color:uint, alpha:Number):void {
      var steep:Boolean = Math.abs(y1 - y0) > Math.abs(x1 - x0);
      var t:int;
      if (steep) {
        t = x0;
        x0 = y0;
        y0 = t;
        t = x1;
        x1 = y1;
        y1 = t;
      }
      if (x0 > x1) {
        t = x0;
        x0 = x1;
        x1 = t;
        t = y0;
        y0 = y1;
        y1 = t;
      }
      var dx:int = x1 - x0;
      var dy:int = Math.abs(y1 - y0);
      var e:int = dx*0.5;
      var ys:int = (y0 < y1) ? 1 : -1;
      var y:int = y0;
      for (var x:int = x0; x <= x1; x++) {
        if (steep) {
          plot(y, x, color, alpha);
        } else {
          plot(x, y, color, alpha);
        }
        e = e - dy;
        if (e < 0) {
          y = y + ys;
          e = e + dx;
        }
      }
    }
    private function plot(x:int, y:int, c:uint, a:Number):void {
      canvas.setPixel32(x, y, c | ((a*0xFF) << 24));
    }

  }

}

Dot.as (particle.Dot.as)
package particle {

  public class Dot {
    // プロパティ
    public var x:Number = 0;
    public var y:Number = 0;
    public var vx:Number = 0;
    public var vy:Number = 0;
    public var cx:Number = 0;
    public var cy:Number = 0;
    public var px:Number = 0;
    public var py:Number = 0;
    public var angle:Number = 0;
    public var power:Number = 1;
    public var energy:Number = 2;
    public var hue:uint = 0;
    public var rgb:uint = 0xFFFFFF;

    // コンストラクタ
    public function Dot(_x:Number, _y:Number, a:Number, p:Number) {
      cx = _x;
      cy = _y;
      angle = a;
      power = p;
    }

    // メソッド

  }

}

Main.as
package {

  import flash.display.Sprite;
  import flash.geom.Rectangle;
  import effects.DotLight;


  [SWF(backgroundColor="#000000", width="600", height="640", frameRate="60")]

  public class Main extends Sprite {
    // プロパティ
    private var light:DotLight;

    // コンストラクタ
    public function Main() {
      init();
    }

    // メソッド
    private function init():void {
      var rect:Rectangle = new Rectangle(0, 0, 600, 600);
      var area:Rectangle = new Rectangle(40, 0, 520, 600);
      light = new DotLight(rect, area);
      addChild(light);
      light.start();
    }

  }

}

Flash CC + Flex 4 SDK でパブリッシュ。