package
{
	import flash.display.Bitmap;
	import flash.display.BitmapData;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.ui.Keyboard;
 
	import org.papervision3d.core.proto.MaterialObject3D;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.materials.WireframeMaterial;
	import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.view.BasicView;
	import org.papervision3d.view.Viewport3D;
	import org.papervision3d.view.layer.ViewportLayer;
	import org.papervision3d.view.layer.util.ViewportLayerSortMode;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class Portal extends BasicView
	{
		private var portalViewport:Viewport3D = new Viewport3D();
		private var portalScene:Scene3D = new Scene3D();
		private var portalPlane:Plane;
 
		private var exposedViewport:Viewport3D = new Viewport3D();
		private var exposedScene:Scene3D = new Scene3D();
 
		private var mainSphere:Sphere;
		private var exposedSphere:Sphere;
 
		public function Portal()
		{
			addChild(exposedViewport);
			addChild(portalViewport);
 
			setupExposedViewport();
			setupPortalViewport();
			setupMainViewport();
 
			startRendering(); 	
			stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);
		}
 
		private function setupExposedViewport():void
		{
			var bitmapData:BitmapData = new BitmapData(640, 480, false, 0xffffff);
			var bitmap:Bitmap = new Bitmap(bitmapData);
			bitmap.x = -320;
			bitmap.y = -240;
 
			var viewportLayer:ViewportLayer = new ViewportLayer(exposedViewport, null);
			viewportLayer.addChild(bitmap);
			exposedViewport.containerSprite.addLayer(viewportLayer);
 
			var light:PointLight3D = new PointLight3D();
			var flatShadeMaterial:FlatShadeMaterial = new FlatShadeMaterial(light, 0xcc0000, 0x2b2b2b, 10);
			exposedSphere = createSpheres(flatShadeMaterial);
 
			var viewportLayer2:ViewportLayer = new ViewportLayer(exposedViewport, exposedSphere);
			for each(var sphere:Sphere in exposedSphere.children)
			{
				viewportLayer2.addDisplayObject3D(sphere);
			}
			exposedViewport.containerSprite.addLayer(viewportLayer2);
 
			viewportLayer.layerIndex = 1;
			viewportLayer2.layerIndex = 2;
			exposedViewport.containerSprite.sortMode = ViewportLayerSortMode.INDEX_SORT;
 
			exposedScene.addChild(exposedSphere);
 
			exposedViewport.containerSprite.mask = portalViewport;
		}
 
		private function setupPortalViewport():void
		{
			var whiteMaterial:ColorMaterial = new ColorMaterial(0xffffff);
			portalPlane = new Plane(whiteMaterial);
			portalPlane.z = -500;
			portalScene.addChild(portalPlane);
		}
 
		private function setupMainViewport():void
		{
			var wireframeMaterial:WireframeMaterial = new WireframeMaterial(0xffffff);
			mainSphere = createSpheres(wireframeMaterial);
 
			scene.addChild(mainSphere);
		}
 
		private function keyDownHandler(event:KeyboardEvent):void
		{
			switch(event.keyCode)
			{
				case Keyboard.UP:
					camera.moveForward(10);
					break;
 
				case Keyboard.DOWN:
					camera.moveBackward(10);
					break;	
			}
		}
 
		private function createSpheres(material:MaterialObject3D):Sphere
		{
			var parentSphere:Sphere = new Sphere(material);
 
			var child1:Sphere = new Sphere(material);
			child1.x = -500;
			var child2:Sphere = new Sphere(material);
			child2.x = 500;
			var child3:Sphere = new Sphere(material);
			child3.y = 500;
			var child4:Sphere = new Sphere(material);
			child4.y = -500;
 
			parentSphere.addChild(child1);
			parentSphere.addChild(child2);
			parentSphere.addChild(child3);
			parentSphere.addChild(child4);
 
			return parentSphere;
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			mainSphere.rotationY++;
			exposedSphere.rotationY++;
 
			portalPlane.moveForward(500);
			portalPlane.rotationY = -viewport.containerSprite.mouseX / 320 * 90;
			portalPlane.moveBackward(500);
 
 
			renderer.renderScene(portalScene, camera, portalViewport);
			renderer.renderScene(exposedScene, camera, exposedViewport);
			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);
		}
	}
}