package {
	import flash.display.Sprite;
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.display.DisplayObject;
	import flash.events.Event;

	public class object_ax_cloud extends Sprite
	{

		public var bsize:Number = 15;
		public var size:Number = 1;
		public var centerX:Number = 0;// 400;
		public var centerY:Number = 0;// 300;
		public var radiusX:Number = 320;
		public var radiusY:Number = 320;
		public var speed:Number = .8;

		private var balls:Array;
		private var numBalls:uint = 50;
		private var fl:Number = 300;
		private var vpX:Number = centerX;// stage.stageWidth / 2;
		private var vpY:Number = centerY; // stage.stageHeight / 2;
		private var parx:DisplayObject;
		
		public function object_ax_cloud(d:DisplayObject)
		{
			init();
			parx = d;
		}
		
		private function init():void
		{
			//stage.align = StageAlign.TOP_LEFT;
			//stage.scaleMode = StageScaleMode.NO_SCALE;
			
			balls = new Array();
			for(var i:uint = 0; i < numBalls; i++)
			{
				var ball:object_ax_ball = new object_ax_ball(bsize);
				//var ball:object_ax_ball3D = new object_ax_ball3D(20);
				balls.push(ball);
				ball.xpos = Math.random() * 320 - 160;
				ball.ypos = Math.random() * 320 - 160;
				ball.zpos = Math.random() * 320 - 160;
				addChild(ball);
			}
			addEventListener(Event.ENTER_FRAME, onEnterFrame);
		}
		
		private function onEnterFrame(event:Event):void
		{
			centerX = parx.width/2; // - this.width;
			centerY = parx.height/2; // - this.height;
			size = centerX / 160;
			//this.scaleX = sc;
			//this.scaleY = sc;
			vpX = centerX;
			vpY = centerY;
			var angleX:Number = (mouseY - vpY) * .001 * speed;
			var angleY:Number = (mouseX - vpX) * .001 * speed;
			for(var i:uint = 0; i < numBalls; i++)
			{
				//var ball:animation_ch18_Ball3D = balls[i];
				var ball:object_ax_ball = balls[i];
				rotateX(ball, angleX);
				rotateY(ball, angleY);
				doPerspective(ball);
			}
			sortZ();
		}
		
		private function rotateX(ball:object_ax_ball, angleX:Number):void
		{
			var position:Array = [ball.xpos, ball.ypos, ball.zpos];
			
			var sin:Number = Math.sin(angleX);
			var cos:Number = Math.cos(angleX);
			var xRotMatrix:Array = new Array();
			xRotMatrix[0] = [1,    0,   0];
			xRotMatrix[1] = [0,  cos, sin];
			xRotMatrix[2] = [0, -sin, cos]
			
			var result:Array = matrixMultiply(position, xRotMatrix);
			ball.xpos = result[0];
			ball.ypos = result[1];
			ball.zpos = result[2];
		}
		
		private function rotateY(ball:object_ax_ball, angleY:Number):void
		{
			var position:Array = [ball.xpos, ball.ypos, ball.zpos];
			
			var sin:Number = Math.sin(angleY);
			var cos:Number = Math.cos(angleY);
			var yRotMatrix:Array = new Array();
			yRotMatrix[0] = [ cos, 0, sin];
			yRotMatrix[1] = [   0, 1,   0];
			yRotMatrix[2] = [-sin, 0, cos]
			
			var result:Array = matrixMultiply(position, yRotMatrix);
			ball.xpos = result[0];
			ball.ypos = result[1];
			ball.zpos = result[2];
		}
		
		private function matrixMultiply(matrixA:Array, matrixB:Array):Array
		{
			var result:Array = new Array();
			result[0] = matrixA[0] * matrixB[0][0] + 
						matrixA[1] * matrixB[1][0] +
						matrixA[2] * matrixB[2][0];
			
			result[1] = matrixA[0] * matrixB[0][1] +
						matrixA[1] * matrixB[1][1] +
						matrixA[2] * matrixB[2][1];
			
			result[2] = matrixA[0] * matrixB[0][2] +
						matrixA[1] * matrixB[1][2] +
						matrixA[2] * matrixB[2][2];
			return result;
		}
		
		private function doPerspective(ball:object_ax_ball):void
		{			
			if(ball.zpos > -fl)
			{
				var scale:Number = fl / (fl + ball.zpos);
				ball.scaleX = ball.scaleY = scale;// * size;
				ball.x = centerX + ball.xpos * scale;
				ball.y = centerY + ball.ypos * scale;
				ball.visible = true;
			}
			else
			{
				ball.visible = false;
			}
		}
		
		private function sortZ():void
		{
			balls.sortOn("zpos", Array.DESCENDING | Array.NUMERIC);
			for(var i:uint = 0; i < numBalls; i++)
			{
				var ball:object_ax_ball = balls[i];
				setChildIndex(ball, i);
			}
		}
	}
}