Converted Flex to Flash Tutorial Example Files

Heya

I dont use Flex so I ran into problems with the tutorials from Matthew Casperson. Im sure you are all aware of them by now. Thanks go out to him for his work.

Main problems to overcome where the mx.core.Application methods. ArrayCollection gave me instant problems so I found a class written for just such a thing. Thanks go to Michael James Williams. This was a real lifesaver.

Next it was a case of adding the mesh to the scene. This meant making sure the Document Class was used a static var for all classes to access.

I commented out the flex code just to show where the changes were.

Instructions

1. Create a new flash file, add the source files in the src directory (File->Publish Settings->Flash Tab->Settings) and set the Document Root as EngineManager.
2. Uncheck "declare all stage instances" (File->Publish Settings->Flash Tab->Settings).

EngineManager.as

package
{
	import alternativa.engine3d.controllers.WalkController;
	import alternativa.engine3d.core.Camera3D;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.core.Scene3D;
	import alternativa.engine3d.display.View;
	import alternativa.types.Point3D;
	import alternativa.utils.FPS;
	
	import flash.display.StageAlign;
	import flash.display.StageScaleMode;
	import flash.events.Event;
	import flash.display.MovieClip;
	import flash.display.Sprite;
	import flash.utils.*;
	
	
	/**
	 * 	The EngineManager holds all of the code related to maintaining the Alternativa 3D engine.
	 */
	public class EngineManager extends Sprite
	{
		
		public var scene:Scene3D;
		public var view:View;
		public var camera:Camera3D;
		public var cameraController:WalkController;
		
		//*** set the static var so other classes can reference the scene ***//
		private static var eman:EngineManager = null;
				
		// a collection of the BaseObjects
		//*** this is using Collection.as as opposed to a Flex ArrayCollection **//
		protected var baseObjects:Collection = new Collection();
		// a collection where new BaseObjects are placed, to avoid adding items 
		// to baseObjects while in the baseObjects collection while it is in a loop
		protected var newBaseObjects:Collection = new Collection();
		// a collection where removed BaseObjects are placed, to avoid removing items 
		// to baseObjects while in the baseObjects collection while it is in a loop
		protected var removedBaseObjects:Collection = new Collection();
		// the last frame time 
		protected var lastFrame:Date;
		
		protected var applicationManagerStarted:Boolean = false;

public function EngineManager()
		{
			//** create an instance of EngineManager for referernce in other classes **//
			eman = this;
			super();
			addEventListener(Event.ADDED_TO_STAGE, init);
			
		}
		//** Access the Document Class from another class.
		//** :Example: Tell cameraController to lookAt scene.root.coords
		//** EngineManager.Instance.cameraController.lookAt(mesh.model.coords);
		public static function get Instance():EngineManager { return eman; }

public function init(e:Event): void
		{
			stage.scaleMode = StageScaleMode.NO_SCALE;
			stage.align = StageAlign.TOP_LEFT;
			
			// Creating scene
			scene = new Scene3D();
			scene.root = new Object3D();
			scene.splitAnalysis = false;

// Adding camera and view
			camera = new Camera3D();
			camera.x = 10;
			camera.y = 10;
			camera.z = 10;
			camera.farClipping = true;
			camera.farClippingDistance = 250;
			scene.root.addChild(camera);
			
			view = new View();
			view.interactive = true;
			addChild(view);
			view.camera = camera;

// Connecting camera controller
			cameraController = new WalkController(stage);   
			cameraController.object = camera; 
			cameraController.flyMode = false;
			cameraController.speed = 100;
			cameraController.pitchSpeed = 1;
			cameraController.yawSpeed = 1;
			cameraController.gravity = 0;   
			cameraController.jumpSpeed = 60;
			cameraController.setDefaultBindings();
			
			cameraController.checkCollisions = true;   
			cameraController.collider.radiusX = 5;   
			cameraController.collider.radiusY = 5;   
			cameraController.collider.radiusZ = 5;   
			cameraController.coords = new Point3D(75, 75, 25);   
			//cameraController.lookAt(scene.root.coords);

// FPS display launch
			FPS.init(stage);

stage.addEventListener(Event.RESIZE, onResize);
			stage.addEventListener(Event.ENTER_FRAME, onEnterFrame);
			onResize(null);

// set the initial frame time
			lastFrame = new Date();
			
						
			// load the resources
			ResourceManager.loadResources();			
		}
		
		private function onResize(e:Event):void 
		{
			view.width = stage.stageWidth;
			view.height = stage.stageHeight;
		}

protected function onEnterFrame(event:Event):void 
		{
			if (ResourceManager.allResourcesLoaded)
			{	
				if (!applicationManagerStarted)
				{
					applicationManagerStarted = true;
					// start the application
					ApplicationManager.Instance.startupApplicationManager();
				}

// Calculate the time since the last frame
				var thisFrame:Date = new Date();
				var seconds:Number = (thisFrame.getTime() - lastFrame.getTime())/1000.0;
		    	lastFrame = thisFrame;
		    	
		    	// sync the baseObjects collection with any BaseObjects created or removed during the 
		    	// render loop
		    	removeDeletedBaseObjects();
		    	insertNewBaseObjects();
		    	
		    	// allow each BaseObject to update itself
		    	for each (var baseObject:BaseObject in baseObjects)
		    		baseObject.enterFrame(seconds);
		    	
		    	
				//cam controller always pointing at scene
				cameraController.lookAt(scene.root.coords);
				// User input processing
				cameraController.processInput();
				// Scene calculating
				scene.calculate();
			}
		}
		
		public function addBaseObject(baseObject:BaseObject):void
		{
			newBaseObjects.addItem(baseObject);
		}
		
		public function removeBaseObject(baseObject:BaseObject):void
		{
			removedBaseObjects.addItem(baseObject);
		}
		
		protected function shutdownAll():void
		{
			// don't dispose objects twice
			for each (var baseObject:BaseObject in baseObjects)
			{
				var found:Boolean = false;
				for each (var removedObject:BaseObject in removedBaseObjects)
				{
					if (removedObject == baseObject)
					{
						found = true;
						break;
					}
				}
				
				if (!found)
					baseObject.shutdown();
			}
		}
		
		protected function insertNewBaseObjects():void
		{
			for each (var baseObject:BaseObject in newBaseObjects)
				baseObjects.addItem(baseObject);
			
			newBaseObjects.removeAll();
		}
		
		protected function removeDeletedBaseObjects():void
		{
			for each (var removedObject:BaseObject in removedBaseObjects)
			{
				var i:int = 0;
				for (i = 0; i < baseObjects._collection.length; ++i)
				{
					if (baseObjects.getItemAt(i) == removedObject)
					{
						baseObjects.removeItemAt(i);
						break;
					}
				}
				
			}
			
			removedBaseObjects.removeAll();
		}
	}
}

