package {
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.ui.Keyboard;
 
	import org.papervision3d.cameras.CameraType;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="900", height="480", backgroundColor="#000000", frameRate="31")]
	public class TestIfCulled extends BasicView
	{
		public function TestIfCulled()
		{
			super(900, 480, true, false, CameraType.DEBUG);
 
			//sidenote: if you don't want objects culled, disable culling
			//camera.useCulling = false;
 
			var length:int = 120;
			for(var i:int = 0; i < length; i++)
			{
				var greenMaterial:ColorMaterial = new ColorMaterial(0x00cc00);
				var plane:Plane = new Plane(greenMaterial);
				plane.x = Math.random() * 6000 - 3000;
				plane.y = Math.random() * 6000 - 3000;
				plane.z = Math.random() * 6000;
 
				scene.addChild(plane);
			}
 
			startRendering(); 
 
			trace("hit the space bar to reset visible planes to green");
			stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);
		}
 
		protected function keyDownHandler(event:KeyboardEvent):void
		{
			//reset all the visible to green when you hit space
			if(event.keyCode == Keyboard.SPACE)
			{
				for each(var plane:Plane in scene.children)
				{
					plane.material.fillColor = 0xc00cc00;
				}	
			}
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			super.onRenderTick(event);
 
			for each(var plane:Plane in scene.children)
			{
				//if it's culled change to red
				if(plane.culled)
				{
					plane.material.fillColor = 0xcc0000;
				}
			}	
		}
	}
}

