package
{
	import flash.display.Bitmap;
	import flash.events.Event;
 
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.BitmapMaterial;
	import org.papervision3d.materials.shaders.PhongShader;
	import org.papervision3d.materials.shaders.ShadedMaterial;
	import org.papervision3d.materials.shaders.Shader;
	import org.papervision3d.materials.utils.MaterialsList;
	import org.papervision3d.objects.primitives.Cube;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class CubeWithDifferentSides extends BasicView
	{
		[Embed(source="assets/back.jpg")]
		private var backAsset:Class;
 
		[Embed(source="assets/bottom.jpg")]
		private var bottomAsset:Class;
 
		[Embed(source="assets/front.jpg")]
		private var frontAsset:Class;
 
		[Embed(source="assets/left.jpg")]
		private var leftAsset:Class;
 
		[Embed(source="assets/right.jpg")]
		private var rightAsset:Class;
 
		[Embed(source="assets/top.jpg")]
		private var topAsset:Class;
 
		private var light:PointLight3D;
		private var cube:Cube;
 
		public function CubeWithDifferentSides()
		{
			var materialsList:MaterialsList = new MaterialsList();
 
			light = new PointLight3D();
 
			materialsList.addMaterial(createShadedMaterial( new backAsset() ), "back");
			materialsList.addMaterial(createShadedMaterial( new bottomAsset() ), "bottom");
			materialsList.addMaterial(createShadedMaterial( new frontAsset() ), "front");
			materialsList.addMaterial(createShadedMaterial( new leftAsset() ), "left");
			materialsList.addMaterial(createShadedMaterial( new rightAsset() ), "right");
			materialsList.addMaterial(createShadedMaterial( new topAsset() ), "top");
 
			cube = new Cube(materialsList, 500, 500, 500, 5, 5, 5);
			scene.addChild(cube);
 
			startRendering();
		}
 
		private function createShadedMaterial(bitmap:Bitmap):ShadedMaterial
		{
			var bitmapMaterial:BitmapMaterial = new BitmapMaterial(bitmap.bitmapData, true);
			var shader:Shader = new PhongShader(light, 0xffffff, 0x333333, 10, bitmap.bitmapData, bitmap.bitmapData);
			var shadedMaterial:ShadedMaterial = new ShadedMaterial(bitmapMaterial, shader);
			return shadedMaterial;
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			cube.rotationY += (viewport.containerSprite.mouseX - cube.rotationY) * .1;
			cube.rotationX += (viewport.containerSprite.mouseY - cube.rotationX) * .1;
			renderer.renderScene(scene, camera, viewport);
		}
	}
}

private var mousePVec:b2Vec2 = new b2Vec2();
private var mouseJoint:b2MouseJoint;
private var mouseXWorldPhys:Number;
private var mouseYWorldPhys:Number;
private var isMouseDown:Boolean = false;

 
private function setupMouseEvents():void
{
	stage.addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
	stage.addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
}
 
private function onMouseDown(e:MouseEvent):void{isMouseDown = true;};
private function onMouseUp(e:MouseEvent):void{isMouseDown = false;};
 
private function updateMouseWorld():void{
	mouseXWorldPhys = mouseX/WORLD_SCALE; 
	mouseYWorldPhys = mouseY/WORLD_SCALE; 
}
 
private function mouseDrag():void{
	// mouse press
	if (isMouseDown && !mouseJoint){
 
		//refer to 'getBodyAtMouse()' below
		var body:b2Body = getBodyAtMouse();
 
		if (body)
		{
			var md:b2MouseJointDef = new b2MouseJointDef();
			md.body1 = world.m_groundBody;
			md.body2 = body;
			md.target = new b2Vec2(mouseXWorldPhys, mouseYWorldPhys);
			md.maxForce = 300.0 * body.m_mass;
			md.timeStep = timeStep;
			mouseJoint = world.CreateJoint(md) as b2MouseJoint;
			body.WakeUp();
		}
	}
 
	// mouse release
	if (!isMouseDown){
		if (mouseJoint){
			world.DestroyJoint(mouseJoint);
			mouseJoint = null;
		}
	}
 
 
	// mouse move
	if (mouseJoint)
	{
		var p2:b2Vec2 = new b2Vec2(mouseXWorldPhys, mouseYWorldPhys);
		mouseJoint.m_target = p2;
	} 
}
 
public function getBodyAtMouse(isStaticIncluded:Boolean=false):b2Body{
	// Make a small box.
	mousePVec = new b2Vec2(mouseXWorldPhys, mouseYWorldPhys);
	var aabb:b2AABB = new b2AABB();
	aabb.lowerBound = new b2Vec2(mouseXWorldPhys - 0.001, mouseYWorldPhys - 0.001);
	aabb.upperBound = new b2Vec2(mouseXWorldPhys + 0.001, mouseYWorldPhys + 0.001);
 
	// Query the world for overlapping shapes.
	var maxCount:int = 10;
	var shapes:Array = new Array();
	var count:int = world.Query(aabb, shapes, maxCount);
	var body:b2Body = null;
	for (var i:int = 0; i < count; ++i)
	{
		var shape:b2Shape = shapes[i] as b2Shape;
		var inside:Boolean = shape.TestPoint(shape.m_body.GetXForm(), mousePVec);
		if (inside)
		{
			body = shape.m_body;
			break;
		}
	}
	return body;
}

