Форум Flasher.ru - Как сделать красивое звёздное небо.

Код:

package {

        import flash.display.Bitmap;

        import flash.display.BitmapData;

        import flash.display.BlendMode;

        import flash.display.DisplayObject;

        import flash.display.Sprite;

        import flash.events.Event;

        import flash.filters.BlurFilter;

        import flash.filters.ColorMatrixFilter;

        import flash.geom.Point;



        [SWF(width="1000", height="500", frameRate="31", backgroundColor="#000000")]

        public class StarField extends Sprite {

                        

                private const NUM_STARS:int = 500;

                                

                public function StarField() {

                        this.init();

                }

                

                private var _starFieldCanvas:BitmapData;

                private var _starFogCanvas:BitmapData;

                private var _starFieldBlur:BitmapData;

                

                private var _alphaFilter:ColorMatrixFilter;

                private const _blurFilter:BlurFilter = new BlurFilter(4, 4, 2);

                

                private var _starsArray:Array;

                private var _amplitudesMap:Array;

                

                private function init():void {

                        

                        var matrix:Array = new Array();

                        matrix = matrix.concat([1, 0, 0, 0, 0]);

                        matrix = matrix.concat([0, 1, 0, 0, 0]);

                        matrix = matrix.concat([0, 0, 1, 0, 0]);

                        matrix = matrix.concat([0, 0, 0, .2, 0]);

                        this._alphaFilter = new ColorMatrixFilter(matrix);

                        

                        this._amplitudesMap = new Array();

                        

                        this._starFieldBlur = new BitmapData(super.stage.stageWidth, super.stage.stageHeight, true, 0);

                        super.addChild(new Bitmap(this._starFieldBlur));

                        

                        this._starFieldCanvas = new BitmapData(super.stage.stageWidth, super.stage.stageHeight, true, 0);

                        super.addChild(new Bitmap(this._starFieldCanvas));

                        

                        this._starFogCanvas = new BitmapData(super.stage.stageWidth, super.stage.stageHeight, true, 0);

                        var tempDo:DisplayObject = super.addChild(new Bitmap(this._starFogCanvas));

                        tempDo.blendMode = BlendMode.LAYER;

                                                

                        for (var k:int = 0; k<15; ++k) {

                                this._amplitudesMap[k] = new Point(Math.random()*this._starFogCanvas.width, Math.random()*this._starFogCanvas.height);

                        }

                        

                        this._starsArray = new Array();

                        for (var i:int = 0; i<NUM_STARS; i++) {

                                this._starsArray.push(new Star(Math.random()*super.stage.stageWidth, Math.random()*super.stage.stageHeight, Math.round(Math.random()*3), Math.round(Math.random()*2)));  

                        }

                        

                        super.addEventListener(Event.ENTER_FRAME, this.handler_enterFrame);

                }

                

                private function handler_enterFrame(event:Event):void {

                        this._starFogCanvas.lock();

                        for (var k:int = 0; k<15; ++k) {

                                this._amplitudesMap[k].x = this._amplitudesMap[k].x-2;

                        }

                        this._starFogCanvas.perlinNoise(this._starFogCanvas.width*.5,this._starFogCanvas.height*.5,3,2,false,false,0,true,this._amplitudesMap);

                        this._starFogCanvas.applyFilter(this._starFogCanvas, this._starFogCanvas.rect, new Point(), this._alphaFilter);

                        this._starFogCanvas.unlock();

                        this._starFieldCanvas.lock();

                        

                        this._starFieldCanvas.applyFilter(this._starFieldCanvas, this._starFieldCanvas.rect, new Point(), this._alphaFilter);

                        

                        for each (var temp:Star in this._starsArray) {

                                var color:uint = 0xFFFFFFFF;

                                var a:uint = color >>> 24;

                                var r:uint = color >>> 16 & 0xFF;

                                var g:uint = color >>>  8 & 0xFF;

                                var b:uint = color & 0xFF;

                                a = Math.round(a/temp.d);

                                var j:int;                                

                                for(j = 0; j<temp.b; j++) {

                                        this._starFieldBlur.setPixel32(temp.x+Math.random()*temp.b-(temp.b>>1), temp.y+Math.random()*temp.b-(temp.b>>1), a << 24 | r << 16 | g << 8 | b);

                                }                                

                                this._starFieldCanvas.setPixel32(temp.x, temp.y, a << 24 | r << 16 | g << 8 | b);

                        }

                        this._starFieldBlur.applyFilter(this._starFieldBlur, this._starFieldBlur.rect, new Point(), this._blurFilter);

                        this._starFieldCanvas.unlock();

                }

        }

}



internal class Star {

        public var x:Number;

        public var y:Number;

        public var d:Number;

        public var b:Number;

        public function Star(x:Number, y:Number, distance:Number, brightness:Number):void {

                this.x = x;

                this.y = y;

                this.d = distance;

                this.b = brightness;

        }

}

package
{
import flash.display.Sprite;
import flash.events.Event;

public class Dust extends Sprite
{
protected var targetObj:Object;
protected var global:Object;
public var fieldWidth:int;
public var fieldHeight:int;
public var points:Array = [];
public var counter:int;
private var oldX:int;
private var oldY:int;
public function Dust(gh:Object=null,w:int=50000,h:int=50000,count:int=100)
{
super();
global=gh;
fieldWidth=w;
fieldHeight=h;
counter=count;
}
public function build():void{

resize();
for(var i:int=0; i<counter; i++){
var deep:Number = Math.random()*10;
var pointEl:Sprite = new Sprite;
pointEl.graphics.lineStyle(.1,0xFFFFFF);
pointEl.graphics.drawCircle(0,0,.2);
pointEl.x=Math.random()*fieldWidth;
pointEl.y=Math.random()*fieldHeight;
pointEl.alpha=1/(deep+1);
addChild(pointEl);
var el:Object = {
point:pointEl,
deep:deep
};
points.push(el);
}
scaleX=1;
scaleY=1;
oldX=Math.round(global.field.x*100)/100;
oldY=Math.round(global.field.y*100)/100;
addEventListener(Event.ENTER_FRAME, calc);
}
public function resize():void{
width=fieldWidth;
height=fieldHeight;
x=-fieldWidth/2;
y=-fieldHeight/2;
}
protected function calc(event:Event):void{
var deltaX:int=(Math.round(global.field.x*100)/100)-oldX;
var deltaY:int=(Math.round(global.field.y*100)/100)-oldY;
if(!deltaX && !deltaY)return;
//deltaX=deltaX/delim;
//deltaY=deltaY/delim;
for each(var el:Object in points){
var dX:Number=deltaX/el.deep;
var dY:Number=deltaY/el.deep;
el.point.x+=dX;
el.point.y+=dY;
if(el.point.x>fieldWidth){
el.point.x=0;
el.point.y=Math.random()*fieldHeight;
}else if(el.point.x<0){
el.point.x=fieldWidth;
el.point.y=Math.random()*fieldHeight;
}
if(el.point.y>fieldHeight){
el.point.y=0;
el.point.x=Math.random()*fieldWidth;
}else if(el.point.y<0){
el.point.y=fieldHeight;
el.point.x=Math.random()*fieldWidth;
}
}
oldX=(Math.round(global.field.x*100)/100);
oldY=(Math.round(global.field.y*100)/100);
}
}
}