Vertex3D

TriangleMesh3D – Create your own mesh

Saturday, December 13th, 2008 | examples, how it works | Comments

This shows you how to make little baby triangles. If you put enough of these together with the proper coordinates and rotations, you could make a Tyrannosaurs Rex!

source

package
{
	import flash.events.Event;
 
	import org.papervision3d.core.geom.TriangleMesh3D;
	import org.papervision3d.core.geom.renderables.Triangle3D;
	import org.papervision3d.core.geom.renderables.Vertex3D;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.view.BasicView;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class TriangleMesh3DExample extends BasicView
	{
		private var triangleMesh3d:TriangleMesh3D;
 
		public function TriangleMesh3DExample()
		{
			var material:ColorMaterial = new ColorMaterial(0xcc0000);
			material.doubleSided = true;
 
			//all the 200's are points of a triangle
			var vertex3D_1:Vertex3D = new Vertex3D(-200, -200, 0);
			var vertex3D_2:Vertex3D = new Vertex3D(200, -200, 0);
			var vertex3D_3:Vertex3D = new Vertex3D(-200, 200, 0);
 
			var triangleVertices:Array = [vertex3D_1, vertex3D_2, vertex3D_3];
 
			//use null because we haven't created its parent mesh yet			
			var triangle3d:Triangle3D = new Triangle3D(null, triangleVertices, material);
			var triangleFaces:Array = [triangle3d];
 
			triangleMesh3d = new TriangleMesh3D(material, triangleVertices, triangleFaces, null);
			//for the triangle to be "renderable", it needs to know who its daddy is
			//this is the same property as the "null" parameter a few lines above
			triangle3d.instance = triangleMesh3d;
 
			scene.addChild(triangleMesh3d);
			startRendering();
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			triangleMesh3d.rotationY = -viewport.containerSprite.mouseX / 2;
			super.onRenderTick(event);
		}
	}
}

Tags: Triangle3D, TriangleMesh3D, Vertex3D

Plane3D intersect point

Thursday, November 27th, 2008 | examples | Comments

A Plane3D (known commonly as a “Plane” in geometry) is an infinite flat surface. In this example, the Plane3D spans across the x-axis and the z-axis (like a floor) represented by this Number3D:

private const XZPLANE:Number3D = new Number3D(0, 1, 0);

The second number (1), means the Plane3D rotates around the Y-axis. You can think of it like the “1″ is the direction the Plane3D is facing, in this case, “up”. To face toward you, you would set 0, 0, 1. So the Plane3D would point to the monitor (like a wall). To face left to right, you would set 1, 0, 0 (like an alley?).

In this example, the camera is moved up slightly to have more of a bird’s eye view of the Plane3D. You won’t see it at first, but after you click around for awhile, you’ll start to notice where the Plane3D exists.

source