override protected function onRenderTick(event:Event=null):void
{
	updateMouseWorld();
	mouseDrag();
[...]

private function createWalls():void
{
	 var wallShapeDef:b2PolygonDef = new b2PolygonDef();
	var wallBodyDef:b2BodyDef = new b2BodyDef();
	var wall:b2Body;
 
	//Left and Right Shape Definition
	wallShapeDef.SetAsBox(100/WORLD_SCALE, (HEIGHT+40)/WORLD_SCALE/2);
 
	// Left
	wallBodyDef.position = new b2Vec2(-95 / WORLD_SCALE, HEIGHT/WORLD_SCALE/2);
	wall = world.CreateBody(wallBodyDef);
	wall.CreateShape(wallShapeDef);
 
	// Right
	wallBodyDef.position = new b2Vec2((WIDTH+95) / WORLD_SCALE, HEIGHT/WORLD_SCALE/2);
	wall = world.CreateBody(wallBodyDef);
	wall.CreateShape(wallShapeDef);
}

private function createCubes():void
{
	for (var i:Number = 0; i < 10; i++)
	{
		var boxWidth:Number = Math.random() * 20 + 10;
 
		var boxBody:b2BodyDef = new b2BodyDef();
		boxBody.position = new b2Vec2(Math.random() * WIDTH / WORLD_SCALE, Math.random() * 50 /WORLD_SCALE);
 
		var box:b2Body = world.CreateBody(boxBody);
 
		var boxShape:b2PolygonDef = new b2PolygonDef();
		boxShape.SetAsBox(boxWidth/WORLD_SCALE, boxWidth/WORLD_SCALE);
		boxShape.density = .7;
		boxShape.friction = .3;
		boxShape.restitution = .9;
 
		box.CreateShape(boxShape);
 
		box.SetMassFromShapes();
 
		var materialsList:MaterialsList = new MaterialsList();
		materialsList.addMaterial(new WireframeMaterial(Math.random() * 0xffffff), "all");
		var cube:Cube = new Cube(materialsList, boxWidth * 2, boxWidth * 2, boxWidth * 2);
 
		scene.addChild(cube);
		box.m_userData = cube;
	}
}

package
{
	import Box2D.Collision.Shapes.b2CircleDef;
	import Box2D.Collision.Shapes.b2PolygonDef;
	import Box2D.Collision.b2AABB;
	import Box2D.Common.Math.b2Vec2;
	import Box2D.Dynamics.b2Body;
	import Box2D.Dynamics.b2BodyDef;
	import Box2D.Dynamics.b2World;
 
	import flash.events.Event;
 
	import org.papervision3d.objects.DisplayObject3D;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class Box2DFlashWithPapervision3D extends BasicView
	{
		private var WORLD_SCALE:Number = 30;
		private var WIDTH:Number = 640;
		private var HEIGHT:Number = 480;
 
		private var world:b2World;
 
		private var iterations:int = 10;
		private var timeStep:Number = 1.0/30.0;
 
		public function Box2DFlashWithPapervision3D()
		{
			setupPapervision3D();
			createWorld();
			createFloor();
			createShapes();
 
			startRendering();
		}
 
		private function setupPapervision3D():void
		{
			camera.focus = 10;
			camera.zoom = 100;
		}
 
		private function createWorld():void {
			var worldBounds:b2AABB = new b2AABB();
			worldBounds.lowerBound = new b2Vec2( 0, 0 );
			worldBounds.upperBound = new b2Vec2(WIDTH/WORLD_SCALE, HEIGHT/WORLD_SCALE);
 
 			var gravity:b2Vec2 = new b2Vec2(0, 10);
			var sleep:Boolean = true;
 
			world = new b2World(worldBounds, gravity, sleep);
		}
 
		private function createFloor():void
		{
			// Create border of boxes
			var floorShapeDef:b2PolygonDef = new b2PolygonDef();
			var floorBodyDef:b2BodyDef = new b2BodyDef();
			var floor:b2Body;
 
			//bottom shape definition
			floorShapeDef.SetAsBox((WIDTH+40)/WORLD_SCALE/2, 100/WORLD_SCALE);
 
			// Bottom
			floorBodyDef.position = new b2Vec2(WIDTH/WORLD_SCALE/2, (HEIGHT+95)/WORLD_SCALE);
			floor = world.CreateBody(floorBodyDef);
			floor.CreateShape(floorShapeDef);
 
			floor.SetMassFromShapes();
		}
 
		private function createShapes():void
		{
			for (var i:Number = 0; i < 20; i++)
			{
				//radius for physics circle and sphere
				var radius:Number = Math.random() * 50 + 10;
 
				var bodyDef:b2BodyDef = new b2BodyDef();
				//random position toward the top of the stage
				bodyDef.position = new b2Vec2(Math.random() * WIDTH / WORLD_SCALE, Math.random() * 50 /WORLD_SCALE);
 
				var body:b2Body = world.CreateBody(bodyDef);
 
				var shapeDef:b2CircleDef = new b2CircleDef();
				shapeDef.radius = radius/WORLD_SCALE;
				shapeDef.density = 1;
				shapeDef.friction = .7;
				shapeDef.restitution = .7;
				body.CreateShape(shapeDef);
				body.SetMassFromShapes();
 
				var sphere:Sphere = new Sphere(null, radius);
 
				scene.addChild(sphere);
				body.m_userData = sphere;
			}
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			world.Step(timeStep, iterations);
 
			//sets the position of any DisplayObject3D to the body position
			for (var bb:b2Body = world.m_bodyList; bb; bb = bb.m_next)
			{
                if (bb.m_userData is DisplayObject3D)
                {
                        bb.m_userData.x = bb.GetPosition().x * WORLD_SCALE - WIDTH * .5;
                        bb.m_userData.y = -bb.GetPosition().y * WORLD_SCALE + HEIGHT * .5;
                        bb.m_userData.rotationZ = -bb.GetAngle() * (180/Math.PI);
                }
			}
			renderer.renderScene(scene, camera, viewport);
		}
	}
}