package
{
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.geom.Point;
 
	import org.papervision3d.core.math.Matrix3D;
	import org.papervision3d.core.math.Number3D;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class Trackball extends BasicView
	{
		private static const FORWARD:Number3D = new Number3D(0, 0, 1);
 
		private var sphere:Sphere;
		private var previousMousePoint:Point = new Point();
		private var isMouseDown:Boolean = false;
 
		public function Trackball()
		{
			var light:PointLight3D = new PointLight3D();
			var flatShadeMaterial:FlatShadeMaterial = new FlatShadeMaterial(light, 0xcc0000, 0x222222);
			sphere = new Sphere(flatShadeMaterial, 500, 32, 24);
 
			scene.addChild(sphere);
			startRendering();
 
			stage.addEventListener(MouseEvent.MOUSE_DOWN, stage_mouseDownHandler);
			stage.addEventListener(MouseEvent.MOUSE_UP, stage_mouseUpHandler);
		}		
 
		private function stage_mouseDownHandler(event:MouseEvent):void
		{
			isMouseDown = true;
		}
 
		private function stage_mouseUpHandler(event:MouseEvent):void
		{
			isMouseDown = false;	
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			var currentMousePoint:Point = new Point(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY);
 
			if(isMouseDown)
			{
				var difference:Point = currentMousePoint.subtract(previousMousePoint);
	 			var vector:Number3D = new Number3D(difference.x, difference.y, 0);
 
				var rotationAxis:Number3D = Number3D.cross(vector, FORWARD);
				rotationAxis.normalize();
 
				var distance:Number = Point.distance(currentMousePoint, previousMousePoint);
				var rotationMatrix:Matrix3D = Matrix3D.rotationMatrix(rotationAxis.x, -rotationAxis.y, rotationAxis.z, distance/250);
 
				sphere.transform.calculateMultiply3x3(rotationMatrix, sphere.transform);
			}
 
			previousMousePoint = currentMousePoint;
 
			super.onRenderTick(event);
		}
	}
}

package
{
	import flash.display.BitmapData;
	import flash.events.Event;
	import flash.events.MouseEvent;
	import flash.geom.Point;
 
	import org.papervision3d.core.geom.renderables.Vertex3D;
	import org.papervision3d.core.math.Number3D;
	import org.papervision3d.core.math.Plane3D;
	import org.papervision3d.core.proto.MaterialObject3D;
	import org.papervision3d.events.InteractiveScene3DEvent;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.BitmapMaterial;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class DraggingPlanes extends BasicView
	{
		private const NUM_PLANES:int = 11;
 
		private var planeToDragOn:Plane3D;
		private var currentPlane:Plane;
 
		private var light:PointLight3D;
 
		public function DraggingPlanes()
		{
			viewport.interactive = true;
 
			camera.y = 100;
 
			for(var i:int = 0; i < NUM_PLANES; i++)
			{
				var material:MaterialObject3D = createMaterial();
				material.interactive = true;
				/*
				Please note that, by default, the material on a plane
				is placed on the "back" of a plane (since the camera defaults
				to -1000 z. So if you tell the plane to "lookAt" the camera,
				you will see the front of the plane with nothing on it. You can
				solve this by making the material doubleSided
				*/
				material.doubleSided = true;
				var plane:Plane = new Plane(material, 100, 100, 4, 4);
				plane.x = (i - NUM_PLANES/2) * 200;
 
				scene.addChild(plane);
				plane.lookAt(camera);
 
				plane.addEventListener(InteractiveScene3DEvent.OBJECT_PRESS, objectPressHandler);
				stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
			}
 
			var up:Number3D = new Number3D(0, 1, 0);
			planeToDragOn = new Plane3D(up, new Number3D(0,0,0));
 
			startRendering(); 	
		}
 
		private function createMaterial():MaterialObject3D
		{
			var bitmapData:BitmapData = new BitmapData(300, 200, false, Math.random() * 0xffffff);
			var bitmapBorder:BitmapData = new BitmapData(320, 220, false, 0xffffff);
 
			bitmapBorder.copyPixels(bitmapData, bitmapData.rect, new Point(10, 10));
 
			var bitmapMaterial:BitmapMaterial = new BitmapMaterial(bitmapBorder, true);
			bitmapMaterial.smooth = true;
 
			return bitmapMaterial;
		}
 
		private function objectPressHandler(event:InteractiveScene3DEvent):void
		{
			currentPlane = event.displayObject3D as Plane;
		}
 
		private function mouseUpHandler(event:MouseEvent):void
		{
			currentPlane = null;
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			var ray:Number3D = camera.unproject(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY);
			ray = Number3D.add(ray, camera.position);
 
			var cameraVertex3D:Vertex3D = new Vertex3D(camera.x, camera.y, camera.z);
			var rayVertex3D:Vertex3D = new Vertex3D(ray.x, ray.y, ray.z);
 
			var intersectPoint:Vertex3D = planeToDragOn.getIntersectionLine(cameraVertex3D, rayVertex3D);
 
			if(currentPlane)
			{
				currentPlane.x = intersectPoint.x;
				currentPlane.y = intersectPoint.y;
				currentPlane.z = intersectPoint.z;
				currentPlane.lookAt(camera);
			}
 
			renderer.renderScene(scene, camera, viewport);
		}
	}
}

