public class StarField extends Sprite
{

private var m_camera:Camera3D;
private var m_view:View3D;
private var m_scene:Scene3D;

private var starContainer:ObjectContainer3D;
private var starCount:int = 200;
private var stars:Vector.;

private var cloudSliceCount:int = 12;
private var clouds:Vector.;
//private var clouds:Vector.;
private var cloudDistance:int = 10000;

private var cloudTestBitmap:Bitmap;
private var cloudTestBitmapData:BitmapData;
private var genClouds:GenerateClouds;

//you can import an image like this
//[Embed(source = "../assets/star.png" , mimeType="image/png")]
//private var starArt:Class;
private var starArt:BitmapData; // in this tutorial we'll create a bitmapData from scratch

private var rotateSpeed:int = 1;
private var rotateDirection:String = "none";

public function StarField()
{
mouseChildren = false;
mouseEnabled = false;

addEventListener(Event.ADDED_TO_STAGE, init);
}

private function init(e:Event) : void {

removeEventListener(Event.ADDED_TO_STAGE, init);

/// clouds

genClouds = new GenerateClouds();

cloudTestBitmapData = new BitmapData(50,50,true,0xFFFF0000);
cloudTestBitmap = new Bitmap(cloudTestBitmapData);
addChild(cloudTestBitmap);

////////

initView();
initObjects();

/////////

//genClouds.generateCloudSlice(cloudTestBitmap);

/// ENTERFRAME
addEventListener(Event.ENTER_FRAME, act);

}

private function initView() : void {

// create view
m_view = new View3D();
addChild(m_view);
//m_view.antiAlias = 4;

m_view.backgroundColor = 0x0033CC;

// debug
var stats:AwayStats = new AwayStats(m_view,true);
stats.x = 450;
addChild(stats);

// scene

m_scene = m_view.scene;

// camera

m_camera = m_view.camera;

//set camera location
m_view.camera.y = 0;
m_view.camera.x = 0;
m_view.camera.z = 0;
//m_view.camera.zoom = 10;
//m_view.camera.focus = 30;

m_camera.lens.far = 100000;

}

private function initLights() : void {

}

private function initObjects() : void {

starContainer = new ObjectContainer3D();
m_scene.addChild(starContainer);

//create bitmapData for our material, 4x4 and white! (0xffffff)
starArt = new BitmapData(4,4,false,0xFFFFFF);

// create an Away3D Material with that bitmapData, this is the image used for our particles!

//var starMaterial:BitmapMaterial = new BitmapMaterial(new starArt().bitmapData); // use this if you decide to import an asset
//var starMaterial:BitmapMaterial = new BitmapMaterial(starArt); // BitmapMaterial() is deprecated
var starBitmapTexture:BitmapTexture = new BitmapTexture(starArt);
var starMaterial:TextureMaterial = new TextureMaterial(starBitmapTexture);
var starMaterial2:ColorMaterial = new ColorMaterial(0xFFFFFF);

var cloudBitmapTexture:BitmapTexture = new BitmapTexture(genClouds.getCloudSlice());
var cloudMaterial:TextureMaterial = new TextureMaterial(cloudBitmapTexture);
cloudMaterial.alphaBlending = true;

// create a Vector array to the size of "starCount"
stars = new Vector.(starCount , true);
clouds = new Vector.(cloudSliceCount , true);

// merge
//var merge:Merge = new Merge();

// start filling the Vector with Sprite3D objects!
for (var i:int = 0; i < starCount; i++) {

var starMaterial3:ColorMaterial = new ColorMaterial(0xFFFFFF);

var star:Sprite3D = new Sprite3D(starMaterial3,4,4);

//star.alignmentType = AlignmentType.VIEWPOINT; // I forgot what this does... haha! look it up!

star.x = -400 + (Math.random() * 800);
star.y = -500 + (Math.random() * 800);
star.z = -1000 + (Math.random() * (1000 + 800));

///m_scene.addChild(star);
starContainer.addChild(star);

//merge.apply(starContainer, star);

stars[i] = star;
}

// clouds
for (i = 0; i < cloudSliceCount; i++) {

var cloudBitmapTextureTemp:BitmapTexture = new BitmapTexture(genClouds.getCloudSlice());
var cloudMaterialTemp:TextureMaterial = new TextureMaterial(cloudBitmapTextureTemp);
cloudMaterialTemp.alphaBlending = true;

var cloud:Sprite3D = new Sprite3D(cloudMaterialTemp,15000,13000); // trying Sprite3D, disappear when center isn't in frame :(
//var cloudShape:PlaneGeometry = new PlaneGeometry(15000,13000,1,1); // trying Meshes but the scale may be to huge, they werent displaying
//var cloud:Mesh = new Mesh(cloudShape,cloudMaterialTemp);
//cloudShape = null;

cloud.x = 0;
cloud.y = 0;
cloud.z = -cloudDistance + (((cloudDistance * 2) / (cloudSliceCount - 0)) * i );

m_scene.addChild(cloud);

clouds[i] = cloud;
}

}

// sets the rotation to look in a certain direction

public function lookForward(): void {
m_camera.rotationY = 180;
m_camera.rotationX = 0;
}

public function lookBackward(): void {
m_camera.rotationY = 0;
m_camera.rotationX = 0;
}

public function lookLeft(): void {
m_camera.rotationY = -90;
m_camera.rotationX = 0;
}

public function lookRight(): void {
m_camera.rotationY = 90;
m_camera.rotationX = 0;
}

// set a rotation direction with the keys

public function rotateLeft() : void {
rotateDirection = "left";
}

public function rotateRight() : void {
rotateDirection = "right";
}

public function rotateUp() : void {
rotateDirection = "up";
}

public function rotateDown() : void {
rotateDirection = "down";
}
public function rotateNone() : void {
rotateDirection = "none";
}

//

private function act( e:Event ) : void {

onPreRender();

m_view.render();

}

// this onPreRender function fires every frame, thanks to our nift Away3d template file!

protected function onPreRender():void
{
var starCount:int = stars.length;
for (var i:int = 0; i < starCount; i++) {

var star:Sprite3D = stars[i];

star.z += 20; // stars move forward on Z-axis every frame

if (star.z > 800) {
star.z = -1000; // when stars move past limit of 800, set them back to -1000 so they loop forever!
}

// fade
var starZ:int = star.z;
if (starZ < 0) starZ *= -1;
var facePerc2:Number = starZ / 800;
//trace("fadePerc: " + facePerc);
ColorMaterial(star.material).alpha = 1 - (facePerc2 * 0.5);

}

var cloudCount:int = clouds.length;
for (var j:int = 0; j < cloudCount; j++) {

var cloud:Sprite3D = clouds[j];

cloud.z += 200; // stars move forward on Z-axis every frame

if (cloud.z >= cloudDistance) {

var cloudBitmapTextureTemp:BitmapTexture = new BitmapTexture(genClouds.getCloudSlice());
var cloudMaterialTemp:TextureMaterial = new TextureMaterial(cloudBitmapTextureTemp);
cloudMaterialTemp.alphaBlending = true;
cloud.material = cloudMaterialTemp;

cloud.z = -cloudDistance; // when stars move past limit of 800, set them back to -1000 so they loop forever!
//TextureMaterial(cloud.material).alpha = 1;
}

// fade
var cloudZ:int = cloud.z;
if (cloudZ < 0) cloudZ *= -1;
var facePerc:Number = cloudZ / cloudDistance;
//trace("fadePerc: " + facePerc);
TextureMaterial(cloud.material).alpha = 1 - facePerc;

}

/*
starContainer.z += 20;
if (starContainer.z > 800) {
starContainer.z = -1000;
}
*/

// handle rotations!
if (rotateDirection == "left") {
m_camera.rotationY -= rotateSpeed;
} else if (rotateDirection == "right") {
m_camera.rotationY += rotateSpeed;
}
if (rotateDirection == "up") {
m_camera.rotationX -= rotateSpeed;
} else if (rotateDirection == "down") {
m_camera.rotationX += rotateSpeed;
}

// new cloud slice
//genClouds.generateCloudSlice(cloudTestBitmap);
cloudTestBitmap.bitmapData = genClouds.getCloudSlice();

}

}

