Как сделать красивое звёздное небо.

[krolser]

Как сделать красивое звёздное небо. Т.е. при перетаскивании создавался эффект естественного неба.

Я придумал следующий вариант.

У меня есть три (четыре, пять, в общем, без разницы) спрайта со звёздами. Каждый из них имеет свой параметр -- отдалённость. Эти спрайты наложены друг на друга.

При передвижении неба каждый из этих спрайтов тоже передвигается в зависимости от своей отдалённости. Чем выше отдалённость, тем меньше он передвигается. Получаются так называемые "дальние" звёзды.

Может есть варианты получше?

[ramshteks]

хм а что лучше то?
вообще у битмапдаты есть неплохой метод perlinNoise с помощью него сожно создать туманности!

[krolser]

Спасибо. Попробую и отпишусь о результатах.

[divinus]

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;
	}
}

[Aldegran]

Я делал так

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);
		}
	}
}

вызывается так

field = new Sprite();
var skyDust:Dust = new Dust(this,800,600,200);
addChild(skyDust);

меняя х и y для field двигаются звёздочки с объемным эфектом