package
{
	import flash.display.MovieClip;
	import flash.events.Event;
	import flash.events.MouseEvent;
 
	import org.papervision3d.materials.MovieMaterial;
	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 SwitchingMovieMaterialsOnACube extends BasicView
	{
		private var cube:Cube;
		private var currentAsset:Class = blueBoxAsset;
 
		public function SwitchingMovieMaterialsOnACube()
		{
			var materialsList:MaterialsList = new MaterialsList();
 
			//blueBoxAsset is the classname of the movie from the library in the MovieMaterials .swc
			//you have to create a new material for each side or the materialsList will replace all
			//the materials when you try to replace one side
			materialsList.addMaterial(createMovieMaterialFromAsset(blueBoxAsset), "front");
			materialsList.addMaterial(createMovieMaterialFromAsset(blueBoxAsset), "back");
			materialsList.addMaterial(createMovieMaterialFromAsset(blueBoxAsset), "left");
			materialsList.addMaterial(createMovieMaterialFromAsset(blueBoxAsset), "right");
			materialsList.addMaterial(createMovieMaterialFromAsset(blueBoxAsset), "top");
			materialsList.addMaterial(createMovieMaterialFromAsset(blueBoxAsset), "bottom");
 
			cube = new Cube(materialsList);
 
			scene.addChild(cube);
 
			startRendering();
 
			stage.addEventListener(MouseEvent.CLICK, stage_clickHandler);
		}
 
		//Creates a MovieMaterial based on a class reference
		//in this case, movieClips in the .swc
		private function createMovieMaterialFromAsset(asset:Class):MovieMaterial
		{
			var movieAsset:MovieClip = MovieClip(new asset());
			var movieMaterial:MovieMaterial = new MovieMaterial(movieAsset, true, true, true);
			movieMaterial.doubleSided = true;
 
			return movieMaterial;
		}
 
		private function stage_clickHandler(event:MouseEvent):void
		{
			var movieMaterial:MovieMaterial;
			if(currentAsset == blueBoxAsset)
			{
				movieMaterial = createMovieMaterialFromAsset(redBoxAsset);
				currentAsset = redBoxAsset;			
			}
			else
			{
				movieMaterial = createMovieMaterialFromAsset(blueBoxAsset);
				currentAsset = blueBoxAsset;			
			}
			//since the camera defaults to -1000 z, the "back" is the "front"
			cube.replaceMaterialByName(movieMaterial, "back");
		}
 
		override protected function onRenderTick(event:Event = null):void
		{
			cube.rotationX += (viewport.containerSprite.mouseY * .25 - cube.rotationX) * .1;
			cube.rotationY += (viewport.containerSprite.mouseX  * .25- cube.rotationY) * .1;
			super.onRenderTick(event);
		}
 
	}
}

