package  
{
    import com.greensock.TimelineMax;
    import com.greensock.TweenMax;
    import com.greensock.easing.Linear;
    import com.greensock.easing.Quart;
 
    import flash.display.Sprite;
 
    /**
     * @author John Lindquist
     */
    [SWF(width="900", height="480", frameRate="31")]
    public class EasingATimeline extends Sprite 
    {
        private var square:Sprite;
        private static const STEP_DURATION:Number = 1;
 
        public function EasingATimeline()
        {
            square = new Sprite();	
            square.graphics.beginFill(0xcc0000);
            square.graphics.drawRect(0, 0, 50, 50);
            square.graphics.endFill();
 
            square.x = 100;
            square.y = 50;
 
            addChild(square);
 
            //set all the eases of your steps to Linear.easeNone
            var step1:TweenMax = TweenMax.to(square, STEP_DURATION, {x: 700, y: 50, ease: Linear.easeNone});
            var step2:TweenMax = TweenMax.to(square, STEP_DURATION, {x: 700, y: 350, ease: Linear.easeNone});
            var step3:TweenMax = TweenMax.to(square, STEP_DURATION, {x: 100, y: 350, ease: Linear.easeNone});
            var step4:TweenMax = TweenMax.to(square, STEP_DURATION, {x: 100, y: 50, ease: Linear.easeNone});
 
            var timeline:TimelineMax = new TimelineMax();
            timeline.append(step1);
            timeline.append(step2);
            timeline.append(step3);
            timeline.append(step4);
            //pause your timeline
            timeline.pause();
 
            //tween your timeline with whatever ease you want
            TweenMax.to(timeline, timeline.totalDuration, {currentTime: timeline.totalDuration, ease: Quart.easeInOut, repeat: -1});
        }
    }
}

package {
	import flash.events.Event;
 
	import gs.TweenMax;
	import gs.easing.Elastic;
 
	import org.papervision3d.core.controller.MorphController;
	import org.papervision3d.core.geom.TriangleMesh3D;
	import org.papervision3d.events.FileLoadEvent;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.shadematerials.EnvMapMaterial;
	import org.papervision3d.objects.parsers.DAE;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="900", height="480", backgroundColor="#000000", frameRate="31")]
	public class MightyMorphingPapervision3D extends BasicView
	{
		[Embed(source="assets/cached.dae", mimeType="application/octet-stream")]
		private var cachedAsset:Class; 
 
		[Embed(source="assets/twisty.dae", mimeType="application/octet-stream")]
		private var twistyAsset:Class; 
 
		[Embed(source="assets/235.jpg")]
		private var textureAsset:Class; 
 
 
		private var cached:DAE = new DAE(); 
		private var twisty:DAE = new DAE(); 
 
		private var dummyMorph:TriangleMesh3D;
		private var cachedChild:TriangleMesh3D;
		private var twistyChild:TriangleMesh3D;
 
		private var morphController:MorphController;
 
		private var light:PointLight3D;
		private var tweenDummy:Object;
 
		public function MightyMorphingPapervision3D()
		{
			super(900, 480);
 
			cached.addEventListener(FileLoadEvent.LOAD_COMPLETE, cached_loadCompleteHandler);
			cached.load(new cachedAsset());
		}
 
		protected function cached_loadCompleteHandler(event:Event):void
		{
			twisty.addEventListener(FileLoadEvent.LOAD_COMPLETE, twisty_loadCompleteHandler);
			twisty.load(new twistyAsset());
		} 
 
		protected function twisty_loadCompleteHandler(event:Event):void
		{
			cached.scale = 50;
			twisty.scale = 50;
 
			cachedChild = cached.getChildByName("pSphere1", true) as TriangleMesh3D;
			twistyChild = twisty.getChildByName("pSphere1", true) as TriangleMesh3D;
 
			dummyMorph = cachedChild.clone() as TriangleMesh3D;
			dummyMorph.scale = 50;
 
			light = new PointLight3D();
			light.x = -1000;
			light.y = 1000;
			var material:EnvMapMaterial = new EnvMapMaterial(light, new textureAsset().bitmapData);
 
			cachedChild.material = material;
			twistyChild.material = material;
			dummyMorph.material = material;
 
			morphController = new MorphController(dummyMorph);
			morphController.addMorphTarget(cachedChild, 0);
			morphController.addMorphTarget(twistyChild, 1);
 
			scene.addChild(dummyMorph);
 
			startRendering();	
 
			tweenDummy = {};
			tweenDummy.dummyProp = 0;
			TweenMax.to(tweenDummy, 1, {dummyProp:1, ease:Elastic.easeInOut, loop:true, yoyo:true});
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			dummyMorph.rotationX += 1;
			dummyMorph.rotationY += .5;
 
			morphController.weights[0] = 1- tweenDummy.dummyProp;
			morphController.weights[1] = tweenDummy.dummyProp;
 
			morphController.update();
 
			light.x = Math.cos(dummyMorph.rotationY / 10) * 1000;
 
			super.onRenderTick(event);
		}
	}
}

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