The changes here reflect :

setting a private static var to reference the DocumentClass

using a custom Collection.as class to substitute ArrayCollection

creating a function to instantiate the class for reference using the private static var as a return value

BaseObject.as

package
{
		
	/**
	 *	The BaseObject class allows extending classes to update themselves during the render loop. 
	 */
	public class BaseObject
	{
		
	
		public function BaseObject()
		{
			
		}
		
		/**
		 * 	Must be called by all extending classes when being created. Adds this object to the list of BaseObjects maintained
		 * 	by the EngineManager.
		 */
		public function startupBaseObject():void
		{
			//** Flex code commented out
			//Application.application.engineManager.addBaseObject(this);
			EngineManager.Instance.addBaseObject(this);

}
		
		/**
		 * 	Must be called by all extending classes when being destroyed. Removes this object to the list of BaseObjects maintained
		 * 	by the EngineManager.
		 */
		public function shutdown():void
		{
			//** Flex code commented out
			//Application.application.engineManager.removeBaseObject(this);
			EngineManager.Instance.removeBaseObject(this);

} 
		
		/**
		 * 	This function is called once per frame before the scene is rendered.
		 * 
		 * 	@param dt The time in seconds since the last frame was rendered.
		 */
		public function enterFrame(dt:Number):void
		{
			
		}
	}
}

