Tech Blog

var autoPlay : Boolean = false; // don't play animations automatically
 
var dae : DAE = new DAE( autoPlay, "myCollada" );
 
dae.addEventListener(FileLoadEvent.LOAD_COMPLETE, onDaeComplete);
dae.addEventListener(FileLoadEvent.LOAD_PROGRESS, onDaeLoadProgress);
 
// optionally pass materials to DAE
// NOTE: here's a change with previous revs :
// 1. lookup the <material> elements in the COLLADA file (inside <library_materials>).
// 2. write down / remember the @id attribute of the <material> element.
// 3. materials.addMaterial( myMaterial, materialElementID ).
// ==> this will probably change in future revs
var materials : MaterialsList = new MaterialsList();
 
// If textures fail to load optionally add some search-paths 
// (relative to the swf):
dae.addFileSearchPath( "images" );
dae.addFileSearchPath( "textures" );
 
// set to true if you get a script-timeout error
var asyncParsing : Boolean = false;
 
// load it!
dae.load( "/path/to/dae", materials, asyncParsing );
 
/**
 * The DAE has loaded completely
 */
private function onDaeComplete(event : FileLoadEvent) : void
{
     var dae : DAE = event.target as DAE;
 
     // add to scene
     scene.addChild( dae );
 
     // start playing animation (if any available)
     // other animation controls include :
     // 1. play( "clipName ")
     // 2. stop()
     // 3. pause()
     // 4. resume()
     // 5. playing (getter: bool indicating if playing)
     dae.play();
 
     // lets create a clone
     // NOTE: DAE#clone() is somewhat bugged still, 
     // but seems to work in most cases
     var clone : DAE = dae.clone() as DAE;
 
     // add clone to scene
     scene.addChild( clone );
 
     // move it a bit
     clone.x = 200;
}
 
private function onDaeLoadProgress(event : FileLoadEvent) : void
{
 
}

var md2 : MD2 = new MD2();
 
var material : MaterialObject3D = new WireframeMaterial();
 
md2.addEventListener(FileLoadEvent.LOAD_COMPLETE, onMD2Complete);
 
md2.load("/path/to/md2", material);
 
scene.addChild(md2);
 