package
{
	import flash.events.Event;
	import flash.filters.BlurFilter;
	import flash.geom.Point;
 
	import org.flintparticles.common.counters.Steady;
	import org.flintparticles.common.displayObjects.RadialDot;
	import org.flintparticles.common.initializers.ImageClass;
	import org.flintparticles.common.initializers.ScaleImageInit;
	import org.flintparticles.twoD.actions.DeathZone;
	import org.flintparticles.twoD.actions.Move;
	import org.flintparticles.twoD.actions.RandomDrift;
	import org.flintparticles.twoD.emitters.Emitter2D;
	import org.flintparticles.twoD.initializers.Position;
	import org.flintparticles.twoD.initializers.Velocity;
	import org.flintparticles.twoD.renderers.DisplayObjectRenderer;
	import org.flintparticles.twoD.zones.LineZone;
	import org.flintparticles.twoD.zones.PointZone;
	import org.flintparticles.twoD.zones.RectangleZone;
	import org.papervision3d.core.effects.view.ReflectionView;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.materials.special.Letter3DMaterial;
	import org.papervision3d.objects.DisplayObject3D;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.typography.Text3D;	
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class MerryChristmas extends ReflectionView
	{
		private var pivotPoint:DisplayObject3D = new DisplayObject3D();
 
		public function MerryChristmas()
		{
			viewportReflection.filters = [new BlurFilter(3,3,1)];
			setReflectionColor(.5, .5, .5);
			surfaceHeight = -80;
 
			setupText();
			setupSnow();
			setupTree();
 
			addEventListener(Event.ENTER_FRAME, enterFrameHandler);
		}
 
		private function setupText():void
		{
			var rockwell:Rockwell = new Rockwell();
			var merryMaterial:Letter3DMaterial = new Letter3DMaterial(0xcc0000);
			var merry:Text3D = new Text3D("MERRY", rockwell, merryMaterial);
 
			var christmasMaterial:Letter3DMaterial = new Letter3DMaterial(0x00cc00);
			var christmas:Text3D = new Text3D("CHRISTMAS", rockwell, christmasMaterial);
 
			merry.z = -700;
			christmas.z = 500;
			christmas.rotationY = 180;
 
			pivotPoint.addChild(merry);
			pivotPoint.addChild(christmas);
 
			scene.addChild(pivotPoint);
		}
 
		private function setupTree():void
		{
			var radius:Number = 300;
			var height:Number = 500;
			var total:uint = 100;
			var looker:DisplayObject3D = new DisplayObject3D();
			for(var i:int = 0; i < total; i++)
			{
				var material:ColorMaterial;
				if((i & 1) == 0) material = new ColorMaterial(0xaa0000);
				else material = new ColorMaterial(0x00aa00);
				material.doubleSided = true;
				var plane:Plane = new Plane(material, 30, 30, 1, 1);
				plane.x = Math.cos(i) * (radius - i * 3);
				plane.z = Math.sin(i) * (radius - i * 3);
				plane.y = i / total * height; 
				looker.copyPosition(plane);
				looker.x = looker.z = 0;
				plane.lookAt(looker);
				pivotPoint.addChild(plane);
			}
		}
 
		private function setupSnow():void
		{
			var emitter:Emitter2D = new Emitter2D();
			emitter.counter = new Steady(100);
 
			emitter.addInitializer(new ImageClass(RadialDot, 2));
			emitter.addInitializer(new Position(new LineZone(new Point(-5,-5), new Point(645, -5))));
			emitter.addInitializer(new Velocity(new PointZone(new Point(0, 65))));
			emitter.addInitializer(new ScaleImageInit(0.75, 2));
 
			emitter.addAction(new Move());
			emitter.addAction(new DeathZone(new RectangleZone(-10, -10, 640, 250), true));
			emitter.addAction(new RandomDrift(15, 15));
 
			var flintRenderer:DisplayObjectRenderer = new DisplayObjectRenderer();
			addChild(flintRenderer);
			flintRenderer.addEmitter(emitter);
 
			emitter.start();
		}
 
		private function enterFrameHandler(event:Event):void
		{
			pivotPoint.rotationY += (viewport.containerSprite.mouseX - pivotPoint.rotationY) * .01;
			singleRender();
		}
	}
}