package
{
	import flash.events.Event;
	import flash.events.MouseEvent;
 
	import org.papervision3d.core.geom.renderables.Vertex3D;
	import org.papervision3d.core.math.Number3D;
	import org.papervision3d.core.math.Plane3D;
	import org.papervision3d.events.InteractiveScene3DEvent;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class DraggingASphere extends BasicView
	{
		private const NUM_SPHERES:int = 11;
 
		private var planeToDragOn:Plane3D;
		private var currentSphere:Sphere;
 
		private var light:PointLight3D;
 
		public function DraggingASphere()
		{
			viewport.interactive = true;
 
			camera.y = 400;
 
			light = new PointLight3D(true);
			scene.addChild(light);
 
			for(var i:int = 0; i < NUM_SPHERES; i++)
			{
				var material:FlatShadeMaterial = new FlatShadeMaterial(light, 0xeeeeee, 0x2d2d2d, 10);
				material.interactive = true;
				var sphere:Sphere = new Sphere(material);
				sphere.x = (i - NUM_SPHERES/2) * 200;
 
				scene.addChild(sphere);
 
				sphere.addEventListener(InteractiveScene3DEvent.OBJECT_PRESS, objectPressHandler);
				stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
			}
 
			var up:Number3D = new Number3D(0, 1, 0);
			planeToDragOn = new Plane3D(up, new Number3D(0,0,0));
 
			startRendering(); 	
		}
 
		private function objectPressHandler(event:InteractiveScene3DEvent):void
		{
			currentSphere = event.displayObject3D as Sphere;
		}
 
		private function mouseUpHandler(event:MouseEvent):void
		{
			currentSphere = null;
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			var ray:Number3D = camera.unproject(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY);
			ray = Number3D.add(ray, camera.position);
 
			var cameraVertex3D:Vertex3D = new Vertex3D(camera.x, camera.y, camera.z);
			var rayVertex3D:Vertex3D = new Vertex3D(ray.x, ray.y, ray.z);
 
			var intersectPoint:Vertex3D = planeToDragOn.getIntersectionLine(cameraVertex3D, rayVertex3D);
 
			if(currentSphere)
			{
				currentSphere.x = intersectPoint.x;
				currentSphere.y = intersectPoint.y;
				currentSphere.z = intersectPoint.z;
			}
 
			light.x = intersectPoint.x;
			light.y = intersectPoint.y + 100;
			light.z = intersectPoint.z;
 
			renderer.renderScene(scene, camera, viewport);
		}
	}
}