private function onMD2Complete(event : FileLoadEvent) : void
{
       var md2 : MD2 = event.target as MD2;
 
       md2.play();
       // or play some clip :
       // md2.play( "run" )
}

 
package {
 
import flash.display.Sprite;
import flash.events.*;
import flash.geom.Point;
import flash.text.TextField;
import flash.text.TextFormat;
 
import org.papervision3d.Papervision3D;
import org.papervision3d.cameras.*;
import org.papervision3d.core.math.*;
import org.papervision3d.core.proto.*;
import org.papervision3d.materials.*;
import org.papervision3d.materials.utils.*;
import org.papervision3d.objects.*;
import org.papervision3d.objects.primitives.*;
import org.papervision3d.render.*;
import org.papervision3d.scenes.*;
import org.papervision3d.view.*;
 
/**
 * @author timknip
 */
public class TutoFrustumCamera3D extends Sprite {
 
	/** The PV3D scene to render */
	public var scene : Scene3D;
 
	/** This PV3D camera */
	public var camera : FrustumCamera3D;
 
	/** The PV3D renderer */
	public var renderer : BasicRenderEngine;
 
	/** The PV3D viewport */
	public var viewport : Viewport3D;
 
	/** Show info */
	public var status : TextField;
 
	/**
	 * Constructor.
	 */
	public function TutoFrustumCamera3D() : void {
		init();
	}
 
	/**
	 * Init.
	 */
	private function init() : void {
 
		// add a textfield
		initStatusLine();
 
		// used by orbiting / zooming
		_lastMouse = new Point();
 
		// create a viewport
		viewport = new Viewport3D(800, 600);
 
		// add
		addChild(viewport);
 
		// create a frustum camera with FOV=60, near=10, far=10000
		camera = new FrustumCamera3D(viewport, 60, 10, 10000);
 
		// create a renderer
		renderer = new BasicRenderEngine();
 
		// create the scene
		scene = new Scene3D();
 
		// init the scene
		initScene();
 
		// mouse listeners
		stage.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
		stage.addEventListener(MouseEvent.MOUSE_MOVE, mouseMoveHandler);
		stage.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
 
		// key listener
		stage.addEventListener(KeyboardEvent.KEY_UP, keyUpHandler);
 
		// render on each frame
		addEventListener(Event.ENTER_FRAME, render);
 
		showInfo();
	}
 
	/**
	 * Init the scene.
	 */
	private function initScene() : void {
 
		var materials : MaterialsList = new MaterialsList();
 
		materials.addMaterial(new WireframeMaterial(0xff0000), "front");
		materials.addMaterial(new WireframeMaterial(0x0000ff), "back");
		materials.addMaterial(new WireframeMaterial(0xffff00), "left");
		materials.addMaterial(new WireframeMaterial(0x00ffff), "right");
		materials.addMaterial(new WireframeMaterial(0x00ff00), "top");
		materials.addMaterial(new WireframeMaterial(0xff00ff), "bottom");
 
		var cube : Cube = new Cube(materials);
 
		scene.addChild(cube);
	}
 
	/**
	 * Add a textfield.
	 */
	private function initStatusLine() : void {
		status = new TextField();
		addChild(status);
		status.x = status.y = 5;
		status.width = 500;
		status.height = 200;
		status.multiline = true;
		status.selectable = false;
		status.defaultTextFormat = new TextFormat("Arial", 12, 0xffff00);
		status.text = "";
	}
 
		/**
	 * Render!
	 */
	private function render( event : Event = null ) : void {
 
		// orbit the camera
		camera.orbit(_camTarget, _camPitch, _camYaw, _camDist);
 
		// render
		renderer.renderScene(scene, camera, viewport);
	}
 
	/**
	 * Show some info;
	 */
	private function showInfo() : void {
		var msg : String = "usage:\ndrag to rotate, drag-shift to zoom\n";
		msg += "- o: toggle ortho / perspective mode\n";
		msg += "- v: increase / decrease(+shift) FOV\n";
		msg += "- f: increase / decrease(+shift) camera far-plane\n";
		msg += "- n: increase / decrease(+shift) camera near-plane\n\n";
 
		msg += "camera\n- projection mode: " + (camera.ortho?"ortho":"perspective") + "\n";
		msg += "- fov: " + camera.fov + " near: " + camera.near + " far: " + camera.far + "\n";
 
		status.text = msg;
	}
 
	/**
	 *
	 * @param	event
	 */
	private function keyUpHandler( event : KeyboardEvent ) : void {
 
		switch(event.keyCode) {
			case 70: // f
				if(!camera.ortho) {
					if(event.shiftKey)
						camera.far -= 10;
					else
						camera.far += 10;
				}
				break;
 
			case 78: // n
				if(!camera.ortho) {
					if(event.shiftKey)
						camera.near -= 10;
					else
						camera.near += 10;
				}
				break;
 
			case 79: // o
				camera.ortho = !camera.ortho;
				break;
 
			case 86: // v
				if(!camera.ortho) {
					if(event.shiftKey)
						camera.fov -= 5;
					else
						camera.fov += 5;
				}
				break;
 
			default:
				break;
		}
 
		showInfo();
	}
 
	/**
	 *
	 * @param	event
	 */
	private function mouseDownHandler( event : MouseEvent ) : void {
		_lastMouse.x = event.stageX;
		_lastMouse.y = event.stageY;
		if(event.shiftKey)
			_zooming = true;
		else
			_orbiting = true;
	}
 
	/**
	 *
	 * @param	event
	 */
	private function mouseMoveHandler( event : MouseEvent ) : void {
		var dx:Number = _lastMouse.x - event.stageX;
		var dy:Number = _lastMouse.y - event.stageY;
 
		if(_orbiting)	{
			_camYaw += dx * (Math.PI/180);
 
			_camPitch -= dy * (Math.PI/180);
			_camPitch = _camPitch < 0.001 ? 0.001 : _camPitch;
			_camPitch = _camPitch > Math.PI/2 ? Math.PI/2 : _camPitch;
 
			_lastMouse.x = event.stageX;
			_lastMouse.y = event.stageY;
		} else if(!camera.ortho && _zooming) {
			if(_camDist - dy > 10)
				_camDist -= dy;
		} else if(camera.ortho && _zooming) {
			// this is the essential bit to zoom the camera in ortho-mode!
			camera.orthoScale += (dy * 0.0005);
		}
 
		render();
 
		event.updateAfterEvent();
	}
 
	/**
	 *
	 * @param	event
	 */
	private function mouseUpHandler( event : MouseEvent ) : void {
		_orbiting = _zooming = false;
	}
 
	/** Are we orbiting the camera? */
	private var _orbiting			: Boolean = false;
 
	/** Are we zooming the camera? */
	private var _zooming			: Boolean = false;
 
	/** A Point to keep track of mouse coords */
	private var _lastMouse			: Point;
 
	/** Camera Yaw */
	private var _camYaw				: Number = -Math.PI/2;
 
	/** Camera Pitch */
	private var _camPitch			: Number = Math.PI/2;
 
	/** Camera distance */
	private var _camDist			: Number = 2000;
 
	/** Camera target */
	private var _camTarget			: DisplayObject3D = DisplayObject3D.ZERO;
}
}