package
{
	import flash.events.Event;
 
	import org.papervision3d.core.math.Matrix3D;
	import org.papervision3d.core.math.Number3D;
	import org.papervision3d.core.proto.LightObject3D;
	import org.papervision3d.core.proto.MaterialObject3D;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.shadematerials.FlatShadeMaterial;
	import org.papervision3d.objects.primitives.Arrow;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="900", height="480", backgroundColor="#000000", frameRate="31")]
	public class CalculateMultiply3x3 extends BasicView
	{
		private var arrow1:Arrow;
		private var arrow2:Arrow;
		private var arrow3:Arrow;
 
		public function CalculateMultiply3x3()
		{
			super(900, 480);
			opaqueBackground = 0x000000;
 
			var light:LightObject3D = new PointLight3D();
			var material:MaterialObject3D = new FlatShadeMaterial(light, 0xcc0000, 0x333333, 10);
 
			arrow1 = new Arrow(material);
			arrow1.x = -750;
			scene.addChild(arrow1);
 
			arrow2 = new Arrow(material);
			scene.addChild(arrow2);
 
			arrow3 = new Arrow(material);
			arrow3.x = 750;
			scene.addChild(arrow3);
 
			startRendering();
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			/* 
			CaculateMultiply3x3 is most often used for advanced rotations where you find the
			axis you want to rotate around at run-time (like a ball rolling in a certain direction).
 
			First, create (or find) a rotation matrix with an axis and a rotation then use 
			calculateMultiply3x3 to add to your object's rotation using your 
			rotation matrix.
 
			It's easiest to think of it in pseudocode as "myObject.rotation += myCustomRotation".
			Another way to think of it: "Rotate this much around this axis
			 */
 
			/* 
			The following commented code is equivalent to arrow.rotationY += 1;
 
			//the axis to rotate around
			var upAxis:Number3D = new Number3D(0, 1, 0);
			//the amount of rotation around that axis
			var rotation:Number = 1 * Number3D.toRADIANS;
 
			var rotationMatrix:Matrix3D = Matrix3D.rotationMatrix(upAxis.x, upAxis.y, upAxis.z, rotation);
			arrow.transform.calculateMultiply3x3(rotationMatrix, arrow.transform);
			 */
 
			//example 1
			var axis1:Number3D = new Number3D(1, 0, 0);
			axis1.normalize();
 
			var rotation1:Number = 3 * Number3D.toRADIANS;
 
			var rotationMatrix1:Matrix3D = Matrix3D.rotationMatrix(axis1.x, axis1.y, axis1.z, rotation1);
			arrow1.transform.calculateMultiply3x3(rotationMatrix1, arrow1.transform);
 
			//example 2
			var axis2:Number3D = new Number3D(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY, 0);
			axis2.normalize();
 
			var rotation2:Number = 3 * Number3D.toRADIANS;
 
			var rotationMatrix2:Matrix3D = Matrix3D.rotationMatrix(axis2.x, axis2.y, axis2.z, rotation2);
			arrow2.transform.calculateMultiply3x3(rotationMatrix2, arrow2.transform);
 
			//example 3			
			var axis3:Number3D = new Number3D(.7, .7, .1);
			axis3.normalize();
 
			var rotation3:Number = viewport.containerSprite.mouseX / 50 * Number3D.toRADIANS;
 
			var rotationMatrix3:Matrix3D = Matrix3D.rotationMatrix(axis3.x, axis3.y, axis3.z, rotation3);
			arrow3.transform.calculateMultiply3x3(rotationMatrix3, arrow3.transform);
 
			super.onRenderTick(event);
		}
	}
}