package
{
	import flash.display.Bitmap;
	import flash.display.StageQuality;
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.ui.Keyboard;
	import flash.utils.ByteArray;
 
	import org.papervision3d.cameras.SpringCamera3D;
	import org.papervision3d.core.clipping.FrustumClipping;
	import org.papervision3d.core.math.Number3D;
	import org.papervision3d.materials.BitmapMaterial;
	import org.papervision3d.materials.utils.MaterialsList;
	import org.papervision3d.objects.DisplayObject3D;
	import org.papervision3d.objects.parsers.DAE;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.view.BasicView;
	import org.papervision3d.view.layer.ViewportLayer;
	import org.papervision3d.view.layer.util.ViewportLayerSortMode;
 
	[SWF(width="640", height="480", backgroundColor="#ffffff", frameRate="60")]
	public class DrivingACar extends BasicView
	{
		[Embed(source="assets/Focus.dae", mimeType = "application/octet-stream")]
		private var carAsset:Class;
 
		[Embed(source="/assets/wheel.jpg")]
		private var wheelBitmapAsset:Class;
 
		[Embed(source="/assets/body.jpg")]
		private var bodyBitmapAsset:Class;
 
		[Embed(source="/assets/grassTexture.jpg")]
		private var grassTextureBitmapAsset:Class;
 
		private var car:DAE;
 
		private var springCamera:SpringCamera3D;
		private var focusMaterials:MaterialsList;
 
		private var topSpeed:Number = 0;
		private var topSteer:Number = 0;
		private var speed:Number = 0;
		private var steer:Number = 0;
 
		private var keyRight:Boolean = false;
		private var keyLeft:Boolean = false;
		private var keyForward:Boolean = false;
		private var keyReverse:Boolean = false;
 
		public function DrivingACar()
		{
			super();
 
			addEventListener(Event.ENTER_FRAME, enterFrameHandler);
			stage.addEventListener( KeyboardEvent.KEY_DOWN, stage_keyDownHandler );
			stage.addEventListener( KeyboardEvent.KEY_UP, stage_keyUpHandler );
 
			setupScene();
 
			stage.quality = StageQuality.MEDIUM;
		}
 
		private function setupScene():void
		{
			renderer.clipping = new FrustumClipping(FrustumClipping.BOTTOM | FrustumClipping.NEAR);
 
			springCamera = new SpringCamera3D();
			springCamera.mass = 10;
			springCamera.damping = 10;
			springCamera.stiffness = 1;
			springCamera.lookOffset = new Number3D(0, 0, 10);
			springCamera.positionOffset = new Number3D(0, 5, -15);
 
			//Setup materials for the object
			var wheelBitmap:Bitmap = new wheelBitmapAsset() as Bitmap;
			var bodyBitmap:Bitmap = new bodyBitmapAsset() as Bitmap;
			var grassBitmap:Bitmap = new grassTextureBitmapAsset() as Bitmap;
 
			var bodyMaterial:BitmapMaterial = new BitmapMaterial(bodyBitmap.bitmapData);
			bodyMaterial.smooth = true;
			var wheelMaterial:BitmapMaterial = new BitmapMaterial(wheelBitmap.bitmapData);
			wheelMaterial.smooth = true;
			var grassMaterial:BitmapMaterial = new BitmapMaterial(grassBitmap.bitmapData);
			grassMaterial.precise = true;
			grassMaterial.tiled = true;
			grassMaterial.maxU = 2;
			grassMaterial.maxV = 2;
			grassMaterial.smooth = true;
 
			focusMaterials = new MaterialsList();
			focusMaterials.addMaterial(bodyMaterial, "materialBody");
			focusMaterials.addMaterial(wheelMaterial, "materialWheel");
 
			// Load Collada
			var byteArray:ByteArray = new carAsset() as ByteArray;
			car = new DAE(true);
			car.load(byteArray, focusMaterials);
			car.scale = 10;
 
			springCamera.target = car;
 
			scene.addChild(car);
 
			var ground:Plane = new Plane( grassMaterial, 1000, 1000, 2, 2);
			ground.y = -20;
			scene.addChild( ground );
 
			// Position the ground
			ground.rotationX = 90;
			viewport.containerSprite.sortMode = ViewportLayerSortMode.INDEX_SORT;
 
			var carViewportLayer:ViewportLayer = new ViewportLayer(viewport, car);
			carViewportLayer.addDisplayObject3D(car, true);
			carViewportLayer.layerIndex = 1;
 
			viewport.containerSprite.addLayer(carViewportLayer);
		}
 
		private function enterFrameHandler( event :Event ):void
		{
			// Check if car has been loaded
			if( car )
			{
				// Calculate current steer and speed
				driveCar();
				// Update car model
				updateCar();
			}
 
			// Render the scene
			singleRender();
		}
 
		private function updateCar():void
		{
			// Steer front wheels
			var steerFR :DisplayObject3D = car.getChildByName( "Steer_FR", true );
			var steerFL :DisplayObject3D = car.getChildByName( "Steer_FL", true );
 
			steerFR.rotationY = -steer;
			steerFL.rotationY = -steer;
 
			// Rotate wheels
			var wheelFR :DisplayObject3D = steerFR.getChildByName( "Wheel_FR", true );
			var wheelFL :DisplayObject3D = steerFL.getChildByName( "Wheel_FL", true );
			var wheelRR :DisplayObject3D = car.getChildByName( "Wheel_RR", true );
			var wheelRL :DisplayObject3D = car.getChildByName( "Wheel_RL", true );
 
			var roll :Number = speed * 2;
			wheelFR.roll(  -roll );
			wheelRR.roll(  -roll );
			wheelFL.roll( roll );
			wheelRL.roll( roll );
 
			// Steer car
			car.yaw( speed * steer / 500 );
 
			// Move car
			car.moveForward( speed );
		}
 
		private function driveCar():void
		{
			// Speed
			if( keyForward )
			{
				topSpeed = 7;
			}
			else if( keyReverse )
			{
				topSpeed = -2;
			}
			else
			{
				topSpeed = 0;
			}
 
			speed -= ( speed - topSpeed ) / 10;
 
			// Steer
			if( keyRight )
			{
				if( topSteer < 45 )
				{
					topSteer += 1.5;
				}
			}
			else if( keyLeft )
			{
				if( topSteer > -45 )
				{
					topSteer -= 1.5;
				}
			}
			else
			{
				topSteer -= topSteer / 24;
			}
 
			steer -= ( steer - topSteer ) / 2;
		}
 
		private function stage_keyDownHandler( event :KeyboardEvent ):void
		{
			switch( event.keyCode )
			{
				case "W".charCodeAt():
				case Keyboard.UP:
					keyForward = true;
					keyReverse = false;
					break;
 
				case "S".charCodeAt():
				case Keyboard.DOWN:
					keyReverse = true;
					keyForward = false;
					break;
 
				case "A".charCodeAt():
				case Keyboard.LEFT:
					keyLeft = true;
					keyRight = false;
					break;
 
				case "D".charCodeAt():
				case Keyboard.RIGHT:
					keyRight = true;
					keyLeft = false;
					break;
			}
		}
 
		private function stage_keyUpHandler( event :KeyboardEvent ):void
		{
			switch( event.keyCode )
			{
				case "W".charCodeAt():
				case Keyboard.UP:
					keyForward = false;
					break;
 
				case "S".charCodeAt():
				case Keyboard.DOWN:
					keyReverse = false;
					break;
 
				case "A".charCodeAt():
				case Keyboard.LEFT:
					keyLeft = false;
					break;
 
				case "D".charCodeAt():
				case Keyboard.RIGHT:
 
					keyRight = false;
					break;
			}
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			renderer.renderScene(scene, springCamera, viewport);
		}
 
	}
}