package
{
	import flash.events.Event;
	import flash.filters.BlurFilter;
	import flash.filters.ColorMatrixFilter;
 
	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.Move;
	import org.flintparticles.threeD.actions.RandomDrift;
	import org.flintparticles.threeD.activities.RotateEmitter;
	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 FlintPixels2 extends BasicView
	{
		private var emitter:Emitter3D;
		private var emitter2:Emitter3D;
		private var flintRenderer:PV3DPixelRenderer;
		private var bitmapEffectLayer:BitmapEffectLayer;
		private var pixels:Pixels;
 
		public function FlintPixels2()
		{
			camera.z = -300;
 
			setupPixels();
			setupEmitter();
			setupEmitter2();
			setupFlintRenderer();
 
			emitter.start();
			emitter2.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)));
			//@see http://livedocs.adobe.com/flex/3/langref/flash/filters/ColorMatrixFilter.html
			bitmapEffectLayer.addEffect(new BitmapLayerEffect(new ColorMatrixFilter([1.09,0,0,0,0,0,1,0,0,0,0,0,1,0,0,0,0,0,1,0])));
		}
 
		private function setupEmitter():void
		{
			emitter = new Emitter3D();
			emitter.counter = new Steady(500);
 
			emitter.position.x = -150;
 
			emitter.addInitializer(new ColorInit(0xffcccc00, 0xffffffff));
			emitter.addInitializer(new Velocity(new DiscZone(new Vector3D(340, 0, 0), new Vector3D(0, 1, 0), 100, 100)));
			emitter.addInitializer(new Lifetime(4));
 
			emitter.addAction(new Move());
			emitter.addAction(new Age());
			emitter.addAction(new RandomDrift(3000, 3000, 3000));
 
			emitter.addActivity(new RotateEmitter(new Vector3D(.1, .3, 0)));
		}
 
		private function setupEmitter2():void
		{
			emitter2 = new Emitter3D();
			emitter2.counter = new Steady(500);
 
			emitter2.position.x = 150;
 
			emitter2.addInitializer(new ColorInit(0xffcccc00, 0xffffffff));
			emitter2.addInitializer(new Velocity(new DiscZone(new Vector3D(-340, 0, 0), new Vector3D(0, 1, 0), 100, 100)));
			emitter2.addInitializer(new Lifetime(4));
 
			emitter2.addAction(new Move());
			emitter2.addAction(new Age());
			emitter2.addAction(new RandomDrift(3000, 3000, 3000));
 
			emitter2.addActivity(new RotateEmitter(new Vector3D(.1, -.3, 0)));
		}
 
		private function setupFlintRenderer():void
		{
			flintRenderer = new PV3DPixelRenderer(pixels);
			flintRenderer.addEmitter(emitter);
			flintRenderer.addEmitter(emitter2);
		}
 
		override protected function onRenderTick(event:Event = null):void
		{
			renderer.renderScene(scene, camera, viewport);
		}
	}
}

private function createDistanceJoint():void
{
	var boxWidth:Number = 50;
 
	var boxBody:b2BodyDef = new b2BodyDef();
	boxBody.position = new b2Vec2(WIDTH/2/WORLD_SCALE, 420/WORLD_SCALE);
 
	var box:b2Body = world.CreateBody(boxBody);
 
	var boxShape:b2PolygonDef = new b2PolygonDef();
	boxShape.SetAsBox(boxWidth/WORLD_SCALE, boxWidth/WORLD_SCALE);
	boxShape.density = .7;
	boxShape.friction = .3;
	boxShape.restitution = .4;
 
	box.CreateShape(boxShape);
 
	//instead of "SetMassFromShapes", I'm setting the box
	//mass extremely high to keep it swinging back and forth
	var massData:b2MassData = new b2MassData();
	massData.mass = 1000;
 
	box.SetMass(massData);
 
	var joint:b2DistanceJointDef = new b2DistanceJointDef();
	var anchor:b2Vec2 = new b2Vec2();
 
	anchor = new b2Vec2(WIDTH/2/WORLD_SCALE, 250/WORLD_SCALE);
	joint.Initialize(box, world.m_groundBody, box.GetWorldCenter(), anchor);
 
	world.CreateJoint(joint);
 
	//start the box swinging
	box.m_linearVelocity = new b2Vec2(10, 0);
 
	var materialsList:MaterialsList = new MaterialsList();
	materialsList.addMaterial(new WireframeMaterial(0xcc0000, 1, 6), "all");
	var cube:Cube = new Cube(materialsList, boxWidth * 2, boxWidth * 2, boxWidth * 2);
 
	scene.addChild(cube);
	box.m_userData = cube;
}