Changes here reflect usage of an instance of EngineManager to reference objects, properties and functions.

ApplicationManager.as

No changes here except removal of a tutorial camera example to give it a simpler look

MeshObject.as

Changes here reflect usage of an instance of EngineManager to reference objects, properties and functions.

ResourceManager.as

package
{
	import alternativa.engine3d.core.Mesh;
	import alternativa.engine3d.core.Object3D;
	import alternativa.engine3d.loaders.LoaderOBJ;
	import alternativa.engine3d.materials.TextureMaterialPrecision;
	import alternativa.utils.MeshUtils;
	
	import flash.events.Event;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	
	
	/**
	 * 	ResourceManager is where we embed and create the resources needed by our application
	 */ 
	public class ResourceManager
	{
		protected static const SERVER_URL:String = "";
		
		public static var fighter:Mesh = null;
		protected static var fighterLoader:LoaderOBJ = null;
		protected static var fighterLoaded:Boolean = false;
		
		public static function get allResourcesLoaded():Boolean
		{
			return fighterLoaded;
		}
		
		public static function loadResources():void
		{
			fighterLoader = new LoaderOBJ();
			fighterLoader.smooth = true;
			fighterLoader.precision = TextureMaterialPrecision.HIGH;
			
			// watch out - case counts on some web servers, but not in windows
			fighterLoader.load(SERVER_URL + "models/fighter/fighter.obj");
			fighterLoader.addEventListener(Event.COMPLETE, onLoadFighterComplete);
			fighterLoader.addEventListener(IOErrorEvent.IO_ERROR, ioError);
			fighterLoader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityError);
		}
		
		protected static function ioError(e:Event):void
		{
			//Application.application.lblLoading.text = "Error Loading";
			trace("Error Loading:IO Error");
		}
		
		protected static function securityError(e:Event):void
		{
			//Application.application.lblLoading.text = "Error Loading";
			trace("Error Loading:Security Error");
		}
		
		protected static function weldVerticesAndFaces(object:Object3D):void 
		{
			if (object != null)
			{
				if (object is Mesh) 
				{
					MeshUtils.autoWeldVertices(Mesh(object), 0.01);
					MeshUtils.autoWeldFaces(Mesh(object), 0.01, 0.001);
				}
				
				// Launching procedure for object's children
				for (var key:* in object.children) 
				{
					weldVerticesAndFaces(key);
				}
			}
		}

protected static function onLoadFighterComplete(e:Event):void
		{
			for (var o:* in fighterLoader.content.children)
			{
				fighter = o;
				weldVerticesAndFaces(fighter);
				break;
			}
			
			fighterLoaded = true;
			
		}
	}
}

I changed this to load OBJ files as I find them more compatible than loading 3DS files.

Collection.as

