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.BitmapData;
	import flash.display.BitmapDataChannel;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.events.AsyncErrorEvent;
	import flash.events.Event;
	import flash.media.Video;
	import flash.net.NetConnection;
	import flash.net.NetStream;
 
	import org.papervision3d.cameras.Camera3D;
	import org.papervision3d.core.proto.MaterialObject3D;
	import org.papervision3d.events.FileLoadEvent;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.BitmapColorMaterial;
	import org.papervision3d.materials.BitmapFileMaterial;
	import org.papervision3d.materials.BitmapMaterial;
	import org.papervision3d.materials.BitmapViewportMaterial;
	import org.papervision3d.materials.BitmapWireframeMaterial;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.materials.MovieMaterial;
	import org.papervision3d.materials.VideoStreamMaterial;
	import org.papervision3d.materials.WireframeMaterial;
	import org.papervision3d.materials.shadematerials.CellMaterial;
	import org.papervision3d.materials.shadematerials.EnvMapMaterial;
	import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
	import org.papervision3d.materials.shadematerials.GouraudMaterial;
	import org.papervision3d.materials.shadematerials.PhongMaterial;
	import org.papervision3d.materials.special.CompositeMaterial;
	import org.papervision3d.objects.DisplayObject3D;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.render.BasicRenderEngine;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.view.BitmapViewport3D;
	import org.papervision3d.view.Viewport3D;
 
	[SWF(width="900", height="480", backgroundColor="#000000", frameRate="31")]
	public class MaterialsReference extends Sprite
	{
		[Embed(source="assets/materials.swf", symbol="movieClipSymbol")]
		public var embeddedMovieClip:Class;
 
		[Embed(source="assets/materials.swf", symbol="bitmapSymbol")]
		public var embeddedBitmap:Class; 
 
		private var viewport:Viewport3D;
		private var scene:Scene3D;
		private var camera:Camera3D;
		private var renderer:BasicRenderEngine;
 
		private var material:MaterialObject3D;
 
		private var light:PointLight3D;
		private var lightInc:Number = 0;
 
		private var holder:DisplayObject3D;
 
		private var bitmapViewport3D:BitmapViewport3D;
 
		public function MaterialsReference()
		{
			init();
		}
 
		private function init():void
		{
			viewport = new Viewport3D(900, 480);
			addChild(viewport);
 
			scene = new Scene3D();
			camera = new Camera3D();
			renderer = new BasicRenderEngine();
 
			createLights();
			createMaterials();
			createObjects();
			addEventListeners();
		}
 
		private function createLights():void
		{
			var showLight:Boolean = true;
			var flipped:Boolean = false;
			light = new PointLight3D();
 
			light.x = -300;
			light.y = 250;
			light.z = -450;
 
			light.scale = 3;
		}
 
		private function makeLightVisible():void
		{
			scene.addChild(light);
		}		
 
/*----------------------------------------------------					
------------------------------------------------------
		___  ___      _            _       _
		|  \/  |     | |          (_)     | |
		| .  . | __ _| |_ ___ _ __ _  __ _| |
		| |\/| |/ _` | __/ _ \ '__| |/ _` | |
		| |  | | (_| | ||  __/ |  | | (_| | |
		\_|  |_/\__,_|\__\___|_|  |_|\__,_|_|
 
 
		______                _   _
		|  ___|              | | (_)
		| |_ _   _ _ __   ___| |_ _  ___  _ __  ___
		|  _| | | | '_ \ / __| __| |/ _ \| '_ \/ __|
		| | | |_| | | | | (__| |_| | (_) | | | \__ \
		\_|  \__,_|_| |_|\___|\__|_|\___/|_| |_|___/
 
		*/			
		private function createMaterials():void
		{
			/*Uncomment the function that corresponds
			to the material you want to test. 
 
			Pro tip #1:
			You can press "Control + / " to toggle a
			comment on and off.
 
			Pro tip #2:
			You can easily navigate between functions
			by using the "Outline" panel in the Flex
			development perspective or by pressing F3
			with the cursor in the the function name.
			*/
 
//			createWireframeMaterial();
//			createColorMaterial();
//			createBitmapMaterial();
//			createBitmapColorMaterial();
//			createBitmapFileMaterial();
//			createBitmapViewportMaterial();
//			createBitmapWireframeMaterial();
//			createMovieMaterial();
//			createCellMaterial();
//			createEnvMapMaterial();
//			createFlatShadeMaterial();
//			createGouraudMaterial();
//			createPhongMaterial();
//			createCompositeMaterial();
			createVideoStreamMaterial();
		}
 
//-------------------------------------------------		
//-------------------------------------------------		
 
 
 
		private function createWireframeMaterial():void
		{
			var color:int = 0xcc0000;
			var alpha:Number = 1;
			var thickness:Number = 3;
 
			material = new WireframeMaterial(color, alpha, thickness);
		}
 
		private function createColorMaterial():void
		{
			var color:Number = 0xcc0000;
			var alpha:Number = 1;
			var interactive:Boolean = false;
 
			material = new ColorMaterial(color, alpha, interactive);
		}
 
		private function createBitmapMaterial():void
		{
			var bitmap:Bitmap = new embeddedBitmap() as Bitmap;
			var bitmapData:BitmapData = bitmap.bitmapData
			var precise:Boolean = true;
 
			material = new BitmapMaterial(bitmapData, precise);
		}
 
		private function createBitmapColorMaterial():void
		{
			var color:int = 0xffffff;
			var alpha:Number = 1;
 
			material = new BitmapColorMaterial(color, alpha);
 
			//The following three lines demonstrate that
			//you can modify the bitmap of a BitmapColorMaterial
			//with the BitmapData class properties/methods
			var seed:Number = Math.floor(Math.random() * 10);
			var channels:uint = BitmapDataChannel.RED | BitmapDataChannel.GREEN;
			material.bitmap.perlinNoise(100, 80, 6, seed, false, true, channels, false, null);
 
		}
 
		private function createBitmapFileMaterial():void
		{
			material = new BitmapFileMaterial("assets/Commons.png");
			//to listen for the events
			/*
			material.addEventListener(FileLoadEvent.LOAD_PROGRESS, onProgressHandler);
			material.addEventListener(FileLoadEvent.LOAD_ERROR, onErrorHandler);
			material.addEventListener(FileLoadEvent.LOAD_COMPLETE, onCompleteHandler);
			*/
		}
 
		//Event handlers for the BitmapFileMaterial-------------------------------
		private function onProgressHandler(event:FileLoadEvent):void
		{
			//handle progress usually with event.bytesLoaded and event.bytesTotal
		}
 
		private function onErrorHandler(event:FileLoadEvent):void
		{
			//handle load errors
		}
 
		private function onCompleteHandler(event:FileLoadEvent):void
		{
			//handle load complete	
		}
		//--------------------------------------------------------------------------
 
 
		private function createBitmapViewportMaterial():void
		{
			var width:Number = 300;
			var height:Number = 200;
			var autoScaleToStage:Boolean = false;
			var bitmapTransparent:Boolean = false;
			var backgroudColor:int = 0xffffff;
 
			bitmapViewport3D = new BitmapViewport3D(width, height, autoScaleToStage, bitmapTransparent, backgroudColor);
 
			var precise:Boolean = true;
 
			var bitmapViewportMaterial:BitmapViewportMaterial = new BitmapViewportMaterial(bitmapViewport3D, precise);
 
			var bitmapViewportWidth:Number = 1000;
			var bitmapViewportHeight:Number = 1000;
 
			var bitmapViewportPlane:Plane = new Plane(bitmapViewportMaterial, bitmapViewportWidth, bitmapViewportHeight);
			bitmapViewportPlane.x = 500;
			bitmapViewportPlane.y = 400;
			bitmapViewportPlane.z = 400;
 
			bitmapViewportPlane.yaw(60);
			bitmapViewportPlane.pitch(-15);
 
 
			scene.addChild(bitmapViewportPlane);
		}
 
		private function createBitmapWireframeMaterial():void
		{
			var color:int = 0xcc0000;
			var alpha:Number = .7;
			var thickness:Number = 1;
 
			material = new BitmapWireframeMaterial(color, alpha, thickness);
		}
 
		private function createMovieMaterial():void
		{
			var movieClip:MovieClip = new embeddedMovieClip()  as MovieClip;
			var transparent:Boolean = true;
			var animated:Boolean = true;
			var precise:Boolean = true;
 
			//loop the MovieClip so it doesn't play beyond 
			movieClip.addFrameScript(movieClip.totalFrames-2, loop);
 
			function loop():void
			{
				movieClip.gotoAndPlay(1);
			}
 
			material = new MovieMaterial(movieClip, transparent, animated, precise);
			material.doubleSided = true;
		}
 
		private function createCompositeMaterial():void
		{
			var mat1:WireframeMaterial = new WireframeMaterial(0xcc0000);
 
			var bitmap:Bitmap = new embeddedBitmap() as Bitmap;
			var bitmapData:BitmapData = bitmap.bitmapData;
			var mat2:BitmapMaterial = new BitmapMaterial(bitmapData);
 
			var compositeMaterial:CompositeMaterial = new CompositeMaterial();
 
			compositeMaterial.addMaterial(mat1);
			compositeMaterial.addMaterial(mat2);
 
			material = compositeMaterial;
		}
 
		private function createCellMaterial():void
		{
			var color_1:int = 0xffffcc;
			var color_2:int = 0xcc0000;
			var steps:int = 10;
 
			material = new CellMaterial(light, color_1, color_2, steps);
 
			makeLightVisible();
		}
 
		private function createEnvMapMaterial():void
		{
			var bitmap:Bitmap = new embeddedBitmap() as Bitmap;
			var bitmapData:BitmapData = bitmap.bitmapData;
			material = new EnvMapMaterial(light, bitmapData);
 
			makeLightVisible();
		}
 
		private function createFlatShadeMaterial():void
		{
			var diffuse:int = 0xcccc00;
			var ambient:int = 0x444444;
 
			material = new FlatShadeMaterial(light, diffuse, ambient);
 
			makeLightVisible();
 
 
		}
 
		private function createGouraudMaterial():void
		{
			var lightColor:int = 0xcccc00;
			var ambientColor:int = 0x444444;
 
			material = new GouraudMaterial(light, lightColor, ambientColor);
 
			makeLightVisible();
		}
 
		private function createPhongMaterial():void
		{
			var lightColor:int = 0xcccc00;
			var ambientColor:int = 0x444444;
			var specular:int = 100;
 
			material = new PhongMaterial(light, lightColor, ambientColor, specular);
 
			makeLightVisible();
		}
 
		private function createVideoStreamMaterial():void
		{
			var netConnection:NetConnection = new NetConnection();
			netConnection.connect(null);
 
			var client:Object = new Object();
			//You just need this to avoid "the onMetaData error"
			//You can make these actual functions if you like
			client.onCuePoint = function():void{};
			client.onMetaData = function():void{};
 
			var netStream:NetStream = new NetStream(netConnection);
			netStream.client = client;
			netStream.addEventListener(AsyncErrorEvent.ASYNC_ERROR, asyncErrorHandler);
			netStream.play("assets/backyard.flv");
 
			var video:Video = new Video(480, 272);
			video.attachNetStream(netStream);
 
			material = new VideoStreamMaterial(video, netStream);
		}
 
		private function createObjects():void
		{	
 
			holder = new DisplayObject3D();
			holder.pitch(-30);
 
			var numberOfPlanes:int = 8;
 
			for(var i:int = 0; i<numberOfPlanes; i++)
			{
//				var carouselObject:Sphere = new Sphere(material, 100);
				var carouselObject:Plane = new Plane(material);
				holder.addChild(carouselObject);
				carouselObject.yaw(360/numberOfPlanes*i);
				carouselObject.moveForward(600);	
			}
 
			var centerObject:Sphere = new Sphere(material, 250, 16, 12);
//			var centerObject:Plane = new Plane(material);
			holder.addChild(centerObject);
 
			scene.addChild(holder);
		}
 
		private function addEventListeners():void
		{
			addEventListener(Event.ENTER_FRAME, render);
		}
 
		private function render(e:Event):void
		{
			holder.yaw(2);
			renderer.renderScene(scene, camera, viewport);
 
			if(bitmapViewport3D != null)
			{
				renderer.renderScene(scene, camera, bitmapViewport3D);
			}
 
			light.x = Math.cos(lightInc) * 1000;
			lightInc += .1;
		}
 
		private function asyncErrorHandler(error:AsyncErrorEvent):void
		{
			//do nothing
		}
 
		private function preventImportDeleting():void
		{
			//These are just placeholders so Flex doesn't auto delete their imports
			//Only for demonstration purposes, not for use in production
 
			Plane;
			Sphere;
 
			WireframeMaterial;
			ColorMaterial;
 
			BitmapColorMaterial;
			BitmapFileMaterial;
			FileLoadEvent; //for events associated with loading bitmaps
			BitmapMaterial;
			BitmapViewport3D;
			BitmapViewportMaterial;
			BitmapWireframeMaterial;
 
			MovieMaterial;
 
			VideoStreamMaterial;
 
			CellMaterial;
			EnvMapMaterial;
			FlatShadeMaterial;
			GouraudMaterial;
			PhongMaterial;
		}
	}
}