public class GenerateClouds
{
private var bitmapData:BitmapData;

private var baseX:Number = 20;
private var baseY:Number = 20;
private var numOctaves:uint = 8;
private var randomSeed:Number = 13;
private var stitch:Boolean = true;
private var fractalNoise:Boolean = true;
private var channelOptions:uint = 7;
private var grayScale:Boolean = true;
private var offsets:Array;

private var cmf:ColorMatrixFilter;

private var cloudSlices:Vector.;

private var sliceWidth:int = 128;
private var sliceHeight:int = 128;
private var sliceZ:Number = 0;

private var currentSlice:int;
private var totalSlices:int = 50;

public function GenerateClouds()
{

bitmapData = new BitmapData(sliceWidth,sliceHeight,true);

cmf = new ColorMatrixFilter([0,0,0,0,255,
0,0,0,0,255,
0,0,0,0,255,
1,0,0,0,0]);

cmf = new ColorMatrixFilter([0,0,0,0,255,
0,0,0,0,255,
0,0,0,0,255,
0.4,0,0,0,0]);

generateSlices(totalSlices);

/*
var myBitmapDataObject:BitmapData = new BitmapData(640, 480);
//var seed:Number = Math.floor(Math.random()*100);
//myBitmapDataObject.perlinNoise(320, 240, 8, seed, true, true, 7, false, null);
var myBitmap:Bitmap = new Bitmap(myBitmapDataObject);
addChildAt(myBitmap, 0);
*/
}

public function generateSlices( _count:int ) : void {

cloudSlices = new Vector.(_count,true);

Perlin.octaves = 4;
Perlin.falloff = 0.01;

for (var i:uint = 0; i < _count; i++) {

generateCloudSlice(i);

bitmapData.applyFilter(bitmapData, bitmapData.rect, new Point(), cmf);

cloudSlices[i] = bitmapData.clone();
}

}

public function generateCloudSlice( _count:int ) : void {

var bd:BitmapData = bitmapData;

var depthSpeed:Number = 1;

for ( var i:uint = 0; i < bd.width; i++ ) {
for ( var j:uint = 0;j < bd.height; j++ ) {

var size:Number = 10;

var fNoise:Number = Perlin.noise( i/size, j/size, _count * depthSpeed );
var iNoise:int = int( (.5+1.*(fNoise-.5))*255 );
var iColor:uint = iNoise << 16 | iNoise << 8 | iNoise;
var iAlpha:uint = (iColor>>>24);
var iCompsite:uint = iAlpha + iColor;
bd.setPixel(i,j, iColor );

}
}

}

public function getCloudSlice( _number:int = -1) : BitmapData {

if (_number == -1) {
_number = currentSlice++;
if (currentSlice>= totalSlices) {
currentSlice = 0;
}
}

//_bitmap.bitmapData = cloudSlices[_number].clone();
/*
var clone:BitmapData = cloudSlices[_number].clone();
var alpha:BitmapData = new BitmapData(clone.width,clone.height, true, 0xFFFFFFFF);
alpha.fillRect(new Rectangle(0,0,25, 50), 0x00000000);

var bd:BitmapData = new BitmapData(clone.width,clone.height, true)
bd.copyPixels(clone, new Rectangle(0,0,clone.width,clone.height), new Point(0,0), clone, new Point(0,0), false);
*/
//return bd;
return cloudSlices[_number].clone();

}

public function getSlice(_sliceNum:int) : BitmapData {

var bd:BitmapData = new BitmapData(100,1);

bd.copyPixels(bitmapData, new Rectangle(0,0,100,1), new Point(0,0), bitmapData, new Point(0,0), true);

return bd;

}
}