package
{
	import flash.events.Event;
	import flash.events.KeyboardEvent;
	import flash.events.MouseEvent;
	import flash.ui.Keyboard;
 
	import org.papervision3d.core.geom.renderables.Vertex3D;
	import org.papervision3d.core.math.Number3D;
	import org.papervision3d.core.math.Plane3D;
	import org.papervision3d.objects.DisplayObject3D;
	import org.papervision3d.objects.primitives.Cylinder;
	import org.papervision3d.scenes.Scene3D;
	import org.papervision3d.view.BasicView;
	import org.papervision3d.view.stats.StatsView;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class Plane3DExample extends BasicView
	{
		private const XZPLANE:Number3D = new Number3D(0, 1, 0);
 
		private var plane3D:Plane3D  = new Plane3D(XZPLANE, Number3D.ZERO);
		private var isRotating:Boolean = false;
 
		public function Plane3DExample() 
		{
			camera.y = 200;
 
			startRendering();
 
			stage.addEventListener(MouseEvent.CLICK, clickHandler);
			stage.addEventListener(KeyboardEvent.KEY_DOWN, keyDownHandler);
		}
 
		private function keyDownHandler(event:KeyboardEvent):void
		{
			//toggle rotating
			if(event.keyCode == Keyboard.CONTROL)
			{
				isRotating = (isRotating == false) ? true : false;
			}
 
			//rebuild scene
			if(event.keyCode == Keyboard.SHIFT)
			{
				scene = new Scene3D();
			}
		}
 
 
		private function clickHandler(event:MouseEvent):void
		{
			var ray:Number3D = camera.unproject(viewport.containerSprite.mouseX, viewport.containerSprite.mouseY);
			ray = Number3D.add(ray, camera.position);
 
			var cameraVertex3D:Vertex3D = new Vertex3D(camera.x, camera.y, camera.z);
			var rayVertex3D:Vertex3D = new Vertex3D(ray.x, ray.y, ray.z);
 
			var intersectPoint:Vertex3D = plane3D.getIntersectionLine(cameraVertex3D, rayVertex3D);
 
			var cylinder:Cylinder = new Cylinder(null, 10, 100, 1, 1);
			cylinder.x = intersectPoint.x;
			cylinder.y = intersectPoint.y;
			cylinder.z = intersectPoint.z;
 
			//the closer to the center, the larger the tower
			cylinder.scale = 1000 / cylinder.distanceTo(new DisplayObject3D());
			//readjust y based on scale (half height times scale)
			cylinder.y += 50 * cylinder.scale;
 
 
			scene.addChild(cylinder);
		}
 
		override protected function onRenderTick(event:Event=null):void
		{
			if(isRotating)
			{
				camera.moveForward(1000);
				camera.yaw(.5);
				camera.moveBackward(1000);
			}
 
			renderer.renderScene(scene, camera, viewport);
		}
	}
 
}

Tags: Plane3D, ray, Vertex3D

Fun with Pixel3D and Vertex3D

Tuesday, November 18th, 2008 | examples | Comments

I was just playing around with Pixel3D and came up with the following result.

The pixels are placed by finding each vertex of the sphere then proportionately moving from the origin (x:0, y:0, z:0) out to the vertex.

View example
source

package {
 
	import flash.events.Event;
 
	import org.papervision3d.core.geom.Pixels;
	import org.papervision3d.core.geom.renderables.Pixel3D;
	import org.papervision3d.core.geom.renderables.Vertex3D;
	import org.papervision3d.materials.ColorMaterial;
	import org.papervision3d.objects.primitives.Sphere;
	import org.papervision3d.view.BasicView;
	import org.papervision3d.view.layer.BitmapEffectLayer;
 
	[SWF(width="640", height="480", backgroundColor="#000000", frameRate="60")]
	public class PixelField extends BasicView
	{
		private const NUM_PIXELS:int = 200;
		private var pixels:Pixels;
		public function PixelField()
		{
			camera.y = 100;
 
			//you need a bitmapEffectLayer for the pixels
			var bitmapEffectLayer:BitmapEffectLayer = new BitmapEffectLayer(viewport);
			//this allows for the neat overdraw cylinder effect
			//bitmapEffectLayer.clearBeforeRender = true;
			pixels = new Pixels(bitmapEffectLayer);
 
			var sphere:Sphere = new Sphere(new ColorMaterial(0xffffff, 0), 500);
			scene.addChild(sphere);
			singleRender();
 
			for each(var vertex3D:Vertex3D in sphere.geometry.vertices)
			{
				for(var i:int = 0; i < NUM_PIXELS; i++)
				{
					//move the x, y, z out to the vertex3D
					//in proportion to the # of pixels
					var randX:Number = vertex3D.x *(i / NUM_PIXELS);
					var randY:Number = vertex3D.y *(i / NUM_PIXELS);
					var randZ:Number = vertex3D.z *(i / NUM_PIXELS);
 
					//Notice the color is an ARGB value, so 8 f's instead of 6
					//meaning the first FF = alpha, then red, green, blue
					var randColor:Number = Math.random() * 0xffffffff;
					var pixel:Pixel3D = new Pixel3D(randColor, randX, randY, randZ);
 
					pixels.addPixel3D(pixel);
				}
 
 
			}
			//remember to add the bitmapEffectLayer to the viewport
			viewport.containerSprite.addLayer(bitmapEffectLayer);
			scene.addChild(pixels);
 
			addEventListener(Event.ENTER_FRAME, renderAndRotateHandler);
		}
 
		private function renderAndRotateHandler(event:Event):void
		{
			pixels.yaw(1);
			singleRender();
		}
	}
}