package
{
	import flash.events.MouseEvent;
 
	import gs.TweenMax;
 
	import org.papervision3d.core.math.Matrix3D;
	import org.papervision3d.core.math.Number3D;
	import org.papervision3d.core.proto.MaterialObject3D;
	import org.papervision3d.materials.WireframeMaterial;
	import org.papervision3d.objects.primitives.Arrow;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="900", height="480", backgroundColor="#000000", frameRate="31")]
	public class TweeningMoveForward extends BasicView
	{
		private var arrow:Arrow;
 
		public function TweeningMoveForward()
		{
			super(900, 480);
			opaqueBackground = 0x000000;
 
			camera.y = 2000;
 
			var material:MaterialObject3D = new WireframeMaterial(0xff0000, 1, 2);
			arrow = new Arrow(material);
			arrow.rotationX = 30;
			arrow.rotationY = 30;
			scene.addChild(arrow);
 
			startRendering();
 
			stage.addEventListener(MouseEvent.CLICK, stage_clickHandler);
		}
 
		protected function stage_clickHandler(event:MouseEvent):void
		{
			var distance:Number = 3000;
			var forwardAxis:Number3D = new Number3D(0, 0, 1);
 
			Matrix3D.rotateAxis(arrow.transform, forwardAxis);
 
			var target:Number3D = new Number3D();
			target.x = distance * forwardAxis.x + arrow.x;
			target.y = distance * forwardAxis.y + arrow.y;
			target.z = distance * forwardAxis.z + arrow.z;
 
			TweenMax.to(arrow, 1, {x:target.x, y:target.y, z:target.z});
		}
	}
}

package
{
	import flash.events.Event;
 
	import org.papervision3d.core.geom.renderables.Triangle3D;
	import org.papervision3d.core.proto.MaterialObject3D;
	import org.papervision3d.lights.PointLight3D;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.materials.shadematerials.CellMaterial;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="900", height="480", backgroundColor="#000000", frameRate="31")]
	public class HolySphere extends BasicView
	{
		private var light:PointLight3D;
		private var lightInc:Number = 0;
		private var sphere:Sphere;
 
		public function HolySphere()
		{
			super(900, 480);
			opaqueBackground = 0x000000;
 
			light = new PointLight3D();
			var material:MaterialObject3D = new CellMaterial(light, 0xffff00, 0x000000, 10);
			material.doubleSided = true;
 
			sphere = new Sphere(material, 500, 32, 24);
 
			var grab2:uint = 0;
			for each(var triangle3D:Triangle3D in sphere.geometry.faces)
			{
				if(grab2 < 2)
				{
					triangle3D.material = new ColorMaterial(0x000000, 0);
					grab2++;
				}
				else
				{
					grab2 = 0;
				}
			}
 
			scene.addChild(sphere);
 
			startRendering();
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			sphere.yaw(1);
			light.x = Math.cos(lightInc) * 2000;
			lightInc += .05;
			super.onRenderTick(event);
		}
	}
}

package
{
	import gs.TweenMax;
 
	import org.papervision3d.core.geom.renderables.Vertex3D;
	import org.papervision3d.core.proto.MaterialObject3D;
	import org.papervision3d.events.InteractiveScene3DEvent;
	import org.papervision3d.materials.WireframeMaterial;
	import org.papervision3d.objects.primitives.Plane;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="900", height="480", backgroundColor="#000000", frameRate="31")]
	public class MovingFaces extends BasicView
	{
 
		public function MovingFaces()
		{
			super(900, 480);
			viewport.interactive = true;
			opaqueBackground = 0x000000;
 
			var material:MaterialObject3D = new WireframeMaterial(0xffff00);
			material.interactive = true;
			var plane:Plane = new Plane(material, 1000, 1000, 10, 10);
 
			plane.addEventListener(InteractiveScene3DEvent.OBJECT_MOVE, plane_objectOverHandler);
 
			scene.addChild(plane);
 
			startRendering();
		}
 
		protected function plane_objectOverHandler(event:InteractiveScene3DEvent):void
		{
			var vertex3D:Vertex3D = event.face3d.v0 as Vertex3D;
			TweenMax.to(vertex3D, .5, {z:"-100"});
		}
	}
}