package
{
	import flash.events.Event;
	import flash.filters.BlurFilter;
 
	import org.flintparticles.common.actions.Age;
	import org.flintparticles.common.counters.Steady;
	import org.flintparticles.common.initializers.ColorInit;
	import org.flintparticles.common.initializers.Lifetime;
	import org.flintparticles.threeD.actions.Accelerate;
	import org.flintparticles.threeD.actions.Move;
	import org.flintparticles.threeD.emitters.Emitter3D;
	import org.flintparticles.threeD.geom.Vector3D;
	import org.flintparticles.threeD.initializers.Velocity;
	import org.flintparticles.threeD.papervision3d.PV3DPixelRenderer;
	import org.flintparticles.threeD.zones.DiscZone;
	import org.papervision3d.core.effects.BitmapLayerEffect;
	import org.papervision3d.core.geom.Pixels;
	import org.papervision3d.view.BasicView;
	import org.papervision3d.view.layer.BitmapEffectLayer;	
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class FlintPixels extends BasicView
	{
		private var emitter:Emitter3D;
		private var flintRenderer:PV3DPixelRenderer;
		private var bitmapEffectLayer:BitmapEffectLayer;
		private var pixels:Pixels;
 
		public function FlintPixels()
		{
			camera.z = -300;
 
			setupPixels();
			setupEmitter();
			setupFlintRenderer();
 
			emitter.start();
 
			startRendering();
		}
 
		private function setupPixels():void
		{
			bitmapEffectLayer = new BitmapEffectLayer(viewport);
			viewport.containerSprite.addLayer( bitmapEffectLayer );
 
			pixels = new Pixels(bitmapEffectLayer);
			bitmapEffectLayer.addDisplayObject3D(pixels);
			scene.addChild(pixels);
 
			bitmapEffectLayer.addEffect(new BitmapLayerEffect(new BlurFilter(2, 2, 1)));
		}
 
		private function setupEmitter():void
		{
			emitter = new Emitter3D();
			emitter.counter = new Steady( 500 );
 
			emitter.addInitializer(new ColorInit(0xffcc0000, 0xffffffff));
			emitter.addInitializer(new Velocity(new DiscZone(new Vector3D(0, 340, 0), new Vector3D(0, 1, 0), 100, 100)));
			emitter.addInitializer(new Lifetime(3));
 
			emitter.addAction(new Move());
			emitter.addAction(new Accelerate(new Vector3D(0, -300, 0)));
			emitter.addAction(new Age());
		}
 
		private function setupFlintRenderer():void
		{
			flintRenderer = new PV3DPixelRenderer(pixels);
			flintRenderer.addEmitter(emitter);
		}
 
		override protected function onRenderTick(event:Event = null):void
		{
			pixels.rotationY += (viewport.containerSprite.mouseX - pixels.rotationY) * .3;
			pixels.rotationX += (viewport.containerSprite.mouseY - pixels.rotationX) * .3;
			renderer.renderScene(scene, camera, viewport);
		}
	}
}

package
{
	import com.as3dmod.ModifierStack;
	import com.as3dmod.modifiers.Bend;
	import com.as3dmod.plugins.pv3d.LibraryPv3d;
 
	import flash.events.Event;
 
	import org.papervision3d.materials.WireframeMaterial;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class Papervision3DwithAS3Dmod extends BasicView
	{
		private var plane:Plane;
		private var modifierStack:ModifierStack;
		private var bend:Bend;
 
		public function Papervision3DwithAS3Dmod()
		{
			var wireframeMaterial:WireframeMaterial = new WireframeMaterial(0xcc0000);
			wireframeMaterial.doubleSided = true;
 
			plane = new Plane(wireframeMaterial, 800, 800, 20, 20);
			plane.rotationX = 45;
			plane.rotationY = 45;
 
			modifierStack = new ModifierStack(new LibraryPv3d(), plane);
			bend = new Bend();
			modifierStack.addModifier(bend);
 
			scene.addChild(plane);
 
			startRendering();
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			plane.rotationY += (viewport.containerSprite.mouseX - plane.rotationY) * .1;
 
			bend.force += (viewport.containerSprite.mouseY / 100 - bend.force) * .3;
			modifierStack.apply();
 
			renderer.renderScene(scene, camera, viewport);
		}
	}
}

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);
		}
	}
}