/***********************************************\
 * Layer 1: earth
\***********************************************/


// creates a sphere
function createSphere(trianglePathOut:GraphicsTrianglePath,
					  vertices3DOut:Vector.<Vector3D>,
					  radius:Number = 100,
					  parallels:int = 5,
					  meridians:int = 10):void {
	
	if (parallels < 3) parallels = 3;
	if (meridians < 3) meridians = 3;
	meridians++; // texture edge meridian duplicated
	
	var parallelStops:int = parallels-1; // for determining u
	var meridianStops:int = meridians-1; // for determining v
	
	// local variables
	var r:Number; // radius
	var x:Number, y:Number, z:Number; // coordinates
	var p:int, pi:int, pa:Number; // parallel vars
	var m:int, mi:int, ma:Number; // meridian vars
	var u:Number, v:Number; // u, v of uvt
	var n:int = -1; // vertices index
	
	// horizontal
	for (p=0; p<parallels; p++){
		v = p/parallelStops;
		pa = v*Math.PI - Math.PI/2;
		y = radius*Math.sin(pa);
		r = radius*Math.cos(pa);
		
		// vertical
		for (m=0; m<meridians; m++){
			u = m/meridianStops;
			ma = u*Math.PI*2;
			x = r*Math.cos(ma);
			z = r*Math.sin(ma);
			
			// vertices
			vertices3DOut[++n] = new Vector3D(x,y,z);
			
			// trianglePathOut
			trianglePathOut.vertices.push(x, y);
			trianglePathOut.uvtData.push(u, v, 1);
			
			if (m != 0){ // not first meridian (texture edge)
				if (p != parallelStops){ // not last parallel (no next parallel to connect)
					trianglePathOut.indices.push(n, n+meridians, n+meridians-1);
					trianglePathOut.indices.push(n, n+meridians-1, n-1);
				}
			}
		}
	}
}





// converts a GraphicsTrianglePath's data to 3D
function transformIn3D(trianglePathOut:GraphicsTrianglePath,
					   vertices3DIn:Vector.<Vector3D>,
					   focal:Number,
					   rotationY:Number):void {
	
	// angle calculations for rotation around y
	var ca:Number = Math.cos(rotationY);
	var sa:Number = Math.sin(rotationY);
	
	var t:Number;
	var i:int, n:int = vertices3DIn.length;
	for (i=0; i<n; i++){
		
		// rotate points around y axis
		var x:Number = vertices3DIn[i].x*ca - vertices3DIn[i].z*sa;
		var z:Number = vertices3DIn[i].x*sa + vertices3DIn[i].z*ca;
		// no change in y rotating around that axis
		
		// 3D perspective
		t = focal/(focal + z);
		
		// set data in trianglePathOut
		trianglePathOut.uvtData[i*3 + 2]	= t; // perspective for bitmap
		trianglePathOut.vertices[i*2]		= x * t; // perspective x
		trianglePathOut.vertices[i*2 + 1]	= vertices3DIn[i].y * t; // perspective y
	}
}





// creates a darker version of a bitmap
function getDarkerBitmap(source:BitmapData, darkness:Number):BitmapData {

	// put source in a Bitmap display object
	// and darken it using a ColorTransform
	var darker:Bitmap = new Bitmap(source);
	darker.transform.colorTransform = new ColorTransform(darkness, darkness, darkness);
	
	// draw() does not take in account of
	// transformations on the object you draw
	// so place it in a container
	var container:Sprite = new Sprite();
	container.addChild(darker);
	
	// create a new BitmapData drawing
	// the darker image in the container
	var bmp:BitmapData = new BitmapData(source.width, source.height, source.transparent, 0);
	bmp.draw(container);
	return bmp;
}





// globe variables
var focal:Number			= 200;
var globeRadius:Number		= 100;
var globeParallels:int		= 10;
var globeMeridians:int		= 20;
var frontFace:BitmapData	= new Erf(0,0);
var backFace:BitmapData		= getDarkerBitmap(frontFace, .25);



// a GraphicsTrianglePath for the path
// data to be drawn in Flash
var triangles:GraphicsTrianglePath	= new GraphicsTrianglePath(
		new Vector.<Number>(), new Vector.<int>(),
		new Vector.<Number>(), TriangleCulling.NEGATIVE);
// create a vector of Vector3D objects to store
// 3D locations of sphere coordinates
var vectors3D:Vector.<Vector3D>		= new Vector.<Vector3D>();

// populate triangles andvectors3D and with
// sphere data
createSphere(triangles, vectors3D, globeRadius, globeParallels, globeMeridians);

// a new GraphicsTrianglePath container using the
// same vector data as triangles is created to draw
// the backside of the sphere once the darker version
// of the bitmap is added to the drawing state
var trianglesDark:GraphicsTrianglePath = new GraphicsTrianglePath(
		triangles.vertices, triangles.indices,
		triangles.uvtData, TriangleCulling.POSITIVE);

// IGraphicsData list of drawing commands, drawing back face
// first (dark), followed by front face (light)
var globeData:Vector.<IGraphicsData> = Vector.<IGraphicsData>([
	new GraphicsStroke(NaN, false, "normal", "none", "round", 3, new GraphicsSolidFill(0xFF0000)),
	new GraphicsBitmapFill(backFace, null, false, true),
	trianglesDark,
	new GraphicsBitmapFill(frontFace, null, false, true),
	triangles
]);




// create globe shape
var globe:Shape = new Shape();
globe.x = 275;
globe.y = 200;
addChild(globe);




// rotate globe in frame loop
addEventListener(Event.ENTER_FRAME, draw);
function draw(event:Event):void {
	
	// updates the triangle data used in globeData
	// applying 3D perspective and rotating around Y
	transformIn3D(triangles, vectors3D, focal, getTimer()/1000);
	
	globe.graphics.clear();
	globe.graphics.drawGraphicsData(globeData);
}


// show outlines when pressing the mouse
stage.addEventListener(MouseEvent.MOUSE_DOWN, toggleStroke);
stage.addEventListener(MouseEvent.MOUSE_UP, toggleStroke);
function toggleStroke(event:MouseEvent):void {
	GraphicsStroke(globeData[0]).thickness = (event.type == MouseEvent.MOUSE_DOWN)
		? 1
		: NaN;
}