package {
	import com.as3dmod.ModifierStack;
	import com.as3dmod.modifiers.Perlin;
	import com.as3dmod.plugins.pv3d.LibraryPv3d;
 
	import flash.events.Event;
 
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.BitmapMaterial;
	import org.papervision3d.materials.shaders.GouraudShader;
	import org.papervision3d.materials.shaders.ShadedMaterial;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="900", height="480", backgroundColor="#000000", frameRate="31")]
	public class PerlinWater extends BasicView
	{
		[Embed(source="assets/seamlesswater.jpg")]
		private var waterAsset:Class; 
 
		private var sphere:Sphere;
		private var modifierStack:ModifierStack;
 
 
		public function PerlinWater()
		{
			var bitmapMaterial:BitmapMaterial = new BitmapMaterial(new waterAsset().bitmapData, true);
 
			sphere = new Sphere(bitmapMaterial, 400, 16, 12);
			sphere.rotationX = 45;
			sphere.rotationY = 45;
 
			modifierStack = new ModifierStack(new LibraryPv3d(), sphere);
 
			var perlin:Perlin = new Perlin(2);
			modifierStack.addModifier(perlin);
 
			scene.addChild(sphere);
 
			startRendering();
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			sphere.rotationY += (viewport.containerSprite.mouseX - sphere.rotationY) * .1;
 
			modifierStack.apply();
 
			super.onRenderTick(event);
		}
 
	}
}