package {
	/**
	 * Collection Class
	 * Version 1.0, 2008-09-20
	 * Created by Michael James Williams
	 * http://www.michaeljameswilliams.com
	 */
	public class Collection extends BaseObject {
		
		public var _collection:Array;

/**
		 * Creates a new collection populated with the specified values
		 * @param	... values
		 */
		public function Collection(... values) {
			_collection = new Array();	
			addItem(values);
		}
		//remove all items
		public function removeAll():void {
			_collection = new Array();
		}
		//get the item specified
		public function getItemAt(index:int, prefetch:int = 0):Object {
			return(_collection[Object]);
		}
		
		/**
		 * Adds the specified items to the collection
		 * @param	... items
		 */
		public function addItem(... items):void {
			for each (var item in items) {
				if (item is Array) {
					for each (var subItem in item) {
						addItem(subItem);
					}
				} else if (item is Collection) {
					for each (subItem in item.itemList) {
						addItem(subItem);
					}
				} else {
					if (!contains(item)) {
						_collection.push(item);
					}
				}
			}
		}
		
		/**
		 * Removes all of the specified items from the collection
		 * @param	... items
		 */
		public function removeItemAt(... items):void {
			for each (var item in items) {
				if (item is Array) {
					for each (var subItem in item) {
						removeItemAt(subItem);
					}
				} else if (item is Collection) {
					for each (subItem in item.itemList) {
						removeItemAt(subItem);
					}
				} else if (contains(item)) {
					_collection.splice(_collection.indexOf(item), 1);
				}
			}
		}
		
		/**
		 * Returns true iff collection contains (or is) specified item
		 * @param	item
		 * @return
		 */
		public function contains(item):Boolean {	
			if ((item is Array) || (item is Collection)) {
				return containsAll(item);
			} else {
				if ((_collection.indexOf(item) > -1) || (this === item)) {
					return true;
				} else {
					return false;
				}
			}
		}
		
		/**
		 * Returns true iff collection contains all specified items (including subitems of an array or collection)
		 * @param	... items
		 * @return
		 */
		public function containsAll(... items):Boolean {	
			var all:Boolean = true;
			for each (var item in items) {
				if (item is Array) {
					for each (var subItem in item) {
						if (!_collection.containsAll(subItem)) { all = false; }
					}
				} else if (item is Collection) {
					for each (subItem in item.itemList) {
						if (!_collection.containsAll(subItem)) { all = false; }
					}
				} else {	
					if (!_collection.contains(item)) { all = false; }
				}
			}
			return all;
		}
		
		/**
		 * Returns true iff collection contains any of the specified items (including subitems of an array or collection)
		 * @param	... items
		 * @return
		 */
		public function containsAny(... items):Boolean {	
			var any:Boolean = false;
			for each (var item in items) {
				if (item is Array) {
					for each (var subItem in item) {
						if (!_collection.containsAny(subItem)) { 
							any = true;
							break;
						}
					}
				} else if (item is Collection) {
					for each (subItem in item.itemList) {
						if (!_collection.containsAny(subItem)) { 
							any = true; 
							break;
						}
					}
				} else {	
					if (!_collection.contains(item)) { 
						any = true;
						break;
					}
				}
			}
			return any;
		}
		
		/**
		 * Executes a test function on each item in the collection and constructs a new collection of all items that return true.
		 * @param	callback
		 * @param	thisObject
		 * @return
		 */
		public function filter(callback:Function, thisObject:* = null):Collection {
			var filtered:Collection = new Collection();
			filtered.addItem(_collection.filter(callback, thisObject));
			return filtered;
		}
		
		/**
		 * Executes a function on each item in the collection.
		 * @param	callback
		 * @param	thisObject
		 */
		public function forEach(callback:Function, thisObject:* = null):void {
			_collection.forEach(callback, thisObject);
		}
		
		/**
		 * Converts the elements in a collection to strings, inserts the specified separator between the elements, concatenates them, and returns the resulting string.
		 * @param	sep
		 * @return
		 */
		public function join(sep:*):String { 
			return _collection.join(sep);
		}
		
		/**
		 * Executes a function on each item in an collection, and constructs a new collection of items corresponding to the results of the function on each item in the original collection.
		 * @param	callback
		 * @param	thisObject
		 * @return
		 */
		public function map(callback:Function, thisObject:* = null):Collection {
			var mappedArray:Array = _collection.map(callback, thisObject);
			var mappedCollection:Collection = new Collection();
			for each (var item in mappedArray) {
				mappedCollection.addItem(item);
			}
			return mappedCollection;
		}
		
		/**
		 * Executes a test function on each item in the collection until an item is reached that returns true. Use this method to determine whether any items in a collection meet a criterion, such as having a value less than a particular number.
		 * @param	callback
		 * @param	thisObject
		 * @return
		 */
		public function some(callback:Function, thisObject:* = null):Boolean {
			return _collection.some(callback, thisObject);
		}
		
		/**
		 * Executes a test function on each item in the collection until an item is reached that returns false for the specified function. You use this method to determine whether all items in a collection meet a criterion, such as having values less than a particular number. 
		 * @param	callback
		 * @param	thisObject
		 * @return
		 */
		public function every(callback:Function, thisObject:* = null):Boolean {
			return _collection.every(callback, thisObject);
		}
		
		/**
		 * Returns a collection made up of items in this collection for which item.property==value
		 * @param	property
		 * @param	value
		 * @return
		 */
		public function subCollection(property:String, value:*):Collection { 
			///Ideally this would accept a method name and a ...params and check to see if item.method(...params)==true
			var subCollection:Collection = new Collection();
			for each (var item in _collection) {
				try {
					if (item[property]==value) {
						subCollection.addItem(item);
					}	
				} catch (err) {
					//this is likely to be very very error prone if the programmer isn't careful so we'll just break out of the loop
					break;
				}
			}
			return subCollection;
		}
		
		/**
		 * Returns a collection made up of all items that are in both this collection and the specified collection
		 * @param	coll
		 * @return
		 */
		public function intersection(coll:Collection):Collection {
			var intersectColl:Collection=new Collection();
			for each (var item in coll.itemList) {
				if (this.contains(item)) { 
					intersectColl.addItem(item);
				}
			}
			return intersectColl;
		}
		
		/**
		 * Returns the intersection of this collection with an arbitrary number of other collections
		 * @param	... colls
		 * @return
		 */
		public function intersectMany(... colls):Collection {
			var intersectColl:Collection = new Collection();
			intersectColl.addItem(_collection);
			for each (var subItem in colls) {
				if (subItem is Collection) {
					intersectColl = intersectColl.intersection(subItem);
				}
			}
			return intersectColl;
		}
		
		/**
		 * Returns a collection made up of all items that are in either this collection or the specified collection (or both)
		 * @param	coll
		 * @return
		 */
		public function union(coll:Collection):Collection {
			var unionColl:Collection = new Collection();
			unionColl.addItem(itemList, coll);
			return unionColl;
		}
		
		/**
		 * Returns the union of this collection with an arbitrary number of other collections
		 * @param	... colls
		 * @return
		 */
		public function unionMany(... colls):Collection {
			var unionColl:Collection = new Collection();
			unionColl.addItem(_collection);
			for each (var subItem in colls) {
				if (subItem is Collection) {
					unionColl = unionColl.union(subItem);
				}
			}
			return unionColl;
		}
		
		/**
		 * Returns the relative complement of the specified collection in this collection
		 * A.relComp(B) := A\B
		 * @param	coll
		 * @return
		 */
		public function relComp(coll):Collection {
			///Returns the relative complement of the specified collection in this collection
			///A.relComp(B) := A\B
			///i.e. returns a collection containing items that are in this collection but not in the specified collection
			var rcColl:Collection = new Collection();
			rcColl.addItem(_collection);
			rcColl.removeItemAt(coll);
			return rcColl;
		}
		
		/**
		 * Returns the relative complement of the union of the specified collections in this collection
		 * @param	... colls
		 * @return
		 */
		public function relCompMany(... colls):Collection {
			var rcColl:Collection = new Collection();
			rcColl.addItem(_collection);
			for each (var subItem in colls) {
				if (subItem is Collection) {
					rcColl.removeItemAt(subItem);
				}
			}
			return rcColl;
		}

/**
		 * Returns the number of items in the collection
		 */
		public function get numItems():uint {
			return _collection.length;
		}
		
		/**
		 * Exposes the underlying array; use this only for e.g. for-each loops
		 */
		public function get itemList():Array {
			return _collection;
		}
	}
}

This class is used instead of the Flex method Application.application.engineManager to reference the DocumentClass.