Section 1
//AnimationFrame (away3d.animators.data.AnimationFrame)
package away3d.animators.data {

	public class AnimationFrame {

		public var frame:Number;
		public var time:uint;
		public var sort:String;

		public function AnimationFrame(_arg1:Number, _arg2:String=null){
			this.frame = _arg1;
			this.sort = _arg2;
		}
	}
}//package away3d.animators.data 
Section 2
//AnimationGroup (away3d.animators.data.AnimationGroup)
package away3d.animators.data {

	public class AnimationGroup {

		public var loop:Boolean;
		public var fps:uint;
		public var playlist:Array;
		public var loopLast:Boolean;

		public function AnimationGroup(_arg1:Array=null, _arg2:Boolean=false){
			this.playlist = _arg1;
			this.loopLast = _arg2;
		}
	}
}//package away3d.animators.data 
Section 3
//AnimationSequence (away3d.animators.data.AnimationSequence)
package away3d.animators.data {

	public class AnimationSequence {

		public var fps:Number;
		public var loop:Boolean;
		public var smooth:Boolean;
		public var prefix:String;

		public function AnimationSequence(_arg1:String, _arg2:Boolean=true, _arg3:Boolean=false, _arg4:Number=3){
			this.prefix = ((_arg1)==null) ? "" : _arg1;
			this.smooth = _arg2;
			this.loop = _arg3;
			this.fps = _arg4;
			if (this.prefix == ""){
				trace("Prefix is null, this might cause enter endless loop");
			};
		}
	}
}//package away3d.animators.data 
Section 4
//Bone (away3d.animators.skin.Bone)
package away3d.animators.skin {
	import away3d.containers.*;
	import away3d.core.base.*;

	public class Bone extends ObjectContainer3D {

		public var joint:ObjectContainer3D;
		public var boneId:String;

		public function Bone(_arg1:Object=null, ... _args):void{
			super(_arg1);
			addChild((joint = new ObjectContainer3D()));
		}
		public function set jointRotationY(_arg1:Number):void{
			joint.rotationY = _arg1;
		}
		public function set jointRotationZ(_arg1:Number):void{
			joint.rotationZ = _arg1;
		}
		public function set jointRotationX(_arg1:Number):void{
			joint.rotationX = _arg1;
		}
		public function set jointScaleX(_arg1:Number):void{
			joint.scaleX = _arg1;
		}
		override public function cloneAll(_arg1:Object3D=null):Object3D{
			var _local2:Bone;
			_local2 = (((_arg1 as Bone)) || (new Bone()));
			_local2.removeChild(joint);
			super.cloneAll(_local2);
			_local2.boneId = boneId;
			_local2.joint = _local2.children[0];
			return (_local2);
		}
		public function set jointScaleY(_arg1:Number):void{
			joint.scaleY = _arg1;
		}
		public function get jointRotationX():Number{
			return (joint.rotationX);
		}
		public function get jointRotationY():Number{
			return (joint.rotationY);
		}
		public function get jointRotationZ():Number{
			return (joint.rotationZ);
		}
		public function set jointScaleZ(_arg1:Number):void{
			joint.scaleZ = _arg1;
		}
		override public function clone(_arg1:Object3D=null):Object3D{
			var _local2:Bone;
			_local2 = (((_arg1 as Bone)) || (new Bone()));
			super.clone(_local2);
			_local2.joint = _local2.children[0];
			return (_local2);
		}
		public function get jointScaleY():Number{
			return (joint.scaleY);
		}
		public function get jointScaleZ():Number{
			return (joint.scaleZ);
		}
		public function get jointScaleX():Number{
			return (joint.scaleX);
		}

	}
}//package away3d.animators.skin 
Section 5
//SkinController (away3d.animators.skin.SkinController)
package away3d.animators.skin {
	import away3d.containers.*;
	import away3d.core.math.*;

	public class SkinController {

		public var sceneTransform:Matrix3D;
		public var joint:ObjectContainer3D;
		public var name:String;
		public var updated:Boolean;
		public var inverseTransform:Matrix3D;
		public var bindMatrix:Matrix3D;

		public function SkinController(){
			sceneTransform = new Matrix3D();
			super();
		}
		public function update():void{
			if (!joint){
				return;
			};
			if (!joint.scene.updatedObjects[joint]){
				updated = false;
				return;
			};
			updated = true;
			sceneTransform.multiply(joint.sceneTransform, bindMatrix);
			sceneTransform.multiply(inverseTransform, sceneTransform);
		}

	}
}//package away3d.animators.skin 
Section 6
//SkinVertex (away3d.animators.skin.SkinVertex)
package away3d.animators.skin {
	import away3d.core.base.*;
	import away3d.core.math.*;

	public class SkinVertex {

		public var skinnedVertex:Vertex;
		private var _position:Number3D;
		private var _i:int;
		public var baseVertex:Vertex;
		public var controllers:Array;
		public var weights:Array;

		public function SkinVertex(_arg1:Vertex){
			_position = new Number3D();
			weights = [];
			controllers = [];
			super();
			skinnedVertex = _arg1;
			baseVertex = _arg1.clone();
		}
		public function update():void{
			var _local1:Boolean;
			var _local2:SkinController;
			_local1 = false;
			for each (_local2 in controllers) {
				_local1 = ((_local1) || (_local2.updated));
			};
			if (!_local1){
				return;
			};
			skinnedVertex.reset();
			_i = weights.length;
			while (_i--) {
				_position.transform(baseVertex.position, (controllers[_i] as SkinController).sceneTransform);
				_position.scale(_position, weights[_i]);
				skinnedVertex.add(_position);
			};
		}

	}
}//package away3d.animators.skin 
Section 7
//IMeshAnimation (away3d.animators.IMeshAnimation)
package away3d.animators {
	import away3d.containers.*;

	public interface IMeshAnimation {

		function update(_arg1:Number, _arg2:Boolean=true):void;
		function clone(_arg1:ObjectContainer3D):IMeshAnimation;

	}
}//package away3d.animators 
Section 8
//ConvexBlock (away3d.blockers.ConvexBlock)
package away3d.blockers {
	import away3d.core.base.*;
	import away3d.core.project.*;

	public class ConvexBlock extends Object3D {

		public var debug:Boolean;
		public var vertices:Array;

		public function ConvexBlock(_arg1:Array, _arg2:Object=null){
			vertices = [];
			super(_arg2);
			this.vertices = _arg1;
			debug = ini.getBoolean("debug", false);
			projectorType = ProjectorType.CONVEX_BLOCK;
		}
	}
}//package away3d.blockers 
Section 9
//AbstractLens (away3d.cameras.lenses.AbstractLens)
package away3d.cameras.lenses {
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.cameras.*;
	import away3d.core.clip.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.core.geom.*;

	public class AbstractLens {

		protected const toDEGREES:Number = 57.2957795130823;
		protected const toRADIANS:Number = 0.0174532925199433;

		protected var _sw:Number;
		protected var _view:View3D;
		protected var _sy:Number;
		protected var _sx:Number;
		protected var _sz:Number;
		protected var _near:Number;
		protected var _clipping:Clipping;
		protected var _frustum:Frustum;
		protected var view:Matrix3D;
		protected var _clipTop:Number;
		protected var _clipRight:Number;
		protected var _cameraVarsStore:CameraVarsStore;
		protected var _clipHeight:Number;
		protected var _drawPrimitiveStore:DrawPrimitiveStore;
		protected var _focusOverZoom:Number;
		protected var _clipBottom:Number;
		protected var _vertex:Vertex;
		protected var _camera:Camera3D;
		protected var _zoom2:Number;
		protected var _persp:Number;
		protected var viewTransform:Matrix3D;
		protected var _clipLeft:Number;
		protected var _clipWidth:Number;
		protected var _plane:Plane3D;
		protected var _far:Number;
		protected var _vx:Number;
		protected var _vz:Number;
		protected var _len:Number;
		protected var classification:int;
		protected var _vy:Number;
		protected var _scz:Number;

		public function AbstractLens(){
			view = new Matrix3D();
			super();
		}
		public function setView(_arg1:View3D):void{
			_view = _arg1;
			_drawPrimitiveStore = _arg1.drawPrimitiveStore;
			_cameraVarsStore = _arg1.cameraVarsStore;
			_camera = _arg1.camera;
			_clipping = _arg1.screenClipping;
			_clipTop = _clipping.maxY;
			_clipBottom = _clipping.minY;
			_clipLeft = _clipping.minX;
			_clipRight = _clipping.maxX;
			_clipHeight = (_clipBottom - _clipTop);
			_clipWidth = (_clipRight - _clipLeft);
			_far = _clipping.maxZ;
		}
		public function get near():Number{
			return (_near);
		}
		public function get far():Number{
			return (_far);
		}

	}
}//package away3d.cameras.lenses 
Section 10
//ILens (away3d.cameras.lenses.ILens)
package away3d.cameras.lenses {
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.math.*;
	import away3d.core.geom.*;

	public interface ILens {

		function getPerspective(_arg1:Number):Number;
		function get near():Number;
		function getZoom():Number;
		function getFrustum(_arg1:Object3D, _arg2:Matrix3D):Frustum;
		function setView(_arg1:View3D):void;
		function get far():Number;
		function project(_arg1:Matrix3D, _arg2:Array, _arg3:Array):void;
		function getFOV():Number;

	}
}//package away3d.cameras.lenses 
Section 11
//ZoomFocusLens (away3d.cameras.lenses.ZoomFocusLens)
package away3d.cameras.lenses {
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.clip.*;
	import away3d.core.math.*;
	import away3d.core.geom.*;

	public class ZoomFocusLens extends AbstractLens implements ILens {

		private var _length:int;

		public function getZoom():Number{
			return (((((_clipTop - _clipBottom) / Math.tan((_camera.fov * toRADIANS))) - (_clipTop * _clipBottom)) / _camera.focus));
		}
		public function project(_arg1:Matrix3D, _arg2:Array, _arg3:Array):void{
			_length = 0;
			for each (_vertex in _arg2) {
				_vx = _vertex.x;
				_vy = _vertex.y;
				_vz = _vertex.z;
				_sz = ((((_vx * _arg1.szx) + (_vy * _arg1.szy)) + (_vz * _arg1.szz)) + _arg1.tz);
				if (isNaN(_sz)){
					throw (new Error("isNaN(sz)"));
				};
				if ((((_sz < _near)) && ((_clipping is RectangleClipping)))){
					_arg3[_length] = null;
					_arg3[(_length + 1)] = null;
					_arg3[(_length + 2)] = null;
					_length = (_length + 3);
				} else {
					_persp = (_camera.zoom / (1 + (_sz / _camera.focus)));
					_arg3[_length] = (((((_vx * _arg1.sxx) + (_vy * _arg1.sxy)) + (_vz * _arg1.sxz)) + _arg1.tx) * _persp);
					_arg3[(_length + 1)] = (((((_vx * _arg1.syx) + (_vy * _arg1.syy)) + (_vz * _arg1.syz)) + _arg1.ty) * _persp);
					_arg3[(_length + 2)] = _sz;
					_length = (_length + 3);
				};
			};
		}
		override public function setView(_arg1:View3D):void{
			super.setView(_arg1);
			if (_clipping.minZ == -(Infinity)){
				_near = (-(_camera.focus) / 2);
			} else {
				_near = _clipping.minZ;
			};
		}
		public function getFOV():Number{
			return ((Math.atan2((_clipTop - _clipBottom), ((_camera.focus * _camera.zoom) + (_clipTop * _clipBottom))) * toDEGREES));
		}
		public function getFrustum(_arg1:Object3D, _arg2:Matrix3D):Frustum{
			_frustum = _cameraVarsStore.createFrustum(_arg1);
			_focusOverZoom = (_camera.focus / _camera.zoom);
			_zoom2 = (_camera.zoom * _camera.zoom);
			_plane = _frustum.planes[Frustum.NEAR];
			_plane.a = 0;
			_plane.b = 0;
			_plane.c = 1;
			_plane.d = -(_near);
			_plane.transform(_arg2);
			_plane = _frustum.planes[Frustum.FAR];
			_plane.a = 0;
			_plane.b = 0;
			_plane.c = -1;
			_plane.d = _far;
			_plane.transform(_arg2);
			_plane = _frustum.planes[Frustum.LEFT];
			_plane.a = (-(_clipHeight) * _focusOverZoom);
			_plane.b = 0;
			_plane.c = ((_clipHeight * _clipLeft) / _zoom2);
			_plane.d = (_plane.c * _camera.focus);
			_plane.transform(_arg2);
			_plane = _frustum.planes[Frustum.RIGHT];
			_plane.a = (_clipHeight * _focusOverZoom);
			_plane.b = 0;
			_plane.c = ((-(_clipHeight) * _clipRight) / _zoom2);
			_plane.d = (_plane.c * _camera.focus);
			_plane.transform(_arg2);
			_plane = _frustum.planes[Frustum.TOP];
			_plane.a = 0;
			_plane.b = (-(_clipWidth) * _focusOverZoom);
			_plane.c = ((_clipWidth * _clipTop) / _zoom2);
			_plane.d = (_plane.c * _camera.focus);
			_plane.transform(_arg2);
			_plane = _frustum.planes[Frustum.BOTTOM];
			_plane.a = 0;
			_plane.b = (_clipWidth * _focusOverZoom);
			_plane.c = ((-(_clipWidth) * _clipBottom) / _zoom2);
			_plane.d = (_plane.c * _camera.focus);
			_plane.transform(_arg2);
			return (_frustum);
		}
		public function getPerspective(_arg1:Number):Number{
			return ((_camera.zoom / (1 + (_arg1 / _camera.focus))));
		}

	}
}//package away3d.cameras.lenses 
Section 12
//Camera3D (away3d.cameras.Camera3D)
package away3d.cameras {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.clip.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.events.*;
	import away3d.cameras.lenses.*;

	public class Camera3D extends Object3D {

		protected const toDEGREES:Number = 57.2957795130823;
		protected const toRADIANS:Number = 0.0174532925199433;

		private var _fov:Number;// = 0
		private var _cameraVarsStore:CameraVarsStore;
		private var _clipping:Clipping;
		private var _zoomDirty:Boolean;
		private var _viewMatrix:Matrix3D;
		public var doflevels:Number;// = 16
		private var _fovDirty:Boolean;
		private var _dof:Boolean;// = false
		private var _flipY:Matrix3D;
		private var _screenIndexStart:int;
		private var _clipTop:Number;
		private var _zoom:Number;// = 10
		private var _screenVertices:Array;
		private var _clipLeft:Number;
		private var _aperture:Number;// = 22
		private var _clipRight:Number;
		private var _clipBottom:Number;
		private var _drawPrimitiveStore:DrawPrimitiveStore;
		private var _vertices:Array;
		public var fixedZoom:Boolean;
		private var _view:View3D;
		public var invViewMatrix:Matrix3D;
		public var maxblur:Number;// = 150
		private var _lens:ILens;
		private var _focus:Number;
		private var _cameraupdated:CameraEvent;

		public function Camera3D(_arg1:Object=null){
			var _local2:Number3D;
			_aperture = 22;
			_dof = false;
			_flipY = new Matrix3D();
			_zoom = 10;
			_fov = 0;
			_viewMatrix = new Matrix3D();
			_vertices = new Array();
			_screenVertices = new Array();
			invViewMatrix = new Matrix3D();
			maxblur = 150;
			doflevels = 16;
			super(_arg1);
			fov = ini.getNumber("fov", _fov);
			focus = ini.getNumber("focus", 100);
			zoom = ini.getNumber("zoom", _zoom);
			fixedZoom = ini.getBoolean("fixedZoom", true);
			lens = (((ini.getObject("lens", AbstractLens) as ILens)) || (new ZoomFocusLens()));
			aperture = ini.getNumber("aperture", 22);
			maxblur = ini.getNumber("maxblur", 150);
			doflevels = ini.getNumber("doflevels", 16);
			dof = ini.getBoolean("dof", false);
			_local2 = ini.getPosition("lookat");
			_flipY.syy = -1;
			if (_local2){
				lookAt(_local2);
			};
		}
		public function set lens(_arg1:ILens):void{
			if (_lens == _arg1){
				return;
			};
			_lens = _arg1;
			notifyCameraUpdate();
		}
		private function notifyCameraUpdate():void{
			if (!hasEventListener(CameraEvent.CAMERA_UPDATED)){
				return;
			};
			if (_cameraupdated == null){
				_cameraupdated = new CameraEvent(CameraEvent.CAMERA_UPDATED, this);
			};
			dispatchEvent(_cameraupdated);
		}
		public function screen(_arg1:Object3D, _arg2:Vertex=null):ScreenVertex{
			if (_arg2 == null){
				_vertices = _arg1.center;
			} else {
				_vertices[0] = _arg2;
			};
			_cameraVarsStore.createViewTransform(_arg1).multiply(viewMatrix, _arg1.sceneTransform);
			_screenVertices.length = 0;
			_lens.project(_cameraVarsStore.viewTransformDictionary[_arg1], _vertices, _screenVertices);
			return (new ScreenVertex(_screenVertices[0], _screenVertices[1], _screenVertices[2]));
		}
		public function unproject(_arg1:Number, _arg2:Number):Number3D{
			var _local3:Number;
			var _local4:Number3D;
			_local3 = ((focus * zoom) / focus);
			_local4 = new Number3D((_arg1 / _local3), (-(_arg2) / _local3), focus);
			transform.multiplyVector3x3(_local4);
			return (_local4);
		}
		public function set dof(_arg1:Boolean):void{
			_dof = _arg1;
			if (_dof){
				enableDof();
			} else {
				disableDof();
			};
		}
		public function pan(_arg1:Number):void{
			super.yaw(_arg1);
		}
		public function get view():View3D{
			return (_view);
		}
		public function enableDof():void{
			DofCache.doflevels = doflevels;
			DofCache.aperture = aperture;
			DofCache.maxblur = maxblur;
			DofCache.focus = focus;
			DofCache.resetDof(true);
		}
		public function tilt(_arg1:Number):void{
			super.pitch(_arg1);
		}
		public function update():void{
			_view.updateScreenClipping();
			_clipping = _view.screenClipping;
			if (((((((!((_clipTop == _clipping.maxY))) || (!((_clipBottom == _clipping.minY))))) || (!((_clipLeft == _clipping.minX))))) || (!((_clipRight == _clipping.maxX))))){
				if (((!(_fovDirty)) && (!(_zoomDirty)))){
					if (fixedZoom){
						_fovDirty = true;
					} else {
						_zoomDirty = true;
					};
				};
				_clipTop = _clipping.maxY;
				_clipBottom = _clipping.minY;
				_clipLeft = _clipping.minX;
				_clipRight = _clipping.maxX;
			};
			lens.setView(_view);
			if (_fovDirty){
				_fovDirty = false;
				_fov = lens.getFOV();
			};
			if (_zoomDirty){
				_zoomDirty = false;
				_zoom = lens.getZoom();
			};
		}
		public function get fov():Number{
			return (_fov);
		}
		public function get viewMatrix():Matrix3D{
			invViewMatrix.multiply(sceneTransform, _flipY);
			_viewMatrix.inverse(invViewMatrix);
			return (_viewMatrix);
		}
		public function get focus():Number{
			return (_focus);
		}
		public function addOnCameraUpdate(_arg1:Function):void{
			addEventListener(CameraEvent.CAMERA_UPDATED, _arg1, false, 0, false);
		}
		public function get lens():ILens{
			return (_lens);
		}
		public function disableDof():void{
			DofCache.resetDof(false);
		}
		public function get dof():Boolean{
			return (_dof);
		}
		override public function clone(_arg1:Object3D=null):Object3D{
			var _local2:Camera3D;
			_local2 = (((_arg1 as Camera3D)) || (new Camera3D()));
			super.clone(_local2);
			_local2.zoom = zoom;
			_local2.focus = focus;
			_local2.lens = lens;
			return (_local2);
		}
		public function set view(_arg1:View3D):void{
			if (_view == _arg1){
				return;
			};
			_view = _arg1;
			_drawPrimitiveStore = _arg1.drawPrimitiveStore;
			_cameraVarsStore = _arg1.cameraVarsStore;
		}
		public function set aperture(_arg1:Number):void{
			_aperture = _arg1;
			DofCache.aperture = _aperture;
		}
		public function removeOnCameraUpdate(_arg1:Function):void{
			removeEventListener(CameraEvent.CAMERA_UPDATED, _arg1, false);
		}
		public function set fov(_arg1:Number):void{
			if (_fov == _arg1){
				return;
			};
			_fov = _arg1;
			_fovDirty = false;
			_zoomDirty = true;
			notifyCameraUpdate();
		}
		public function get aperture():Number{
			return (_aperture);
		}
		public function set zoom(_arg1:Number):void{
			if (_zoom == _arg1){
				return;
			};
			_zoom = _arg1;
			_zoomDirty = false;
			_fovDirty = true;
			notifyCameraUpdate();
		}
		public function set focus(_arg1:Number):void{
			_focus = _arg1;
			DofCache.focus = _focus;
			notifyCameraUpdate();
		}
		public function get zoom():Number{
			return (_zoom);
		}

	}
}//package away3d.cameras 
Section 13
//HoverCamera3D (away3d.cameras.HoverCamera3D)
package away3d.cameras {

	public class HoverCamera3D extends TargetCamera3D {

		public var distance:Number;// = 800
		public var mintiltangle:Number;// = 0
		public var tiltangle:Number;// = 90
		public var panangle:Number;// = 0
		public var wrappanangle:Boolean;
		public var targetpanangle:Number;// = 0
		public var yfactor:Number;// = 2
		public var steps:Number;// = 8
		public var maxtiltangle:Number;// = 90
		public var targettiltangle:Number;// = 90

		public function HoverCamera3D(_arg1:Object=null){
			yfactor = 2;
			distance = 800;
			panangle = 0;
			tiltangle = 90;
			targetpanangle = 0;
			targettiltangle = 90;
			mintiltangle = 0;
			maxtiltangle = 90;
			steps = 8;
			super(_arg1);
			yfactor = ini.getNumber("yfactor", yfactor);
			distance = ini.getNumber("distance", distance);
			wrappanangle = ini.getBoolean("wrappanangle", false);
			panangle = ini.getNumber("panangle", panangle);
			tiltangle = ini.getNumber("tiltangle", tiltangle);
			targetpanangle = ini.getNumber("targetpanangle", targetpanangle);
			targettiltangle = ini.getNumber("targettiltangle", targettiltangle);
			mintiltangle = ini.getNumber("mintiltangle", mintiltangle);
			maxtiltangle = ini.getNumber("maxtiltangle", maxtiltangle);
			steps = ini.getNumber("steps", steps);
			moveCamera();
		}
		public function moveCamera():Boolean{
			var _local1:Number;
			var _local2:Number;
			var _local3:Number;
			_local1 = ((distance * Math.sin((panangle * toRADIANS))) * Math.cos((tiltangle * toRADIANS)));
			_local2 = ((distance * Math.cos((panangle * toRADIANS))) * Math.cos((tiltangle * toRADIANS)));
			_local3 = ((distance * Math.sin((tiltangle * toRADIANS))) * yfactor);
			if ((((((x == _local1)) && ((y == _local3)))) && ((z == _local2)))){
				return (false);
			};
			x = _local1;
			y = _local3;
			z = _local2;
			return (true);
		}
		public function hover():Boolean{
			if ((((targettiltangle == tiltangle)) && ((targetpanangle == panangle)))){
				return (moveCamera());
			};
			targettiltangle = Math.max(mintiltangle, Math.min(maxtiltangle, targettiltangle));
			if (wrappanangle){
				if (targetpanangle < 0){
					targetpanangle = ((targetpanangle % 360) + 360);
				} else {
					targetpanangle = (targetpanangle % 360);
				};
				if ((targetpanangle - panangle) < -180){
					targetpanangle = (targetpanangle + 360);
				} else {
					if ((targetpanangle - panangle) > 180){
						targetpanangle = (targetpanangle - 360);
					};
				};
			};
			tiltangle = (tiltangle + ((targettiltangle - tiltangle) / (steps + 1)));
			panangle = (panangle + ((targetpanangle - panangle) / (steps + 1)));
			if ((((Math.abs((targettiltangle - tiltangle)) < 0.01)) && ((Math.abs((targetpanangle - panangle)) < 0.01)))){
				tiltangle = targettiltangle;
				panangle = targetpanangle;
			};
			return (moveCamera());
		}

	}
}//package away3d.cameras 
Section 14
//TargetCamera3D (away3d.cameras.TargetCamera3D)
package away3d.cameras {
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.math.*;

	public class TargetCamera3D extends Camera3D {

		public var target:Object3D;

		public function TargetCamera3D(_arg1:Object=null){
			super(_arg1);
			target = ((ini.getObject3D("target")) || (new Object3D()));
		}
		override public function get viewMatrix():Matrix3D{
			if (target != null){
				lookAt((target.scene) ? target.scenePosition : target.position);
			};
			return (super.viewMatrix);
		}
		override public function set parent(_arg1:ObjectContainer3D):void{
			if (_arg1 != null){
				throw (new Error("TargetCamera can't be parented"));
			};
		}

	}
}//package away3d.cameras 
Section 15
//ILODObject (away3d.containers.ILODObject)
package away3d.containers {
	import away3d.cameras.*;

	public interface ILODObject {

		function matchLOD(_arg1:Camera3D):Boolean;

	}
}//package away3d.containers 
Section 16
//IPhysicsScene (away3d.containers.IPhysicsScene)
package away3d.containers {

	public interface IPhysicsScene {

		function updateTime(_arg1:int):void;

	}
}//package away3d.containers 
Section 17
//ObjectContainer3D (away3d.containers.ObjectContainer3D)
package away3d.containers {
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.loaders.data.*;
	import away3d.loaders.utils.*;
	import away3d.events.*;
	import away3d.core.traverse.*;
	import away3d.animators.skin.*;
	import away3d.core.project.*;

	public class ObjectContainer3D extends Object3D {

		private var _children:Array;

		public function ObjectContainer3D(... _args){
			var _local2:Object;
			var _local3:Array;
			var _local4:Object;
			var _local5:Object3D;
			_children = [];
			_local3 = [];
			for each (_local4 in _args) {
				if ((_local4 is Object3D)){
					_local3.push(_local4);
				} else {
					_local2 = _local4;
				};
			};
			super(_local2);
			projectorType = ProjectorType.OBJECT_CONTAINER;
			for each (_local5 in _local3) {
				addChild(_local5);
			};
		}
		public function centerMeshes():void{
			var _local1:Object3D;
			for each (_local1 in children) {
				_local1.centerPivot();
			};
		}
		function internalRemoveChild(_arg1:Object3D):void{
			var _local2:int;
			_local2 = children.indexOf(_arg1);
			if (_local2 == -1){
				return;
			};
			_arg1.removeOnTransformChange(onChildChange);
			_arg1.removeOnDimensionsChange(onChildChange);
			_children.splice(_local2, 1);
			notifyDimensionsChange();
			if (((session) && (!(_arg1.ownCanvas)))){
				session.internalRemoveOwnSession(_arg1);
			};
			_sessionDirty = true;
		}
		public function getChildByName(_arg1:String):Object3D{
			var _local2:Object3D;
			var _local3:Object3D;
			for each (_local3 in children) {
				if (_local3.name){
					if (_local3.name == _arg1){
						return (_local3);
					};
				};
				if ((_local3 is ObjectContainer3D)){
					_local2 = (_local3 as ObjectContainer3D).getChildByName(_arg1);
					if (_local2){
						return (_local2);
					};
				};
			};
			return (null);
		}
		private function onChildChange(_arg1:Object3DEvent):void{
			notifyDimensionsChange();
		}
		public function removeChildByName(_arg1:String):void{
			removeChild(getChildByName(_arg1));
		}
		override public function applyPosition(_arg1:Number, _arg2:Number, _arg3:Number):void{
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Object3D;
			var _local8:Number3D;
			for each (_local7 in children) {
				_local4 = _local7.x;
				_local5 = _local7.y;
				_local6 = _local7.z;
				_local7.moveTo((_local4 - _arg1), (_local5 - _arg2), (_local6 - _arg3));
			};
			_local8 = new Number3D(_arg1, _arg2, _arg3);
			new Number3D(_arg1, _arg2, _arg3).rotate(_local8, _transform);
			_local8.add(_local8, position);
			moveTo(_local8.x, _local8.y, _local8.z);
		}
		private function cloneBones(_arg1:ObjectContainer3D, _arg2:ObjectContainer3D):void{
			var _local3:Array;
			var _local4:Object3D;
			var _local5:Geometry;
			var _local6:Array;
			var _local7:Bone;
			var _local8:SkinController;
			var _local9:Bone;
			_local3 = _arg1.children;
			for each (_local4 in _local3) {
				if ((_local4 is ObjectContainer3D)){
					(_local4 as ObjectContainer3D).cloneBones((_local4 as ObjectContainer3D), _arg2);
				} else {
					if ((_local4 is Mesh)){
						_local5 = (_local4 as Mesh).geometry;
						_local6 = _local5.skinControllers;
						for each (_local8 in _local6) {
							_local9 = _arg2.getBoneByName(_local8.name);
							if (_local9){
								_local8.joint = _local9.joint;
								if (!(_local9.parent.parent is Bone)){
									_local7 = _local9;
								};
							} else {
								Debug.warning(("no joint found for " + _local8.name));
							};
						};
						for each (_local8 in _local6) {
							_local8.inverseTransform = _local4.parent.inverseSceneTransform;
						};
					};
				};
			};
		}
		function internalAddChild(_arg1:Object3D):void{
			_children.push(_arg1);
			_arg1.addOnTransformChange(onChildChange);
			_arg1.addOnDimensionsChange(onChildChange);
			notifyDimensionsChange();
			if (((_session) && (!(_arg1.ownCanvas)))){
				session.internalAddOwnSession(_arg1);
			};
			_sessionDirty = true;
		}
		override public function applyRotations():void{
			var _local1:Number;
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Object3D;
			_local6 = (Math.PI / 180);
			_local7 = (rotationX * _local6);
			_local8 = (rotationY * _local6);
			_local9 = (rotationZ * _local6);
			_local10 = Math.sin(_local7);
			_local11 = Math.cos(_local7);
			_local12 = Math.sin(_local8);
			_local13 = Math.cos(_local8);
			_local14 = Math.sin(_local9);
			_local15 = Math.cos(_local9);
			for each (_local16 in children) {
				_local1 = _local16.x;
				_local2 = _local16.y;
				_local3 = _local16.z;
				_local5 = _local2;
				_local2 = ((_local5 * _local11) + (_local3 * -(_local10)));
				_local3 = ((_local5 * _local10) + (_local3 * _local11));
				_local4 = _local1;
				_local1 = ((_local4 * _local13) + (_local3 * _local12));
				_local3 = ((_local4 * -(_local12)) + (_local3 * _local13));
				_local4 = _local1;
				_local1 = ((_local4 * _local15) + (_local2 * -(_local14)));
				_local2 = ((_local4 * _local14) + (_local2 * _local15));
				_local16.moveTo(_local1, _local2, _local3);
			};
			rotationX = 0;
			rotationY = 0;
			rotationZ = 0;
		}
		override public function centerPivot():void{
			var _local1:Object3D;
			for each (_local1 in children) {
				_local1.centerPivot();
			};
			super.centerPivot();
		}
		public function removeChild(_arg1:Object3D):void{
			if (_arg1 == null){
				throw (new Error("ObjectContainer3D.removeChild(null)"));
			};
			if (_arg1.parent != this){
				return;
			};
			_arg1.parent = null;
		}
		public function addChild(_arg1:Object3D):void{
			if (_arg1 == null){
				throw (new Error("ObjectContainer3D.addChild(null)"));
			};
			_arg1.parent = this;
		}
		public function cloneAll(_arg1:Object3D=null):Object3D{
			var _local2:ObjectContainer3D;
			var _local3:ObjectContainer3D;
			var _local4:Object3D;
			var _local5:ObjectContainer3D;
			var _local6:AnimationData;
			var _local7:MaterialData;
			_local2 = (((_arg1 as ObjectContainer3D)) || (new ObjectContainer3D()));
			super.clone(_local2);
			for each (_local4 in children) {
				if ((_local4 is Bone)){
					_local3 = new Bone();
					_local2.addChild(_local3);
					(_local4 as Bone).cloneAll(_local3);
				} else {
					if ((_local4 is ObjectContainer3D)){
						_local3 = new ObjectContainer3D();
						_local2.addChild(_local3);
						(_local4 as ObjectContainer3D).cloneAll(_local3);
					} else {
						if ((_local4 is Mesh)){
							_local2.addChild((_local4 as Mesh).cloneAll());
						} else {
							_local2.addChild(_local4.clone());
						};
					};
				};
			};
			if (animationLibrary){
				_local2.animationLibrary = new AnimationLibrary();
				for each (_local6 in animationLibrary) {
					_local6.clone(_local2);
				};
			};
			if (materialLibrary){
				_local2.materialLibrary = new MaterialLibrary();
				for each (_local7 in materialLibrary) {
					_local7.clone(_local2);
				};
			};
			_local5 = _local2;
			while (_local5.parent) {
				_local5 = _local5.parent;
			};
			if (_local2 == _local5){
				cloneBones(_local2, _local5);
			};
			return (_local2);
		}
		public function getBoneByName(_arg1:String):Bone{
			var _local2:Bone;
			var _local3:Object3D;
			for each (_local3 in children) {
				if ((_local3 is Bone)){
					_local2 = (_local3 as Bone);
					if (_local2.name){
						if (_local2.name == _arg1){
							return (_local2);
						};
					};
					if (_local2.boneId){
						if (_local2.boneId == _arg1){
							return (_local2);
						};
					};
				};
				if ((_local3 is ObjectContainer3D)){
					_local2 = (_local3 as ObjectContainer3D).getBoneByName(_arg1);
					if (_local2){
						return (_local2);
					};
				};
			};
			return (null);
		}
		override public function clone(_arg1:Object3D=null):Object3D{
			var _local2:ObjectContainer3D;
			var _local3:Object3D;
			_local2 = (((_arg1 as ObjectContainer3D)) || (new ObjectContainer3D()));
			super.clone(_local2);
			for each (_local3 in children) {
				if (!(_local3 is Bone)){
					_local2.addChild(_local3.clone());
				};
			};
			return (_local2);
		}
		override public function traverse(_arg1:Traverser):void{
			var _local2:Object3D;
			if (_arg1.match(this)){
				_arg1.enter(this);
				_arg1.apply(this);
				for each (_local2 in children) {
					_local2.traverse(_arg1);
				};
				_arg1.leave(this);
			};
		}
		override protected function updateDimensions():void{
			var _local1:Array;
			var _local2:Number;
			var _local3:Number;
			var _local4:Number3D;
			var _local5:Object3D;
			_local1 = _children.concat();
			if (_local1.length){
				if (_scaleX < 0){
					_boundingScale = -(_scaleX);
				} else {
					_boundingScale = _scaleX;
				};
				if ((((_scaleY < 0)) && ((_boundingScale < -(_scaleY))))){
					_boundingScale = -(_scaleY);
				} else {
					if (_boundingScale < _scaleY){
						_boundingScale = _scaleY;
					};
				};
				if ((((_scaleZ < 0)) && ((_boundingScale < -(_scaleZ))))){
					_boundingScale = -(_scaleZ);
				} else {
					if (_boundingScale < _scaleZ){
						_boundingScale = _scaleZ;
					};
				};
				_local2 = 0;
				_local4 = new Number3D();
				for each (_local5 in _local1) {
					_local4.sub(_local5.position, _pivotPoint);
					_local3 = (_local4.modulo + _local5.parentBoundingRadius);
					if (_local2 < _local3){
						_local2 = _local3;
					};
				};
				_boundingRadius = _local2;
				_local1.sortOn("parentmaxX", (Array.DESCENDING | Array.NUMERIC));
				_maxX = _local1[0].parentmaxX;
				_local1.sortOn("parentminX", Array.NUMERIC);
				_minX = _local1[0].parentminX;
				_local1.sortOn("parentmaxY", (Array.DESCENDING | Array.NUMERIC));
				_maxY = _local1[0].parentmaxY;
				_local1.sortOn("parentminY", Array.NUMERIC);
				_minY = _local1[0].parentminY;
				_local1.sortOn("parentmaxZ", (Array.DESCENDING | Array.NUMERIC));
				_maxZ = _local1[0].parentmaxZ;
				_local1.sortOn("parentminZ", Array.NUMERIC);
				_minZ = _local1[0].parentminZ;
			};
			super.updateDimensions();
		}
		public function addChildren(... _args):void{
			var _local2:Object3D;
			for each (_local2 in _args) {
				addChild(_local2);
			};
		}
		public function get children():Array{
			return (_children);
		}

	}
}//package away3d.containers 
Section 18
//Scene3D (away3d.containers.Scene3D)
package away3d.containers {
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import flash.utils.*;
	import away3d.events.*;
	import away3d.core.traverse.*;

	public class Scene3D extends ObjectContainer3D {

		private var _currentView:View3D;
		public var tickTraverser:TickTraverser;
		public var physics:IPhysicsScene;
		public var updatedSessions:Dictionary;
		private var _projtraverser:ProjectionTraverser;
		public var geometries:Dictionary;
		private var _mesh:Mesh;
		private var _lighttraverser:LightTraverser;
		public var viewDictionary:Dictionary;
		public var autoUpdate:Boolean;
		public var meshes:Dictionary;
		private var _sessiontraverser:SessionTraverser;
		public var updateLight:Boolean;
		private var _objects:Array;
		public var updatedObjects:Dictionary;

		public function Scene3D(... _args){
			var _local2:Object;
			var _local3:Array;
			var _local4:Object;
			var _local5:Object;
			var _local6:Object3D;
			_objects = new Array();
			_projtraverser = new ProjectionTraverser();
			_sessiontraverser = new SessionTraverser();
			_lighttraverser = new LightTraverser();
			viewDictionary = new Dictionary(true);
			tickTraverser = new TickTraverser();
			_local3 = [];
			for each (_local4 in _args) {
				if ((_local4 is Object3D)){
					_local3.push(_local4);
				} else {
					_local2 = _local4;
				};
			};
			if (_local2){
				_local2["ownCanvas"] = true;
				_local2["ownLights"] = true;
			} else {
				_local2 = {ownCanvas:true, ownLights:true};
			};
			super(_local2);
			autoUpdate = ini.getBoolean("autoUpdate", true);
			updateLight = ini.getBoolean("updateLight", true);
			_local5 = ini.getObject("physics");
			if ((_local5 is IPhysicsScene)){
				physics = (_local5 as IPhysicsScene);
			};
			if ((_local5 is Boolean)){
				if (_local5 == true){
					physics = null;
				};
			};
			if ((_local5 is Object)){
				physics = null;
			};
			for each (_local6 in _local3) {
				addChild(_local6);
			};
		}
		override public function get sceneTransform():Matrix3D{
			if (_transformDirty){
				_sceneTransformDirty = true;
			};
			if (_sceneTransformDirty){
				notifySceneTransformChange();
			};
			return (transform);
		}
		function clearId(_arg1:int):void{
			delete _objects[_arg1];
		}
		public function update():void{
			var _local1:View3D;
			var _local2:Array;
			var _local3:Geometry;
			var _local4:Object;
			updatedObjects = new Dictionary(true);
			updatedSessions = new Dictionary(true);
			meshes = new Dictionary(true);
			geometries = new Dictionary(true);
			if (updateLight){
				traverse(_lighttraverser);
			};
			for each (_local1 in viewDictionary) {
				_local1.camera.update();
				_local1.blockers = new Dictionary(true);
				_local1.drawPrimitiveStore.blockerDictionary = new Dictionary(true);
				_local1.cameraVarsStore.reset();
				_local1.blockerarray.clip = _local1.screenClipping;
				_projtraverser.view = _local1;
				traverse(_projtraverser);
			};
			for (_local4 in meshes) {
				_mesh = (_local4 as Mesh);
				_local2 = meshes[_mesh];
				for each (_local1 in _local2) {
					_mesh.updateMaterials(_mesh, _local1);
				};
			};
			for each (_local3 in geometries) {
				_local3.updateElements();
			};
			traverse(_sessiontraverser);
		}
		function setId(_arg1:Object3D):void{
			var _local2:int;
			_local2 = 0;
			while (_objects[_local2]) {
				_local2++;
			};
			_objects[_local2] = _arg1;
			_arg1._id = _local2;
		}
		public function updateTime(_arg1:int=-1):void{
			if (_arg1 == -1){
				_arg1 = getTimer();
			};
			tickTraverser.now = _arg1;
			traverse(tickTraverser);
			if (physics != null){
				physics.updateTime(_arg1);
			};
		}
		function internalAddView(_arg1:View3D):void{
			_arg1.addEventListener(ViewEvent.UPDATE_SCENE, onUpdate);
		}
		private function onUpdate(_arg1:ViewEvent):void{
			if (autoUpdate){
				if (((_currentView) && (!((_currentView == _arg1.view))))){
					Debug.warning("Multiple views detected! Should consider switching to manual update");
				};
				_currentView = _arg1.view;
				update();
			};
		}
		function internalRemoveView(_arg1:View3D):void{
			_arg1.removeEventListener(ViewEvent.UPDATE_SCENE, onUpdate);
		}

	}
}//package away3d.containers 
Section 19
//View3D (away3d.containers.View3D)
package away3d.containers {
	import flash.geom.*;
	import flash.display.*;
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.core.base.*;
	import away3d.cameras.*;
	import away3d.core.clip.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.materials.*;
	import away3d.core.block.*;
	import away3d.core.render.*;
	import flash.utils.*;
	import away3d.events.*;
	import away3d.core.traverse.*;
	import away3d.overlays.*;
	import away3d.core.project.*;
	import away3d.blockers.*;
	import away3d.core.stats.*;

	public class View3D extends Sprite {

		private var _stageHeight:Number;
		var _movieClipSpriteProjector:MovieClipSpriteProjector;
		public var mouseEvents:Boolean;
		private var _clipping:Clipping;
		private var _renderer:IRenderer;
		private var _cameraVarsStore:CameraVarsStore;
		private var persp:Number;
		private var _camera:Camera3D;
		var _objectContainerProjector:ObjectContainerProjector;
		private var _viewZero:Point;
		public var overlay:Sprite;
		private var _pritraverser:PrimitiveTraverser;
		private var _screenClippingDirty:Boolean;
		public var mouseObject:Object3D;
		var _convexBlockProjector:ConvexBlockProjector;
		public var mouseZeroMove:Boolean;
		private var uv:UV;
		public var statsPanel:Stats;
		public var stats:Boolean;
		private var _hitPointX:Number;
		private var _hitPointY:Number;
		public var blockerarray:BlockerArray;
		private var drawpri:DrawPrimitive;
		public var mouseMaterial:IUVMaterial;
		public var hud:Sprite;
		private var _loaderHeight:Number;
		private var _internalsession:AbstractRenderSession;
		private var element:Object;
		private var _container:DisplayObject;
		private var _stageWidth:Number;
		private var _renderComplete:ViewEvent;
		private var _ini:Init;
		private var _mouseIsOverView:Boolean;
		private var material:IUVMaterial;
		private var _ddo:DrawDisplayObject;
		public var background:Sprite;
		var _spriteProjector:SpriteProjector;
		private var _drawPrimitiveStore:DrawPrimitiveStore;
		private var object:Object3D;
		private var _mousedown:Boolean;
		private var sceneX:Number;
		private var sceneY:Number;
		private var sceneZ:Number;
		var _meshProjector:MeshProjector;
		public var sourceURL:String;
		private var _consumer:IPrimitiveConsumer;
		private var _session:AbstractRenderSession;
		var _dofSpriteProjector:DofSpriteProjector;
		var _screenClipping:Clipping;
		private var screenZ:Number;// = INF
		private var screenX:Number;
		private var screenY:Number;
		private var _updated:Boolean;
		private var _overlays:Dictionary;
		public var statsOpen:Boolean;
		public var forceUpdate:Boolean;
		private var _scene:Scene3D;
		private var _updatescene:ViewEvent;
		private var _loaderWidth:Number;
		public var blockers:Dictionary;
		private var _loaderDirty:Boolean;
		var _dirSpriteProjector:DirSpriteProjector;
		private var _lastmove_mouseX:Number;
		private var _lastmove_mouseY:Number;
		var _interactiveLayer:Sprite;
		private var inv:Matrix3D;
		private var _x:Number;
		private var _y:Number;

		public function View3D(_arg1:Object=null){
			var _local2:Boolean;
			_interactiveLayer = new Sprite();
			_convexBlockProjector = new ConvexBlockProjector();
			_dirSpriteProjector = new DirSpriteProjector();
			_dofSpriteProjector = new DofSpriteProjector();
			_meshProjector = new MeshProjector();
			_movieClipSpriteProjector = new MovieClipSpriteProjector();
			_objectContainerProjector = new ObjectContainerProjector();
			_spriteProjector = new SpriteProjector();
			_viewZero = new Point();
			_drawPrimitiveStore = new DrawPrimitiveStore();
			_cameraVarsStore = new CameraVarsStore();
			_pritraverser = new PrimitiveTraverser();
			_ddo = new DrawDisplayObject();
			screenZ = Infinity;
			inv = new Matrix3D();
			_overlays = new Dictionary();
			background = new Sprite();
			overlay = new Sprite();
			hud = new Sprite();
			blockerarray = new BlockerArray();
			super();
			_ini = (Init.parse(_arg1) as Init);
			_local2 = _ini.getBoolean("stats", true);
			session = (((_ini.getObject("session") as AbstractRenderSession)) || (new SpriteRenderSession()));
			scene = (((_ini.getObjectOrInit("scene", Scene3D) as Scene3D)) || (new Scene3D()));
			camera = (((_ini.getObjectOrInit("camera", Camera3D) as Camera3D)) || (new Camera3D({x:0, y:0, z:-1000, lookat:"center"})));
			renderer = (((_ini.getObject("renderer") as IRenderer)) || (new BasicRenderer()));
			clipping = (((_ini.getObject("clipping", Clipping) as Clipping)) || (new RectangleClipping()));
			x = _ini.getNumber("x", 0);
			y = _ini.getNumber("y", 0);
			forceUpdate = _ini.getBoolean("forceUpdate", false);
			mouseZeroMove = _ini.getBoolean("mouseZeroMove", false);
			mouseEvents = _ini.getBoolean("mouseEvents", true);
			_interactiveLayer.blendMode = BlendMode.ALPHA;
			_convexBlockProjector.view = this;
			_dirSpriteProjector.view = this;
			_dofSpriteProjector.view = this;
			_meshProjector.view = this;
			_movieClipSpriteProjector.view = this;
			_objectContainerProjector.view = this;
			_spriteProjector.view = this;
			_drawPrimitiveStore.view = this;
			_cameraVarsStore.view = this;
			_pritraverser.view = this;
			addEventListener(MouseEvent.MOUSE_DOWN, onMouseDown);
			addEventListener(MouseEvent.MOUSE_UP, onMouseUp);
			addEventListener(MouseEvent.ROLL_OUT, onRollOut);
			addEventListener(MouseEvent.ROLL_OVER, onRollOver);
			if (_local2){
				addEventListener(Event.ADDED_TO_STAGE, createStatsMenu);
			};
		}
		public function fireMouseMoveEvent(_arg1:Boolean=false):void{
			if (!_mouseIsOverView){
				return;
			};
			if (!((mouseZeroMove) || (_arg1))){
				if ((((mouseX == _lastmove_mouseX)) && ((mouseY == _lastmove_mouseY)))){
					return;
				};
			};
			fireMouseEvent(MouseEvent3D.MOUSE_MOVE, mouseX, mouseY);
			_lastmove_mouseX = mouseX;
			_lastmove_mouseY = mouseY;
		}
		private function onCameraUpdated(_arg1:CameraEvent):void{
			_updated = true;
		}
		public function set camera(_arg1:Camera3D):void{
			if (_camera == _arg1){
				return;
			};
			if (_camera){
				_camera.removeOnSceneTransformChange(onCameraTransformChange);
				_camera.removeOnCameraUpdate(onCameraUpdated);
			};
			_camera = _arg1;
			_camera.view = this;
			_updated = true;
			if (_camera){
				_camera.addOnSceneTransformChange(onCameraTransformChange);
				_camera.addOnCameraUpdate(onCameraUpdated);
			} else {
				throw (new Error("View cannot have camera set to null"));
			};
		}
		private function onSessionChange(_arg1:Object3DEvent):void{
			_session.sessions = [_arg1.object.session];
		}
		public function addOnMouseDown(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_DOWN, _arg1, false, 0, false);
		}
		private function checkSession(_arg1:AbstractRenderSession):void{
			var _local2:Array;
			var _local3:DrawPrimitive;
			var _local4:Array;
			if (_arg1.getContainer(this).hitTestPoint(_hitPointX, _hitPointY)){
				if ((_arg1 is BitmapRenderSession)){
					_container = (_arg1 as BitmapRenderSession).getBitmapContainer(this);
					_hitPointX = (_hitPointX + _container.x);
					_hitPointY = (_hitPointY + _container.y);
				};
				_local2 = _arg1.getConsumer(this).list();
				for each (_local3 in _local2) {
					checkPrimitive(_local3);
				};
				_local4 = _arg1.sessions;
				for each (_arg1 in _local4) {
					checkSession(_arg1);
				};
				if ((_arg1 is BitmapRenderSession)){
					_container = (_arg1 as BitmapRenderSession).getBitmapContainer(this);
					_hitPointX = (_hitPointX - _container.x);
					_hitPointY = (_hitPointY - _container.y);
				};
			};
		}
		public function addOverlay(_arg1:IOverlay):void{
			if (_overlays[_arg1]){
				return;
			};
			_overlays[_arg1] = _arg1;
			overlay.addChild((_arg1 as Sprite));
		}
		public function get cameraVarsStore():CameraVarsStore{
			return (_cameraVarsStore);
		}
		public function updateScreenClipping():void{
			try {
				_loaderWidth = loaderInfo.width;
				_loaderHeight = loaderInfo.height;
				if (_loaderDirty){
					_loaderDirty = false;
					_screenClippingDirty = true;
				};
			} catch(error:Error) {
				_loaderDirty = true;
				_loaderWidth = stage.stageWidth;
				_loaderHeight = stage.stageHeight;
			};
			_viewZero.x = 0;
			_viewZero.y = 0;
			_viewZero = localToGlobal(_viewZero);
			if (((((!((_x == _viewZero.x))) || (!((_y == _viewZero.y))))) || (((!((stage.scaleMode == StageScaleMode.NO_SCALE))) && (((!((_stageWidth == stage.stageWidth))) || (!((_stageHeight == stage.stageHeight))))))))){
				_x = _viewZero.x;
				_y = _viewZero.y;
				_stageWidth = stage.stageWidth;
				_stageHeight = stage.stageHeight;
				_screenClippingDirty = true;
			};
		}
		public function get scene():Scene3D{
			return (_scene);
		}
		public function clear():void{
			_updated = true;
			if (_internalsession){
				_internalsession.clear(this);
			};
		}
		public function get session():AbstractRenderSession{
			return (_session);
		}
		public function addOnMouseOver(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_OVER, _arg1, false, 0, false);
		}
		public function removeOnMouseDown(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_DOWN, _arg1, false);
		}
		private function bubbleMouseEvent(_arg1:MouseEvent3D):Array{
			var _local2:Object3D;
			var _local3:Array;
			_local2 = _arg1.object;
			_local3 = [];
			while (_local2 != null) {
				_local3.unshift(_local2);
				_local2.dispatchMouseEvent(_arg1);
				_local2 = _local2.parent;
			};
			return (_local3);
		}
		public function get drawPrimitiveStore():DrawPrimitiveStore{
			return (_drawPrimitiveStore);
		}
		private function notifyRenderComplete():void{
			if (!hasEventListener(ViewEvent.RENDER_COMPLETE)){
				return;
			};
			if (!_renderComplete){
				_renderComplete = new ViewEvent(ViewEvent.RENDER_COMPLETE, this);
			};
			dispatchEvent(_renderComplete);
		}
		public function get updated():Boolean{
			return (_updated);
		}
		private function checkPrimitive(_arg1:DrawPrimitive):void{
			var _local2:Number;
			var _local3:DrawTriangle;
			var _local4:UV;
			var _local5:IUVMaterial;
			if ((_arg1 is DrawFog)){
				return;
			};
			if (((!(_arg1.source)) || (!(_arg1.source._mouseEnabled)))){
				return;
			};
			if (_arg1.minX > screenX){
				return;
			};
			if (_arg1.maxX < screenX){
				return;
			};
			if (_arg1.minY > screenY){
				return;
			};
			if (_arg1.maxY < screenY){
				return;
			};
			if ((((_arg1 is DrawDisplayObject)) && (!((_arg1 as DrawDisplayObject).displayobject.hitTestPoint(_hitPointX, _hitPointY, true))))){
				return;
			};
			if (_arg1.contains(screenX, screenY)){
				_local2 = _arg1.getZ(screenX, screenY);
				if (_local2 < screenZ){
					if ((_arg1 is DrawTriangle)){
						_local3 = (_arg1 as DrawTriangle);
						_local4 = _local3.getUV(screenX, screenY);
						if ((_local3.material is IUVMaterial)){
							_local5 = (_local3.material as IUVMaterial);
							if (((!((_local3.material is BitmapMaterialContainer))) && (!((_local5.getPixel32(_local4.u, _local4.v) >> 24))))){
								return;
							};
							uv = _local4;
						};
						material = _local5;
					} else {
						uv = null;
					};
					screenZ = _local2;
					persp = (camera.zoom / (1 + (screenZ / camera.focus)));
					inv = camera.invViewMatrix;
					sceneX = (((((screenX / persp) * inv.sxx) + ((screenY / persp) * inv.sxy)) + (screenZ * inv.sxz)) + inv.tx);
					sceneY = (((((screenX / persp) * inv.syx) + ((screenY / persp) * inv.syy)) + (screenZ * inv.syz)) + inv.ty);
					sceneZ = (((((screenX / persp) * inv.szx) + ((screenY / persp) * inv.szy)) + (screenZ * inv.szz)) + inv.tz);
					drawpri = _arg1;
					object = _arg1.source;
					element = null;
				};
			};
		}
		private function onRollOut(_arg1:MouseEvent):void{
			_mouseIsOverView = false;
			fireMouseEvent(MouseEvent3D.MOUSE_OUT, mouseX, mouseY, _arg1.ctrlKey, _arg1.shiftKey);
		}
		public function get clipping():Clipping{
			return (_clipping);
		}
		private function traverseRollEvent(_arg1:MouseEvent3D, _arg2:Array, _arg3:Boolean):void{
			var _local4:Object3D;
			for each (_local4 in _arg2) {
				_local4.dispatchMouseEvent(_arg1);
				if (_arg3){
					buttonMode = ((buttonMode) || (_local4.useHandCursor));
				} else {
					if (((buttonMode) && (_local4.useHandCursor))){
						buttonMode = false;
					};
				};
			};
		}
		private function onStageResized(_arg1:Event):void{
			_screenClippingDirty = true;
		}
		public function get renderer():IRenderer{
			return (_renderer);
		}
		public function removeOnMouseOver(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_OVER, _arg1, false);
		}
		public function addOnMouseOut(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_OUT, _arg1, false, 0, false);
		}
		private function createStatsMenu(_arg1:Event):void{
			statsPanel = new Stats(this, stage.frameRate);
			statsOpen = false;
			stage.addEventListener(Event.RESIZE, onStageResized);
		}
		public function getMouseEvent(_arg1:String):MouseEvent3D{
			var _local2:MouseEvent3D;
			_local2 = new MouseEvent3D(_arg1);
			_local2.screenX = screenX;
			_local2.screenY = screenY;
			_local2.screenZ = screenZ;
			_local2.sceneX = sceneX;
			_local2.sceneY = sceneY;
			_local2.sceneZ = sceneZ;
			_local2.view = this;
			_local2.drawpri = drawpri;
			_local2.material = material;
			_local2.element = element;
			_local2.object = object;
			_local2.uv = uv;
			return (_local2);
		}
		private function onScreenUpdated(_arg1:ClippingEvent):void{
			_updated = true;
		}
		public function removeOnMouseOut(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_OUT, _arg1, false);
		}
		function dispatchMouseEvent(_arg1:MouseEvent3D):void{
			if (!hasEventListener(_arg1.type)){
				return;
			};
			dispatchEvent(_arg1);
		}
		public function get camera():Camera3D{
			return (_camera);
		}
		public function findHit(_arg1:AbstractRenderSession, _arg2:Number, _arg3:Number):void{
			screenX = _arg2;
			screenY = _arg3;
			screenZ = Infinity;
			material = null;
			object = null;
			if (((!(_arg1)) || (!(_mouseIsOverView)))){
				return;
			};
			_hitPointX = stage.mouseX;
			_hitPointY = stage.mouseY;
			if ((this.session is BitmapRenderSession)){
				_container = this.session.getContainer(this);
				_hitPointX = (_hitPointX + _container.x);
				_hitPointY = (_hitPointY + _container.y);
			};
			checkSession(_arg1);
		}
		public function set session(_arg1:AbstractRenderSession):void{
			if (_session == _arg1){
				return;
			};
			if (_session){
				_session.removeOnSessionUpdate(onSessionUpdate);
				if (_scene){
					_session.internalRemoveSceneSession(_scene.ownSession);
				};
			};
			_session = _arg1;
			_updated = true;
			if (_session){
				_session.addOnSessionUpdate(onSessionUpdate);
				if (_scene){
					_session.internalAddSceneSession(_scene.ownSession);
				};
			} else {
				throw (new Error("View cannot have session set to null"));
			};
			while (numChildren) {
				removeChildAt(0);
			};
			addChild(background);
			addChild(_session.getContainer(this));
			addChild(_interactiveLayer);
			addChild(overlay);
			addChild(hud);
		}
		public function set scene(_arg1:Scene3D):void{
			if (_scene == _arg1){
				return;
			};
			if (_scene){
				_scene.internalRemoveView(this);
				delete _scene.viewDictionary[this];
				_scene.removeOnSessionChange(onSessionChange);
				if (_session){
					_session.internalRemoveSceneSession(_scene.ownSession);
				};
			};
			_scene = _arg1;
			_updated = true;
			if (_scene){
				_scene.internalAddView(this);
				_scene.addOnSessionChange(onSessionChange);
				_scene.viewDictionary[this] = this;
				if (_session){
					_session.internalAddSceneSession(_scene.ownSession);
				};
			} else {
				throw (new Error("View cannot have scene set to null"));
			};
		}
		public function removeOverlay(_arg1:IOverlay):void{
			if (_overlays[_arg1]){
				overlay.removeChild((_arg1 as Sprite));
				_overlays[_arg1] = null;
			};
		}
		private function onMouseUp(_arg1:MouseEvent):void{
			_mousedown = false;
			fireMouseEvent(MouseEvent3D.MOUSE_UP, mouseX, mouseY, _arg1.ctrlKey, _arg1.shiftKey);
		}
		public function removeOnMouseUp(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_UP, _arg1, false);
		}
		public function get screenClipping():Clipping{
			if (_screenClippingDirty){
				updateScreenClipping();
				_screenClippingDirty = false;
				return ((_screenClipping = _clipping.screen(this, _loaderWidth, _loaderHeight)));
			};
			return (_screenClipping);
		}
		private function onSessionUpdate(_arg1:SessionEvent):void{
			if ((_arg1.target is BitmapRenderSession)){
				_scene.updatedSessions[_arg1.target] = _arg1.target;
			};
		}
		public function getBitmapData():BitmapData{
			if ((_session is BitmapRenderSession)){
				return ((_session as BitmapRenderSession).getBitmapData(this));
			};
			throw (new Error("incorrect session object - require BitmapRenderSession"));
		}
		private function notifySceneUpdate():void{
			if (!_updatescene){
				_updatescene = new ViewEvent(ViewEvent.UPDATE_SCENE, this);
			};
			dispatchEvent(_updatescene);
		}
		public function set clipping(_arg1:Clipping):void{
			if (_clipping == _arg1){
				return;
			};
			if (_clipping){
				_clipping.removeOnClippingUpdate(onClippingUpdated);
				_clipping.removeOnScreenUpdate(onScreenUpdated);
			};
			_clipping = _arg1;
			_clipping.view = this;
			if (_clipping){
				_clipping.addOnClippingUpdate(onClippingUpdated);
				_clipping.addOnScreenUpdate(onScreenUpdated);
			} else {
				throw (new Error("View cannot have clip set to null"));
			};
			_updated = true;
			_screenClippingDirty = true;
		}
		public function set renderer(_arg1:IRenderer):void{
			if (_renderer == _arg1){
				return;
			};
			_renderer = _arg1;
			_updated = true;
			if (!_renderer){
				throw (new Error("View cannot have renderer set to null"));
			};
		}
		public function render():void{
			var _local1:ConvexBlock;
			notifySceneUpdate();
			if (_internalsession != _session){
				_internalsession = _session;
			};
			if (_session.renderer != (_renderer as IPrimitiveConsumer)){
				_session.renderer = (_renderer as IPrimitiveConsumer);
			};
			_session.clear(this);
			_drawPrimitiveStore.reset();
			if (_session.updated){
				if ((_scene.ownSession is SpriteRenderSession)){
					(_scene.ownSession as SpriteRenderSession).cacheAsBitmap = true;
				};
				_ddo.view = this;
				_ddo.displayobject = _scene.session.getContainer(this);
				_ddo.session = _session;
				_ddo.vx = 0;
				_ddo.vy = 0;
				_ddo.vz = 0;
				_ddo.calc();
				_consumer = _session.getConsumer(this);
				_consumer.primitive(_ddo);
			};
			for each (_local1 in blockers) {
				_convexBlockProjector.blockers(_local1, cameraVarsStore.viewTransformDictionary[_local1], blockerarray);
			};
			_scene.traverse(_pritraverser);
			_session.render(this);
			_updated = false;
			if (statsOpen){
				statsPanel.updateStats(_session.getTotalFaces(this), camera);
			};
			Init.checkUnusedArguments();
			processOverlays();
			fireMouseMoveEvent();
			notifyRenderComplete();
		}
		public function addOnMouseMove(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_MOVE, _arg1, false, 0, false);
		}
		public function addOnMouseUp(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_UP, _arg1, false, 0, false);
		}
		private function processOverlays():void{
			var _local1:IOverlay;
			for each (_local1 in _overlays) {
				_local1.update();
			};
		}
		public function addSourceURL(_arg1:String):void{
			sourceURL = _arg1;
			if (statsPanel){
				statsPanel.addSourceURL(_arg1);
			};
		}
		private function onClippingUpdated(_arg1:ClippingEvent):void{
			_screenClippingDirty = true;
		}
		private function onCameraTransformChange(_arg1:Object3DEvent):void{
			_updated = true;
		}
		private function onMouseDown(_arg1:MouseEvent):void{
			_mousedown = true;
			fireMouseEvent(MouseEvent3D.MOUSE_DOWN, mouseX, mouseY, _arg1.ctrlKey, _arg1.shiftKey);
		}
		public function fireMouseEvent(_arg1:String, _arg2:Number, _arg3:Number, _arg4:Boolean=false, _arg5:Boolean=false):void{
			var _local6:MouseEvent3D;
			var _local7:Array;
			var _local8:Array;
			var _local9:int;
			if (!mouseEvents){
				return;
			};
			findHit(_internalsession, _arg2, _arg3);
			_local6 = getMouseEvent(_arg1);
			_local7 = [];
			_local8 = [];
			_local6.ctrlKey = _arg4;
			_local6.shiftKey = _arg5;
			if (((!((_arg1 == MouseEvent3D.MOUSE_OUT))) && (!((_arg1 == MouseEvent3D.MOUSE_OVER))))){
				dispatchMouseEvent(_local6);
				bubbleMouseEvent(_local6);
			};
			if (((!((mouseObject == object))) || (!((mouseMaterial == material))))){
				if (mouseObject != null){
					_local6 = getMouseEvent(MouseEvent3D.MOUSE_OUT);
					_local6.object = mouseObject;
					_local6.material = mouseMaterial;
					_local6.ctrlKey = _arg4;
					_local6.shiftKey = _arg5;
					dispatchMouseEvent(_local6);
					_local7 = bubbleMouseEvent(_local6);
				};
				if (object != null){
					_local6 = getMouseEvent(MouseEvent3D.MOUSE_OVER);
					_local6.ctrlKey = _arg4;
					_local6.shiftKey = _arg5;
					dispatchMouseEvent(_local6);
					_local8 = bubbleMouseEvent(_local6);
				};
				if (mouseObject != object){
					_local9 = 0;
					while (((_local7[_local9]) && ((_local7[_local9] == _local8[_local9])))) {
						_local9++;
					};
					if (mouseObject != null){
						_local6 = getMouseEvent(MouseEvent3D.ROLL_OUT);
						_local6.object = mouseObject;
						_local6.material = mouseMaterial;
						_local6.ctrlKey = _arg4;
						_local6.shiftKey = _arg5;
						traverseRollEvent(_local6, _local7.slice(_local9), false);
					};
					if (object != null){
						_local6 = getMouseEvent(MouseEvent3D.ROLL_OVER);
						_local6.ctrlKey = _arg4;
						_local6.shiftKey = _arg5;
						traverseRollEvent(_local6, _local8.slice(_local9), true);
					};
				};
				mouseObject = object;
				mouseMaterial = material;
			};
		}
		public function removeOnMouseMove(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_MOVE, _arg1, false);
		}
		public function getContainer():DisplayObject{
			return (_session.getContainer(this));
		}
		private function onRollOver(_arg1:MouseEvent):void{
			_mouseIsOverView = true;
			fireMouseEvent(MouseEvent3D.MOUSE_OVER, mouseX, mouseY, _arg1.ctrlKey, _arg1.shiftKey);
		}

	}
}//package away3d.containers 
Section 20
//Animation (away3d.core.base.Animation)
package away3d.core.base {
	import flash.events.*;
	import flash.utils.*;
	import away3d.events.*;

	public class Animation extends EventDispatcher implements IAnimation {

		public var delay:Number;// = 0
		private var _transition:AnimationTransition;
		public var loop:Boolean;// = false
		private var _latest:uint;// = 0
		private var _time:uint;
		public var smooth:Boolean;// = false
		private var _isRunning:Boolean;// = false
		public var sequence:Array;
		public var cycleEvent:Boolean;// = false
		public var sequenceEvent:Boolean;// = false
		private var _cycle:AnimationEvent;
		private var _sequenceupdate:AnimationEvent;
		public var frame:Number;// = 0
		public var fps:Number;// = 24
		public var geometry:Geometry;
		public var mesh:Mesh;

		public function Animation(_arg1:Geometry){
			_isRunning = false;
			_latest = 0;
			frame = 0;
			fps = 24;
			loop = false;
			smooth = false;
			cycleEvent = false;
			sequenceEvent = false;
			delay = 0;
			sequence = [];
			super();
			geometry = _arg1;
			_cycle = new AnimationEvent(AnimationEvent.CYCLE, this);
			_sequenceupdate = new AnimationEvent(AnimationEvent.SEQUENCE_UPDATE, this);
		}
		public function interpolate():void{
			var _local1:Boolean;
			_local1 = (_transition == null);
			if (_local1){
				createTransition();
			} else {
				_transition.reset();
			};
		}
		public function stop():void{
			_isRunning = false;
			_latest = 0;
		}
		public function get latest():uint{
			return (_latest);
		}
		public function get transitionValue():Number{
			return (((_transition)==null) ? 10 : _transition.transitionValue);
		}
		public function get isRunning():Boolean{
			return (_isRunning);
		}
		public function set transitionValue(_arg1:Number):void{
			createTransition();
			_transition.transitionValue = _arg1;
		}
		public function update():void{
			var _local1:uint;
			var _local2:int;
			var _local3:int;
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			if (((!(_isRunning)) && (!(sequenceEvent)))){
				return;
			};
			_local1 = getTimer();
			frame = (frame + (((_local1 - _time) * fps) / 1000));
			_time = _local1;
			_local2 = sequence.length;
			_local3 = ((_local2 - 1) + delay);
			if (_local2 == 1){
				if (cycleEvent){
					dispatchEvent(_cycle);
				};
				if (sequenceEvent){
					dispatchEvent(_sequenceupdate);
				};
				if (!loop){
					_isRunning = false;
				};
				_latest = 0;
				frame = 0;
			} else {
				if (((loop) && (!(sequenceEvent)))){
					while (frame > _local3) {
						frame = (frame - _local3);
					};
				} else {
					if (frame > _local3){
						frame = _local3;
						if (cycleEvent){
							dispatchEvent(_cycle);
						};
						if (sequenceEvent){
							dispatchEvent(_sequenceupdate);
						};
						if (!loop){
							_isRunning = false;
						};
					};
				};
			};
			_local4 = frame;
			if (!smooth){
				_local4 = Math.round(_local4);
			};
			if (_local4 < 0){
				_local4 = 0;
			};
			if (_local4 > (_local2 - 1)){
				_local4 = (_local2 - 1);
			};
			if (_local4 == Math.round(_local4)){
				geometry.frames[sequence[int(_local4)].frame].adjust(1);
			} else {
				_local5 = Math.floor(_local4);
				_local6 = Math.ceil(_local4);
				geometry.frames[sequence[int(_local5)].frame].adjust(1);
				geometry.frames[sequence[int(_local6)].frame].adjust((_local4 - _local5));
				if (((loop) || (sequenceEvent))){
					if ((((((_latest == 0)) || (((_latest + 1) == sequence[int(_local5)].frame)))) || ((_latest == sequence[int(_local5)].frame)))){
						_latest = sequence[int(_local5)].frame;
					} else {
						_latest = 0;
						if (cycleEvent){
							dispatchEvent(_cycle);
						};
						if (sequenceEvent){
							dispatchEvent(_sequenceupdate);
						};
					};
				} else {
					if (((((cycleEvent) || (sequenceEvent))) || ((_local2 == 2)))){
						if (cycleEvent){
							dispatchEvent(_cycle);
						};
						if (sequenceEvent){
							dispatchEvent(_sequenceupdate);
						};
					};
				};
			};
			if (smooth){
				if (_transition.interpolate < 1){
					_transition.update();
				};
			};
		}
		public function start():void{
			_time = getTimer();
			_isRunning = true;
			_latest = 0;
			frame = 0;
		}
		public function createTransition():void{
			if (_transition == null){
				_transition = new AnimationTransition(geometry);
			};
		}

	}
}//package away3d.core.base 
Section 21
//AnimationTransition (away3d.core.base.AnimationTransition)
package away3d.core.base {

	public class AnimationTransition {

		private var _interpolate:Number;
		private var _steps:Number;// = 0.1
		private var _refFrame:Array;
		private var _geom:Geometry;
		private var _transitionvalue:Number;// = 10

		public function AnimationTransition(_arg1:Geometry){
			_steps = 0.1;
			_transitionvalue = 10;
			super();
			_interpolate = 1;
			_geom = _arg1;
			setRef();
		}
		public function get interpolate():Number{
			return (_interpolate);
		}
		public function update():void{
			var _local1:Number;
			var _local2:int;
			var _local3:int;
			if (_interpolate < 1){
				_local1 = (1 - _interpolate);
				_local2 = _refFrame.length;
				_local3 = 0;
				while (_local3 < _local2) {
					_geom.vertices[_local3].x = ((_refFrame[_local3].x * _local1) + (_geom.vertices[_local3].x * _interpolate));
					_geom.vertices[_local3].y = ((_refFrame[_local3].y * _local1) + (_geom.vertices[_local3].y * _interpolate));
					_geom.vertices[_local3].z = ((_refFrame[_local3].z * _local1) + (_geom.vertices[_local3].z * _interpolate));
					_local3++;
				};
				_interpolate = (_interpolate + _steps);
			};
		}
		private function updateRef():void{
			var _local1:int;
			var _local2:int;
			_local1 = _refFrame.length;
			_local2 = 0;
			while (_local2 < _local1) {
				_refFrame[_local2].x = _geom.vertices[_local2].x;
				_refFrame[_local2].y = _geom.vertices[_local2].y;
				_refFrame[_local2].z = _geom.vertices[_local2].z;
				_local2++;
			};
		}
		private function setRef():void{
			var _local1:int;
			var _local2:int;
			_refFrame = [];
			_local1 = _geom.vertices.length;
			_local2 = 0;
			while (_local2 < _local1) {
				_refFrame.push(new Vertex(_geom.vertices[_local2].x, _geom.vertices[_local2].y, _geom.vertices[_local2].z));
				_local2++;
			};
		}
		public function set transitionValue(_arg1:Number):void{
			_transitionvalue = ((_arg1)<1) ? 1 : _arg1;
			_steps = (1 / _arg1);
		}
		public function get transitionValue():Number{
			return (_transitionvalue);
		}
		public function reset():void{
			updateRef();
			_interpolate = _steps;
		}

	}
}//package away3d.core.base 
Section 22
//Billboard (away3d.core.base.Billboard)
package away3d.core.base {
	import away3d.core.utils.*;
	import away3d.materials.*;

	public class Billboard extends Element {

		private var _rotation:Number;
		var _material:IBillboardMaterial;
		public var billboardVO:BillboardVO;
		var _vertex:Vertex;
		private var _scaling:Number;
		private var _index:int;
		private var _width:Number;
		private var _vertices:Array;
		private var _height:Number;
		private var _commands:Array;

		public function Billboard(_arg1:Vertex, _arg2:IBillboardMaterial=null, _arg3:Number=10, _arg4:Number=10, _arg5:Number=0, _arg6:Number=1){
			_vertices = new Array();
			_commands = new Array();
			billboardVO = new BillboardVO();
			super();
			this.vertex = _arg1;
			this.material = _arg2;
			this.width = _arg3;
			this.height = _arg4;
			this.rotation = _arg5;
			this.scaling = _arg6;
			billboardVO.billboard = this;
			vertexDirty = true;
		}
		override public function get vertices():Array{
			return (_vertices);
		}
		override public function get maxX():Number{
			return (_vertex._x);
		}
		override public function get commands():Array{
			return (_commands);
		}
		public function get z():Number{
			return (_vertex.z);
		}
		public function get y():Number{
			return (_vertex.y);
		}
		public function set x(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(x)"));
			};
			if (_vertex.x == _arg1){
				return;
			};
			if (_arg1 == Infinity){
				Debug.warning("x == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("x == -Infinity");
			};
			_vertex.x = _arg1;
		}
		public function set y(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(y)"));
			};
			if (_vertex.y == _arg1){
				return;
			};
			if (_arg1 == Infinity){
				Debug.warning("y == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("y == -Infinity");
			};
			_vertex.y = _arg1;
		}
		public function set width(_arg1:Number):void{
			if (_width == _arg1){
				return;
			};
			_width = (billboardVO.width = _arg1);
			notifyMappingChange();
		}
		public function set material(_arg1:IBillboardMaterial):void{
			if (_material == _arg1){
				return;
			};
			if (((!((_material == null))) && (parent))){
				parent.removeMaterial(this, _material);
			};
			_material = (billboardVO.material = _arg1);
			if (((!((_material == null))) && (parent))){
				parent.addMaterial(this, _material);
			};
		}
		public function get vertex():Vertex{
			return (_vertex);
		}
		public function get material():IBillboardMaterial{
			return (_material);
		}
		public function get scaling():Number{
			return (_scaling);
		}
		public function set z(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(z)"));
			};
			if (_vertex.z == _arg1){
				return;
			};
			if (_arg1 == Infinity){
				Debug.warning("z == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("z == -Infinity");
			};
			_vertex.z = _arg1;
		}
		public function get height():Number{
			return (_width);
		}
		public function set height(_arg1:Number):void{
			if (_height == _arg1){
				return;
			};
			_height = (billboardVO.height = _arg1);
			notifyMappingChange();
		}
		public function set scaling(_arg1:Number):void{
			if (_scaling == _arg1){
				return;
			};
			_scaling = (billboardVO.scaling = _arg1);
			notifyMappingChange();
		}
		override public function get minX():Number{
			return (_vertex._x);
		}
		override public function get minZ():Number{
			return (_vertex._z);
		}
		override public function get minY():Number{
			return (_vertex._y);
		}
		public function set vertex(_arg1:Vertex):void{
			if (_arg1 == _vertex){
				return;
			};
			if (_vertex){
				_index = _vertex.parents.indexOf(this);
				if (_index != -1){
					_vertex.parents.splice(_index, 1);
				};
			};
			_commands[0] = (billboardVO.command = "M");
			_vertices[0] = (_vertex = (billboardVO.vertex = _arg1));
			if (_vertex){
				_vertex.parents.push(this);
			};
			vertexDirty = true;
		}
		override public function get radius2():Number{
			return (0);
		}
		public function get width():Number{
			return (_width);
		}
		override public function get maxY():Number{
			return (_vertex._y);
		}
		override public function get maxZ():Number{
			return (_vertex._z);
		}
		public function get x():Number{
			return (_vertex.x);
		}
		public function set rotation(_arg1:Number):void{
			if (_rotation == _arg1){
				return;
			};
			_rotation = (billboardVO.rotation = _arg1);
			notifyMappingChange();
		}
		public function get rotation():Number{
			return (_rotation);
		}

	}
}//package away3d.core.base 
Section 23
//DrawingCommand (away3d.core.base.DrawingCommand)
package away3d.core.base {

	public class DrawingCommand {

		public var pEnd:Vertex;
		public var pControl:Vertex;
		public var pStart:Vertex;
		public var type:String;

		public static const MOVE:String = "M";
		public static const LINE:String = "L";
		public static const CURVE:String = "C";

		public function DrawingCommand(_arg1:String, _arg2:Vertex, _arg3:Vertex, _arg4:Vertex){
			this.type = _arg1;
			this.pStart = _arg2;
			this.pControl = _arg3;
			this.pEnd = _arg4;
		}
		public function toString():String{
			return (((((((("DrawingCommand: " + type) + ", ") + pStart) + ", ") + pControl) + ", ") + pEnd));
		}

	}
}//package away3d.core.base 
Section 24
//Element (away3d.core.base.Element)
package away3d.core.base {
	import flash.events.*;
	import away3d.events.*;

	public class Element extends EventDispatcher {

		public var vertexDirty:Boolean;
		public var extra:Object;
		private var _vertexchanged:ElementEvent;
		private var _visiblechanged:ElementEvent;
		public var parent:Geometry;
		var _visible:Boolean;// = true
		private var _mappingchanged:ElementEvent;
		private var _vertexvaluechanged:ElementEvent;

		public function Element(){
			_visible = true;
			super();
		}
		function notifyVisibleChange():void{
			if (!hasEventListener(ElementEvent.VISIBLE_CHANGED)){
				return;
			};
			if (_visiblechanged == null){
				_visiblechanged = new ElementEvent(ElementEvent.VISIBLE_CHANGED, this);
			};
			dispatchEvent(_visiblechanged);
		}
		function notifyVertexValueChange():void{
			if (!hasEventListener(ElementEvent.VERTEXVALUE_CHANGED)){
				return;
			};
			if (_vertexvaluechanged == null){
				_vertexvaluechanged = new ElementEvent(ElementEvent.VERTEXVALUE_CHANGED, this);
			};
			dispatchEvent(_vertexvaluechanged);
		}
		public function get commands():Array{
			throw (new Error("Not implemented"));
		}
		public function addOnVertexChange(_arg1:Function):void{
			addEventListener(ElementEvent.VERTEX_CHANGED, _arg1, false, 0, true);
		}
		public function removeOnVertexChange(_arg1:Function):void{
			removeEventListener(ElementEvent.VERTEX_CHANGED, _arg1, false);
		}
		public function addOnMappingChange(_arg1:Function):void{
			addEventListener(ElementEvent.MAPPING_CHANGED, _arg1, false, 0, true);
		}
		public function addOnVertexValueChange(_arg1:Function):void{
			addEventListener(ElementEvent.VERTEXVALUE_CHANGED, _arg1, false, 0, true);
		}
		public function get minX():Number{
			return (-(Math.sqrt(radius2)));
		}
		public function get minZ():Number{
			return (-(Math.sqrt(radius2)));
		}
		public function addOnVisibleChange(_arg1:Function):void{
			addEventListener(ElementEvent.VISIBLE_CHANGED, _arg1, false, 0, true);
		}
		public function get minY():Number{
			return (-(Math.sqrt(radius2)));
		}
		function notifyMappingChange():void{
			if (!hasEventListener(ElementEvent.MAPPING_CHANGED)){
				return;
			};
			if (_mappingchanged == null){
				_mappingchanged = new ElementEvent(ElementEvent.MAPPING_CHANGED, this);
			};
			dispatchEvent(_mappingchanged);
		}
		function notifyVertexChange():void{
			if (!hasEventListener(ElementEvent.VERTEX_CHANGED)){
				return;
			};
			if (_vertexchanged == null){
				_vertexchanged = new ElementEvent(ElementEvent.VERTEX_CHANGED, this);
			};
			dispatchEvent(_vertexchanged);
		}
		public function get radius2():Number{
			var _local1:Number;
			var _local2:Vertex;
			var _local3:Number;
			_local1 = 0;
			for each (_local2 in vertices) {
				_local3 = (((_local2._x * _local2._x) + (_local2._y * _local2._y)) + (_local2._z * _local2._z));
				if (_local3 > _local1){
					_local1 = _local3;
				};
			};
			return (_local1);
		}
		public function removeOnMappingChange(_arg1:Function):void{
			removeEventListener(ElementEvent.MAPPING_CHANGED, _arg1, false);
		}
		public function set visible(_arg1:Boolean):void{
			if (_arg1 == _visible){
				return;
			};
			_visible = _arg1;
			notifyVisibleChange();
		}
		public function get visible():Boolean{
			return (_visible);
		}
		public function get maxY():Number{
			return (Math.sqrt(radius2));
		}
		public function get maxZ():Number{
			return (Math.sqrt(radius2));
		}
		public function get vertices():Array{
			throw (new Error("Not implemented"));
		}
		public function removeOnVertexValueChange(_arg1:Function):void{
			removeEventListener(ElementEvent.VERTEXVALUE_CHANGED, _arg1, false);
		}
		public function get maxX():Number{
			return (Math.sqrt(radius2));
		}
		public function removeOnVisibleChange(_arg1:Function):void{
			removeEventListener(ElementEvent.VISIBLE_CHANGED, _arg1, false);
		}

	}
}//package away3d.core.base 
Section 25
//Face (away3d.core.base.Face)
package away3d.core.base {
	import flash.events.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.materials.*;
	import away3d.events.*;

	public class Face extends Element {

		private var _s:Number;
		private var _normal:Number3D;
		private var _lastAddedVertex:Vertex;
		var _v0:Vertex;
		var _v1:Vertex;
		var _v2:Vertex;
		private var _vertices:Array;
		private var _area:Number;
		private var _normalDirty:Boolean;
		private var _drawingCommands:Array;
		var _material:ITriangleMaterial;
		private var _index:int;
		var _back:ITriangleMaterial;
		public var faceVO:FaceVO;
		private var _areaDirty:Boolean;
		private var _b:Number;
		private var _a:Number;
		private var _commands:Array;
		var _uv0:UV;
		var _uv1:UV;
		var _uv2:UV;
		private var _c:Number;

		public function Face(_arg1:Vertex=null, _arg2:Vertex=null, _arg3:Vertex=null, _arg4:ITriangleMaterial=null, _arg5:UV=null, _arg6:UV=null, _arg7:UV=null){
			_normal = new Number3D();
			_vertices = new Array();
			_commands = new Array();
			_drawingCommands = new Array();
			faceVO = new FaceVO();
			super();
			if (_arg1){
				this.v0 = _arg1;
			};
			if (_arg2){
				this.v1 = _arg2;
			};
			if (_arg3){
				this.v2 = _arg3;
			};
			this.material = _arg4;
			this.uv0 = _arg5;
			this.uv1 = _arg6;
			this.uv2 = _arg7;
			faceVO.face = this;
			vertexDirty = true;
		}
		public function get uvs():Array{
			return ([_uv0, _uv1, _uv2]);
		}
		public function get back():ITriangleMaterial{
			return (_back);
		}
		public function get normal():Number3D{
			if (vertexDirty){
				updateVertex();
			};
			if (_normalDirty){
				updateNormal();
			};
			return (_normal);
		}
		private function updateNormal():void{
			var _local1:Number;
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			_normalDirty = false;
			_local1 = (_v1.x - _v0.x);
			_local2 = (_v1.y - _v0.y);
			_local3 = (_v1.z - _v0.z);
			_local4 = (_v2.x - _v0.x);
			_local5 = (_v2.y - _v0.y);
			_local6 = (_v2.z - _v0.z);
			_local7 = ((_local2 * _local6) - (_local3 * _local5));
			_local8 = ((_local3 * _local4) - (_local1 * _local6));
			_local9 = ((_local1 * _local5) - (_local2 * _local4));
			_local10 = Math.sqrt((((_local7 * _local7) + (_local8 * _local8)) + (_local9 * _local9)));
			_normal.x = (_local7 / _local10);
			_normal.y = (_local8 / _local10);
			_normal.z = (_local9 / _local10);
		}
		public function set v0(_arg1:Vertex):void{
			addVertexAt(0, _arg1, "M");
		}
		public function get material():ITriangleMaterial{
			return (_material);
		}
		public function moveTo(_arg1:Number, _arg2:Number, _arg3:Number):void{
			var _local4:Vertex;
			_local4 = new Vertex(_arg1, _arg2, _arg3);
			addVertexAt(_vertices.length, _local4, DrawingCommand.MOVE);
			_drawingCommands.push(new DrawingCommand(DrawingCommand.MOVE, _lastAddedVertex, null, _local4));
			_lastAddedVertex = _local4;
		}
		override public function get minX():Number{
			if (_v0._x < _v1._x){
				if (_v0._x < _v2._x){
					return (_v0._x);
				};
				return (_v2._x);
				//unresolved jump
			};
			if (_v1._x < _v2._x){
				return (_v1._x);
			};
			return (_v2._x);
		}
		override public function get minZ():Number{
			if (_v0._z < _v1._z){
				if (_v0._z < _v2._z){
					return (_v0._z);
				};
				return (_v2._z);
				//unresolved jump
			};
			if (_v1._z < _v2._z){
				return (_v1._z);
			};
			return (_v2._z);
		}
		override public function get minY():Number{
			if (_v0._y < _v1._y){
				if (_v0._y < _v2._y){
					return (_v0._y);
				};
				return (_v2._y);
				//unresolved jump
			};
			if (_v1._y < _v2._y){
				return (_v1._y);
			};
			return (_v2._y);
		}
		public function set normalDirty(_arg1:Boolean):void{
			vertexDirty = _arg1;
		}
		public function set uv0(_arg1:UV):void{
			if (_arg1 == _uv0){
				return;
			};
			if (_uv0 != null){
				if (((!((_uv0 == _uv1))) && (!((_uv0 == _uv2))))){
					_uv0.removeOnChange(onUVChange);
				};
			};
			_uv0 = (faceVO.uv0 = _arg1);
			if (_uv0 != null){
				if (((!((_uv0 == _uv1))) && (!((_uv0 == _uv2))))){
					_uv0.addOnChange(onUVChange);
				};
			};
			notifyMappingChange();
		}
		public function set uv1(_arg1:UV):void{
			if (_arg1 == _uv1){
				return;
			};
			if (_uv1 != null){
				if (((!((_uv1 == _uv0))) && (!((_uv1 == _uv2))))){
					_uv1.removeOnChange(onUVChange);
				};
			};
			_uv1 = (faceVO.uv1 = _arg1);
			if (_uv1 != null){
				if (((!((_uv1 == _uv0))) && (!((_uv1 == _uv2))))){
					_uv1.addOnChange(onUVChange);
				};
			};
			notifyMappingChange();
		}
		public function set uv2(_arg1:UV):void{
			if (_arg1 == _uv2){
				return;
			};
			if (_uv2 != null){
				if (((!((_uv2 == _uv1))) && (!((_uv2 == _uv0))))){
					_uv2.removeOnChange(onUVChange);
				};
			};
			_uv2 = (faceVO.uv2 = _arg1);
			if (_uv2 != null){
				if (((!((_uv2 == _uv1))) && (!((_uv2 == _uv0))))){
					_uv2.addOnChange(onUVChange);
				};
			};
			notifyMappingChange();
		}
		public function clone():Face{
			var _local1:Face;
			var _local2:uint;
			var _local3:DrawingCommand;
			_local1 = new Face();
			while (_local2 < drawingCommands.length) {
				_local3 = drawingCommands[_local2];
				switch (_local3.type){
					case DrawingCommand.MOVE:
						_local1.moveTo(_local3.pEnd.x, _local3.pEnd.y, _local3.pEnd.z);
						break;
					case DrawingCommand.LINE:
						_local1.lineTo(_local3.pEnd.x, _local3.pEnd.y, _local3.pEnd.z);
						break;
					case DrawingCommand.CURVE:
						_local1.curveTo(_local3.pControl.x, _local3.pControl.y, _local3.pControl.z, _local3.pEnd.x, _local3.pEnd.y, _local3.pEnd.z);
						break;
				};
				_local2++;
			};
			return (_local1);
		}
		public function set material(_arg1:ITriangleMaterial):void{
			if (_arg1 == _material){
				return;
			};
			if (((!((_material == null))) && (parent))){
				parent.removeMaterial(this, _material);
			};
			_material = (faceVO.material = _arg1);
			if (((!((_material == null))) && (parent))){
				parent.addMaterial(this, _material);
			};
			notifyMappingChange();
		}
		override public function get maxX():Number{
			if (_v0._x > _v1._x){
				if (_v0._x > _v2._x){
					return (_v0._x);
				};
				return (_v2._x);
				//unresolved jump
			};
			if (_v1._x > _v2._x){
				return (_v1._x);
			};
			return (_v2._x);
		}
		override public function get maxY():Number{
			if (_v0._y > _v1._y){
				if (_v0._y > _v2._y){
					return (_v0._y);
				};
				return (_v2._y);
				//unresolved jump
			};
			if (_v1._y > _v2._y){
				return (_v1._y);
			};
			return (_v2._y);
		}
		override public function get maxZ():Number{
			if (_v0._z > _v1._z){
				if (_v0._z > _v2._z){
					return (_v0._z);
				};
				return (_v2._z);
				//unresolved jump
			};
			if (_v1._z > _v2._z){
				return (_v1._z);
			};
			return (_v2._z);
		}
		public function get v0():Vertex{
			return (_v0);
		}
		public function get v2():Vertex{
			return (_v2);
		}
		public function get v1():Vertex{
			return (_v1);
		}
		override public function get commands():Array{
			return (_commands);
		}
		public function lineTo(_arg1:Number, _arg2:Number, _arg3:Number):void{
			var _local4:Vertex;
			_local4 = new Vertex(_arg1, _arg2, _arg3);
			addVertexAt(_vertices.length, _local4, DrawingCommand.LINE);
			_drawingCommands.push(new DrawingCommand(DrawingCommand.LINE, _lastAddedVertex, null, _local4));
			_lastAddedVertex = _local4;
		}
		private function onUVChange(_arg1:Event):void{
			notifyMappingChange();
		}
		public function get area():Number{
			if (vertexDirty){
				updateVertex();
			};
			if (_areaDirty){
				updateArea();
			};
			return (_area);
		}
		public function scaleAboutCenter(_arg1:Number):void{
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:uint;
			var _local9:DrawingCommand;
			var _local10:Number3D;
			var _local11:Number3D;
			var _local12:Number3D;
			_local2 = Number.MAX_VALUE;
			_local3 = -(Number.MAX_VALUE);
			_local4 = Number.MAX_VALUE;
			_local5 = -(Number.MAX_VALUE);
			_local6 = Number.MAX_VALUE;
			_local7 = -(Number.MAX_VALUE);
			_local8 = 0;
			while (_local8 < drawingCommands.length) {
				_local9 = drawingCommands[_local8];
				if (_local9.pControl){
					if (_local9.pControl.x < _local2){
						_local2 = _local9.pControl.x;
					};
					if (_local9.pControl.x > _local3){
						_local3 = _local9.pControl.x;
					};
					if (_local9.pControl.y < _local4){
						_local4 = _local9.pControl.y;
					};
					if (_local9.pControl.y > _local5){
						_local5 = _local9.pControl.y;
					};
					if (_local9.pControl.z < _local6){
						_local6 = _local9.pControl.z;
					};
					if (_local9.pControl.z > _local7){
						_local7 = _local9.pControl.z;
					};
				};
				if (_local9.pEnd){
					if (_local9.pEnd.x < _local2){
						_local2 = _local9.pEnd.x;
					};
					if (_local9.pEnd.x > _local3){
						_local3 = _local9.pEnd.x;
					};
					if (_local9.pEnd.y < _local4){
						_local4 = _local9.pEnd.y;
					};
					if (_local9.pEnd.y > _local5){
						_local5 = _local9.pEnd.y;
					};
					if (_local9.pEnd.z < _local6){
						_local6 = _local9.pEnd.z;
					};
					if (_local9.pEnd.z > _local7){
						_local7 = _local9.pEnd.z;
					};
				};
				_local8++;
			};
			_local10 = new Number3D(((_local3 + _local2) / 2), ((_local5 + _local4) / 2), ((_local7 + _local6) / 2));
			_local8 = 0;
			while (_local8 < drawingCommands.length) {
				_local9 = drawingCommands[_local8];
				if (_local9.pControl){
					_local11 = new Number3D(_local9.pControl.x, _local9.pControl.y, _local9.pControl.z);
					new Number3D(_local9.pControl.x, _local9.pControl.y, _local9.pControl.z).sub(_local11, _local10);
					_local11.scale(_local11, _arg1);
					_local9.pControl.x = (_local10.x + _local11.x);
					_local9.pControl.y = (_local10.y + _local11.y);
					_local9.pControl.z = (_local10.z + _local11.z);
				};
				if (_local9.pEnd){
					_local12 = new Number3D(_local9.pEnd.x, _local9.pEnd.y, _local9.pEnd.z);
					new Number3D(_local9.pEnd.x, _local9.pEnd.y, _local9.pEnd.z).sub(_local12, _local10);
					_local12.scale(_local12, _arg1);
					_local9.pEnd.x = (_local10.x + _local12.x);
					_local9.pEnd.y = (_local10.y + _local12.y);
					_local9.pEnd.z = (_local10.z + _local12.z);
				};
				_local8++;
			};
		}
		public function offset(_arg1:Number, _arg2:Number, _arg3:Number):void{
			var _local4:uint;
			var _local5:DrawingCommand;
			while (_local4 < drawingCommands.length) {
				_local5 = drawingCommands[_local4];
				if (_local5.pControl){
					_local5.pControl.x = (_local5.pControl.x + _arg1);
					_local5.pControl.y = (_local5.pControl.y + _arg2);
					_local5.pControl.z = (_local5.pControl.z + _arg3);
				};
				if (_local5.pEnd){
					_local5.pEnd.x = (_local5.pEnd.x + _arg1);
					_local5.pEnd.y = (_local5.pEnd.y + _arg2);
					_local5.pEnd.z = (_local5.pEnd.z + _arg3);
				};
				_local4++;
			};
		}
		public function get uv0():UV{
			return (_uv0);
		}
		public function get uv2():UV{
			return (_uv2);
		}
		public function get uv1():UV{
			return (_uv1);
		}
		private function addVertexAt(_arg1:uint, _arg2:Vertex, _arg3:String):void{
			if (((_vertices[_arg1]) && ((_vertices[_arg1] == _arg2)))){
				return;
			};
			if (_vertices[_arg1]){
				_index = _vertices[_arg1].parents.indexOf(this);
				if (_index != -1){
					_vertices[_arg1].parents.splice(_index, 1);
				};
			};
			_commands[_arg1] = (faceVO.commands[_arg1] = _arg3);
			_vertices[_arg1] = (faceVO.vertices[_arg1] = _arg2);
			if (_arg1 == 0){
				_v0 = (faceVO.v0 = _arg2);
			} else {
				if (_arg1 == 1){
					_v1 = (faceVO.v1 = _arg2);
				} else {
					if (_arg1 == 2){
						_v2 = (faceVO.v2 = _arg2);
					};
				};
			};
			if (_arg1 == 2){
				if ((-0.5 * (((_v0.x * (_v2.y - _v1.y)) + (_v1.x * (_v0.y - _v2.y))) + (_v2.x * (_v1.y - _v0.y)))) < 0){
					faceVO.reverseArea = true;
				};
			};
			_arg2._index = _arg1;
			_arg2.parents.push(this);
			vertexDirty = true;
		}
		public function get drawingCommands():Array{
			return (_drawingCommands);
		}
		public function curveTo(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number):void{
			var _local7:Vertex;
			var _local8:Vertex;
			_local7 = new Vertex(_arg1, _arg2, _arg3);
			_local8 = new Vertex(_arg4, _arg5, _arg6);
			addVertexAt(_vertices.length, _local7, DrawingCommand.CURVE);
			addVertexAt(_vertices.length, _local8, "P");
			_drawingCommands.push(new DrawingCommand(DrawingCommand.CURVE, _lastAddedVertex, _local7, _local8));
			_lastAddedVertex = _local8;
		}
		private function updateVertex():void{
			vertexDirty = false;
			_normalDirty = true;
			_areaDirty = true;
		}
		public function set back(_arg1:ITriangleMaterial):void{
			if (_arg1 == _back){
				return;
			};
			if (_back != null){
				parent.removeMaterial(this, _back);
			};
			_back = (faceVO.back = _arg1);
			if (_back != null){
				parent.addMaterial(this, _back);
			};
			notifyMappingChange();
		}
		override public function get radius2():Number{
			var _local1:Number;
			var _local2:Number;
			var _local3:Number;
			_local1 = (((_v0._x * _v0._x) + (_v0._y * _v0._y)) + (_v0._z * _v0._z));
			_local2 = (((_v1._x * _v1._x) + (_v1._y * _v1._y)) + (_v1._z * _v1._z));
			_local3 = (((_v2._x * _v2._x) + (_v2._y * _v2._y)) + (_v2._z * _v2._z));
			if (_local1 > _local2){
				if (_local1 > _local3){
					return (_local1);
				};
				return (_local3);
				//unresolved jump
			};
			if (_local2 > _local3){
				return (_local2);
			};
			return (_local3);
		}
		public function invert():void{
			faceVO.v2 = this._v1;
			faceVO.v1 = this._v2;
			faceVO.uv2 = this._uv1;
			faceVO.uv1 = this._uv2;
			this._v1 = faceVO.v1;
			this._v2 = faceVO.v2;
			this._uv1 = faceVO.uv1;
			this._uv2 = faceVO.uv2;
			vertexDirty = true;
			notifyMappingChange();
		}
		private function updateArea():void{
			_a = v0.position.distance(v1.position);
			_b = v1.position.distance(v2.position);
			_c = v2.position.distance(v0.position);
			_s = (((_a + _b) + _c) / 2);
			_area = Math.sqrt((((_s * (_s - _a)) * (_s - _b)) * (_s - _c)));
		}
		public function set v2(_arg1:Vertex):void{
			addVertexAt(2, _arg1, "L");
		}
		override public function get vertices():Array{
			return (_vertices);
		}
		public function set v1(_arg1:Vertex):void{
			addVertexAt(1, _arg1, "L");
		}

	}
}//package away3d.core.base 
Section 26
//Frame (away3d.core.base.Frame)
package away3d.core.base {

	public class Frame implements IFrame {

		public var vertexpositions:Array;

		public function Frame(){
			vertexpositions = [];
			super();
		}
		public function getIndexes(_arg1:Array):Array{
			var _local2:Array;
			var _local3:VertexPosition;
			_local2 = [];
			for each (_local3 in vertexpositions) {
				_local2.push(_local3.getIndex(_arg1));
			};
			return (_local2);
		}
		public function adjust(_arg1:Number=1):void{
			var _local2:VertexPosition;
			for each (_local2 in vertexpositions) {
				_local2.adjust(_arg1);
			};
		}

	}
}//package away3d.core.base 
Section 27
//Geometry (away3d.core.base.Geometry)
package away3d.core.base {
	import flash.events.*;
	import away3d.containers.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.materials.*;
	import flash.utils.*;
	import away3d.loaders.data.*;
	import away3d.events.*;
	import away3d.animators.skin.*;
	import away3d.animators.data.*;

	public class Geometry extends EventDispatcher {

		private var _animation:Animation;
		public var framenames:Dictionary;
		private var _activePrefix:String;
		public var materialDictionary:Dictionary;
		private var _neighbour01:Dictionary;
		private var _fAngle:Number;
		private var clonedskincontrollers:Dictionary;
		private var _dispatchedDimensionsChange:Boolean;
		var billboardVOs:Array;
		private var _neighboursDirty:Boolean;// = true
		private var _neighbour12:Dictionary;
		private var _element_vertices:Array;
		private var _materialData:MaterialData;
		private var _vertices:Array;
		private var _neighbour20:Dictionary;
		var faceVOs:Array;
		private var _verticesDirty:Boolean;// = true
		private var _vertnormals:Dictionary;
		private var _frame:int;
		private var _billboardVO:BillboardVO;
		private var _quarterFacesTotal:int;// = 0
		var commands:Array;
		public var graphics:Graphics3D;
		public var skinVertices:Array;
		private var _animationgroup:AnimationGroup;
		private var clonedskinvertices:Dictionary;
		private var clonedvertices:Dictionary;
		public var skinControllers:Array;
		private var _sequencedone:AnimationEvent;
		private var _vertfaces:Dictionary;
		var indices:Array;
		private var _fVectors:Array;
		private var _segmentVO:SegmentVO;
		private var _fNormal:Number3D;
		private var _billboards:Array;
		private var _faces:Array;
		private var _element:Element;
		private var _vertex:Vertex;
		public var rootBone:Bone;
		var segmentVOs:Array;
		private var _dimensionschanged:GeometryEvent;
		private var _vertfacesDirty:Boolean;// = true
		private var _processed:Dictionary;
		private var _element_commands:Array;
		private var _index:int;
		public var cloneElementDictionary:Dictionary;
		private var _vertnormalsDirty:Boolean;// = true
		public var frames:Dictionary;
		protected var ini:Init;
		var startIndices:Array;
		private var _cycle:AnimationEvent;
		private var cloneduvs:Dictionary;
		private var _faceVO:FaceVO;
		private var _segments:Array;

		public function Geometry():void{
			commands = [];
			indices = [];
			startIndices = [];
			faceVOs = [];
			segmentVOs = [];
			billboardVOs = [];
			_faces = [];
			_segments = [];
			_billboards = [];
			_vertices = [];
			_verticesDirty = true;
			_neighboursDirty = true;
			_vertfacesDirty = true;
			_vertnormalsDirty = true;
			_quarterFacesTotal = 0;
			materialDictionary = new Dictionary(true);
			cloneElementDictionary = new Dictionary();
			graphics = new Graphics3D();
			super();
			graphics.geometry = this;
		}
		public function removeFace(_arg1:Face):void{
			var _local2:int;
			_local2 = _faces.indexOf(_arg1);
			if (_local2 == -1){
				return;
			};
			removeElement(_arg1);
			if (_arg1.material){
				removeMaterial(_arg1, _arg1.material);
			};
			_vertfacesDirty = true;
			_arg1.v0.geometry = null;
			_arg1.v1.geometry = null;
			_arg1.v2.geometry = null;
			_faces.splice(_local2, 1);
		}
		function getFacesByVertex(_arg1:Vertex):Array{
			if (_vertfacesDirty){
				findVertFaces();
			};
			return (_vertfaces[_arg1]);
		}
		public function removeOnSequenceDone(_arg1:Function):void{
			removeEventListener(AnimationEvent.SEQUENCE_DONE, _arg1, false);
		}
		public function gotoAndStop(_arg1:int):void{
			_frame = (_animation.frame = _arg1);
			frames[_frame].adjust(1);
			if (_animation.isRunning){
				_animation.stop();
			};
		}
		public function gotoAndPlay(_arg1:int):void{
			_frame = (_animation.frame = _arg1);
			frames[_frame].adjust(1);
			if (!_animation.isRunning){
				_animation.start();
			};
		}
		public function addOnMappingChange(_arg1:Function):void{
			addEventListener(ElementEvent.MAPPING_CHANGED, _arg1, false, 0, true);
		}
		public function playFrames(_arg1:Array, _arg2:uint, _arg3:Boolean=true, _arg4:Boolean=false):void{
			var _local5:String;
			if (_animation){
				_animation.sequence = [];
			} else {
				_animation = new Animation(this);
			};
			_animation.fps = _arg2;
			_animation.smooth = _arg3;
			_animation.loop = _arg4;
			if (_arg3){
				_animation.createTransition();
			};
			for each (_local5 in _arg1) {
				if (framenames[_local5] != null){
					_animation.sequence.push(new AnimationFrame(framenames[_local5]));
				};
			};
			if (_animation.sequence.length){
				_animation.start();
			};
		}
		public function get billboards():Array{
			return (_billboards);
		}
		public function neighbour20(_arg1:Face):Face{
			if (_neighboursDirty){
				findNeighbours();
			};
			return (_neighbour20[_arg1]);
		}
		public function get transitionValue():Number{
			return (_animation.transitionValue);
		}
		private function onVertexValueChange(_arg1:ElementEvent):void{
			if ((_arg1.element is Face)){
				(_arg1.element as Face).normalDirty = true;
			};
			notifyDimensionsChange();
		}
		function getVertexNormal(_arg1:Vertex):Number3D{
			if (_vertfacesDirty){
				findVertFaces();
			};
			if (_vertnormalsDirty){
				findVertNormals();
			};
			return (_vertnormals[_arg1]);
		}
		private function addElement(_arg1:Element):void{
			_verticesDirty = true;
			_arg1.addOnVertexChange(onVertexChange);
			_arg1.addOnVertexValueChange(onVertexValueChange);
			_arg1.addOnMappingChange(onMappingChange);
			_arg1.parent = this;
			notifyDimensionsChange();
		}
		public function removeOnCycle(_arg1:Function):void{
			_animation.cycleEvent = false;
			_animation.removeEventListener(AnimationEvent.CYCLE, _arg1, false);
		}
		public function addSegment(_arg1:Segment):void{
			addElement(_arg1);
			if (_arg1.material){
				addMaterial(_arg1, _arg1.material);
			};
			_arg1.v0.geometry = this;
			_arg1.v1.geometry = this;
			_segments.push(_arg1);
		}
		private function findNeighbours():void{
			var _local1:Face;
			var _local2:Boolean;
			var _local3:Face;
			_neighbour01 = new Dictionary();
			_neighbour12 = new Dictionary();
			_neighbour20 = new Dictionary();
			for each (_local1 in _faces) {
				_local2 = true;
				for each (_local3 in _faces) {
					if (_local2){
						if (_local1 == _local3){
							_local2 = false;
						};
					} else {
						if ((((_local1._v0 == _local3._v2)) && ((_local1._v1 == _local3._v1)))){
							_neighbour01[_local1] = _local3;
							_neighbour12[_local3] = _local1;
						};
						if ((((_local1._v0 == _local3._v0)) && ((_local1._v1 == _local3._v2)))){
							_neighbour01[_local1] = _local3;
							_neighbour20[_local3] = _local1;
						};
						if ((((_local1._v0 == _local3._v1)) && ((_local1._v1 == _local3._v0)))){
							_neighbour01[_local1] = _local3;
							_neighbour01[_local3] = _local1;
						};
						if ((((_local1._v1 == _local3._v2)) && ((_local1._v2 == _local3._v1)))){
							_neighbour12[_local1] = _local3;
							_neighbour12[_local3] = _local1;
						};
						if ((((_local1._v1 == _local3._v0)) && ((_local1._v2 == _local3._v2)))){
							_neighbour12[_local1] = _local3;
							_neighbour20[_local3] = _local1;
						};
						if ((((_local1._v1 == _local3._v1)) && ((_local1._v2 == _local3._v0)))){
							_neighbour12[_local1] = _local3;
							_neighbour01[_local3] = _local1;
						};
						if ((((_local1._v2 == _local3._v2)) && ((_local1._v0 == _local3._v1)))){
							_neighbour20[_local1] = _local3;
							_neighbour12[_local3] = _local1;
						};
						if ((((_local1._v2 == _local3._v0)) && ((_local1._v0 == _local3._v2)))){
							_neighbour20[_local1] = _local3;
							_neighbour20[_local3] = _local1;
						};
						if ((((_local1._v2 == _local3._v1)) && ((_local1._v0 == _local3._v0)))){
							_neighbour20[_local1] = _local3;
							_neighbour01[_local3] = _local1;
						};
					};
				};
			};
			_neighboursDirty = false;
		}
		public function removeSegment(_arg1:Segment):void{
			var _local2:int;
			_local2 = _segments.indexOf(_arg1);
			if (_local2 == -1){
				return;
			};
			removeElement(_arg1);
			if (_arg1.material){
				removeMaterial(_arg1, _arg1.material);
			};
			_arg1.v0.geometry = null;
			_arg1.v1.geometry = null;
			_segments.splice(_local2, 1);
		}
		private function cloneFrame(_arg1:Frame):Frame{
			var _local2:Frame;
			var _local3:Array;
			var _local4:VertexPosition;
			_local2 = new Frame();
			_local3 = _arg1.vertexpositions;
			for each (_local4 in _local3) {
				_local2.vertexpositions.push(cloneVertexPosition(_local4));
			};
			return (_local2);
		}
		public function quarterFace(_arg1:Face, _arg2:Dictionary=null):void{
			var _local3:Vertex;
			var _local4:Vertex;
			var _local5:Vertex;
			var _local6:Vertex;
			var _local7:Vertex;
			var _local8:Vertex;
			var _local9:UV;
			var _local10:UV;
			var _local11:UV;
			var _local12:UV;
			var _local13:UV;
			var _local14:UV;
			var _local15:ITriangleMaterial;
			if (_arg2 == null){
				_arg2 = new Dictionary();
			};
			_local3 = _arg1.v0;
			_local4 = _arg1.v1;
			_local5 = _arg1.v2;
			if (_arg2[_local3] == null){
				_arg2[_local3] = new Dictionary();
			};
			if (_arg2[_local4] == null){
				_arg2[_local4] = new Dictionary();
			};
			if (_arg2[_local5] == null){
				_arg2[_local5] = new Dictionary();
			};
			_local6 = _arg2[_local3][_local4];
			if (_local6 == null){
				_local6 = Vertex.median(_local3, _local4);
				_arg2[_local3][_local4] = _local6;
				_arg2[_local4][_local3] = _local6;
			};
			_local7 = _arg2[_local4][_local5];
			if (_local7 == null){
				_local7 = Vertex.median(_local4, _local5);
				_arg2[_local4][_local5] = _local7;
				_arg2[_local5][_local4] = _local7;
			};
			_local8 = _arg2[_local5][_local3];
			if (_local8 == null){
				_local8 = Vertex.median(_local5, _local3);
				_arg2[_local5][_local3] = _local8;
				_arg2[_local3][_local5] = _local8;
			};
			_local9 = _arg1.uv0;
			_local10 = _arg1.uv1;
			_local11 = _arg1.uv2;
			_local12 = UV.median(_local9, _local10);
			_local13 = UV.median(_local10, _local11);
			_local14 = UV.median(_local11, _local9);
			_local15 = _arg1.material;
			removeFace(_arg1);
			addFace(new Face(_local3, _local6, _local8, _local15, _local9, _local12, _local14));
			addFace(new Face(_local6, _local4, _local7, _local15, _local12, _local10, _local13));
			addFace(new Face(_local8, _local7, _local5, _local15, _local14, _local13, _local11));
			addFace(new Face(_local7, _local8, _local6, _local15, _local13, _local14, _local12));
		}
		public function removeBillboard(_arg1:Billboard):void{
			var _local2:int;
			_local2 = _billboards.indexOf(_arg1);
			if (_local2 == -1){
				return;
			};
			removeElement(_arg1);
			if (_arg1.material){
				removeMaterial(_arg1, _arg1.material);
			};
			_arg1.vertex.geometry = null;
			_billboards.splice(_local2, 1);
		}
		public function set transitionValue(_arg1:Number):void{
			_animation.transitionValue = _arg1;
		}
		public function get isRunning():Boolean{
			return (((_animation)!=null) ? _animation.isRunning : false);
		}
		function notifyDimensionsChange():void{
			if (((_dispatchedDimensionsChange) || (!(hasEventListener(GeometryEvent.DIMENSIONS_CHANGED))))){
				return;
			};
			if (!_dimensionschanged){
				_dimensionschanged = new GeometryEvent(GeometryEvent.DIMENSIONS_CHANGED, this);
			};
			dispatchEvent(_dimensionschanged);
			_dispatchedDimensionsChange = true;
		}
		public function set loop(_arg1:Boolean):void{
			_animation.loop = _arg1;
		}
		private function findVertFaces():void{
			var _local1:Face;
			var _local2:Vertex;
			var _local3:Vertex;
			var _local4:Vertex;
			_vertfaces = new Dictionary();
			for each (_local1 in faces) {
				_local2 = _local1.v0;
				if (_vertfaces[_local2] == null){
					_vertfaces[_local2] = [_local1];
				} else {
					_vertfaces[_local2].push(_local1);
				};
				_local3 = _local1.v1;
				if (_vertfaces[_local3] == null){
					_vertfaces[_local3] = [_local1];
				} else {
					_vertfaces[_local3].push(_local1);
				};
				_local4 = _local1.v2;
				if (_vertfaces[_local4] == null){
					_vertfaces[_local4] = [_local1];
				} else {
					_vertfaces[_local4].push(_local1);
				};
			};
			_vertfacesDirty = false;
			_vertnormalsDirty = true;
		}
		public function removeOnMaterialUpdate(_arg1:Function):void{
			removeEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false);
		}
		public function play(_arg1:AnimationSequence):void{
			var _local2:Boolean;
			var _local3:String;
			if (!_animation){
				_animation = new Animation(this);
			} else {
				_animation.sequence = [];
			};
			_animation.fps = _arg1.fps;
			_animation.smooth = _arg1.smooth;
			_animation.loop = _arg1.loop;
			if (((!((_arg1.prefix == null))) && (!((_arg1.prefix == ""))))){
				if (_animation.smooth){
					_animation.interpolate();
				};
				for (_local3 in framenames) {
					if (_local3.indexOf(_arg1.prefix) == 0){
						_local2 = true;
						_activePrefix = ((_activePrefix)!=_arg1.prefix) ? _arg1.prefix : _activePrefix;
						_animation.sequence.push(new AnimationFrame(framenames[_local3], ("" + parseInt(_local3.substring(_arg1.prefix.length)))));
					};
				};
				if (_local2){
					_animation.sequence.sortOn("sort", Array.NUMERIC);
					frames[_frame].adjust(1);
					_animation.start();
				} else {
					trace((("--------- \n--> unable to play animation: unvalid prefix [" + _arg1.prefix) + "]\n--------- "));
				};
			} else {
				trace("--------- \n--> unable to play animation: prefix is null \n--------- ");
			};
		}
		public function addOnMaterialUpdate(_arg1:Function):void{
			addEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false, 0, true);
		}
		public function removeOnMappingChange(_arg1:Function):void{
			removeEventListener(ElementEvent.MAPPING_CHANGED, _arg1, false);
		}
		public function clone():Geometry{
			var _local1:Geometry;
			var _local2:Face;
			var _local3:Segment;
			var _local4:int;
			var _local5:Frame;
			var _local6:String;
			var _local7:SkinVertex;
			var _local8:SkinController;
			var _local9:Face;
			var _local10:Segment;
			_local1 = new Geometry();
			clonedvertices = new Dictionary();
			cloneduvs = new Dictionary();
			if (skinVertices){
				clonedskinvertices = new Dictionary(true);
				clonedskincontrollers = new Dictionary(true);
				_local1.skinVertices = [];
				_local1.skinControllers = [];
				for each (_local7 in skinVertices) {
					_local1.skinVertices.push(cloneSkinVertex(_local7));
				};
				for each (_local8 in clonedskincontrollers) {
					_local1.skinControllers.push(_local8);
				};
			};
			for each (_local2 in _faces) {
				_local9 = new Face(cloneVertex(_local2._v0), cloneVertex(_local2._v1), cloneVertex(_local2._v2), _local2.material, cloneUV(_local2._uv0), cloneUV(_local2._uv1), cloneUV(_local2._uv2));
				_local1.addFace(_local9);
				cloneElementDictionary[_local2] = _local9;
			};
			for each (_local3 in _segments) {
				_local10 = new Segment(cloneVertex(_local3._v0), cloneVertex(_local3._v1), _local3.material);
				_local1.addSegment(_local10);
				cloneElementDictionary[_local3] = _local10;
			};
			_local1.frames = new Dictionary(true);
			_local4 = 0;
			for each (_local5 in frames) {
				var _temp1 = _local4;
				_local4 = (_local4 + 1);
				var _local13 = _temp1;
				_local1.frames[_local13] = cloneFrame(_local5);
			};
			_local1.framenames = new Dictionary(true);
			for (_local6 in framenames) {
				_local1.framenames[_local6] = framenames[_local6];
			};
			return (_local1);
		}
		public function get activePrefix():String{
			return (_activePrefix);
		}
		private function cloneVertex(_arg1:Vertex):Vertex{
			var _local2:Vertex;
			_local2 = clonedvertices[_arg1];
			if (_local2 == null){
				_local2 = _arg1.clone();
				_local2.extra = ((_arg1.extra is IClonable)) ? (_arg1.extra as IClonable).clone() : _arg1.extra;
				clonedvertices[_arg1] = _local2;
			};
			return (_local2);
		}
		public function quarterFaces():void{
			var _local1:Dictionary;
			var _local2:Face;
			_quarterFacesTotal++;
			_local1 = new Dictionary();
			for each (_local2 in _faces.concat([])) {
				quarterFace(_local2, _local1);
			};
		}
		public function updateMaterials(_arg1:Object3D, _arg2:View3D):void{
			var _local3:MaterialData;
			for each (_local3 in materialDictionary) {
				_local3.material.updateMaterial(_arg1, _arg2);
			};
		}
		public function get frame():int{
			return (_animation.frame);
		}
		private function onMappingChange(_arg1:ElementEvent):void{
			dispatchEvent(_arg1);
		}
		public function invertFaces():void{
			var _local1:Face;
			for each (_local1 in _faces) {
				_local1.invert();
			};
		}
		private function findVertNormals():void{
			var _local1:Vertex;
			var _local2:Array;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			var _local6:Face;
			var _local7:Number3D;
			var _local8:Array;
			var _local9:Vertex;
			_vertnormals = new Dictionary();
			for each (_local1 in vertices) {
				_local2 = _vertfaces[_local1];
				_local3 = 0;
				_local4 = 0;
				_local5 = 0;
				for each (_local6 in _local2) {
					_fNormal = _local6.normal;
					_fVectors = [];
					_local8 = _local6.vertices;
					for each (_local9 in _local8) {
						if (_local9 != _local1){
							_fVectors.push(new Number3D((_local9.x - _local1.x), (_local9.y - _local1.y), (_local9.z - _local1.z), true));
						};
					};
					_fAngle = Math.acos((_fVectors[0] as Number3D).dot((_fVectors[1] as Number3D)));
					_local3 = (_local3 + (_fNormal.x * _fAngle));
					_local4 = (_local4 + (_fNormal.y * _fAngle));
					_local5 = (_local5 + (_fNormal.z * _fAngle));
				};
				_local7 = new Number3D(_local3, _local4, _local5);
				_local7.normalize();
				_vertnormals[_local1] = _local7;
			};
			_vertnormalsDirty = false;
		}
		private function updatePlaySequence(_arg1:AnimationEvent):void{
			var _local2:int;
			_local2 = _animationgroup.playlist.length;
			if (_local2 == 0){
				_animation.removeEventListener(AnimationEvent.SEQUENCE_UPDATE, updatePlaySequence);
				_animation.sequenceEvent = false;
				if (hasSequenceEvent){
					if (_sequencedone == null){
						_sequencedone = new AnimationEvent(AnimationEvent.SEQUENCE_DONE, null);
					};
					dispatchEvent(_sequencedone);
				};
				if (_animationgroup.loopLast){
					_animation.start();
				};
			} else {
				if (_local2 == 1){
					loop = _animationgroup.loopLast;
					_animationgroup.playlist[0].loop = _animationgroup.loopLast;
				};
				play(_animationgroup.playlist.shift());
			};
		}
		public function removeOnDimensionsChange(_arg1:Function):void{
			removeEventListener(GeometryEvent.DIMENSIONS_CHANGED, _arg1, false);
		}
		public function addOnDimensionsChange(_arg1:Function):void{
			addEventListener(GeometryEvent.DIMENSIONS_CHANGED, _arg1, false, 0, true);
		}
		private function onMaterialUpdate(_arg1:MaterialEvent):void{
			dispatchEvent(_arg1);
		}
		public function addOnCycle(_arg1:Function):void{
			_animation.cycleEvent = true;
			_cycle = new AnimationEvent(AnimationEvent.CYCLE, _animation);
			_animation.addEventListener(AnimationEvent.CYCLE, _arg1, false, 0, false);
		}
		function get vertexDirty():Boolean{
			var _local1:Boolean;
			var _local2:Vertex;
			_local1 = false;
			for each (_local2 in vertices) {
				if (_local2.getVertexDirty()){
					_local1 = true;
				};
			};
			return (_local1);
		}
		public function splitFace(_arg1:Face, _arg2:int=0):void{
			var _local3:Vertex;
			var _local4:Vertex;
			var _local5:Vertex;
			var _local6:UV;
			var _local7:UV;
			var _local8:UV;
			var _local9:Vertex;
			var _local10:UV;
			var _local11:ITriangleMaterial;
			_local3 = _arg1.v0;
			_local4 = _arg1.v1;
			_local5 = _arg1.v2;
			_local6 = _arg1.uv0;
			_local7 = _arg1.uv1;
			_local8 = _arg1.uv2;
			_local11 = _arg1.material;
			removeFace(_arg1);
			switch (_arg2){
				case 0:
					_local9 = new Vertex(((_arg1.v0.x + _arg1.v1.x) * 0.5), ((_arg1.v0.y + _arg1.v1.y) * 0.5), ((_arg1.v0.z + _arg1.v1.z) * 0.5));
					_local10 = new UV(((_local6.u + _local7.u) * 0.5), ((_local6.v + _local7.v) * 0.5));
					addFace(new Face(_local9, _local4, _local5, _local11, _local10, _local7, _local8));
					addFace(new Face(_local3, _local9, _local5, _local11, _local6, _local10, _local8));
					break;
				case 1:
					_local9 = new Vertex(((_arg1.v1.x + _arg1.v2.x) * 0.5), ((_arg1.v1.y + _arg1.v2.y) * 0.5), ((_arg1.v1.z + _arg1.v2.z) * 0.5));
					_local10 = new UV(((_local7.u + _local8.u) * 0.5), ((_local7.v + _local8.v) * 0.5));
					addFace(new Face(_local3, _local4, _local9, _local11, _local6, _local7, _local10));
					addFace(new Face(_local3, _local9, _local5, _local11, _local6, _local10, _local8));
					break;
				default:
					_local9 = new Vertex(((_arg1.v2.x + _arg1.v0.x) * 0.5), ((_arg1.v2.y + _arg1.v0.y) * 0.5), ((_arg1.v2.z + _arg1.v0.z) * 0.5));
					_local10 = new UV(((_local8.u + _local6.u) * 0.5), ((_local8.v + _local6.v) * 0.5));
					addFace(new Face(_local3, _local4, _local9, _local11, _local6, _local7, _local10));
					addFace(new Face(_local9, _local4, _local5, _local11, _local10, _local7, _local8));
			};
		}
		public function addOnSequenceDone(_arg1:Function):void{
			addEventListener(AnimationEvent.SEQUENCE_DONE, _arg1, false, 0, false);
		}
		public function get loop():Boolean{
			return (_animation.loop);
		}
		public function addFace(_arg1:Face):void{
			addElement(_arg1);
			if (_arg1.material){
				addMaterial(_arg1, _arg1.material);
			};
			_vertfacesDirty = true;
			if (_arg1.v0){
				_arg1.v0.geometry = this;
			};
			if (_arg1.v1){
				_arg1.v1.geometry = this;
			};
			if (_arg1.v2){
				_arg1.v2.geometry = this;
			};
			_faces.push(_arg1);
		}
		private function cloneVertexPosition(_arg1:VertexPosition):VertexPosition{
			var _local2:VertexPosition;
			_local2 = new VertexPosition(cloneVertex(_arg1.vertex));
			_local2.x = _arg1.x;
			_local2.y = _arg1.y;
			_local2.z = _arg1.z;
			return (_local2);
		}
		private function cloneSkinController(_arg1:SkinController):SkinController{
			var _local2:SkinController;
			_local2 = clonedskincontrollers[_arg1];
			if (_local2 == null){
				_local2 = new SkinController();
				_local2.name = _arg1.name;
				_local2.bindMatrix = _arg1.bindMatrix;
				clonedskincontrollers[_arg1] = _local2;
			};
			return (_local2);
		}
		public function get hasCycleEvent():Boolean{
			return (_animation.hasEventListener(AnimationEvent.CYCLE));
		}
		public function splitFaces(_arg1:int=0):void{
			var _local2:Face;
			_arg1 = ((_arg1)<0) ? 0 : ((_arg1)>2) ? 2 : _arg1;
			for each (_local2 in _faces.concat([])) {
				splitFace(_local2, _arg1);
			};
		}
		private function cloneSkinVertex(_arg1:SkinVertex):SkinVertex{
			var _local2:SkinVertex;
			var _local3:Array;
			var _local4:SkinController;
			_local2 = clonedskinvertices[_arg1];
			if (_local2 == null){
				_local2 = new SkinVertex(cloneVertex(_arg1.skinnedVertex));
				_local2.weights = _arg1.weights.concat();
				_local3 = _arg1.controllers;
				for each (_local4 in _local3) {
					_local2.controllers.push(cloneSkinController(_local4));
				};
				clonedskinvertices[_arg1] = _local2;
			};
			return (_local2);
		}
		public function addBillboard(_arg1:Billboard):void{
			addElement(_arg1);
			if (_arg1.material){
				addMaterial(_arg1, _arg1.material);
			};
			_arg1.vertex.geometry = this;
			_billboards.push(_arg1);
		}
		public function get segments():Array{
			return (_segments);
		}
		private function cloneUV(_arg1:UV):UV{
			var _local2:UV;
			if (_arg1 == null){
				return (null);
			};
			_local2 = cloneduvs[_arg1];
			if (_local2 == null){
				_local2 = new UV(_arg1._u, _arg1._v);
				cloneduvs[_arg1] = _local2;
			};
			return (_local2);
		}
		function removeMaterial(_arg1:Element, _arg2:IMaterial):void{
			if ((_materialData = materialDictionary[_arg2])){
				if ((_index = _materialData.elements.indexOf(_arg1)) != -1){
					_materialData.elements.splice(_index, 1);
				};
				if (!_materialData.elements.length){
					delete materialDictionary[_arg2];
					_arg2.removeOnMaterialUpdate(onMaterialUpdate);
				};
			};
		}
		public function updateVertex(_arg1:Vertex, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Boolean=false):void{
			_arg1.setValue(_arg2, _arg3, _arg4);
			if (_arg5){
				_vertnormalsDirty = true;
			};
		}
		public function get smooth():Boolean{
			return (_animation.smooth);
		}
		public function set fps(_arg1:int):void{
			_animation.fps = ((_arg1)>=1) ? _arg1 : 1;
		}
		public function setPlaySequences(_arg1:Array, _arg2:Boolean=false):void{
			var _local3:int;
			var _local4:int;
			_local3 = _arg1.length;
			if (_local3 == 0){
				return;
			};
			if (!_animation){
				_animation = new Animation(this);
			};
			_animationgroup = new AnimationGroup();
			_animationgroup.loopLast = _arg2;
			_animationgroup.playlist = [];
			_local4 = 0;
			while (_local4 < _local3) {
				_animationgroup.playlist[_local4] = new AnimationSequence(_arg1[_local4].prefix, _arg1[_local4].smooth, true, _arg1[_local4].fps);
				_local4++;
			};
			if (!_animation.hasEventListener(AnimationEvent.SEQUENCE_UPDATE)){
				_animation.addEventListener(AnimationEvent.SEQUENCE_UPDATE, updatePlaySequence);
			};
			_animation.sequenceEvent = true;
			loop = true;
			play(_animationgroup.playlist.shift());
		}
		private function removeElement(_arg1:Element):void{
			_verticesDirty = true;
			_arg1.removeOnVertexChange(onVertexChange);
			_arg1.removeOnVertexValueChange(onVertexValueChange);
			_arg1.notifyMappingChange();
			_arg1.removeOnMappingChange(onMappingChange);
			notifyDimensionsChange();
		}
		public function applyPosition(_arg1:Number, _arg2:Number, _arg3:Number):void{
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Vertex;
			for each (_local7 in vertices) {
				_local4 = _local7.x;
				_local5 = _local7.y;
				_local6 = _local7.z;
				_local7.setValue((_local4 - _arg1), (_local5 - _arg2), (_local6 - _arg3));
			};
		}
		public function set frame(_arg1:int):void{
			if (_animation.frame == _arg1){
				return;
			};
			_frame = _arg1;
			_animation.frame = _arg1;
			frames[_arg1].adjust(1);
		}
		public function neighbour01(_arg1:Face):Face{
			if (_neighboursDirty){
				findNeighbours();
			};
			return (_neighbour01[_arg1]);
		}
		public function set smooth(_arg1:Boolean):void{
			_animation.smooth = _arg1;
		}
		public function triFace(_arg1:Face):void{
			var _local2:Vertex;
			var _local3:Vertex;
			var _local4:Vertex;
			var _local5:Vertex;
			var _local6:UV;
			var _local7:UV;
			var _local8:UV;
			var _local9:UV;
			var _local10:ITriangleMaterial;
			_local2 = _arg1.v0;
			_local3 = _arg1.v1;
			_local4 = _arg1.v2;
			_local5 = new Vertex((((_arg1.v0.x + _arg1.v1.x) + _arg1.v2.x) / 3), (((_arg1.v0.y + _arg1.v1.y) + _arg1.v2.y) / 3), (((_arg1.v0.z + _arg1.v1.z) + _arg1.v2.z) / 3));
			_local6 = _arg1.uv0;
			_local7 = _arg1.uv1;
			_local8 = _arg1.uv2;
			_local9 = new UV((((_local6.u + _local7.u) + _local8.u) / 3), (((_local6.v + _local7.v) + _local8.v) / 3));
			_local10 = _arg1.material;
			removeFace(_arg1);
			addFace(new Face(_local2, _local3, _local5, _local10, _local6, _local7, _local9));
			addFace(new Face(_local5, _local3, _local4, _local10, _local9, _local7, _local8));
			addFace(new Face(_local2, _local5, _local4, _local10, _local6, _local9, _local8));
		}
		public function get faces():Array{
			return (_faces);
		}
		public function get hasSequenceEvent():Boolean{
			return (hasEventListener(AnimationEvent.SEQUENCE_DONE));
		}
		function addMaterial(_arg1:Element, _arg2:IMaterial):void{
			if (!(_materialData = materialDictionary[_arg2])){
				_materialData = (materialDictionary[_arg2] = new MaterialData());
				_materialData.material = _arg2;
				_arg2.addOnMaterialUpdate(onMaterialUpdate);
			};
			if (_materialData.elements.indexOf(_arg1) == -1){
				_materialData.elements.push(_arg1);
			};
		}
		public function get fps():int{
			return (_animation.fps);
		}
		public function triFaces():void{
			var _local1:Face;
			for each (_local1 in _faces.concat([])) {
				triFace(_local1);
			};
		}
		public function applyRotations(_arg1:Number, _arg2:Number, _arg3:Number):void{
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Number;
			var _local19:Vertex;
			_local9 = (Math.PI / 180);
			_local10 = (_arg1 * _local9);
			_local11 = (_arg2 * _local9);
			_local12 = (_arg3 * _local9);
			_local13 = Math.sin(_local10);
			_local14 = Math.cos(_local10);
			_local15 = Math.sin(_local11);
			_local16 = Math.cos(_local11);
			_local17 = Math.sin(_local12);
			_local18 = Math.cos(_local12);
			for each (_local19 in vertices) {
				_local4 = _local19.x;
				_local5 = _local19.y;
				_local6 = _local19.z;
				_local8 = _local5;
				_local5 = ((_local8 * _local14) + (_local6 * -(_local13)));
				_local6 = ((_local8 * _local13) + (_local6 * _local14));
				_local7 = _local4;
				_local4 = ((_local7 * _local16) + (_local6 * _local15));
				_local6 = ((_local7 * -(_local15)) + (_local6 * _local16));
				_local7 = _local4;
				_local4 = ((_local7 * _local18) + (_local5 * -(_local17)));
				_local5 = ((_local7 * _local17) + (_local5 * _local18));
				updateVertex(_local19, _local4, _local5, _local6, false);
			};
		}
		public function updateElements():void{
			var _local1:SkinController;
			var _local2:SkinVertex;
			_dispatchedDimensionsChange = false;
			for each (_local1 in skinControllers) {
				_local1.update();
			};
			for each (_local2 in skinVertices) {
				_local2.update();
			};
			if (((!((_animation == null))) && (!((frames == null))))){
				_animation.update();
			};
			if (vertexDirty){
				notifyDimensionsChange();
			};
		}
		private function onVertexChange(_arg1:ElementEvent):void{
			_verticesDirty = true;
			if ((_arg1.element is Face)){
				(_arg1.element as Face).normalDirty = true;
				_vertfacesDirty = true;
			};
			notifyDimensionsChange();
		}
		public function get elements():Array{
			return (_faces.concat(_segments, _billboards));
		}
		public function get vertices():Array{
			if (_verticesDirty){
				_verticesDirty = false;
				_vertices.length = 0;
				indices.length = 0;
				commands.length = 0;
				startIndices.length = 0;
				faceVOs.length = 0;
				segmentVOs.length = 0;
				billboardVOs.length = 0;
				_processed = new Dictionary(true);
				for each (_element in elements) {
					if (((_element.visible) && ((_element.vertices.length > 0)))){
						_element_vertices = _element.vertices;
						_element_commands = _element.commands;
						startIndices[startIndices.length] = indices.length;
						if ((_element is Face)){
							_faceVO = (_element as Face).faceVO;
							faceVOs[faceVOs.length] = _faceVO;
						} else {
							if ((_element is Segment)){
								_segmentVO = (_element as Segment).segmentVO;
								segmentVOs[segmentVOs.length] = _segmentVO;
							} else {
								if ((_element is Billboard)){
									_billboardVO = (_element as Billboard).billboardVO;
									billboardVOs[billboardVOs.length] = _billboardVO;
								};
							};
						};
						_index = 0;
						while (_index < _element_vertices.length) {
							_vertex = _element_vertices[_index];
							if (!_processed[_vertex]){
								_vertices[_vertices.length] = _vertex;
								indices[indices.length] = ((_processed[_vertex] = _vertices.length) - 1);
							} else {
								indices[indices.length] = (_processed[_vertex] - 1);
							};
							commands[commands.length] = _element_commands[_index];
							_index++;
						};
					};
				};
				startIndices[startIndices.length] = indices.length;
			};
			return (_vertices);
		}
		public function get quarterFacesTotal():int{
			return (_quarterFacesTotal);
		}
		public function neighbour12(_arg1:Face):Face{
			if (_neighboursDirty){
				findNeighbours();
			};
			return (_neighbour12[_arg1]);
		}

	}
}//package away3d.core.base 
Section 28
//Graphics3D (away3d.core.base.Graphics3D)
package away3d.core.base {
	import away3d.materials.*;

	public class Graphics3D {

		private var _currentMaterial:WireColorMaterial;
		private var _geometry:Geometry;
		private var _zOffset:Number;// = 0
		private var _currentFace:Face;

		public function Graphics3D(){
			_zOffset = 0;
			super();
		}
		public function startNewShape():void{
			_currentFace = new Face();
			_currentFace.material = _currentMaterial;
			_geometry.addFace(_currentFace);
		}
		public function set geometry(_arg1:Geometry):void{
			_geometry = _arg1;
		}
		public function curveTo(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			_currentFace.curveTo(_arg1, -(_arg2), _zOffset, _arg3, -(_arg4), _zOffset);
		}
		public function beginFill(_arg1:int=-1, _arg2:Number=-1):void{
			_currentMaterial = new WireColorMaterial();
			_currentMaterial.wirealpha = 0;
			if (_arg1 != -1){
				_currentMaterial.color = _arg1;
			};
			if (_arg2 != -1){
				_currentMaterial.alpha = _arg2;
			};
			if (_currentFace){
				_currentFace.material = _currentMaterial;
			};
		}
		public function clear():void{
			var _local1:Face;
			for each (_local1 in _geometry.faces) {
				_geometry.removeFace(_local1);
			};
		}
		public function moveTo(_arg1:Number, _arg2:Number):void{
			_currentFace.moveTo(_arg1, -(_arg2), _zOffset);
		}
		public function lineTo(_arg1:Number, _arg2:Number):void{
			_currentFace.lineTo(_arg1, -(_arg2), _zOffset);
		}
		public function lineStyle(_arg1:Number=-1, _arg2:int=-1, _arg3:Number=-1):void{
		}
		public function endFill():void{
		}

	}
}//package away3d.core.base 
Section 29
//IAnimation (away3d.core.base.IAnimation)
package away3d.core.base {

	public interface IAnimation {

		function update():void;

	}
}//package away3d.core.base 
Section 30
//IFrame (away3d.core.base.IFrame)
package away3d.core.base {

	public interface IFrame {

		function adjust(_arg1:Number=1):void;

	}
}//package away3d.core.base 
Section 31
//Mesh (away3d.core.base.Mesh)
package away3d.core.base {
	import away3d.containers.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.materials.*;
	import flash.utils.*;
	import away3d.events.*;
	import away3d.animators.data.*;
	import away3d.core.project.*;

	public class Mesh extends Object3D {

		public var outline:ISegmentMaterial;
		private var _faceMaterial:ITriangleMaterial;
		private var _material:IMaterial;
		private var _uvMaterial:IUVMaterial;
		private var _vertex:Vertex;
		public var indexes:Array;
		public var bothsides:Boolean;
		public var type:String;// = "mesh"
		private var _face:Face;
		private var _segmentMaterial:ISegmentMaterial;
		private var _billboardMaterial:IBillboardMaterial;
		public var url:String;
		private var _back:ITriangleMaterial;
		var _geometry:Geometry;

		public function Mesh(_arg1:Object=null){
			type = "mesh";
			super(_arg1);
			geometry = new Geometry();
			outline = ini.getSegmentMaterial("outline");
			material = ini.getMaterial("material");
			faceMaterial = (((ini.getMaterial("faceMaterial") as ITriangleMaterial)) || (_faceMaterial));
			segmentMaterial = (((ini.getMaterial("segmentMaterial") as ISegmentMaterial)) || (_segmentMaterial));
			billboardMaterial = (((ini.getMaterial("billboardMaterial") as IBillboardMaterial)) || (_billboardMaterial));
			back = (ini.getMaterial("back") as ITriangleMaterial);
			bothsides = ini.getBoolean("bothsides", false);
			projectorType = ProjectorType.MESH;
		}
		public function removeOnSequenceDone(_arg1:Function):void{
			geometry.removeOnSequenceDone(_arg1);
		}
		public function removeSegment(_arg1:Segment):void{
			_geometry.removeSegment(_arg1);
		}
		public function set transitionValue(_arg1:Number):void{
			geometry.transitionValue = _arg1;
		}
		public function set material(_arg1:IMaterial):void{
			if ((((_material == _arg1)) && (!((_material == null))))){
				return;
			};
			removeMaterial(_material);
			addMaterial((_material = _arg1));
			if ((_material is ITriangleMaterial)){
				_faceMaterial = (_material as ITriangleMaterial);
			} else {
				faceMaterial = new WireColorMaterial();
			};
			if ((_material is ISegmentMaterial)){
				_segmentMaterial = (_material as ISegmentMaterial);
			} else {
				segmentMaterial = new WireframeMaterial();
			};
			if ((_material is IBillboardMaterial)){
				_billboardMaterial = (_material as IBillboardMaterial);
			} else {
				billboardMaterial = new ColorMaterial();
			};
			_sessionDirty = true;
		}
		public function quarterFaces():void{
			_geometry.quarterFaces();
		}
		public function addOnCycle(_arg1:Function):void{
			geometry.addOnCycle(_arg1);
		}
		public function get commands():Array{
			return (_geometry.commands);
		}
		public function get geometry():Geometry{
			return (_geometry);
		}
		private function onMaterialUpdate(_arg1:MaterialEvent):void{
			_sessionDirty = true;
		}
		public function asXML():XML{
			var result:XML;
			var refvertices:Dictionary;
			var verticeslist:Array;
			var remembervertex:Function;
			var refuvs:Dictionary;
			var uvslist:Array;
			var rememberuv:Function;
			var face:Face;
			var vn:int;
			var v:Vertex;
			var uvn:int;
			var uv:UV;
			var f:Face;
			result = <mesh></mesh>
			;
			refvertices = new Dictionary();
			verticeslist = [];
			remembervertex = function (_arg1:Vertex):void{
				if (refvertices[_arg1] == null){
					refvertices[_arg1] = verticeslist.length;
					verticeslist.push(_arg1);
				};
			};
			refuvs = new Dictionary();
			uvslist = [];
			rememberuv = function (_arg1:UV):void{
				if (_arg1 == null){
					return;
				};
				if (refuvs[_arg1] == null){
					refuvs[_arg1] = uvslist.length;
					uvslist.push(_arg1);
				};
			};
			for each (face in _geometry.faces) {
				remembervertex(face._v0);
				remembervertex(face._v1);
				remembervertex(face._v2);
				rememberuv(face._uv0);
				rememberuv(face._uv1);
				rememberuv(face._uv2);
			};
			vn = 0;
			for each (v in verticeslist) {
				result.appendChild(new XML((((((((("<vertex id=\"" + ??esc_xattr
) + "\" x=\"") + ??esc_xattr
) + "\" y=\"") + ??esc_xattr
) + "\" z=\"") + ??esc_xattr
) + "\"/>")));
				vn = (vn + 1);
			};
			uvn = 0;
			for each (uv in uvslist) {
				result.appendChild(new XML((((((("<uv id=\"" + ??esc_xattr
) + "\" u=\"") + ??esc_xattr
) + "\" v=\"") + ??esc_xattr
) + "\"/>")));
				uvn = (uvn + 1);
			};
			for each (f in _geometry.faces) {
				result.appendChild(new XML((((((((((((("<face v0=\"" + ??esc_xattr
) + "\" v1=\"") + ??esc_xattr
) + "\" v2=\"") + ??esc_xattr
) + "\" uv0=\"") + ??esc_xattr
) + "\" uv1=\"") + ??esc_xattr
) + "\" uv2=\"") + ??esc_xattr
) + "\"/>")));
			};
			return (result);
		}
		private function onMappingChange(_arg1:ElementEvent):void{
			_sessionDirty = true;
			if ((_face = (_arg1.element as Face))){
				if (_face.material){
					_uvMaterial = (_face.material as IUVMaterial);
				} else {
					_uvMaterial = (_faceMaterial as IUVMaterial);
				};
				if (_uvMaterial){
					_uvMaterial.getFaceMaterialVO(_face.faceVO, this).invalidated = true;
				};
			};
		}
		public function addFace(_arg1:Face):void{
			_geometry.addFace(_arg1);
		}
		public function triFace(_arg1:Face):void{
			_geometry.triFace(_arg1);
		}
		override public function applyPosition(_arg1:Number, _arg2:Number, _arg3:Number):void{
			var _local4:Number3D;
			_geometry.applyPosition(_arg1, _arg2, _arg3);
			_local4 = new Number3D(_arg1, _arg2, _arg3);
			new Number3D(_arg1, _arg2, _arg3).rotate(_local4, _transform);
			_local4.add(_local4, position);
			moveTo(_local4.x, _local4.y, _local4.z);
		}
		public function get faceMaterial():ITriangleMaterial{
			return (_faceMaterial);
		}
		public function get segmentVOs():Array{
			return (_geometry.segmentVOs);
		}
		public function gotoAndPlay(_arg1:int):void{
			geometry.gotoAndPlay(_arg1);
		}
		public function get loop():Boolean{
			return (geometry.loop);
		}
		public function splitFace(_arg1:Face, _arg2:int=0):void{
			_geometry.splitFace(_arg1, _arg2);
		}
		public function get hasSequenceEvent():Boolean{
			return (geometry.hasSequenceEvent);
		}
		public function set frame(_arg1:int):void{
			geometry.frame = _arg1;
		}
		override public function applyRotations():void{
			_geometry.applyRotations(rotationX, rotationY, rotationZ);
			rotationX = 0;
			rotationY = 0;
			rotationZ = 0;
		}
		private function addMaterial(_arg1:IMaterial):void{
			if (!_arg1){
				return;
			};
			_arg1.addOnMaterialUpdate(onMaterialUpdate);
		}
		public function get startIndices():Array{
			return (_geometry.startIndices);
		}
		public function get back():ITriangleMaterial{
			return (_back);
		}
		public function set geometry(_arg1:Geometry):void{
			if (_geometry == _arg1){
				return;
			};
			if (_geometry != null){
				_geometry.removeOnMaterialUpdate(onMaterialUpdate);
				_geometry.removeOnMappingChange(onMappingChange);
				_geometry.removeOnDimensionsChange(onDimensionsChange);
			};
			_geometry = _arg1;
			if (_geometry != null){
				_geometry.addOnMaterialUpdate(onMaterialUpdate);
				_geometry.addOnMappingChange(onMappingChange);
				_geometry.addOnDimensionsChange(onDimensionsChange);
			};
		}
		public function splitFaces(_arg1:int=0):void{
			_geometry.splitFaces(_arg1);
		}
		public function get elements():Array{
			return (_geometry.elements);
		}
		public function get fps():int{
			return (geometry.fps);
		}
		public function playFrames(_arg1:Array, _arg2:uint, _arg3:Boolean=true, _arg4:Boolean=false):void{
			geometry.playFrames(_arg1, _arg2, _arg3, _arg4);
		}
		public function setPlaySequences(_arg1:Array, _arg2:Boolean=false):void{
			geometry.setPlaySequences(_arg1, _arg2);
		}
		public function triFaces():void{
			_geometry.triFaces();
		}
		public function removeFace(_arg1:Face):void{
			_geometry.removeFace(_arg1);
		}
		public function cloneAll(_arg1:Object3D=null):Object3D{
			var _local2:Mesh;
			_local2 = (((_arg1 as Mesh)) || (new Mesh()));
			super.clone(_local2);
			_local2.type = type;
			_local2.material = material;
			_local2.outline = outline;
			_local2.back = back;
			_local2.bothsides = bothsides;
			_local2.debugbb = debugbb;
			_local2.geometry = geometry.clone();
			return (_local2);
		}
		public function get billboards():Array{
			return (_geometry.billboards);
		}
		public function get transitionValue():Number{
			return (geometry.transitionValue);
		}
		public function set segmentMaterial(_arg1:ISegmentMaterial):void{
			if (_segmentMaterial == _arg1){
				return;
			};
			removeMaterial(_segmentMaterial);
			addMaterial((_segmentMaterial = _arg1));
		}
		public function quarterFace(_arg1:Face):void{
			_geometry.quarterFace(_arg1);
		}
		public function removeBillboard(_arg1:Billboard):void{
			_geometry.removeBillboard(_arg1);
		}
		public function set billboardMaterial(_arg1:IBillboardMaterial):void{
			if (_billboardMaterial == _arg1){
				return;
			};
			removeMaterial(_billboardMaterial);
			addMaterial((_billboardMaterial = _arg1));
		}
		public function get material():IMaterial{
			return (_material);
		}
		public function get isRunning():Boolean{
			return (geometry.isRunning);
		}
		public function get activePrefix():String{
			return (geometry.activePrefix);
		}
		public function set faceMaterial(_arg1:ITriangleMaterial):void{
			if (_faceMaterial == _arg1){
				return;
			};
			removeMaterial(_faceMaterial);
			addMaterial((_faceMaterial = _arg1));
		}
		public function play(_arg1:AnimationSequence):void{
			geometry.play(_arg1);
		}
		public function set smooth(_arg1:Boolean):void{
			geometry.smooth = _arg1;
		}
		override public function clone(_arg1:Object3D=null):Object3D{
			var _local2:Mesh;
			_local2 = (((_arg1 as Mesh)) || (new Mesh()));
			super.clone(_local2);
			_local2.type = type;
			_local2.material = material;
			_local2.outline = outline;
			_local2.back = back;
			_local2.bothsides = bothsides;
			_local2.debugbb = debugbb;
			_local2.geometry = geometry;
			return (_local2);
		}
		public function set loop(_arg1:Boolean):void{
			geometry.loop = _arg1;
		}
		public function addSegment(_arg1:Segment):void{
			_geometry.addSegment(_arg1);
		}
		public function updateMaterials(_arg1:Object3D, _arg2:View3D):void{
			if (_material){
				_material.updateMaterial(_arg1, _arg2);
			};
			if (back){
				back.updateMaterial(_arg1, _arg2);
			};
			geometry.updateMaterials(_arg1, _arg2);
		}
		public function removeOnCycle(_arg1:Function):void{
			geometry.removeOnCycle(_arg1);
		}
		public function get segmentMaterial():ISegmentMaterial{
			return (_segmentMaterial);
		}
		public function get faceVOs():Array{
			return (_geometry.faceVOs);
		}
		public function get billboardVOs():Array{
			return (_geometry.billboardVOs);
		}
		override protected function updateDimensions():void{
			var _local1:Array;
			var _local2:int;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number3D;
			var _local6:Vertex;
			_local1 = geometry.vertices.concat();
			_local2 = _local1.length;
			if (_local2){
				if (_scaleX < 0){
					_boundingScale = -(_scaleX);
				} else {
					_boundingScale = _scaleX;
				};
				if ((((_scaleY < 0)) && ((_boundingScale < -(_scaleY))))){
					_boundingScale = -(_scaleY);
				} else {
					if (_boundingScale < _scaleY){
						_boundingScale = _scaleY;
					};
				};
				if ((((_scaleZ < 0)) && ((_boundingScale < -(_scaleZ))))){
					_boundingScale = -(_scaleZ);
				} else {
					if (_boundingScale < _scaleZ){
						_boundingScale = _scaleZ;
					};
				};
				_local3 = 0;
				_local5 = new Number3D();
				for each (_local6 in _local1) {
					_local5.sub(_local6.position, _pivotPoint);
					_local4 = _local5.modulo2;
					if (_local3 < _local4){
						_local3 = _local4;
					};
				};
				if (_local3){
					_boundingRadius = Math.sqrt(_local3);
				} else {
					_boundingRadius = 0;
				};
				_local1.sortOn("x", (Array.DESCENDING | Array.NUMERIC));
				_maxX = _local1[0].x;
				_minX = _local1[(_local2 - 1)].x;
				_local1.sortOn("y", (Array.DESCENDING | Array.NUMERIC));
				_maxY = _local1[0].y;
				_minY = _local1[(_local2 - 1)].y;
				_local1.sortOn("z", (Array.DESCENDING | Array.NUMERIC));
				_maxZ = _local1[0].z;
				_minZ = _local1[(_local2 - 1)].z;
			};
			super.updateDimensions();
		}
		public function invertFaces():void{
			_geometry.invertFaces();
		}
		public function get frame():int{
			return (geometry.frame);
		}
		public function addOnSequenceDone(_arg1:Function):void{
			geometry.addOnSequenceDone(_arg1);
		}
		public function addBillboard(_arg1:Billboard):void{
			_geometry.addBillboard(_arg1);
		}
		public function get indices():Array{
			return (_geometry.indices);
		}
		public function get segments():Array{
			return (_geometry.segments);
		}
		public function get hasCycleEvent():Boolean{
			return (geometry.hasCycleEvent);
		}
		public function get smooth():Boolean{
			return (geometry.smooth);
		}
		public function get faces():Array{
			return (_geometry.faces);
		}
		public function get billboardMaterial():IBillboardMaterial{
			return (_billboardMaterial);
		}
		public function gotoAndStop(_arg1:int):void{
			geometry.gotoAndStop(_arg1);
		}
		private function removeMaterial(_arg1:IMaterial):void{
			if (!_arg1){
				return;
			};
			_arg1.removeOnMaterialUpdate(onMaterialUpdate);
		}
		public function set back(_arg1:ITriangleMaterial):void{
			if (_back == _arg1){
				return;
			};
			removeMaterial(_back);
			addMaterial((_back = _arg1));
		}
		public function updateVertex(_arg1:Vertex, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Boolean=false):void{
			_geometry.updateVertex(_arg1, _arg2, _arg3, _arg4, _arg5);
		}
		private function onDimensionsChange(_arg1:GeometryEvent):void{
			_sessionDirty = true;
			notifyDimensionsChange();
		}
		public function set fps(_arg1:int):void{
			geometry.fps = _arg1;
		}
		public function asAS3Class(_arg1:String=null, _arg2:String="", _arg3:Boolean=false, _arg4:Boolean=false):String{
			var importextra:String;
			var source:String;
			var refvertices:Dictionary;
			var verticeslist:Array;
			var remembervertex:Function;
			var refuvs:Dictionary;
			var uvslist:Array;
			var rememberuv:Function;
			var face:Face;
			var uv:UV;
			var v:Vertex;
			var myPattern:RegExp;
			var myPattern2:RegExp;
			var f:Face;
			var tmp:String;
			var ind:Array;
			var auv:Array;
			var i:int;
			var afn:Array;
			var avp:Array;
			var tmpnames:Array;
			var y:int;
			var framename:String;
			var fr:Frame;
			var classname = _arg1;
			var packagename = _arg2;
			var round = _arg3;
			var animated = _arg4;
			classname = ((((classname) || (name))) || ("Away3DObject"));
			importextra = (animated) ? "\timport flash.utils.Dictionary;\n" : "";
			source = (((((("package " + packagename) + "\n{\n\timport away3d.core.base.*;\n\timport away3d.core.utils.*;\n") + importextra) + "\n\tpublic class ") + classname) + " extends Mesh\n\t{\n");
			source = (source + "\t\tprivate var varr:Array = [];\n\t\tprivate var uvarr:Array = [];\n\t\tprivate var scaling:Number;\n");
			if (animated){
				source = (source + "\t\tprivate var fnarr:Array = [];\n\n");
				source = (source + "\n\t\tprivate function v():void\n\t\t{\n");
				source = (source + "\t\t\tfor(var i:int = 0;i<vcount;++i){\n\t\t\t\tvarr.push(new Vertex(0,0,0));\n\t\t\t}\n\t\t}\n\n");
			} else {
				source = (source + "\n\t\tprivate function v(x:Number,y:Number,z:Number):void\n\t\t{\n");
				source = (source + "\t\t\tvarr.push(new Vertex(x*scaling, y*scaling, z*scaling));\n\t\t}\n\n");
			};
			source = (source + "\t\tprivate function uv(u:Number,v:Number):void\n\t\t{\n");
			source = (source + "\t\t\tuvarr.push(new UV(u,v));\n\t\t}\n\n");
			source = (source + "\t\tprivate function f(vn0:int, vn1:int, vn2:int, uvn0:int, uvn1:int, uvn2:int):void\n\t\t{\n");
			source = (source + "\t\t\taddFace(new Face(varr[vn0],varr[vn1],varr[vn2], null, uvarr[uvn0],uvarr[uvn1],uvarr[uvn2]));\n\t\t}\n\n");
			source = (source + (((("\t\tpublic function " + classname) + "(init:Object = null)\n\t\t{\n\t\t\tsuper(init);\n\t\t\tinit = Init.parse(init);\n\t\t\tscaling = init.getNumber(\"scaling\", 1);\n\t\t\tbuild();\n\t\t\ttype = \"") + classname) + "\";\n\t\t}\n\n"));
			source = (source + "\t\tprivate function build():void\n\t\t{\n");
			refvertices = new Dictionary();
			verticeslist = [];
			remembervertex = function (_arg1:Vertex):void{
				if (refvertices[_arg1] == null){
					refvertices[_arg1] = verticeslist.length;
					verticeslist.push(_arg1);
				};
			};
			refuvs = new Dictionary();
			uvslist = [];
			rememberuv = function (_arg1:UV):void{
				if (_arg1 == null){
					return;
				};
				if (refuvs[_arg1] == null){
					refuvs[_arg1] = uvslist.length;
					uvslist.push(_arg1);
				};
			};
			for each (face in _geometry.faces) {
				remembervertex(face._v0);
				remembervertex(face._v1);
				remembervertex(face._v2);
				rememberuv(face._uv0);
				rememberuv(face._uv1);
				rememberuv(face._uv2);
			};
			if (animated){
				myPattern = new RegExp("vcount", "g");
				source = source.replace(myPattern, verticeslist.length);
				source = (source + "\n\t\t\tv();\n\n");
			} else {
				for each (v in verticeslist) {
					source = (source + (round) ? (((((("\t\t\tv(" + v._x.toFixed(4)) + ",") + v._y.toFixed(4)) + ",") + v._z.toFixed(4)) + ");\n") : (((((("\t\t\tv(" + v._x) + ",") + v._y) + ",") + v._z) + ");\n"));
				};
			};
			for each (uv in uvslist) {
				source = (source + (round) ? (((("\t\t\tuv(" + uv._u.toFixed(4)) + ",") + uv._v.toFixed(4)) + ");\n") : (((("\t\t\tuv(" + uv._u) + ",") + uv._v) + ");\n"));
			};
			if (round){
				myPattern2 = new RegExp(".0000", "g");
			};
			if (animated){
				auv = [];
				for each (f in _geometry.faces) {
					auv.push((round) ? ((((refuvs[f._uv0].toFixed(4) + ",") + refuvs[f._uv1].toFixed(4)) + ",") + refuvs[f._uv2].toFixed(4)) : ((((refuvs[f._uv0] + ",") + refuvs[f._uv1]) + ",") + refuvs[f._uv2]));
				};
				i = 0;
				while (i < indexes.length) {
					ind = indexes[i];
					source = (source + (((((((("\t\t\tf(" + ind[0]) + ",") + ind[1]) + ",") + ind[2]) + ",") + auv[i]) + ");\n"));
					i = (i + 1);
				};
			} else {
				for each (f in _geometry.faces) {
					source = (source + (((((((((((("\t\t\tf(" + refvertices[f._v0]) + ",") + refvertices[f._v1]) + ",") + refvertices[f._v2]) + ",") + refuvs[f._uv0]) + ",") + refuvs[f._uv1]) + ",") + refuvs[f._uv2]) + ");\n"));
				};
			};
			if (round){
				source = source.replace(myPattern2, "");
			};
			if (animated){
				afn = [];
				tmpnames = [];
				i = 0;
				y = 0;
				source = (source + "\n\t\t\tgeometry.frames = new Dictionary();\n");
				source = (source + "\t\t\tgeometry.framenames = new Dictionary();\n");
				source = (source + "\t\t\tvar oFrames:Object = {};\n");
				myPattern = new RegExp(" ", "g");
				for (framename in geometry.framenames) {
					tmpnames.push(framename);
				};
				tmpnames.sort();
				i = 0;
				while (i < tmpnames.length) {
					avp = [];
					fr = geometry.frames[geometry.framenames[tmpnames[i]]];
					if (tmpnames[i].indexOf(" ") != -1){
						tmpnames[i] = tmpnames[i].replace(myPattern, "");
					};
					afn.push((("\"" + tmpnames[i]) + "\""));
					source = (source + (("\n\t\t\toFrames." + tmpnames[i]) + "=["));
					y = 0;
					while (y < verticeslist.length) {
						if (round){
							avp.push(fr.vertexpositions[y].x.toFixed(4));
							avp.push(fr.vertexpositions[y].y.toFixed(4));
							avp.push(fr.vertexpositions[y].z.toFixed(4));
						} else {
							avp.push(fr.vertexpositions[y].x);
							avp.push(fr.vertexpositions[y].y);
							avp.push(fr.vertexpositions[y].z);
						};
						y = (y + 1);
					};
					if (round){
						tmp = avp.toString();
						tmp = tmp.replace(myPattern2, "");
						source = (source + (tmp + "];\n"));
					} else {
						source = (source + (avp.toString() + "];\n"));
					};
					i = (i + 1);
				};
				source = (source + (("\n\t\t\tfnarr = [" + afn.toString()) + "];\n"));
				source = (source + "\n\t\t\tvar y:int;\n");
				source = (source + "\t\t\tvar z:int;\n");
				source = (source + "\t\t\tvar frame:Frame;\n");
				source = (source + "\t\t\tfor(var i:int = 0;i<fnarr.length; ++i){\n");
				source = (source + "\t\t\t\ttrace(\"[ \"+fnarr[i]+\" ]\");\n");
				source = (source + "\t\t\t\tframe = new Frame();\n");
				source = (source + "\t\t\t\tgeometry.framenames[fnarr[i]] = i;\n");
				source = (source + "\t\t\t\tgeometry.frames[i] = frame;\n");
				source = (source + "\t\t\t\tz=0;\n");
				source = (source + "\t\t\t\tfor (y = 0; y < oFrames[fnarr[i]].length; y+=3){\n");
				source = (source + "\t\t\t\t\tvar vp:VertexPosition = new VertexPosition(varr[z]);\n");
				source = (source + "\t\t\t\t\tz++;\n");
				source = (source + "\t\t\t\t\tvp.x = oFrames[fnarr[i]][y]*scaling;\n");
				source = (source + "\t\t\t\t\tvp.y = oFrames[fnarr[i]][y+1]*scaling;\n");
				source = (source + "\t\t\t\t\tvp.z = oFrames[fnarr[i]][y+2]*scaling;\n");
				source = (source + "\t\t\t\t\tframe.vertexpositions.push(vp);\n");
				source = (source + "\t\t\t\t}\n");
				source = (source + "\t\t\t\tif (i == 0)\n");
				source = (source + "\t\t\t\t\tframe.adjust();\n");
				source = (source + "\t\t\t}\n");
			};
			source = (source + "\n\t\t}\n\t}\n}");
			return (source);
		}
		public function get vertices():Array{
			return (_geometry.vertices);
		}

	}
}//package away3d.core.base 
Section 32
//Object3D (away3d.core.base.Object3D)
package away3d.core.base {
	import away3d.primitives.*;
	import flash.display.*;
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.core.light.*;
	import away3d.core.render.*;
	import away3d.loaders.utils.*;
	import away3d.events.*;
	import away3d.core.traverse.*;

	public class Object3D extends EventDispatcher implements IClonable {

		var _boundingScale:Number;// = 1
		protected var _pivotPoint:Number3D;
		public var extra:Object;
		var _objectDirty:Boolean;
		private var _blendMode:String;
		public var projectorType:String;
		private var _renderer:IPrimitiveConsumer;
		private var _oldscene:Scene3D;
		private var _transformchanged:Object3DEvent;
		private var _dispatchedDimensionsChange:Boolean;
		private var _zAxis:Number3D;
		var _maxX:Number;// = 0
		var _maxZ:Number;// = 0
		var _maxY:Number;// = 0
		public var center:Array;
		var _sceneTransform:Matrix3D;
		public var screenYOffset:Number;
		private var _vector:Number3D;
		private var _alpha:Number;
		private var _scenechanged:Object3DEvent;
		private var _pivotZero:Boolean;
		public var animationLibrary:AnimationLibrary;
		public var name:String;
		private var _lightarray:ILightConsumer;
		var _sceneTransformDirty:Boolean;
		var _mouseEnabled:Boolean;// = true
		private var _filters:Array;
		private var _quaternion:Quaternion;
		var _sessionDirty:Boolean;
		private var _yAxis:Number3D;
		private var _parentupdated:Object3DEvent;
		public var mouseEnabled:Boolean;// = true
		private var _rotationDirty:Boolean;
		private var _ownCanvas:Boolean;
		public var pushback:Boolean;
		private var _debugBoundingSphere:WireSphere;
		private var _rot:Number3D;
		var _rotationX:Number;// = 0
		var _rotationY:Number;// = 0
		var _rotationZ:Number;// = 0
		var _minX:Number;// = 0
		var _minY:Number;// = 0
		var _minZ:Number;// = 0
		private var _visible:Boolean;
		public var screenXOffset:Number;
		private var _xAxis:Number3D;
		private var _eulers:Number3D;
		public var pushfront:Boolean;
		var _localTransformDirty:Boolean;
		private var _scenetransformchanged:Object3DEvent;
		var _session:AbstractRenderSession;
		private var _sca:Number3D;
		var _lookingAtTarget:Number3D;
		var _scaleX:Number;// = 1
		var _scaleY:Number;// = 1
		var _scaleZ:Number;// = 1
		var _boundingRadius:Number;// = 0
		private var _sessionchanged:Object3DEvent;
		private var _sessionupdated:Object3DEvent;
		private var _debugBoundingBox:WireCube;
		var _scene:Scene3D;
		public var inverseSceneTransform:Matrix3D;
		public var useHandCursor:Boolean;// = false
		public var screenZOffset:Number;
		public var materialLibrary:MaterialLibrary;
		var _id:int;
		private var _ownLights:Boolean;
		var _dimensionsDirty:Boolean;// = false
		private var _dimensionschanged:Object3DEvent;
		private var _parent:ObjectContainer3D;
		private var _ownSession:AbstractRenderSession;
		public var debugbb:Boolean;
		private var _scenePivotPoint:Number3D;
		protected var ini:Init;
		var _transformDirty:Boolean;
		public var geometryLibrary:GeometryLibrary;
		public var debugbs:Boolean;
		var _transform:Matrix3D;
		private var _m:Matrix3D;
		private var _lightsDirty:Boolean;

		private static var toDEGREES:Number = 57.2957795130823;
		private static var toRADIANS:Number = 0.0174532925199433;

		public function Object3D(_arg1:Object=null):void{
			_mouseEnabled = true;
			_transform = new Matrix3D();
			_sceneTransform = new Matrix3D();
			_dimensionsDirty = false;
			_boundingRadius = 0;
			_boundingScale = 1;
			_maxX = 0;
			_minX = 0;
			_maxY = 0;
			_minY = 0;
			_maxZ = 0;
			_minZ = 0;
			_lookingAtTarget = new Number3D();
			_eulers = new Number3D();
			_rotationX = 0;
			_rotationY = 0;
			_rotationZ = 0;
			_scaleX = 1;
			_scaleY = 1;
			_scaleZ = 1;
			_pivotPoint = new Number3D();
			_scenePivotPoint = new Number3D();
			_quaternion = new Quaternion();
			_rot = new Number3D();
			_sca = new Number3D();
			_vector = new Number3D();
			_m = new Matrix3D();
			_xAxis = new Number3D();
			_yAxis = new Number3D();
			_zAxis = new Number3D();
			inverseSceneTransform = new Matrix3D();
			mouseEnabled = true;
			useHandCursor = false;
			center = [new Vertex()];
			super();
			ini = Init.parse(_arg1);
			name = ini.getString("name", name);
			ownSession = (ini.getObject("ownSession", AbstractRenderSession) as AbstractRenderSession);
			ownCanvas = ini.getBoolean("ownCanvas", ownCanvas);
			ownLights = ini.getBoolean("ownLights", false);
			visible = ini.getBoolean("visible", true);
			mouseEnabled = ini.getBoolean("mouseEnabled", mouseEnabled);
			useHandCursor = ini.getBoolean("useHandCursor", useHandCursor);
			renderer = (ini.getObject("renderer", IPrimitiveConsumer) as IPrimitiveConsumer);
			filters = ini.getArray("filters");
			alpha = ini.getNumber("alpha", 1);
			blendMode = ini.getString("blendMode", BlendMode.NORMAL);
			debugbb = ini.getBoolean("debugbb", false);
			debugbs = ini.getBoolean("debugbs", false);
			pushback = ini.getBoolean("pushback", false);
			pushfront = ini.getBoolean("pushfront", false);
			screenXOffset = ini.getNumber("screenXOffset", 0);
			screenYOffset = ini.getNumber("screenYOffset", 0);
			screenZOffset = ini.getNumber("screenZOffset", 0);
			x = ini.getNumber("x", 0);
			y = ini.getNumber("y", 0);
			z = ini.getNumber("z", 0);
			rotationX = ini.getNumber("rotationX", 0);
			rotationY = ini.getNumber("rotationY", 0);
			rotationZ = ini.getNumber("rotationZ", 0);
			pivotPoint = ((ini.getNumber3D("pivotPoint")) || (new Number3D()));
			extra = ini.getObject("extra");
			scale(ini.getNumber("scale", 1));
			if ((this is Scene3D)){
				_scene = (this as Scene3D);
			} else {
				parent = (ini.getObject3D("parent") as ObjectContainer3D);
			};
		}
		public function get pivotZero():Boolean{
			return (_pivotZero);
		}
		public function moveDown(_arg1:Number):void{
			translate(Number3D.DOWN, _arg1);
		}
		public function get scenePivotPoint():Number3D{
			if (_sceneTransformDirty){
				updateSceneTransform();
			};
			return (_scenePivotPoint);
		}
		public function get eulers():Number3D{
			if (_rotationDirty){
				updateRotation();
			};
			_eulers.x = (_rotationX * toDEGREES);
			_eulers.y = (_rotationY * toDEGREES);
			_eulers.z = (_rotationZ * toDEGREES);
			return (_eulers);
		}
		private function onParentSceneChange(_arg1:Object3DEvent):void{
			if (_scene){
				_scene.clearId(_id);
			};
			_scene = _parent.scene;
			if (_scene){
				_scene.setId(this);
			};
			notifySceneChange();
		}
		function notifySessionUpdate():void{
			if (_scene){
				_scene.updatedSessions[_session] = _session;
			};
			if (!hasEventListener(Object3DEvent.SESSION_UPDATED)){
				return;
			};
			if (!_sessionupdated){
				_sessionupdated = new Object3DEvent(Object3DEvent.SESSION_UPDATED, this);
			};
			dispatchEvent(_sessionupdated);
		}
		public function get ownSession():AbstractRenderSession{
			return (_ownSession);
		}
		public function removeOnTransformChange(_arg1:Function):void{
			removeEventListener(Object3DEvent.TRANSFORM_CHANGED, _arg1, false);
		}
		public function moveTo(_arg1:Number, _arg2:Number, _arg3:Number):void{
			if ((((((_transform.tx == _arg1)) && ((_transform.ty == _arg2)))) && ((_transform.tz == _arg3)))){
				return;
			};
			_transform.tx = _arg1;
			_transform.ty = _arg2;
			_transform.tz = _arg3;
			_localTransformDirty = true;
			_sceneTransformDirty = true;
		}
		private function updateLights():void{
			if (!_ownLights){
				_lightarray = parent.lightarray;
			} else {
				_lightarray = new LightArray();
			};
			_lightsDirty = false;
		}
		public function removeOnSceneTransformChange(_arg1:Function):void{
			removeEventListener(Object3DEvent.SCENETRANSFORM_CHANGED, _arg1, false);
		}
		public function get minZ():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return (_minZ);
		}
		public function get scaleZ():Number{
			return (_scaleZ);
		}
		public function set position(_arg1:Number3D):void{
			_transform.tx = _arg1.x;
			_transform.ty = _arg1.y;
			_transform.tz = _arg1.z;
			_sceneTransformDirty = true;
			_localTransformDirty = true;
		}
		public function get minY():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return (_minY);
		}
		public function get sceneTransform():Matrix3D{
			if ((((_scene == null)) || ((_scene == this)))){
				if (_transformDirty){
					_sceneTransformDirty = true;
				};
				if (_sceneTransformDirty){
					notifySceneTransformChange();
				};
				return (transform);
			};
			if (_transformDirty){
				updateTransform();
			};
			if (_sceneTransformDirty){
				updateSceneTransform();
			};
			if (_localTransformDirty){
				notifyTransformChange();
			};
			return (_sceneTransform);
		}
		function notifySceneChange():void{
			_sceneTransformDirty = true;
			if (!hasEventListener(Object3DEvent.SCENE_CHANGED)){
				return;
			};
			if (!_scenechanged){
				_scenechanged = new Object3DEvent(Object3DEvent.SCENE_CHANGED, this);
			};
			dispatchEvent(_scenechanged);
		}
		public function get minX():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return (_minX);
		}
		public function set eulers(_arg1:Number3D):void{
			_rotationX = (_arg1.x * toRADIANS);
			_rotationY = (_arg1.y * toRADIANS);
			_rotationZ = (_arg1.z * toRADIANS);
			_transformDirty = true;
		}
		public function moveUp(_arg1:Number):void{
			translate(Number3D.UP, _arg1);
		}
		public function set ownSession(_arg1:AbstractRenderSession):void{
			if (_ownSession == _arg1){
				return;
			};
			if (_ownSession){
				if (((_parent) && (_parent.session))){
					_parent.session.removeChildSession(_ownSession);
				};
				_ownSession.clearChildSessions();
				_ownSession.renderer = null;
				_ownSession.internalRemoveOwnSession(this);
				_ownSession.removeOnSessionUpdate(onSessionUpdate);
			} else {
				if (((_parent) && (_parent.session))){
					_parent.session.internalRemoveOwnSession(this);
				};
			};
			_ownSession = _arg1;
			if (_ownSession){
				if (((_parent) && (_parent.session))){
					_parent.session.addChildSession(_ownSession);
				};
				_ownSession.clearChildSessions();
				_ownSession.renderer = _renderer;
				_ownSession.filters = _filters;
				_ownSession.alpha = _alpha;
				_ownSession.blendMode = _blendMode;
				_ownSession.internalAddOwnSession(this);
				_ownSession.addOnSessionUpdate(onSessionUpdate);
			} else {
				if ((this is Scene3D)){
					throw (new Error("Scene cannot have ownSession set to null"));
				};
				if (((_parent) && (_parent.session))){
					_parent.session.internalAddOwnSession(this);
				};
			};
			if (_ownSession){
				_ownCanvas = true;
			} else {
				_ownCanvas = false;
			};
			notifySessionChange();
		}
		override public function toString():String{
			return ((((((((name) ? name : "$" + ": x:") + Math.round(x)) + " y:") + Math.round(y)) + " z:") + Math.round(z)));
		}
		public function get pivotPoint():Number3D{
			return (_pivotPoint);
		}
		public function yaw(_arg1:Number):void{
			rotate(Number3D.UP, _arg1);
		}
		public function get scaleX():Number{
			return (_scaleX);
		}
		public function get scaleY():Number{
			return (_scaleY);
		}
		public function get visible():Boolean{
			return (_visible);
		}
		public function addOnDimensionsChange(_arg1:Function):void{
			addEventListener(Object3DEvent.DIMENSIONS_CHANGED, _arg1, false, 0, true);
		}
		public function addOnMouseDown(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_DOWN, _arg1, false, 0, false);
		}
		public function get y():Number{
			return (_transform.ty);
		}
		public function get z():Number{
			return (_transform.tz);
		}
		public function roll(_arg1:Number):void{
			rotate(Number3D.FORWARD, _arg1);
		}
		public function get ownCanvas():Boolean{
			return (_ownCanvas);
		}
		public function get x():Number{
			return (_transform.tx);
		}
		public function set ownLights(_arg1:Boolean):void{
			_ownLights = _arg1;
			_lightsDirty = true;
		}
		public function get scene():Scene3D{
			return (_scene);
		}
		public function removeOnRollOut(_arg1:Function):void{
			removeEventListener(MouseEvent3D.ROLL_OUT, _arg1, false);
		}
		public function addOnSceneTransformChange(_arg1:Function):void{
			addEventListener(Object3DEvent.SCENETRANSFORM_CHANGED, _arg1, false, 0, true);
		}
		public function addOnParentUpdate(_arg1:Function):void{
			addEventListener(Object3DEvent.PARENT_UPDATED, _arg1, false, 0, true);
		}
		public function get session():AbstractRenderSession{
			return (_session);
		}
		public function addOnMouseOver(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_OVER, _arg1, false, 0, false);
		}
		public function get rotationY():Number{
			if (_rotationDirty){
				updateRotation();
			};
			return ((_rotationY * toDEGREES));
		}
		public function get rotationZ():Number{
			if (_rotationDirty){
				updateRotation();
			};
			return ((_rotationZ * toDEGREES));
		}
		public function get parentBoundingRadius():Number{
			return ((boundingRadius * _boundingScale));
		}
		public function get rotationX():Number{
			if (_rotationDirty){
				updateRotation();
			};
			return ((_rotationX * toDEGREES));
		}
		protected function updateTransform():void{
			if (_rotationDirty){
				updateRotation();
			};
			_quaternion.euler2quaternion(_rotationY, _rotationZ, -(_rotationX));
			_transform.quaternion2matrix(_quaternion);
			_transform.scale(_transform, _scaleX, _scaleY, _scaleZ);
			_transformDirty = false;
			_sceneTransformDirty = true;
			_localTransformDirty = true;
		}
		public function set scaleY(_arg1:Number):void{
			if (_scaleY == _arg1){
				return;
			};
			_scaleY = _arg1;
			_transformDirty = true;
			_dimensionsDirty = true;
		}
		public function set scaleZ(_arg1:Number):void{
			if (_scaleZ == _arg1){
				return;
			};
			_scaleZ = _arg1;
			_transformDirty = true;
			_dimensionsDirty = true;
		}
		public function set scaleX(_arg1:Number):void{
			if (_scaleX == _arg1){
				return;
			};
			_scaleX = _arg1;
			_transformDirty = true;
			_dimensionsDirty = true;
		}
		public function applyPosition(_arg1:Number, _arg2:Number, _arg3:Number):void{
			throw (new Error("Not implemented in Object3D - Use Mesh or ObjectContainer3D"));
		}
		public function get renderer():IPrimitiveConsumer{
			return (_renderer);
		}
		private function changeSession():void{
			if (_ownSession){
				_session = _ownSession;
			} else {
				if (_parent){
					_session = _parent.session;
				} else {
					_session = null;
				};
			};
			_sessionDirty = true;
		}
		public function get objectDepth():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return ((_maxZ - _minZ));
		}
		public function get parent():ObjectContainer3D{
			return (_parent);
		}
		public function removeOnMouseDown(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_DOWN, _arg1, false);
		}
		public function set alpha(_arg1:Number):void{
			if (_alpha == _arg1){
				return;
			};
			_alpha = _arg1;
			if (_ownSession){
				_ownSession.alpha = _alpha;
			};
		}
		public function removeOnMouseOver(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_OVER, _arg1, false);
		}
		public function set transform(_arg1:Matrix3D):void{
			if (_transform.compare(_arg1)){
				return;
			};
			_transform.clone(_arg1);
			_transformDirty = false;
			_rotationDirty = true;
			_sceneTransformDirty = true;
			_localTransformDirty = true;
			_sca.matrix2scale(_transform);
			if (((((!((_scaleX == _sca.x))) || (!((_scaleY == _sca.y))))) || (!((_scaleZ == _sca.z))))){
				_scaleX = _sca.x;
				_scaleY = _sca.y;
				_scaleZ = _sca.z;
				_dimensionsDirty = true;
			};
		}
		public function moveBackward(_arg1:Number):void{
			translate(Number3D.BACKWARD, _arg1);
		}
		public function set visible(_arg1:Boolean):void{
			if (_visible == _arg1){
				return;
			};
			_visible = _arg1;
			_sessionDirty = true;
			notifyParentUpdate();
		}
		public function applyRotations():void{
			throw (new Error("Not implemented in Object3D - Use Mesh or ObjectContainer3D"));
		}
		public function addOnMouseOut(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_OUT, _arg1, false, 0, false);
		}
		public function set pivotPoint(_arg1:Number3D):void{
			_pivotPoint.clone(_arg1);
			_pivotZero = ((((!(_pivotPoint.x)) && (!(_pivotPoint.y)))) && (!(_pivotPoint.z)));
			_sceneTransformDirty = true;
			_dimensionsDirty = true;
			notifyParentUpdate();
		}
		public function moveRight(_arg1:Number):void{
			translate(Number3D.RIGHT, _arg1);
		}
		public function set x(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(x)"));
			};
			if (_transform.tx == _arg1){
				return;
			};
			if (_arg1 == Infinity){
				Debug.warning("x == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("x == -Infinity");
			};
			_transform.tx = _arg1;
			_sceneTransformDirty = true;
			_localTransformDirty = true;
		}
		public function movePivot(_arg1:Number, _arg2:Number, _arg3:Number):void{
			_pivotPoint.x = _arg1;
			_pivotPoint.y = _arg2;
			_pivotPoint.z = _arg3;
			_pivotZero = ((((!(_arg1)) && (!(_arg2)))) && (!(_arg3)));
			_sceneTransformDirty = true;
			_dimensionsDirty = true;
			notifyParentUpdate();
		}
		public function set y(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(y)"));
			};
			if (_transform.ty == _arg1){
				return;
			};
			if (_arg1 == Infinity){
				Debug.warning("y == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("y == -Infinity");
			};
			_transform.ty = _arg1;
			_sceneTransformDirty = true;
			_localTransformDirty = true;
		}
		function notifySceneTransformChange():void{
			_sceneTransformDirty = false;
			_objectDirty = true;
			if (!hasEventListener(Object3DEvent.SCENETRANSFORM_CHANGED)){
				return;
			};
			if (!_scenetransformchanged){
				_scenetransformchanged = new Object3DEvent(Object3DEvent.SCENETRANSFORM_CHANGED, this);
			};
			dispatchEvent(_scenetransformchanged);
		}
		public function set ownCanvas(_arg1:Boolean):void{
			if (_ownCanvas == _arg1){
				return;
			};
			if (_arg1){
				ownSession = new SpriteRenderSession();
			} else {
				if ((this is Scene3D)){
					throw (new Error("Scene cannot have ownCanvas set to false"));
				};
				ownSession = null;
			};
		}
		private function onParentSessionChange(_arg1:Object3DEvent):void{
			if (((_ownSession) && (_arg1.object.parent))){
				_arg1.object.parent.session.removeChildSession(_ownSession);
			};
			if (((_ownSession) && (_parent.session))){
				_parent.session.addChildSession(_ownSession);
			};
			if (((!(_ownSession)) && (!((_session == _parent.session))))){
				changeSession();
				dispatchEvent(_arg1);
			};
		}
		public function addOnSceneChange(_arg1:Function):void{
			addEventListener(Object3DEvent.SCENE_CHANGED, _arg1, false, 0, true);
		}
		public function set z(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(z)"));
			};
			if (_transform.tz == _arg1){
				return;
			};
			if (_arg1 == Infinity){
				Debug.warning("z == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("z == -Infinity");
			};
			_transform.tz = _arg1;
			_sceneTransformDirty = true;
			_localTransformDirty = true;
		}
		public function get lightarray():ILightConsumer{
			if (_lightsDirty){
				updateLights();
			};
			return (_lightarray);
		}
		public function removeOnMouseOut(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_OUT, _arg1, false);
		}
		public function addOnRollOut(_arg1:Function):void{
			addEventListener(MouseEvent3D.ROLL_OUT, _arg1, false, 0, false);
		}
		function dispatchMouseEvent(_arg1:MouseEvent3D):Boolean{
			if (!hasEventListener(_arg1.type)){
				return (false);
			};
			dispatchEvent(_arg1);
			return (true);
		}
		function notifySessionChange():void{
			changeSession();
			if (!hasEventListener(Object3DEvent.SESSION_CHANGED)){
				return;
			};
			if (!_sessionchanged){
				_sessionchanged = new Object3DEvent(Object3DEvent.SESSION_CHANGED, this);
			};
			dispatchEvent(_sessionchanged);
		}
		public function get parentmaxX():Number{
			return (((boundingRadius * _boundingScale) + _transform.tx));
		}
		public function get parentmaxY():Number{
			return (((boundingRadius * _boundingScale) + _transform.ty));
		}
		public function get parentmaxZ():Number{
			return (((boundingRadius * _boundingScale) + _transform.tz));
		}
		public function get id():int{
			return (_id);
		}
		public function removeOnSessionChange(_arg1:Function):void{
			removeEventListener(Object3DEvent.SESSION_CHANGED, _arg1, false);
		}
		public function get position():Number3D{
			return (transform.position);
		}
		public function removeOnMouseUp(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_UP, _arg1, false);
		}
		public function lookAt(_arg1:Number3D, _arg2:Number3D=null):void{
			_lookingAtTarget = _arg1;
			_zAxis.sub(_arg1, position);
			_zAxis.normalize();
			if ((((_zAxis.modulo > 0.1)) && (((((!((_zAxis.x == _transform.sxz))) || (!((_zAxis.y == _transform.syz))))) || (!((_zAxis.z == _transform.szz))))))){
				_xAxis.cross(_zAxis, ((_arg2) || (Number3D.UP)));
				if (!_xAxis.modulo2){
					_xAxis.cross(_zAxis, Number3D.BACKWARD);
				};
				_xAxis.normalize();
				_yAxis.cross(_zAxis, _xAxis);
				_yAxis.normalize();
				_transform.sxx = (_xAxis.x * _scaleX);
				_transform.syx = (_xAxis.y * _scaleX);
				_transform.szx = (_xAxis.z * _scaleX);
				_transform.sxy = (-(_yAxis.x) * _scaleY);
				_transform.syy = (-(_yAxis.y) * _scaleY);
				_transform.szy = (-(_yAxis.z) * _scaleY);
				_transform.sxz = (_zAxis.x * _scaleZ);
				_transform.syz = (_zAxis.y * _scaleZ);
				_transform.szz = (_zAxis.z * _scaleZ);
				_transformDirty = false;
				_rotationDirty = true;
				_sceneTransformDirty = true;
				_localTransformDirty = true;
			};
		}
		public function get debugBoundingBox():WireCube{
			if (((_dimensionsDirty) || (!(_debugBoundingBox)))){
				updateDimensions();
			};
			return (_debugBoundingBox);
		}
		public function set rotationY(_arg1:Number):void{
			if (rotationY == _arg1){
				return;
			};
			_rotationY = (_arg1 * toRADIANS);
			_transformDirty = true;
		}
		public function set rotationX(_arg1:Number):void{
			if (rotationX == _arg1){
				return;
			};
			_rotationX = (_arg1 * toRADIANS);
			_transformDirty = true;
		}
		public function rotateTo(_arg1:Number, _arg2:Number, _arg3:Number):void{
			_rotationX = (_arg1 * toRADIANS);
			_rotationY = (_arg2 * toRADIANS);
			_rotationZ = (_arg3 * toRADIANS);
			_rotationDirty = false;
			_transformDirty = true;
		}
		public function set rotationZ(_arg1:Number):void{
			if (rotationZ == _arg1){
				return;
			};
			_rotationZ = (_arg1 * toRADIANS);
			_transformDirty = true;
		}
		public function set blendMode(_arg1:String):void{
			if (_blendMode == _arg1){
				return;
			};
			_blendMode = _arg1;
			if (_ownSession){
				_ownSession.blendMode = _blendMode;
			};
		}
		public function centerPivot():void{
			var _local1:Number3D;
			_local1 = new Number3D(((maxX + minX) / 2), ((maxY + minY) / 2), ((maxZ + minZ) / 2));
			movePivot(_local1.x, _local1.y, _local1.z);
			_local1.transform(_local1, transform);
			moveTo((x + _local1.x), (y + _local1.y), (z + _local1.z));
		}
		public function get ownLights():Boolean{
			return (_ownLights);
		}
		public function removeOnParentUpdate(_arg1:Function):void{
			removeEventListener(Object3DEvent.PARENT_UPDATED, _arg1, false);
		}
		function notifyDimensionsChange():void{
			_dimensionsDirty = true;
			if (((_dispatchedDimensionsChange) || (!(hasEventListener(Object3DEvent.DIMENSIONS_CHANGED))))){
				return;
			};
			if (!_dimensionschanged){
				_dimensionschanged = new Object3DEvent(Object3DEvent.DIMENSIONS_CHANGED, this);
			};
			dispatchEvent(_dimensionschanged);
			_dispatchedDimensionsChange = true;
		}
		public function pitch(_arg1:Number):void{
			rotate(Number3D.RIGHT, _arg1);
		}
		public function get objectHeight():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return ((_maxY - _minY));
		}
		public function translate(_arg1:Number3D, _arg2:Number):void{
			_arg1.normalize();
			_vector.rotate(_arg1, transform);
			x = (x + (_arg2 * _vector.x));
			y = (y + (_arg2 * _vector.y));
			z = (z + (_arg2 * _vector.z));
		}
		public function distanceTo(_arg1:Object3D):Number{
			var _local2:Matrix3D;
			var _local3:Matrix3D;
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			_local2 = ((_scene == this)) ? transform : sceneTransform;
			_local3 = ((_arg1.scene == _arg1)) ? _arg1.transform : _arg1.sceneTransform;
			_local4 = (_local2.tx - _local3.tx);
			_local5 = (_local2.ty - _local3.ty);
			_local6 = (_local2.tz - _local3.tz);
			return (Math.sqrt((((_local4 * _local4) + (_local5 * _local5)) + (_local6 * _local6))));
		}
		public function set parent(_arg1:ObjectContainer3D):void{
			if ((this is Scene3D)){
				throw (new Error("Scene cannot be parented"));
			};
			if (_arg1 == _parent){
				return;
			};
			_oldscene = _scene;
			if (_parent != null){
				_parent.removeOnParentUpdate(onParentUpdate);
				_parent.removeOnSessionChange(onParentSessionChange);
				_parent.removeOnSceneChange(onParentSceneChange);
				_parent.removeOnSceneTransformChange(onParentTransformChange);
				_parent.internalRemoveChild(this);
				if (((_ownSession) && (_parent.session))){
					_parent.session.removeChildSession(_ownSession);
				};
			};
			_parent = _arg1;
			_scene = (_parent) ? _parent.scene : null;
			if (_parent != null){
				_parent.internalAddChild(this);
				_parent.addOnParentUpdate(onParentUpdate);
				_parent.addOnSessionChange(onParentSessionChange);
				_parent.addOnSceneChange(onParentSceneChange);
				_parent.addOnSceneTransformChange(onParentTransformChange);
				if (((_ownSession) && (_parent.session))){
					_parent.session.addChildSession(_ownSession);
				};
			};
			if (_scene != _oldscene){
				if (_oldscene){
					_oldscene.clearId(_id);
				};
				if (_scene){
					_scene.setId(this);
				};
				notifySceneChange();
			};
			if (((!(_ownSession)) && (((!(_parent)) || (!((_session == _parent.session))))))){
				notifySessionChange();
			};
			_sceneTransformDirty = true;
			_localTransformDirty = true;
		}
		public function get boundingRadius():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return (_boundingRadius);
		}
		public function rotate(_arg1:Number3D, _arg2:Number):void{
			_arg1.normalize();
			_m.rotationMatrix(_arg1.x, _arg1.y, _arg1.z, (_arg2 * toRADIANS));
			_transform.multiply3x3(transform, _m);
			_rotationDirty = true;
			_sceneTransformDirty = true;
			_localTransformDirty = true;
		}
		public function clone(_arg1:Object3D=null):Object3D{
			var _local2:Object3D;
			_local2 = ((_arg1) || (new Object3D()));
			_local2.transform = transform;
			_local2.name = name;
			_local2.ownCanvas = _ownCanvas;
			_local2.renderer = _renderer;
			_local2.filters = _filters.concat();
			_local2.blendMode = blendMode;
			_local2.alpha = _alpha;
			_local2.visible = visible;
			_local2.mouseEnabled = mouseEnabled;
			_local2.useHandCursor = useHandCursor;
			_local2.pushback = pushback;
			_local2.pushfront = pushfront;
			_local2.screenZOffset = screenZOffset;
			_local2.pivotPoint = pivotPoint;
			_local2.projectorType = projectorType;
			_local2.extra = ((extra is IClonable)) ? (extra as IClonable).clone() : extra;
			return (_local2);
		}
		public function get alpha():Number{
			return (_alpha);
		}
		private function onSessionUpdate(_arg1:SessionEvent):void{
			if ((_arg1.target is BitmapRenderSession)){
				_scene.updatedSessions[_arg1.target] = _arg1.target;
			};
		}
		public function scale(_arg1:Number):void{
			_scaleX = (_scaleY = (_scaleZ = _arg1));
			_transformDirty = true;
			_dimensionsDirty = true;
		}
		private function updateRotation():void{
			_rot.matrix2euler(_transform);
			_rotationX = _rot.x;
			_rotationY = _rot.y;
			_rotationZ = _rot.z;
			_rotationDirty = false;
		}
		private function updateSceneTransform():void{
			_sceneTransform.multiply(_parent.sceneTransform, transform);
			if (!_pivotZero){
				_scenePivotPoint.rotate(_pivotPoint, _sceneTransform);
				_sceneTransform.tx = (_sceneTransform.tx - _scenePivotPoint.x);
				_sceneTransform.ty = (_sceneTransform.ty - _scenePivotPoint.y);
				_sceneTransform.tz = (_sceneTransform.tz - _scenePivotPoint.z);
			};
			inverseSceneTransform.inverse(_sceneTransform);
			notifySceneTransformChange();
		}
		public function get transform():Matrix3D{
			if (_transformDirty){
				updateTransform();
			};
			return (_transform);
		}
		public function addOnRollOver(_arg1:Function):void{
			addEventListener(MouseEvent3D.ROLL_OVER, _arg1, false, 0, false);
		}
		public function traverse(_arg1:Traverser):void{
			if (_arg1.match(this)){
				_arg1.enter(this);
				_arg1.apply(this);
				_arg1.leave(this);
			};
		}
		public function updateObject():void{
			if (_objectDirty){
				_scene.updatedObjects[this] = this;
				_objectDirty = false;
				_sessionDirty = true;
			};
		}
		public function get maxX():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return (_maxX);
		}
		public function get maxY():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return (_maxY);
		}
		public function addOnSessionChange(_arg1:Function):void{
			addEventListener(Object3DEvent.SESSION_CHANGED, _arg1, false, 0, true);
		}
		public function moveLeft(_arg1:Number):void{
			translate(Number3D.LEFT, _arg1);
		}
		public function removeOnDimensionsChange(_arg1:Function):void{
			removeEventListener(Object3DEvent.DIMENSIONS_CHANGED, _arg1, false);
		}
		protected function updateDimensions():void{
			_dimensionsDirty = false;
			_dispatchedDimensionsChange = false;
			if (debugbb){
				if (!_debugBoundingBox){
					_debugBoundingBox = new WireCube({material:"#333333"});
					_scene.setId(_debugBoundingBox);
				};
				if (_boundingRadius){
					_debugBoundingBox.visible = true;
					_debugBoundingBox.v000.setValue(_minX, _minY, _minZ);
					_debugBoundingBox.v100.setValue(_maxX, _minY, _minZ);
					_debugBoundingBox.v010.setValue(_minX, _maxY, _minZ);
					_debugBoundingBox.v110.setValue(_maxX, _maxY, _minZ);
					_debugBoundingBox.v001.setValue(_minX, _minY, _maxZ);
					_debugBoundingBox.v101.setValue(_maxX, _minY, _maxZ);
					_debugBoundingBox.v011.setValue(_minX, _maxY, _maxZ);
					_debugBoundingBox.v111.setValue(_maxX, _maxY, _maxZ);
				} else {
					debugBoundingBox.visible = false;
				};
			};
			if (debugbs){
				if (!_debugBoundingSphere){
					_debugBoundingSphere = new WireSphere({material:"#cyan", segmentsW:16, segmentsH:12});
					_scene.setId(_debugBoundingSphere);
				};
				if (_boundingRadius){
					_debugBoundingSphere.visible = true;
					_debugBoundingSphere.radius = _boundingRadius;
					_debugBoundingSphere.updateObject();
					_debugBoundingSphere.applyPosition(-(_pivotPoint.x), -(_pivotPoint.y), -(_pivotPoint.z));
				} else {
					debugBoundingSphere.visible = false;
				};
			};
		}
		public function set renderer(_arg1:IPrimitiveConsumer):void{
			if (_renderer == _arg1){
				return;
			};
			_renderer = _arg1;
			if (_ownSession){
				_ownSession.renderer = _renderer;
			};
			_sessionDirty = true;
		}
		public function addOnMouseMove(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_MOVE, _arg1, false, 0, false);
		}
		public function get maxZ():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return (_maxZ);
		}
		private function onParentUpdate(_arg1:Object3DEvent):void{
			_sessionDirty = true;
			dispatchEvent(_arg1);
		}
		private function onParentTransformChange(_arg1:Object3DEvent):void{
			_sceneTransformDirty = true;
		}
		public function updateSession():void{
			if (_sessionDirty){
				notifySessionUpdate();
				_sessionDirty = false;
			};
		}
		public function tick(_arg1:int):void{
		}
		public function addOnMouseUp(_arg1:Function):void{
			addEventListener(MouseEvent3D.MOUSE_UP, _arg1, false, 0, false);
		}
		public function get lookingAtTarget():Number3D{
			return (_lookingAtTarget);
		}
		public function get blendMode():String{
			return (_blendMode);
		}
		function notifyTransformChange():void{
			_localTransformDirty = false;
			if (!hasEventListener(Object3DEvent.TRANSFORM_CHANGED)){
				return;
			};
			if (!_transformchanged){
				_transformchanged = new Object3DEvent(Object3DEvent.TRANSFORM_CHANGED, this);
			};
			dispatchEvent(_transformchanged);
		}
		public function moveForward(_arg1:Number):void{
			translate(Number3D.FORWARD, _arg1);
		}
		public function addOnTransformChange(_arg1:Function):void{
			addEventListener(Object3DEvent.TRANSFORM_CHANGED, _arg1, false, 0, true);
		}
		public function removeOnRollOver(_arg1:Function):void{
			removeEventListener(MouseEvent3D.ROLL_OVER, _arg1, false);
		}
		public function get objectWidth():Number{
			if (_dimensionsDirty){
				updateDimensions();
			};
			return ((_maxX - _minX));
		}
		public function get debugBoundingSphere():WireSphere{
			if (((_dimensionsDirty) || (!(_debugBoundingSphere)))){
				updateDimensions();
			};
			return (_debugBoundingSphere);
		}
		public function get scenePosition():Number3D{
			return (sceneTransform.position);
		}
		public function removeOnSceneChange(_arg1:Function):void{
			removeEventListener(Object3DEvent.SCENE_CHANGED, _arg1, false);
		}
		public function removeOnMouseMove(_arg1:Function):void{
			removeEventListener(MouseEvent3D.MOUSE_MOVE, _arg1, false);
		}
		public function get parentminX():Number{
			return (((-(boundingRadius) * _boundingScale) + _transform.tx));
		}
		public function get parentminY():Number{
			return (((-(boundingRadius) * _boundingScale) + _transform.ty));
		}
		public function get parentminZ():Number{
			return (((-(boundingRadius) * _boundingScale) + _transform.tz));
		}
		public function get filters():Array{
			return (_filters);
		}
		function notifyParentUpdate():void{
			if (((_ownCanvas) && (_parent))){
				_parent._sessionDirty = true;
			};
			if (!hasEventListener(Object3DEvent.PARENT_UPDATED)){
				return;
			};
			if (!_parentupdated){
				_parentupdated = new Object3DEvent(Object3DEvent.PARENT_UPDATED, this);
			};
			dispatchEvent(_parentupdated);
		}
		public function set filters(_arg1:Array):void{
			if (_filters == _arg1){
				return;
			};
			_filters = _arg1;
			if (_ownSession){
				_ownSession.filters = _filters;
			};
		}

	}
}//package away3d.core.base 
Section 33
//Segment (away3d.core.base.Segment)
package away3d.core.base {
	import flash.events.*;
	import away3d.core.utils.*;
	import away3d.materials.*;
	import away3d.events.*;

	public class Segment extends Element {

		var _material:ISegmentMaterial;
		var _v0:Vertex;
		var _v1:Vertex;
		public var segmentVO:SegmentVO;
		private var _index:int;
		private var _vertices:Array;
		private var _commands:Array;

		public function Segment(_arg1:Vertex, _arg2:Vertex, _arg3:ISegmentMaterial=null){
			_vertices = new Array();
			_commands = new Array();
			segmentVO = new SegmentVO();
			super();
			this.v0 = _arg1;
			this.v1 = _arg2;
			this.material = _arg3;
			vertexDirty = true;
		}
		override public function get vertices():Array{
			return (_vertices);
		}
		public function get v1():Vertex{
			return (_v1);
		}
		override public function get maxX():Number{
			if (_v0._x > _v1._x){
				return (_v0._x);
			};
			return (_v1._x);
		}
		override public function get commands():Array{
			return (_commands);
		}
		public function get v0():Vertex{
			return (_v0);
		}
		public function set material(_arg1:ISegmentMaterial):void{
			if (_arg1 == _material){
				return;
			};
			if (((!((_material == null))) && (parent))){
				parent.removeMaterial(this, _material);
			};
			_material = (segmentVO.material = _arg1);
			if (((!((_material == null))) && (parent))){
				parent.addMaterial(this, _material);
			};
		}
		private function onVertexValueChange(_arg1:Event):void{
			notifyVertexValueChange();
		}
		public function lineTo(_arg1:Vertex):void{
			addVertexAt(_vertices.length, _arg1, "L");
		}
		public function moveTo(_arg1:Vertex):void{
			addVertexAt(_vertices.length, _arg1, "M");
		}
		public function set v0(_arg1:Vertex):void{
			addVertexAt(0, _arg1, "M");
		}
		public function get material():ISegmentMaterial{
			return (_material);
		}
		private function addVertexAt(_arg1:uint, _arg2:Vertex, _arg3:String):void{
			if (((_vertices[_arg1]) && ((_vertices[_arg1] == _arg2)))){
				return;
			};
			if (_vertices[_arg1]){
				_index = _vertices[_arg1].parents.indexOf(this);
				if (_index != -1){
					_vertices[_arg1].parents.splice(_index, 1);
				};
			};
			_commands[_arg1] = (segmentVO.commands[_arg1] = _arg3);
			_vertices[_arg1] = (segmentVO.vertices[_arg1] = _arg2);
			if (_arg1 == 0){
				_v0 = (segmentVO.v0 = _arg2);
			} else {
				if (_arg1 == 1){
					_v1 = (segmentVO.v1 = _arg2);
				};
			};
			_arg2.parents.push(this);
			vertexDirty = true;
		}
		override public function get minX():Number{
			if (_v0._x < _v1._x){
				return (_v0._x);
			};
			return (_v1._x);
		}
		override public function get minZ():Number{
			if (_v0._z < _v1._z){
				return (_v0._z);
			};
			return (_v1._z);
		}
		override public function get minY():Number{
			if (_v0._y < _v1._y){
				return (_v0._y);
			};
			return (_v1._y);
		}
		public function curveTo(_arg1:Vertex, _arg2:Vertex):void{
			addVertexAt(_vertices.length, _arg1, "C");
			addVertexAt(_vertices.length, _arg2, "P");
		}
		override public function get radius2():Number{
			var _local1:Number;
			var _local2:Number;
			_local1 = (((_v0._x * _v0._x) + (_v0._y * _v0._y)) + (_v0._z * _v0._z));
			_local2 = (((_v1._x * _v1._x) + (_v1._y * _v1._y)) + (_v1._z * _v1._z));
			if (_local1 > _local2){
				return (_local1);
			};
			return (_local2);
		}
		override public function get maxY():Number{
			if (_v0._y > _v1._y){
				return (_v0._y);
			};
			return (_v1._y);
		}
		override public function get maxZ():Number{
			if (_v0._z > _v1._z){
				return (_v0._z);
			};
			return (_v1._z);
		}
		public function set v1(_arg1:Vertex):void{
			addVertexAt(1, _arg1, "L");
		}

	}
}//package away3d.core.base 
Section 34
//UV (away3d.core.base.UV)
package away3d.core.base {
	import away3d.core.utils.*;

	public class UV extends ValueObject {

		public var extra:Object;
		var _u:Number;
		var _v:Number;

		public function UV(_arg1:Number=0, _arg2:Number=0){
			_u = _arg1;
			_v = _arg2;
		}
		public function clone():UV{
			return (new UV(_u, _v));
		}
		public function set u(_arg1:Number):void{
			if (_arg1 == _u){
				return;
			};
			_u = _arg1;
			notifyChange();
		}
		public function set v(_arg1:Number):void{
			if (_arg1 == _v){
				return;
			};
			_v = _arg1;
			notifyChange();
		}
		public function get u():Number{
			return (_u);
		}
		override public function toString():String{
			return ((((("new UV(" + _u) + ", ") + _v) + ")"));
		}
		public function get v():Number{
			return (_v);
		}

		static function median(_arg1:UV, _arg2:UV):UV{
			if (_arg1 == null){
				return (null);
			};
			if (_arg2 == null){
				return (null);
			};
			return (new UV(((_arg1._u + _arg2._u) / 2), ((_arg1._v + _arg2._v) / 2)));
		}
		static function weighted(_arg1:UV, _arg2:UV, _arg3:Number, _arg4:Number):UV{
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			if (_arg1 == null){
				return (null);
			};
			if (_arg2 == null){
				return (null);
			};
			_local5 = (_arg3 + _arg4);
			_local6 = (_arg3 / _local5);
			_local7 = (_arg4 / _local5);
			return (new UV(((_arg1._u * _local6) + (_arg2._u * _local7)), ((_arg1._v * _local6) + (_arg2._v * _local7))));
		}

	}
}//package away3d.core.base 
Section 35
//VectorInstructionType (away3d.core.base.VectorInstructionType)
package away3d.core.base {

	public class VectorInstructionType {

		public static const MOVE:String = "M";
		public static const LINE:String = "L";
		public static const CURVE:String = "C";

	}
}//package away3d.core.base 
Section 36
//Vertex (away3d.core.base.Vertex)
package away3d.core.base {
	import away3d.core.draw.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;

	public class Vertex extends ValueObject {

		var _x:Number;
		var _z:Number;
		private var _position:Number3D;
		public var parents:Array;
		public var extra:Object;
		var _y:Number;
		private var _positionDirty:Boolean;
		private var _persp:Number;
		private var _vertexDirty:Boolean;
		var _index:int;
		public var geometry:Geometry;

		public function Vertex(_arg1:Number=0, _arg2:Number=0, _arg3:Number=0){
			_position = new Number3D();
			parents = [];
			super();
			_x = _arg1;
			_y = _arg2;
			_z = _arg3;
			_positionDirty = true;
		}
		public function set z(_arg1:Number):void{
			if (_z == _arg1){
				return;
			};
			_z = _arg1;
			_positionDirty = true;
		}
		public function get y():Number{
			if (_positionDirty){
				updatePosition();
			};
			return (_y);
		}
		private function updatePosition():void{
			var _local1:Element;
			_positionDirty = false;
			for each (_local1 in parents) {
				_local1.vertexDirty = true;
			};
			_vertexDirty = true;
			_position.x = _x;
			_position.y = _y;
			_position.z = _z;
		}
		public function adjust(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number=1):void{
			setValue(((_x * (1 - _arg4)) + (_arg1 * _arg4)), ((_y * (1 - _arg4)) + (_arg2 * _arg4)), ((_z * (1 - _arg4)) + (_arg3 * _arg4)));
		}
		public function add(_arg1:Number3D):void{
			_x = (_x + _arg1.x);
			_y = (_y + _arg1.y);
			_z = (_z + _arg1.z);
			_positionDirty = true;
		}
		public function get position():Number3D{
			if (_positionDirty){
				updatePosition();
			};
			return (_position);
		}
		public function setValue(_arg1:Number, _arg2:Number, _arg3:Number):void{
			_x = _arg1;
			_y = _arg2;
			_z = _arg3;
			_positionDirty = true;
		}
		public function perspective(_arg1:Number):ScreenVertex{
			_persp = (1 / (1 + (_z / _arg1)));
			return (new ScreenVertex((_x * _persp), (_y * _persp), _z));
		}
		public function reset():void{
			_x = 0;
			_y = 0;
			_z = 0;
			_positionDirty = true;
		}
		function getVertexDirty():Boolean{
			if (_positionDirty){
				updatePosition();
			};
			if (_vertexDirty){
				_vertexDirty = false;
				return (true);
			};
			return (false);
		}
		public function clone():Vertex{
			return (new Vertex(_x, _y, _z));
		}
		override public function toString():String{
			return ((((((("new Vertex(" + _x) + ", ") + _y) + ", ") + _z) + ")"));
		}
		public function set x(_arg1:Number):void{
			if (_x == _arg1){
				return;
			};
			_x = _arg1;
			_positionDirty = true;
		}
		public function transform(_arg1:Matrix3D):void{
			setValue(((((_x * _arg1.sxx) + (_y * _arg1.sxy)) + (_z * _arg1.sxz)) + _arg1.tx), ((((_x * _arg1.syx) + (_y * _arg1.syy)) + (_z * _arg1.syz)) + _arg1.ty), ((((_x * _arg1.szx) + (_y * _arg1.szy)) + (_z * _arg1.szz)) + _arg1.tz));
		}
		public function get x():Number{
			if (_positionDirty){
				updatePosition();
			};
			return (_x);
		}
		public function set y(_arg1:Number):void{
			if (_y == _arg1){
				return;
			};
			_y = _arg1;
			_positionDirty = true;
		}
		public function get z():Number{
			if (_positionDirty){
				updatePosition();
			};
			return (_z);
		}

		public static function median(_arg1:Vertex, _arg2:Vertex):Vertex{
			return (new Vertex(((_arg1._x + _arg2._x) / 2), ((_arg1._y + _arg2._y) / 2), ((_arg1._z + _arg2._z) / 2)));
		}
		public static function weighted(_arg1:Vertex, _arg2:Vertex, _arg3:Number, _arg4:Number):Vertex{
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			_local5 = (_arg3 + _arg4);
			_local6 = (_arg3 / _local5);
			_local7 = (_arg4 / _local5);
			return (new Vertex(((_arg1._x * _local6) + (_arg2._x * _local7)), ((_arg1._y * _local6) + (_arg2._y * _local7)), ((_arg1._z * _local6) + (_arg2._z * _local7))));
		}
		public static function distanceSqr(_arg1:Vertex, _arg2:Vertex):Number{
			return (((((_arg1._x + _arg2._x) * (_arg1._x + _arg2._x)) + ((_arg1._y + _arg2._y) * (_arg1._y + _arg2._y))) + ((_arg1._z + _arg2._z) * (_arg1._z + _arg2._z))));
		}

	}
}//package away3d.core.base 
Section 37
//VertexClassification (away3d.core.base.VertexClassification)
package away3d.core.base {
	import away3d.core.geom.*;

	public class VertexClassification {

		public var vertex:Vertex;
		public var distance:Number;
		public var plane:Plane3D;

		public function getDistance(_arg1:Plane3D):Number{
			var _local2:Number;
			_local2 = _arg1.distance(vertex.position);
			if ((((_local2 < 0)) && (!(isNaN(_local2))))){
				plane = _arg1;
				distance = _local2;
			};
			return (_local2);
		}

	}
}//package away3d.core.base 
Section 38
//VertexPosition (away3d.core.base.VertexPosition)
package away3d.core.base {
	import away3d.core.math.*;

	public class VertexPosition {

		public var vertex:Vertex;
		public var x:Number;
		public var y:Number;
		public var z:Number;

		public function VertexPosition(_arg1:Vertex){
			this.vertex = _arg1;
			this.x = 0;
			this.y = 0;
			this.z = 0;
		}
		public function add(_arg1:Number3D):void{
			vertex.add(_arg1);
		}
		public function transform(_arg1:Matrix3D):void{
			vertex.transform(_arg1);
		}
		public function adjust(_arg1:Number=1):void{
			vertex.adjust(x, y, z, _arg1);
		}
		public function getIndex(_arg1:Array):int{
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:int;
			var _local6:int;
			_local2 = vertex.x;
			_local3 = vertex.y;
			_local4 = vertex.z;
			vertex.x = NaN;
			vertex.y = NaN;
			vertex.z = NaN;
			_local5 = 0;
			_local6 = 0;
			while (_local6 < _arg1.length) {
				if (((((isNaN(_arg1[_local6].x)) && (isNaN(_arg1[_local6].y)))) && (isNaN(_arg1[_local6].z)))){
					_local5 = _local6;
					break;
				};
				_local6++;
			};
			vertex.x = _local2;
			vertex.y = _local3;
			vertex.z = _local4;
			return (_local5);
		}
		public function reset():void{
			vertex.reset();
		}

	}
}//package away3d.core.base 
Section 39
//Blocker (away3d.core.block.Blocker)
package away3d.core.block {
	import away3d.core.draw.*;

	public class Blocker extends DrawPrimitive {

		public function block(_arg1:DrawPrimitive):Boolean{
			return (false);
		}

	}
}//package away3d.core.block 
Section 40
//BlockerArray (away3d.core.block.BlockerArray)
package away3d.core.block {
	import away3d.core.clip.*;

	public class BlockerArray implements IBlockerConsumer {

		private var _clip:Clipping;
		private var _blockers:Array;

		public function BlockerArray(){
			_blockers = [];
			super();
		}
		public function set clip(_arg1:Clipping):void{
			_clip = _arg1;
			_blockers = [];
		}
		public function blocker(_arg1:Blocker):void{
			if (_clip.checkPrimitive(_arg1)){
				_blockers.push(_arg1);
			};
		}
		public function get clip():Clipping{
			return (_clip);
		}
		public function list():Array{
			_blockers.sortOn("screenZ", Array.NUMERIC);
			return (_blockers);
		}

	}
}//package away3d.core.block 
Section 41
//ConvexBlocker (away3d.core.block.ConvexBlocker)
package away3d.core.block {
	import flash.display.*;
	import away3d.core.draw.*;
	import away3d.core.utils.*;
	import away3d.core.geom.*;
	import flash.utils.*;

	public class ConvexBlocker extends Blocker {

		private var _boundlines:Array;
		public var vertices:Array;

		override public function block(_arg1:DrawPrimitive):Boolean{
			var _local2:DrawTriangle;
			if ((_arg1 is DrawTriangle)){
				_local2 = (_arg1 as DrawTriangle);
				return (((((contains(_local2.v0x, _local2.v0y)) && (contains(_local2.v1x, _local2.v1y)))) && (contains(_local2.v2x, _local2.v2y))));
			};
			return (((((((contains(_arg1.minX, _arg1.minY)) && (contains(_arg1.minX, _arg1.maxY)))) && (contains(_arg1.maxX, _arg1.maxY)))) && (contains(_arg1.maxX, _arg1.minY))));
		}
		override public function render():void{
			var _local1:Graphics;
			var _local2:int;
			var _local3:int;
			var _local4:int;
			var _local5:int;
			var _local6:Line2D;
			var _local7:Line2D;
			var _local8:Line2D;
			var _local9:ScreenVertex;
			var _local10:ScreenVertex;
			var _local11:Number;
			var _local12:Number;
			_local1 = source.session.graphics;
			_local1.lineStyle(2, Color.fromHSV(0, 0, ((Math.sin((getTimer() / 1000)) + 1) / 2)));
			_local2 = _boundlines.length;
			_local3 = 0;
			while (_local3 < _local2) {
				_local6 = _boundlines[_local3];
				_local7 = _boundlines[(((_local3 - 1) + _local2) % _local2)];
				_local8 = _boundlines[(((_local3 + 1) + _local2) % _local2)];
				_local9 = Line2D.cross(_local7, _local6);
				_local10 = Line2D.cross(_local6, _local8);
				_local1.moveTo(_local9.x, _local9.y);
				_local1.lineTo(_local10.x, _local10.y);
				_local1.moveTo(_local9.x, _local9.y);
				_local3++;
			};
			_local4 = (((maxX - minX) * (maxY - minY)) / 2000);
			if (_local4 > 50){
				_local4 = 50;
			};
			_local5 = 0;
			while (_local5 < _local4) {
				_local11 = (minX + ((maxX - minX) * Math.random()));
				_local12 = (minY + ((maxY - minY) * Math.random()));
				if (contains(_local11, _local12)){
					_local1.lineStyle(1, Color.fromHSV(0, 0, Math.random()));
					_local1.drawCircle(_local11, _local12, 3);
				};
				_local5++;
			};
		}
		override public function contains(_arg1:Number, _arg2:Number):Boolean{
			var _local3:Line2D;
			for each (_local3 in _boundlines) {
				if (_local3.side(_arg1, _arg2) < 0){
					return (false);
				};
			};
			return (true);
		}
		override public function calc():void{
			var _local1:int;
			var _local2:int;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			var _local6:int;
			_boundlines = [];
			screenZ = 0;
			maxX = -(Infinity);
			maxY = -(Infinity);
			minX = Infinity;
			minY = Infinity;
			_local1 = (vertices.length / 3);
			_local2 = 0;
			while (_local2 < _local1) {
				_local3 = vertices[_local2];
				_local4 = vertices[(_local2 + 1)];
				_local5 = vertices[(_local2 + 2)];
				_local6 = ((_local2 + 3) % _local1);
				_boundlines.push(Line2D.from2points(_local3, _local4, vertices[_local6], vertices[(_local6 + 1)]));
				if (screenZ < _local5){
					screenZ = _local5;
				};
				if (minX > _local3){
					minX = _local3;
				};
				if (maxX < _local3){
					maxX = _local3;
				};
				if (minY > _local4){
					minY = _local4;
				};
				if (maxY < _local4){
					maxY = _local4;
				};
				_local2++;
			};
			maxZ = screenZ;
			minZ = screenZ;
		}

	}
}//package away3d.core.block 
Section 42
//IBlockerConsumer (away3d.core.block.IBlockerConsumer)
package away3d.core.block {

	public interface IBlockerConsumer {

		function blocker(_arg1:Blocker):void;

	}
}//package away3d.core.block 
Section 43
//IBlockerProvider (away3d.core.block.IBlockerProvider)
package away3d.core.block {
	import away3d.core.base.*;
	import away3d.core.math.*;

	public interface IBlockerProvider {

		function blockers(_arg1:Object3D, _arg2:Matrix3D, _arg3:IBlockerConsumer):void;

	}
}//package away3d.core.block 
Section 44
//Clipping (away3d.core.clip.Clipping)
package away3d.core.clip {
	import flash.geom.*;
	import flash.display.*;
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.events.*;

	public class Clipping extends EventDispatcher {

		private var _view:View3D;
		private var _maX:Number;
		private var _clippingupdated:ClippingEvent;
		private var _stageHeight:Number;
		private var _stageWidth:Number;
		private var _minX:Number;
		private var _minY:Number;
		private var _minZ:Number;
		var _cameraVarsStore:CameraVarsStore;
		private var _maY:Number;
		private var _clippingClone:Clipping;
		private var _zeroPoint:Point;
		private var _screenupdated:ClippingEvent;
		private var _maxX:Number;
		private var _maxZ:Number;
		private var _maxY:Number;
		protected var ini:Init;
		private var _globalPoint:Point;
		var _objectCulling:Boolean;
		private var _miX:Number;
		private var _miY:Number;
		private var _stage:Stage;

		public function Clipping(_arg1:Object=null){
			_zeroPoint = new Point(0, 0);
			super();
			ini = (Init.parse(_arg1) as Init);
			minX = ini.getNumber("minX", -(Infinity));
			minY = ini.getNumber("minY", -(Infinity));
			minZ = ini.getNumber("minZ", -(Infinity));
			maxX = ini.getNumber("maxX", Infinity);
			maxY = ini.getNumber("maxY", Infinity);
			maxZ = ini.getNumber("maxZ", Infinity);
		}
		public function set minZ(_arg1:Number):void{
			if (_minZ == _arg1){
				return;
			};
			_minZ = _arg1;
			notifyClippingUpdate();
		}
		public function rect(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Boolean{
			if (this.maxX < _arg1){
				return (false);
			};
			if (this.minX > _arg3){
				return (false);
			};
			if (this.maxY < _arg2){
				return (false);
			};
			if (this.minY > _arg4){
				return (false);
			};
			return (true);
		}
		public function get maxZ():Number{
			return (_maxZ);
		}
		public function screen(_arg1:Sprite, _arg2:Number, _arg3:Number):Clipping{
			if (!_clippingClone){
				_clippingClone = clone();
				_clippingClone.addOnClippingUpdate(onScreenUpdate);
			};
			_stage = _arg1.stage;
			if (_stage.scaleMode == StageScaleMode.NO_SCALE){
				_stageWidth = _stage.stageWidth;
				_stageHeight = _stage.stageHeight;
			} else {
				if (_stage.scaleMode == StageScaleMode.EXACT_FIT){
					_stageWidth = _arg2;
					_stageHeight = _arg3;
				} else {
					if (_stage.scaleMode == StageScaleMode.SHOW_ALL){
						if ((_stage.stageWidth / _arg2) < (_stage.stageHeight / _arg3)){
							_stageWidth = _arg2;
							_stageHeight = ((_stage.stageHeight * _stageWidth) / _stage.stageWidth);
						} else {
							_stageHeight = _arg3;
							_stageWidth = ((_stage.stageWidth * _stageHeight) / _stage.stageHeight);
						};
					} else {
						if (_stage.scaleMode == StageScaleMode.NO_BORDER){
							if ((_stage.stageWidth / _arg2) > (_stage.stageHeight / _arg3)){
								_stageWidth = _arg2;
								_stageHeight = ((_stage.stageHeight * _stageWidth) / _stage.stageWidth);
							} else {
								_stageHeight = _arg3;
								_stageWidth = ((_stage.stageWidth * _stageHeight) / _stage.stageHeight);
							};
						};
					};
				};
			};
			if (_stage.align == StageAlign.TOP_LEFT){
				_zeroPoint.x = 0;
				_zeroPoint.y = 0;
				_globalPoint = _arg1.globalToLocal(_zeroPoint);
				_maX = ((_miX = _globalPoint.x) + _stageWidth);
				_maY = ((_miY = _globalPoint.y) + _stageHeight);
			} else {
				if (_stage.align == StageAlign.TOP_RIGHT){
					_zeroPoint.x = _arg2;
					_zeroPoint.y = 0;
					_globalPoint = _arg1.globalToLocal(_zeroPoint);
					_miX = ((_maX = _globalPoint.x) - _stageWidth);
					_maY = ((_miY = _globalPoint.y) + _stageHeight);
				} else {
					if (_stage.align == StageAlign.BOTTOM_LEFT){
						_zeroPoint.x = 0;
						_zeroPoint.y = _arg3;
						_globalPoint = _arg1.globalToLocal(_zeroPoint);
						_maX = ((_miX = _globalPoint.x) + _stageWidth);
						_miY = ((_maY = _globalPoint.y) - _stageHeight);
					} else {
						if (_stage.align == StageAlign.BOTTOM_RIGHT){
							_zeroPoint.x = _arg2;
							_zeroPoint.y = _arg3;
							_globalPoint = _arg1.globalToLocal(_zeroPoint);
							_miX = ((_maX = _globalPoint.x) - _stageWidth);
							_miY = ((_maY = _globalPoint.y) - _stageHeight);
						} else {
							if (_stage.align == StageAlign.TOP){
								_zeroPoint.x = (_arg2 / 2);
								_zeroPoint.y = 0;
								_globalPoint = _arg1.globalToLocal(_zeroPoint);
								_miX = (_globalPoint.x - (_stageWidth / 2));
								_maX = (_globalPoint.x + (_stageWidth / 2));
								_maY = ((_miY = _globalPoint.y) + _stageHeight);
							} else {
								if (_stage.align == StageAlign.BOTTOM){
									_zeroPoint.x = (_arg2 / 2);
									_zeroPoint.y = _arg3;
									_globalPoint = _arg1.globalToLocal(_zeroPoint);
									_miX = (_globalPoint.x - (_stageWidth / 2));
									_maX = (_globalPoint.x + (_stageWidth / 2));
									_miY = ((_maY = _globalPoint.y) - _stageHeight);
								} else {
									if (_stage.align == StageAlign.LEFT){
										_zeroPoint.x = 0;
										_zeroPoint.y = (_arg3 / 2);
										_globalPoint = _arg1.globalToLocal(_zeroPoint);
										_maX = ((_miX = _globalPoint.x) + _stageWidth);
										_miY = (_globalPoint.y - (_stageHeight / 2));
										_maY = (_globalPoint.y + (_stageHeight / 2));
									} else {
										if (_stage.align == StageAlign.RIGHT){
											_zeroPoint.x = _arg2;
											_zeroPoint.y = (_arg3 / 2);
											_globalPoint = _arg1.globalToLocal(_zeroPoint);
											_miX = ((_maX = _globalPoint.x) - _stageWidth);
											_miY = (_globalPoint.y - (_stageHeight / 2));
											_maY = (_globalPoint.y + (_stageHeight / 2));
										} else {
											_zeroPoint.x = (_arg2 / 2);
											_zeroPoint.y = (_arg3 / 2);
											_globalPoint = _arg1.globalToLocal(_zeroPoint);
											_miX = (_globalPoint.x - (_stageWidth / 2));
											_maX = (_globalPoint.x + (_stageWidth / 2));
											_miY = (_globalPoint.y - (_stageHeight / 2));
											_maY = (_globalPoint.y + (_stageHeight / 2));
										};
									};
								};
							};
						};
					};
				};
			};
			if (_minX > _miX){
				_clippingClone.minX = _minX;
			} else {
				_clippingClone.minX = _miX;
			};
			if (_maxX < _maX){
				_clippingClone.maxX = _maxX;
			} else {
				_clippingClone.maxX = _maX;
			};
			if (_minY > _miY){
				_clippingClone.minY = _minY;
			} else {
				_clippingClone.minY = _miY;
			};
			if (_maxY < _maY){
				_clippingClone.maxY = _maxY;
			} else {
				_clippingClone.maxY = _maY;
			};
			_clippingClone.minZ = _minZ;
			_clippingClone.maxZ = _maxZ;
			_clippingClone.objectCulling = _objectCulling;
			return (_clippingClone);
		}
		public function removeOnScreenUpdate(_arg1:Function):void{
			removeEventListener(ClippingEvent.SCREEN_UPDATED, _arg1, false);
		}
		public function set minX(_arg1:Number):void{
			if (_minX == _arg1){
				return;
			};
			_minX = _arg1;
			notifyClippingUpdate();
		}
		public function set minY(_arg1:Number):void{
			if (_minY == _arg1){
				return;
			};
			_minY = _arg1;
			notifyClippingUpdate();
		}
		public function checkElements(_arg1:Mesh, _arg2:Array, _arg3:Array, _arg4:Array, _arg5:Array, _arg6:Array, _arg7:Array, _arg8:Array):void{
			throw (new Error("Not implemented"));
		}
		public function get maxX():Number{
			return (_maxX);
		}
		public function addOnClippingUpdate(_arg1:Function):void{
			addEventListener(ClippingEvent.CLIPPING_UPDATED, _arg1, false, 0, false);
		}
		public function get view():View3D{
			return (_view);
		}
		public function removeOnClippingUpdate(_arg1:Function):void{
			removeEventListener(ClippingEvent.CLIPPING_UPDATED, _arg1, false);
		}
		private function notifyScreenUpdate():void{
			if (!hasEventListener(ClippingEvent.SCREEN_UPDATED)){
				return;
			};
			if (_screenupdated == null){
				_screenupdated = new ClippingEvent(ClippingEvent.SCREEN_UPDATED, this);
			};
			dispatchEvent(_screenupdated);
		}
		public function checkPrimitive(_arg1:DrawPrimitive):Boolean{
			return (true);
		}
		public function get minX():Number{
			return (_minX);
		}
		public function get minZ():Number{
			return (_minZ);
		}
		public function get minY():Number{
			return (_minY);
		}
		public function clone(_arg1:Clipping=null):Clipping{
			var _local2:Clipping;
			_local2 = ((_arg1) || (new Clipping()));
			_local2.minX = minX;
			_local2.minY = minY;
			_local2.minZ = minZ;
			_local2.maxX = maxX;
			_local2.maxY = maxY;
			_local2.maxZ = maxZ;
			_local2.objectCulling = objectCulling;
			_local2._cameraVarsStore = _cameraVarsStore;
			return (_local2);
		}
		private function onScreenUpdate(_arg1:ClippingEvent):void{
			notifyScreenUpdate();
		}
		public function set maxX(_arg1:Number):void{
			if (_maxX == _arg1){
				return;
			};
			_maxX = _arg1;
			notifyClippingUpdate();
		}
		public function set objectCulling(_arg1:Boolean):void{
			_objectCulling = _arg1;
		}
		public function set maxY(_arg1:Number):void{
			if (_maxY == _arg1){
				return;
			};
			_maxY = _arg1;
			notifyClippingUpdate();
		}
		override public function toString():String{
			return ((((((((((((("{minX:" + minX) + " maxX:") + maxX) + " minY:") + minY) + " maxY:") + maxY) + " minZ:") + minZ) + " maxZ:") + maxZ) + "}"));
		}
		public function addOnScreenUpdate(_arg1:Function):void{
			addEventListener(ClippingEvent.SCREEN_UPDATED, _arg1, false, 0, false);
		}
		public function get objectCulling():Boolean{
			return (_objectCulling);
		}
		public function set maxZ(_arg1:Number):void{
			if (_maxZ == _arg1){
				return;
			};
			_maxZ = _arg1;
			notifyClippingUpdate();
		}
		public function get maxY():Number{
			return (_maxY);
		}
		private function notifyClippingUpdate():void{
			if (!hasEventListener(ClippingEvent.CLIPPING_UPDATED)){
				return;
			};
			if (_clippingupdated == null){
				_clippingupdated = new ClippingEvent(ClippingEvent.CLIPPING_UPDATED, this);
			};
			dispatchEvent(_clippingupdated);
		}
		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_cameraVarsStore = view.cameraVarsStore;
		}

	}
}//package away3d.core.clip 
Section 45
//FrustumClipping (away3d.core.clip.FrustumClipping)
package away3d.core.clip {
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.geom.*;
	import away3d.core.render.*;
	import flash.utils.*;

	public class FrustumClipping extends Clipping {

		private var _uv2:UV;
		private var _newFaceVO:FaceVO;
		private var _v0:Vertex;
		private var _v1:Vertex;
		private var _v2:Vertex;
		private var _faceVOs:Array;
		private var _frustum:Frustum;
		private var _v01:Vertex;
		private var _uv01:UV;
		private var _face:Face;
		private var _session:AbstractRenderSession;
		private var _v12:Vertex;
		private var _uv12:UV;
		private var _v1C:VertexClassification;
		private var _v0d:Number;
		private var _v20:Vertex;
		private var _v0C:VertexClassification;
		private var _v0w:Number;
		private var _uv20:UV;
		private var _v2C:VertexClassification;
		private var _v1d:Number;
		private var _v1w:Number;
		private var _v2d:Number;
		private var _faces:Array;
		private var _v2w:Number;
		private var _processed:Dictionary;
		private var _d:Number;
		private var _pass:Boolean;
		private var _uv1:UV;
		private var _faceVO:FaceVO;
		private var _uv0:UV;

		public function FrustumClipping(_arg1:Object=null){
			_faceVOs = new Array();
			super(_arg1);
			objectCulling = ini.getBoolean("objectCulling", true);
		}
		override public function checkElements(_arg1:Mesh, _arg2:Array, _arg3:Array, _arg4:Array, _arg5:Array, _arg6:Array, _arg7:Array, _arg8:Array):void{
			var _local9:Plane3D;
			var _local10:Array;
			var _local11:Boolean;
			_session = _arg1.session;
			_frustum = _cameraVarsStore.frustumDictionary[_arg1];
			_processed = new Dictionary(true);
			_faces = _arg1.faces;
			_faceVOs.length = 0;
			for each (_face in _faces) {
				if (!_face.visible){
				} else {
					_faceVOs[_faceVOs.length] = _face.faceVO;
				};
			};
			for each (_faceVO in _faceVOs) {
				_pass = true;
				_v0C = _cameraVarsStore.createVertexClassification(_faceVO.v0);
				_v1C = _cameraVarsStore.createVertexClassification(_faceVO.v1);
				_v2C = _cameraVarsStore.createVertexClassification(_faceVO.v2);
				if (((((_v0C.plane) || (_v1C.plane))) || (_v2C.plane))){
					_local9 = _v0C.plane;
					if (_local9){
						_v0d = _v0C.distance;
						_v1d = _v1C.getDistance(_local9);
						_v2d = _v2C.getDistance(_local9);
					} else {
						_local9 = _v1C.plane;
						if (_local9){
							_v0d = _v0C.getDistance(_local9);
							_v1d = _v1C.distance;
							_v2d = _v2C.getDistance(_local9);
						} else {
							_local9 = _v2C.plane;
							if (_local9){
								_v0d = _v0C.getDistance(_local9);
								_v1d = _v1C.getDistance(_local9);
								_v2d = _v2C.distance;
							};
						};
					};
					if ((((((_v0d < 0)) && ((_v1d < 0)))) && ((_v2d < 0)))){
						continue;
					};
					if ((((((_v0d < 0)) || ((_v1d < 0)))) || ((_v2d < 0)))){
						_pass = false;
					};
				} else {
					_local10 = _frustum.planes;
					_local11 = false;
					for each (_local9 in _local10) {
						_v0d = _v0C.getDistance(_local9);
						_v1d = _v1C.getDistance(_local9);
						_v2d = _v2C.getDistance(_local9);
						if ((((((_v0d < 0)) && ((_v1d < 0)))) && ((_v2d < 0)))){
							_local11 = true;
							break;
						};
						if ((((((_v0d < 0)) || ((_v1d < 0)))) || ((_v2d < 0)))){
							_pass = false;
							break;
						};
					};
					if (_local11){
						continue;
					};
				};
				if (_pass){
					_arg2[_arg2.length] = _faceVO;
					_arg8[_arg8.length] = _arg7.length;
					if (!_processed[_faceVO.v0]){
						_arg5[_arg5.length] = _faceVO.v0;
						_arg7[_arg7.length] = ((_processed[_faceVO.v0] = _arg5.length) - 1);
					} else {
						_arg7[_arg7.length] = (_processed[_faceVO.v0] - 1);
					};
					if (!_processed[_faceVO.v1]){
						_arg5[_arg5.length] = _faceVO.v1;
						_arg7[_arg7.length] = ((_processed[_faceVO.v1] = _arg5.length) - 1);
					} else {
						_arg7[_arg7.length] = (_processed[_faceVO.v1] - 1);
					};
					if (!_processed[_faceVO.v2]){
						_arg5[_arg5.length] = _faceVO.v2;
						_arg7[_arg7.length] = ((_processed[_faceVO.v2] = _arg5.length) - 1);
					} else {
						_arg7[_arg7.length] = (_processed[_faceVO.v2] - 1);
					};
				} else {
					if ((((_v0d >= 0)) && ((_v1d < 0)))){
						_v0w = _v0d;
						_v1w = _v1d;
						_v2w = _v2d;
						_v0 = _faceVO.v0;
						_v1 = _faceVO.v1;
						_v2 = _faceVO.v2;
						_uv0 = _faceVO.uv0;
						_uv1 = _faceVO.uv1;
						_uv2 = _faceVO.uv2;
					} else {
						if ((((_v1d >= 0)) && ((_v2d < 0)))){
							_v0w = _v1d;
							_v1w = _v2d;
							_v2w = _v0d;
							_v0 = _faceVO.v1;
							_v1 = _faceVO.v2;
							_v2 = _faceVO.v0;
							_uv0 = _faceVO.uv1;
							_uv1 = _faceVO.uv2;
							_uv2 = _faceVO.uv0;
						} else {
							if ((((_v2d >= 0)) && ((_v0d < 0)))){
								_v0w = _v2d;
								_v1w = _v0d;
								_v2w = _v1d;
								_v0 = _faceVO.v2;
								_v1 = _faceVO.v0;
								_v2 = _faceVO.v1;
								_uv0 = _faceVO.uv2;
								_uv1 = _faceVO.uv0;
								_uv2 = _faceVO.uv1;
							};
						};
					};
					_d = (_v0w - _v1w);
					_v01 = _cameraVarsStore.createVertex((((_v1.x * _v0w) - (_v0.x * _v1w)) / _d), (((_v1.y * _v0w) - (_v0.y * _v1w)) / _d), (((_v1.z * _v0w) - (_v0.z * _v1w)) / _d));
					_uv01 = (_uv0) ? _cameraVarsStore.createUV((((_uv1.u * _v0w) - (_uv0.u * _v1w)) / _d), (((_uv1.v * _v0w) - (_uv0.v * _v1w)) / _d), _session) : null;
					if (_v2w < 0){
						_d = (_v0w - _v2w);
						_v20 = _cameraVarsStore.createVertex((((_v2.x * _v0w) - (_v0.x * _v2w)) / _d), (((_v2.y * _v0w) - (_v0.y * _v2w)) / _d), (((_v2.z * _v0w) - (_v0.z * _v2w)) / _d));
						_uv20 = (_uv0) ? _cameraVarsStore.createUV((((_uv2.u * _v0w) - (_uv0.u * _v2w)) / _d), (((_uv2.v * _v0w) - (_uv0.v * _v2w)) / _d), _session) : null;
						_newFaceVO = (_faceVOs[_faceVOs.length] = _cameraVarsStore.createFaceVO(_faceVO.face, _faceVO.material, _faceVO.back, _uv0, _uv01, _uv20));
						_newFaceVO.vertices[0] = (_newFaceVO.v0 = _v0);
						_newFaceVO.vertices[1] = (_newFaceVO.v1 = _v01);
						_newFaceVO.vertices[2] = (_newFaceVO.v2 = _v20);
					} else {
						_d = (_v2w - _v1w);
						_v12 = _cameraVarsStore.createVertex((((_v1.x * _v2w) - (_v2.x * _v1w)) / _d), (((_v1.y * _v2w) - (_v2.y * _v1w)) / _d), (((_v1.z * _v2w) - (_v2.z * _v1w)) / _d));
						_uv12 = (_uv0) ? _cameraVarsStore.createUV((((_uv1.u * _v2w) - (_uv2.u * _v1w)) / _d), (((_uv1.v * _v2w) - (_uv2.v * _v1w)) / _d), _session) : null;
						_newFaceVO = (_faceVOs[_faceVOs.length] = _cameraVarsStore.createFaceVO(_faceVO.face, _faceVO.material, _faceVO.back, _uv0, _uv01, _uv2));
						_newFaceVO.vertices[0] = (_newFaceVO.v0 = _v0);
						_newFaceVO.vertices[1] = (_newFaceVO.v1 = _v01);
						_newFaceVO.vertices[2] = (_newFaceVO.v2 = _v2);
						_newFaceVO = (_faceVOs[_faceVOs.length] = _cameraVarsStore.createFaceVO(_faceVO.face, _faceVO.material, _faceVO.back, _uv01, _uv12, _uv2));
						_newFaceVO.vertices[0] = (_newFaceVO.v0 = _v01);
						_newFaceVO.vertices[1] = (_newFaceVO.v1 = _v12);
						_newFaceVO.vertices[2] = (_newFaceVO.v2 = _v2);
					};
				};
			};
			_arg8[_arg8.length] = _arg7.length;
		}
		override public function clone(_arg1:Clipping=null):Clipping{
			var _local2:FrustumClipping;
			_local2 = (((_arg1 as FrustumClipping)) || (new FrustumClipping()));
			super.clone(_local2);
			return (_local2);
		}
		override public function rect(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Boolean{
			if (this.maxX < _arg1){
				return (false);
			};
			if (this.minX > _arg3){
				return (false);
			};
			if (this.maxY < _arg2){
				return (false);
			};
			if (this.minY > _arg4){
				return (false);
			};
			return (true);
		}
		override public function set objectCulling(_arg1:Boolean):void{
			if (!_arg1){
				throw (new Error("objectCulling requires setting to true for FrustumClipping"));
			};
			_objectCulling = _arg1;
		}

	}
}//package away3d.core.clip 
Section 46
//RectangleClipping (away3d.core.clip.RectangleClipping)
package away3d.core.clip {
	import away3d.core.draw.*;

	public class RectangleClipping extends Clipping {

		public function RectangleClipping(_arg1:Object=null){
			super(_arg1);
			objectCulling = ini.getBoolean("objectCulling", false);
		}
		override public function clone(_arg1:Clipping=null):Clipping{
			var _local2:RectangleClipping;
			_local2 = (((_arg1 as RectangleClipping)) || (new RectangleClipping()));
			super.clone(_local2);
			return (_local2);
		}
		override public function checkPrimitive(_arg1:DrawPrimitive):Boolean{
			if (_arg1.maxX < minX){
				return (false);
			};
			if (_arg1.minX > maxX){
				return (false);
			};
			if (_arg1.maxY < minY){
				return (false);
			};
			if (_arg1.minY > maxY){
				return (false);
			};
			return (true);
		}

	}
}//package away3d.core.clip 
Section 47
//DrawBillboard (away3d.core.draw.DrawBillboard)
package away3d.core.draw {
	import flash.geom.*;
	import away3d.core.utils.*;
	import away3d.materials.*;

	public class DrawBillboard extends DrawPrimitive {

		private var h:Number;
		public var screenVertices:Array;
		private var cos:Number;
		public var bottomleftx:Number;
		private var sinh:Number;
		private var pointMapping:Matrix;
		public var screenIndices:Array;
		public var topleftx:Number;
		private var sinw:Number;
		public var bottomlefty:Number;
		public var toplefty:Number;
		private var cosh:Number;
		public var vx:Number;
		public var vy:Number;
		public var height:Number;
		public var mapping:Matrix;
		public var bottomrighty:Number;
		public var scale:Number;
		public var index:int;
		private var _index:int;
		public var bottomrightx:Number;
		private var cosw:Number;
		private var sin:Number;
		public var billboardVO:BillboardVO;
		public var width:Number;
		public var material:IBillboardMaterial;
		private var uvMaterial:IUVMaterial;
		public var toprightx:Number;
		public var toprighty:Number;
		private var w:Number;
		public var rotation:Number;

		public function DrawBillboard(){
			mapping = new Matrix();
			super();
		}
		override public function render():void{
			material.renderBillboard(this);
		}
		override public function contains(_arg1:Number, _arg2:Number):Boolean{
			var _local3:Point;
			var _local4:uint;
			if (rotation != 0){
				if ((((topleftx * (_arg2 - toprighty)) + (toprightx * (toplefty - _arg2))) + (_arg1 * (toprighty - toplefty))) > 0.001){
					return (false);
				};
				if ((((toprightx * (_arg2 - bottomrighty)) + (bottomrightx * (toprighty - _arg2))) + (_arg1 * (bottomrighty - toprighty))) > 0.001){
					return (false);
				};
				if ((((bottomrightx * (_arg2 - bottomlefty)) + (bottomleftx * (bottomrighty - _arg2))) + (_arg1 * (bottomlefty - bottomrighty))) > 0.001){
					return (false);
				};
				if ((((bottomleftx * (_arg2 - toplefty)) + (topleftx * (bottomlefty - _arg2))) + (_arg1 * (toplefty - bottomlefty))) > 0.001){
					return (false);
				};
			};
			uvMaterial = (material as IUVMaterial);
			if (((!(uvMaterial)) || (!(uvMaterial.bitmap.transparent)))){
				return (true);
			};
			pointMapping = mapping.clone();
			pointMapping.invert();
			_local3 = pointMapping.transformPoint(new Point(_arg1, _arg2));
			if (_local3.x < 0){
				_local3.x = 0;
			};
			if (_local3.y < 0){
				_local3.y = 0;
			};
			if (_local3.x >= uvMaterial.width){
				_local3.x = (uvMaterial.width - 1);
			};
			if (_local3.y >= uvMaterial.height){
				_local3.y = (uvMaterial.height - 1);
			};
			_local4 = uvMaterial.bitmap.getPixel32(int(_local3.x), int(_local3.y));
			return ((uint((_local4 >> 24)) > 128));
		}
		override public function clear():void{
		}
		override public function calc():void{
			var _local1:Array;
			var _local2:int;
			var _local3:Array;
			var _local4:int;
			_index = (screenIndices[index] * 3);
			vx = screenVertices[_index];
			vy = screenVertices[(_index + 1)];
			screenZ = screenVertices[(_index + 2)];
			minZ = screenZ;
			maxZ = screenZ;
			uvMaterial = (material as IUVMaterial);
			if (uvMaterial){
				w = (uvMaterial.width * scale);
				h = (uvMaterial.height * scale);
			} else {
				w = (width * scale);
				h = (height * scale);
			};
			if (rotation != 0){
				cos = Math.cos(((rotation * Math.PI) / 180));
				sin = Math.sin(((rotation * Math.PI) / 180));
				cosw = ((cos * w) / 2);
				cosh = ((cos * h) / 2);
				sinw = ((sin * w) / 2);
				sinh = ((sin * h) / 2);
				topleftx = ((vx - cosw) - sinh);
				toplefty = ((vy + sinw) - cosh);
				toprightx = ((vx + cosw) - sinh);
				toprighty = ((vy - sinw) - cosh);
				bottomleftx = ((vx - cosw) + sinh);
				bottomlefty = ((vy + sinw) + cosh);
				bottomrightx = ((vx + cosw) + sinh);
				bottomrighty = ((vy - sinw) + cosh);
				_local1 = [];
				_local1.push(topleftx);
				_local1.push(toprightx);
				_local1.push(bottomleftx);
				_local1.push(bottomrightx);
				minX = 100000;
				maxX = -100000;
				for each (_local2 in _local1) {
					if (minX > _local2){
						minX = _local2;
					};
					if (maxX < _local2){
						maxX = _local2;
					};
				};
				_local3 = [];
				_local3.push(toplefty);
				_local3.push(toprighty);
				_local3.push(bottomlefty);
				_local3.push(bottomrighty);
				minY = 100000;
				maxY = -100000;
				for each (_local4 in _local3) {
					if (minY > _local4){
						minY = _local4;
					};
					if (maxY < _local4){
						maxY = _local4;
					};
				};
				mapping.a = (scale * cos);
				mapping.b = (-(scale) * sin);
				mapping.c = (scale * sin);
				mapping.d = (scale * cos);
				mapping.tx = topleftx;
				mapping.ty = toplefty;
			} else {
				bottomrightx = (toprightx = ((bottomleftx = (topleftx = (vx - (w / 2)))) + w));
				bottomrighty = (bottomlefty = ((toprighty = (toplefty = (vy - (h / 2)))) + h));
				minX = topleftx;
				minY = toplefty;
				maxX = bottomrightx;
				maxY = bottomrighty;
				mapping.a = (mapping.d = scale);
				mapping.c = (mapping.b = 0);
				mapping.tx = topleftx;
				mapping.ty = toplefty;
			};
		}

	}
}//package away3d.core.draw 
Section 48
//DrawDisplayObject (away3d.core.draw.DrawDisplayObject)
package away3d.core.draw {
	import flash.geom.*;
	import flash.display.*;
	import away3d.core.render.*;

	public class DrawDisplayObject extends DrawPrimitive {

		public var vx:Number;
		public var vy:Number;
		public var displayobject:DisplayObject;
		private var displayRect:Rectangle;
		public var session:AbstractRenderSession;
		public var vz:Number;

		override public function clear():void{
			displayobject = null;
		}
		override public function calc():void{
			displayRect = displayobject.getBounds(displayobject);
			screenZ = vz;
			minZ = screenZ;
			maxZ = screenZ;
			minX = (vx + displayRect.left);
			minY = (vy + displayRect.top);
			maxX = (vx + displayRect.right);
			maxY = (vy + displayRect.bottom);
		}
		override public function render():void{
			displayobject.x = vx;
			displayobject.y = vy;
			session.addDisplayObject(displayobject);
		}
		override public function contains(_arg1:Number, _arg2:Number):Boolean{
			return (true);
		}

	}
}//package away3d.core.draw 
Section 49
//DrawFog (away3d.core.draw.DrawFog)
package away3d.core.draw {
	import away3d.core.clip.*;
	import away3d.materials.*;

	public class DrawFog extends DrawPrimitive {

		public var clip:Clipping;
		public var material:IFogMaterial;

		override public function render():void{
			material.renderFog(this);
		}

	}
}//package away3d.core.draw 
Section 50
//DrawPrimitive (away3d.core.draw.DrawPrimitive)
package away3d.core.draw {
	import away3d.containers.*;
	import away3d.core.base.*;

	public class DrawPrimitive {

		public var quadrant:PrimitiveQuadrantTreeNode;
		public var minX:Number;
		public var minZ:Number;
		public var generated:Boolean;
		public var source:Object3D;
		public var minY:Number;
		public var view:View3D;
		public var screenZ:Number;
		public var maxX:Number;
		public var maxY:Number;
		public var create:Function;
		public var maxZ:Number;

		public function getZ(_arg1:Number, _arg2:Number):Number{
			return (screenZ);
		}
		public function clear():void{
			throw (new Error("Not implemented"));
		}
		public function calc():void{
			throw (new Error("Not implemented"));
		}
		public function render():void{
			throw (new Error("Not implemented"));
		}
		public function contains(_arg1:Number, _arg2:Number):Boolean{
			throw (new Error("Not implemented"));
		}
		public function quarter(_arg1:Number):Array{
			return ([this]);
		}
		public function toString():String{
			return ((((((("P{ screenZ = " + screenZ) + ", minZ = ") + minZ) + ", maxZ = ") + maxZ) + " }"));
		}

	}
}//package away3d.core.draw 
Section 51
//DrawScaledBitmap (away3d.core.draw.DrawScaledBitmap)
package away3d.core.draw {
	import flash.geom.*;
	import flash.display.*;

	public class DrawScaledBitmap extends DrawPrimitive {

		private var cos:Number;
		public var bottomleftx:Number;
		private var sinh:Number;
		private var pointMapping:Matrix;
		public var topleftx:Number;
		public var toplefty:Number;
		private var sinw:Number;
		public var bottomlefty:Number;
		private var height:Number;
		public var smooth:Boolean;
		private var cosh:Number;
		public var vx:Number;
		public var vy:Number;
		public var vz:Number;
		private var mapping:Matrix;
		public var bottomrighty:Number;
		private var cosw:Number;
		public var bitmap:BitmapData;
		public var bottomrightx:Number;
		private var sin:Number;
		public var scale:Number;
		private var width:Number;
		public var toprightx:Number;
		public var toprighty:Number;
		public var rotation:Number;

		public function DrawScaledBitmap(){
			mapping = new Matrix();
			super();
		}
		override public function render():void{
			source.session.renderScaledBitmap(this, bitmap, mapping, smooth);
		}
		override public function contains(_arg1:Number, _arg2:Number):Boolean{
			var _local3:Point;
			var _local4:uint;
			if (rotation != 0){
				if ((((topleftx * (_arg2 - toprighty)) + (toprightx * (toplefty - _arg2))) + (_arg1 * (toprighty - toplefty))) > 0.001){
					return (false);
				};
				if ((((toprightx * (_arg2 - bottomrighty)) + (bottomrightx * (toprighty - _arg2))) + (_arg1 * (bottomrighty - toprighty))) > 0.001){
					return (false);
				};
				if ((((bottomrightx * (_arg2 - bottomlefty)) + (bottomleftx * (bottomrighty - _arg2))) + (_arg1 * (bottomlefty - bottomrighty))) > 0.001){
					return (false);
				};
				if ((((bottomleftx * (_arg2 - toplefty)) + (topleftx * (bottomlefty - _arg2))) + (_arg1 * (toplefty - bottomlefty))) > 0.001){
					return (false);
				};
			};
			if (!bitmap.transparent){
				return (true);
			};
			pointMapping = mapping.clone();
			pointMapping.invert();
			_local3 = pointMapping.transformPoint(new Point(_arg1, _arg2));
			if (_local3.x < 0){
				_local3.x = 0;
			};
			if (_local3.y < 0){
				_local3.y = 0;
			};
			if (_local3.x >= bitmap.width){
				_local3.x = (bitmap.width - 1);
			};
			if (_local3.y >= bitmap.height){
				_local3.y = (bitmap.height - 1);
			};
			_local4 = bitmap.getPixel32(int(_local3.x), int(_local3.y));
			return ((uint((_local4 >> 24)) > 128));
		}
		override public function clear():void{
			bitmap = null;
		}
		override public function calc():void{
			var _local1:Array;
			var _local2:int;
			var _local3:Array;
			var _local4:int;
			screenZ = vz;
			minZ = screenZ;
			maxZ = screenZ;
			width = (bitmap.width * scale);
			height = (bitmap.height * scale);
			if (rotation != 0){
				cos = Math.cos(((rotation * Math.PI) / 180));
				sin = Math.sin(((rotation * Math.PI) / 180));
				cosw = ((cos * width) / 2);
				cosh = ((cos * height) / 2);
				sinw = ((sin * width) / 2);
				sinh = ((sin * height) / 2);
				topleftx = ((vx - cosw) - sinh);
				toplefty = ((vy + sinw) - cosh);
				toprightx = ((vx + cosw) - sinh);
				toprighty = ((vy - sinw) - cosh);
				bottomleftx = ((vx - cosw) + sinh);
				bottomlefty = ((vy + sinw) + cosh);
				bottomrightx = ((vx + cosw) + sinh);
				bottomrighty = ((vy - sinw) + cosh);
				_local1 = [];
				_local1.push(topleftx);
				_local1.push(toprightx);
				_local1.push(bottomleftx);
				_local1.push(bottomrightx);
				minX = 100000;
				maxX = -100000;
				for each (_local2 in _local1) {
					if (minX > _local2){
						minX = _local2;
					};
					if (maxX < _local2){
						maxX = _local2;
					};
				};
				_local3 = [];
				_local3.push(toplefty);
				_local3.push(toprighty);
				_local3.push(bottomlefty);
				_local3.push(bottomrighty);
				minY = 100000;
				maxY = -100000;
				for each (_local4 in _local3) {
					if (minY > _local4){
						minY = _local4;
					};
					if (maxY < _local4){
						maxY = _local4;
					};
				};
				mapping.a = (scale * cos);
				mapping.b = (-(scale) * sin);
				mapping.c = (scale * sin);
				mapping.d = (scale * cos);
				mapping.tx = topleftx;
				mapping.ty = toplefty;
			} else {
				topleftx = (vx - (width / 2));
				toplefty = (vy - (height / 2));
				toprightx = (topleftx + width);
				toprighty = toplefty;
				bottomleftx = topleftx;
				bottomlefty = (toplefty + height);
				bottomrightx = toprightx;
				bottomrighty = bottomlefty;
				minX = topleftx;
				minY = toplefty;
				maxX = bottomrightx;
				maxY = bottomrighty;
				mapping.a = (mapping.d = scale);
				mapping.c = (mapping.b = 0);
				mapping.tx = topleftx;
				mapping.ty = toplefty;
			};
		}

	}
}//package away3d.core.draw 
Section 52
//DrawSegment (away3d.core.draw.DrawSegment)
package away3d.core.draw {
	import away3d.core.utils.*;
	import away3d.materials.*;

	public class DrawSegment extends DrawPrimitive {

		private var bzf:Number;
		private var det:Number;
		public var screenCommands:Array;
		private var axf:Number;
		private var faz:Number;
		public var material:ISegmentMaterial;
		public var segmentVO:SegmentVO;
		private var ayf:Number;
		private var ax:Number;
		private var ay:Number;
		private var az:Number;
		public var v0y:Number;
		public var v0z:Number;
		private var fbz:Number;
		private var azf:Number;
		private var bx:Number;
		private var by:Number;
		public var v1x:Number;
		public var v1y:Number;
		private var bz:Number;
		private var xfocus:Number;
		public var v1z:Number;
		public var v0x:Number;
		private var db:Number;
		private var da:Number;
		private var dx:Number;
		private var dy:Number;
		public var startIndex:int;
		public var screenIndices:Array;
		public var screenVertices:Array;
		public var endIndex:int;
		private var bxf:Number;
		private var _index:int;
		private var focus:Number;
		public var length:Number;
		private var byf:Number;
		private var yfocus:Number;

		function onepointcut(_arg1:Number, _arg2:Number, _arg3:Number):Array{
			var _local4:int;
			var _local5:int;
			var _local6:int;
			_local4 = screenIndices.length;
			screenIndices[screenIndices.length] = startIndex;
			screenIndices[screenIndices.length] = screenVertices.length;
			_local5 = screenIndices.length;
			screenIndices[screenIndices.length] = screenVertices.length;
			screenIndices[screenIndices.length] = (startIndex + 1);
			_local6 = screenIndices.length;
			screenVertices[screenVertices.length] = _arg1;
			screenVertices[screenVertices.length] = _arg2;
			screenVertices[screenVertices.length] = _arg3;
			return ([create(source, segmentVO, material, screenVertices, screenIndices, screenCommands, _local4, _local5, true), create(source, segmentVO, material, screenVertices, screenIndices, screenCommands, _local5, _local6, true)]);
		}
		override public function contains(_arg1:Number, _arg2:Number):Boolean{
			if (Math.abs((((v0x * (_arg2 - v1y)) + (v1x * (v0y - _arg2))) + (_arg1 * (v1y - v0y)))) > ((0.001 * 1000) * 1000)){
				return (false);
			};
			if ((distanceToCenter(_arg1, _arg2) * 2) > length){
				return (false);
			};
			return (true);
		}
		override public function clear():void{
		}
		override public function calc():void{
			_index = (screenIndices[startIndex] * 3);
			v0x = screenVertices[_index];
			v0y = screenVertices[(_index + 1)];
			v0z = screenVertices[(_index + 2)];
			_index = (screenIndices[(startIndex + 1)] * 3);
			v1x = screenVertices[_index];
			v1y = screenVertices[(_index + 1)];
			v1z = screenVertices[(_index + 2)];
			if (v0z < v1z){
				minZ = v0z;
				maxZ = (v1z + 1);
			} else {
				minZ = v1z;
				maxZ = (v0z + 1);
			};
			screenZ = ((v0z + v1z) / 2);
			if (v0x < v1x){
				minX = v0x;
				maxX = (v1x + 1);
			} else {
				minX = v1x;
				maxX = (v0x + 1);
			};
			if (v0y < v1y){
				minY = v0y;
				maxY = (v1y + 1);
			} else {
				minY = v1y;
				maxY = (v0y + 1);
			};
			length = Math.sqrt((((maxX - minX) * (maxX - minX)) + ((maxY - minY) * (maxY - minY))));
		}
		override public function toString():String{
			return ((((((("S{ screenZ = " + screenZ) + ", minZ = ") + minZ) + ", maxZ = ") + maxZ) + " }"));
		}
		override public function render():void{
			material.renderSegment(this);
		}
		override public function quarter(_arg1:Number):Array{
			var _local2:int;
			var _local3:int;
			var _local4:int;
			if (length < 5){
				return (null);
			};
			_local2 = screenIndices.length;
			screenIndices[screenIndices.length] = startIndex;
			screenIndices[screenIndices.length] = screenVertices.length;
			_local3 = screenIndices.length;
			screenIndices[screenIndices.length] = screenVertices.length;
			screenIndices[screenIndices.length] = (startIndex + 1);
			_local4 = screenIndices.length;
			ScreenVertex.median(startIndex, (startIndex + 1), screenVertices, screenIndices, _arg1);
			return ([create(source, segmentVO, material, screenVertices, screenIndices, screenCommands, _local2, _local3, true), create(source, segmentVO, material, screenVertices, screenIndices, screenCommands, _local3, _local4, true)]);
		}
		override public function getZ(_arg1:Number, _arg2:Number):Number{
			focus = view.camera.focus;
			ax = v0x;
			ay = v0y;
			az = v0z;
			bx = v1x;
			by = v1y;
			bz = v1z;
			if ((((ax == _arg1)) && ((ay == _arg2)))){
				return (az);
			};
			if ((((bx == _arg1)) && ((by == _arg2)))){
				return (bz);
			};
			dx = (bx - ax);
			dy = (by - ay);
			azf = (az / focus);
			bzf = (bz / focus);
			faz = (1 + azf);
			fbz = (1 + bzf);
			xfocus = _arg1;
			yfocus = _arg2;
			axf = ((ax * faz) - (_arg1 * azf));
			bxf = ((bx * fbz) - (_arg1 * bzf));
			ayf = ((ay * faz) - (_arg2 * azf));
			byf = ((by * fbz) - (_arg2 * bzf));
			det = ((dx * (axf - bxf)) + (dy * (ayf - byf)));
			db = ((dx * (axf - _arg1)) + (dy * (ayf - _arg2)));
			da = ((dx * (_arg1 - bxf)) + (dy * (_arg2 - byf)));
			return ((((da * az) + (db * bz)) / det));
		}
		private function distanceToCenter(_arg1:Number, _arg2:Number):Number{
			var _local3:Number;
			var _local4:Number;
			_local3 = ((v0x + v1x) / 2);
			_local4 = ((v0y + v1y) / 2);
			return (Math.sqrt((((_local3 - _arg1) * (_local3 - _arg1)) + ((_local4 - _arg2) * (_local4 - _arg2)))));
		}

	}
}//package away3d.core.draw 
Section 53
//DrawTriangle (away3d.core.draw.DrawTriangle)
package away3d.core.draw {
	import flash.geom.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.materials.*;

	public class DrawTriangle extends DrawPrimitive {

		private var _u0:Number;
		private var _z:Number;
		private var _y:Number;
		private var bzf:Number;
		private var det:Number;
		private var axf:Number;
		private var _v0:Number;
		private var _v1:Number;
		private var _v2:Number;
		public var screenCommands:Array;
		private var _vertexCount:uint;
		private var faz:Number;
		public var backface:Boolean;// = false
		private var ayf:Number;
		private var materialHeight:Number;
		private var ax:Number;
		private var ay:Number;
		private var az:Number;
		private var au:Number;
		private var av:Number;
		public var v0y:Number;
		public var v0z:Number;
		private var fbz:Number;
		private var _areaSign:Number;
		private var bu:Number;
		private var azf:Number;
		private var bx:Number;
		private var by:Number;
		private var bz:Number;
		private var bv:Number;
		private var fcz:Number;
		public var v1y:Number;
		public var v1z:Number;
		private var uv01:UV;
		public var material:ITriangleMaterial;
		private var cv:Number;
		private var cx:Number;
		private var cy:Number;
		private var cz:Number;
		private var cu:Number;
		private var da:Number;
		private var db:Number;
		private var dc:Number;
		private var _invtexmapping:Matrix;
		private var uv12:UV;
		public var v1x:Number;
		public var v2x:Number;
		private var cxf:Number;
		public var area:Number;
		public var startIndex:int;
		public var screenIndices:Array;
		public var screenVertices:Array;
		private var uv20:UV;
		public var v0x:Number;
		public var v2y:Number;
		public var uv0:UV;
		public var uv2:UV;
		private var cyf:Number;
		private var _vertex:int;
		public var endIndex:int;
		public var uv1:UV;
		private var czf:Number;
		private var bxf:Number;
		public var v2z:Number;
		private var _index:int;
		public var reverseArea:Boolean;
		public var faceVO:FaceVO;
		private var focus:Number;
		private var materialWidth:Number;
		private var byf:Number;
		private var _x:Number;
		private var _u1:Number;
		private var _u2:Number;

		public function DrawTriangle(){
			_invtexmapping = new Matrix();
			backface = false;
			super();
		}
		final public function transformUV(_arg1:IUVMaterial):Matrix{
			materialWidth = _arg1.width;
			materialHeight = _arg1.height;
			if ((((((uv0 == null)) || ((uv1 == null)))) || ((uv2 == null)))){
				return (null);
			};
			_u0 = (materialWidth * uv0._u);
			_u1 = (materialWidth * uv1._u);
			_u2 = (materialWidth * uv2._u);
			_v0 = (materialHeight * (1 - uv0._v));
			_v1 = (materialHeight * (1 - uv1._v));
			_v2 = (materialHeight * (1 - uv2._v));
			if ((((((_u0 == _u1)) && ((_v0 == _v1)))) || ((((_u0 == _u2)) && ((_v0 == _v2)))))){
				if (_u0 > 0.05){
					_u0 = (_u0 - 0.05);
				} else {
					_u0 = (_u0 + 0.05);
				};
				if (_v0 > 0.07){
					_v0 = (_v0 - 0.07);
				} else {
					_v0 = (_v0 + 0.07);
				};
			};
			if ((((_u2 == _u1)) && ((_v2 == _v1)))){
				if (_u2 > 0.04){
					_u2 = (_u2 - 0.04);
				} else {
					_u2 = (_u2 + 0.04);
				};
				if (_v2 > 0.06){
					_v2 = (_v2 - 0.06);
				} else {
					_v2 = (_v2 + 0.06);
				};
			};
			_invtexmapping.a = (_u1 - _u0);
			_invtexmapping.b = (_v1 - _v0);
			_invtexmapping.c = (_u2 - _u0);
			_invtexmapping.d = (_v2 - _v0);
			if ((_arg1 is BitmapMaterialContainer)){
				_invtexmapping.tx = (_u0 - faceVO.bitmapRect.x);
				_invtexmapping.ty = (_v0 - faceVO.bitmapRect.y);
			} else {
				_invtexmapping.tx = _u0;
				_invtexmapping.ty = _v0;
			};
			return (_invtexmapping);
		}
		final override public function contains(_arg1:Number, _arg2:Number):Boolean{
			var _local3:Boolean;
			var _local4:int;
			var _local5:int;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:int;
			var _local11:int;
			if (_vertexCount > 3){
				_local3 = false;
				_local4 = startIndex;
				_local5 = (endIndex - 1);
				while (_local4 < endIndex) {
					if (screenCommands[_local4] == DrawingCommand.CURVE){
						_local4++;
					};
					_local10 = (screenIndices[_local4] * 3);
					_local7 = screenVertices[(_local10 + 1)];
					_local11 = (screenIndices[_local5] * 3);
					_local9 = screenVertices[(_local11 + 1)];
					if (((!(((_local7 > _arg2) == (_local9 > _arg2)))) && ((_arg1 < ((((screenVertices[_local11] - screenVertices[_local10]) * (_arg2 - _local7)) / (_local9 - _local7)) + _local6))))){
						_local3 = !(_local3);
					};
					var _temp1 = _local4;
					_local4 = (_local4 + 1);
					_local5 = _temp1;
					if (screenCommands[_local4] == DrawingCommand.MOVE){
						var _temp2 = _local4;
						_local4 = (_local4 + 1);
						_local5 = _temp2;
					};
				};
				return (_local3);
			};
			if (((((v0x * (_arg2 - v1y)) + (v1x * (v0y - _arg2))) + (_arg1 * (v1y - v0y))) * _areaSign) < -0.001){
				return (false);
			};
			if (((((v0x * (v2y - _arg2)) + (_arg1 * (v0y - v2y))) + (v2x * (_arg2 - v0y))) * _areaSign) < -0.001){
				return (false);
			};
			if (((((_arg1 * (v2y - v1y)) + (v1x * (_arg2 - v2y))) + (v2x * (v1y - _arg2))) * _areaSign) < -0.001){
				return (false);
			};
			return (true);
		}
		override public function clear():void{
			uv0 = null;
			uv1 = null;
			uv2 = null;
		}
		override public function calc():void{
			_index = (screenIndices[startIndex] * 3);
			v0x = screenVertices[_index];
			v0y = screenVertices[(_index + 1)];
			v0z = screenVertices[(_index + 2)];
			_index = (screenIndices[(startIndex + 1)] * 3);
			v1x = screenVertices[_index];
			v1y = screenVertices[(_index + 1)];
			v1z = screenVertices[(_index + 2)];
			_index = (screenIndices[(startIndex + 2)] * 3);
			v2x = screenVertices[_index];
			v2y = screenVertices[(_index + 1)];
			v2z = screenVertices[(_index + 2)];
			_vertexCount = (endIndex - startIndex);
			if (_vertexCount > 3){
				screenZ = 0;
				_index = endIndex;
				minX = Infinity;
				maxX = -(Infinity);
				minY = Infinity;
				maxY = -(Infinity);
				minZ = Infinity;
				maxZ = -(Infinity);
				while (_index-- > startIndex) {
					_vertex = (screenIndices[_index] * 3);
					_x = screenVertices[_vertex];
					_y = screenVertices[(_vertex + 1)];
					_z = screenVertices[(_vertex + 2)];
					if (minX > _x){
						minX = _x;
					};
					if (maxX < _x){
						maxX = _x;
					};
					if (minY > _y){
						minY = _y;
					};
					if (maxY < _y){
						maxY = _y;
					};
					if (minZ > _z){
						minZ = _z;
					};
					if (maxZ < _z){
						maxZ = _z;
					};
					screenZ = (screenZ + _z);
				};
				screenZ = (screenZ / _vertexCount);
			} else {
				if (v0x > v1x){
					if (v0x > v2x){
						maxX = v0x;
					} else {
						maxX = v2x;
					};
				} else {
					if (v1x > v2x){
						maxX = v1x;
					} else {
						maxX = v2x;
					};
				};
				if (v0x < v1x){
					if (v0x < v2x){
						minX = v0x;
					} else {
						minX = v2x;
					};
				} else {
					if (v1x < v2x){
						minX = v1x;
					} else {
						minX = v2x;
					};
				};
				if (v0y > v1y){
					if (v0y > v2y){
						maxY = v0y;
					} else {
						maxY = v2y;
					};
				} else {
					if (v1y > v2y){
						maxY = v1y;
					} else {
						maxY = v2y;
					};
				};
				if (v0y < v1y){
					if (v0y < v2y){
						minY = v0y;
					} else {
						minY = v2y;
					};
				} else {
					if (v1y < v2y){
						minY = v1y;
					} else {
						minY = v2y;
					};
				};
				if (v0z > v1z){
					if (v0z > v2z){
						maxZ = v0z;
					} else {
						maxZ = v2z;
					};
				} else {
					if (v1z > v2z){
						maxZ = v1z;
					} else {
						maxZ = v2z;
					};
				};
				if (v0z < v1z){
					if (v0z < v2z){
						minZ = v0z;
					} else {
						minZ = v2z;
					};
				} else {
					if (v1z < v2z){
						minZ = v1z;
					} else {
						minZ = v2z;
					};
				};
				screenZ = (((v0z + v1z) + v2z) / 3);
			};
			area = (0.5 * (((v0x * (v2y - v1y)) + (v1x * (v0y - v2y))) + (v2x * (v1y - v0y))));
			if (area > 0){
				_areaSign = 1;
			} else {
				_areaSign = -1;
			};
		}
		function fivepointcut(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number, _arg7:Number, _arg8:Number, _arg9:Number, _arg10:UV, _arg11:UV, _arg12:UV, _arg13:UV, _arg14:UV):Array{
			var _local15:int;
			var _local16:int;
			var _local17:int;
			var _local18:int;
			var _local19:int;
			var _local20:int;
			var _local21:int;
			var _local22:int;
			var _local23:int;
			var _local24:int;
			var _local25:int;
			var _local26:int;
			_local15 = (screenVertices.length / 3);
			_local16 = screenIndices[_arg1];
			_local17 = screenIndices[_arg5];
			_local18 = screenIndices[_arg9];
			if (ScreenVertex.distanceSqr(screenVertices[(_local16 * 3)], screenVertices[((_local16 * 3) + 1)], _arg6, _arg7) < ScreenVertex.distanceSqr(_arg2, _arg3, screenVertices[(_local18 * 3)], screenVertices[((_local18 * 3) + 1)])){
				_local19 = screenIndices.length;
				screenIndices[screenIndices.length] = _local16;
				screenIndices[screenIndices.length] = _local15;
				screenIndices[screenIndices.length] = (_local15 + 1);
				_local20 = screenIndices.length;
				screenIndices[screenIndices.length] = _local15;
				screenIndices[screenIndices.length] = _local17;
				screenIndices[screenIndices.length] = (_local15 + 1);
				_local21 = screenIndices.length;
				screenIndices[screenIndices.length] = _local16;
				screenIndices[screenIndices.length] = (_local15 + 1);
				screenIndices[screenIndices.length] = _local18;
				_local22 = screenIndices.length;
				screenVertices[screenVertices.length] = _arg2;
				screenVertices[screenVertices.length] = _arg3;
				screenVertices[screenVertices.length] = _arg4;
				screenVertices[screenVertices.length] = _arg6;
				screenVertices[screenVertices.length] = _arg7;
				screenVertices[screenVertices.length] = _arg8;
				return ([create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local19, _local20, _arg10, _arg11, _arg13, true), create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local20, _local21, _arg11, _arg12, _arg13, true), create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local21, _local22, _arg10, _arg13, _arg14, true)]);
			};
			_local23 = screenIndices.length;
			screenIndices[screenIndices.length] = _local16;
			screenIndices[screenIndices.length] = _local15;
			screenIndices[screenIndices.length] = _local18;
			_local24 = screenIndices.length;
			screenIndices[screenIndices.length] = _local15;
			screenIndices[screenIndices.length] = _local17;
			screenIndices[screenIndices.length] = (_local15 + 1);
			_local25 = screenIndices.length;
			screenIndices[screenIndices.length] = _local15;
			screenIndices[screenIndices.length] = (_local15 + 1);
			screenIndices[screenIndices.length] = _local18;
			_local26 = screenIndices.length;
			screenVertices[screenVertices.length] = _arg2;
			screenVertices[screenVertices.length] = _arg3;
			screenVertices[screenVertices.length] = _arg4;
			screenVertices[screenVertices.length] = _arg6;
			screenVertices[screenVertices.length] = _arg7;
			screenVertices[screenVertices.length] = _arg8;
			return ([create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local23, _local24, _arg10, _arg11, _arg14, true), create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local24, _local25, _arg11, _arg12, _arg13, true), create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local25, _local26, _arg11, _arg13, _arg14, true)]);
		}
		override public function toString():String{
			var _local1:String;
			_local1 = "";
			if ((material is WireColorMaterial)){
				switch ((material as WireColorMaterial).color){
					case 0xFF00:
						_local1 = "green";
						break;
					case 0xFFFF00:
						_local1 = "yellow";
						break;
					case 0xFF0000:
						_local1 = "red";
						break;
					case 0xFF:
						_local1 = "blue";
						break;
				};
			};
			return (((((((((("T{" + _local1) + int(area)) + " screenZ = ") + num(screenZ)) + ", minZ = ") + num(minZ)) + ", maxZ = ") + num(maxZ)) + " }"));
		}
		private function num(_arg1:Number):Number{
			return ((int((_arg1 * 1000)) / 1000));
		}
		override public function render():void{
			material.renderTriangle(this);
		}
		public function getUV(_arg1:Number, _arg2:Number):UV{
			if (uv0 == null){
				return (null);
			};
			if (uv1 == null){
				return (null);
			};
			if (uv2 == null){
				return (null);
			};
			au = uv0._u;
			av = uv0._v;
			bu = uv1._u;
			bv = uv1._v;
			cu = uv2._u;
			cv = uv2._v;
			focus = view.camera.focus;
			ax = v0x;
			ay = v0y;
			az = v0z;
			bx = v1x;
			by = v1y;
			bz = v1z;
			cx = v2x;
			cy = v2y;
			cz = v2z;
			if ((((ax == _arg1)) && ((ay == _arg2)))){
				return (uv0);
			};
			if ((((bx == _arg1)) && ((by == _arg2)))){
				return (uv1);
			};
			if ((((cx == _arg1)) && ((cy == _arg2)))){
				return (uv2);
			};
			azf = (az / focus);
			bzf = (bz / focus);
			czf = (cz / focus);
			faz = (1 + azf);
			fbz = (1 + bzf);
			fcz = (1 + czf);
			axf = ((ax * faz) - (_arg1 * azf));
			bxf = ((bx * fbz) - (_arg1 * bzf));
			cxf = ((cx * fcz) - (_arg1 * czf));
			ayf = ((ay * faz) - (_arg2 * azf));
			byf = ((by * fbz) - (_arg2 * bzf));
			cyf = ((cy * fcz) - (_arg2 * czf));
			det = (((axf * (byf - cyf)) + (bxf * (cyf - ayf))) + (cxf * (ayf - byf)));
			da = (((_arg1 * (byf - cyf)) + (bxf * (cyf - _arg2))) + (cxf * (_arg2 - byf)));
			db = (((axf * (_arg2 - cyf)) + (_arg1 * (cyf - ayf))) + (cxf * (ayf - _arg2)));
			dc = (((axf * (byf - _arg2)) + (bxf * (_arg2 - ayf))) + (_arg1 * (ayf - byf)));
			return (new UV(((((da * au) + (db * bu)) + (dc * cu)) / det), ((((da * av) + (db * bv)) + (dc * cv)) / det)));
		}
		final override public function quarter(_arg1:Number):Array{
			var _local2:int;
			var _local3:int;
			var _local4:int;
			var _local5:int;
			var _local6:int;
			var _local7:int;
			if ((((area > -20)) && ((area < 20)))){
				return (null);
			};
			_local2 = (screenVertices.length / 3);
			_local3 = screenIndices.length;
			screenIndices[screenIndices.length] = screenIndices[startIndex];
			screenIndices[screenIndices.length] = _local2;
			screenIndices[screenIndices.length] = (_local2 + 2);
			_local4 = screenIndices.length;
			screenIndices[screenIndices.length] = screenIndices[(startIndex + 1)];
			screenIndices[screenIndices.length] = (_local2 + 1);
			screenIndices[screenIndices.length] = _local2;
			_local5 = screenIndices.length;
			screenIndices[screenIndices.length] = screenIndices[(startIndex + 2)];
			screenIndices[screenIndices.length] = (_local2 + 2);
			screenIndices[screenIndices.length] = (_local2 + 1);
			_local6 = screenIndices.length;
			screenIndices[screenIndices.length] = _local2;
			screenIndices[screenIndices.length] = (_local2 + 1);
			screenIndices[screenIndices.length] = (_local2 + 2);
			_local7 = screenIndices.length;
			ScreenVertex.median(startIndex, (startIndex + 1), screenVertices, screenIndices, _arg1);
			ScreenVertex.median((startIndex + 1), (startIndex + 2), screenVertices, screenIndices, _arg1);
			ScreenVertex.median((startIndex + 2), startIndex, screenVertices, screenIndices, _arg1);
			uv01 = UV.median(uv0, uv1);
			uv12 = UV.median(uv1, uv2);
			uv20 = UV.median(uv2, uv0);
			return ([create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local3, _local4, uv0, uv01, uv20, true), create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local4, _local5, uv1, uv12, uv01, true), create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local5, _local6, uv2, uv20, uv12, true), create(source, faceVO, material, screenVertices, screenIndices, screenCommands, _local6, _local7, uv01, uv12, uv20, true)]);
		}
		final override public function getZ(_arg1:Number, _arg2:Number):Number{
			focus = view.camera.focus;
			if (_vertexCount > 3){
				return (screenZ);
			};
			ax = v0x;
			ay = v0y;
			az = v0z;
			bx = v1x;
			by = v1y;
			bz = v1z;
			cx = v2x;
			cy = v2y;
			cz = v2z;
			if ((((ax == _arg1)) && ((ay == _arg2)))){
				return (az);
			};
			if ((((bx == _arg1)) && ((by == _arg2)))){
				return (bz);
			};
			if ((((cx == _arg1)) && ((cy == _arg2)))){
				return (cz);
			};
			azf = (az / focus);
			bzf = (bz / focus);
			czf = (cz / focus);
			faz = (1 + azf);
			fbz = (1 + bzf);
			fcz = (1 + czf);
			axf = ((ax * faz) - (_arg1 * azf));
			bxf = ((bx * fbz) - (_arg1 * bzf));
			cxf = ((cx * fcz) - (_arg1 * czf));
			ayf = ((ay * faz) - (_arg2 * azf));
			byf = ((by * fbz) - (_arg2 * bzf));
			cyf = ((cy * fcz) - (_arg2 * czf));
			det = (((axf * (byf - cyf)) + (bxf * (cyf - ayf))) + (cxf * (ayf - byf)));
			da = (((_arg1 * (byf - cyf)) + (bxf * (cyf - _arg2))) + (cxf * (_arg2 - byf)));
			db = (((axf * (_arg2 - cyf)) + (_arg1 * (cyf - ayf))) + (cxf * (ayf - _arg2)));
			dc = (((axf * (byf - _arg2)) + (bxf * (_arg2 - ayf))) + (_arg1 * (ayf - byf)));
			return (((((da * az) + (db * bz)) + (dc * cz)) / det));
		}
		final public function distanceToCenter(_arg1:Number, _arg2:Number):Number{
			var _local3:Number;
			var _local4:Number;
			_local3 = (((v0x + v1x) + v2x) / 3);
			_local4 = (((v0y + v1y) + v2y) / 3);
			return (Math.sqrt((((_local3 - _arg1) * (_local3 - _arg1)) + ((_local4 - _arg2) * (_local4 - _arg2)))));
		}

	}
}//package away3d.core.draw 
Section 54
//IPrimitiveConsumer (away3d.core.draw.IPrimitiveConsumer)
package away3d.core.draw {
	import away3d.containers.*;

	public interface IPrimitiveConsumer {

		function clone():IPrimitiveConsumer;
		function primitive(_arg1:DrawPrimitive):Boolean;
		function clear(_arg1:View3D):void;
		function list():Array;

	}
}//package away3d.core.draw 
Section 55
//IPrimitiveProvider (away3d.core.draw.IPrimitiveProvider)
package away3d.core.draw {
	import away3d.core.base.*;
	import away3d.core.math.*;

	public interface IPrimitiveProvider {

		function primitives(_arg1:Object3D, _arg2:Matrix3D, _arg3:IPrimitiveConsumer):void;

	}
}//package away3d.core.draw 
Section 56
//PrimitiveQuadrantTreeNode (away3d.core.draw.PrimitiveQuadrantTreeNode)
package away3d.core.draw {
	import away3d.core.base.*;

	public final class PrimitiveQuadrantTreeNode {

		public var parent:PrimitiveQuadrantTreeNode;
		public var create:Function;
		private var level:int;
		public var righttopFlag:Boolean;
		public var rightbottom:PrimitiveQuadrantTreeNode;
		public var rightbottomFlag:Boolean;
		public var onlysource:Object3D;
		public var xdiv:Number;
		private var halfheight:Number;
		private var maxlevel:int;// = 4
		private var render_center_length:int;// = -1
		public var onlysourceFlag:Boolean;// = true
		public var center:Array;
		private var render_center_index:int;// = -1
		public var leftbottom:PrimitiveQuadrantTreeNode;
		private var halfwidth:Number;
		public var lefttop:PrimitiveQuadrantTreeNode;
		public var ydiv:Number;
		public var righttop:PrimitiveQuadrantTreeNode;
		public var lefttopFlag:Boolean;
		public var leftbottomFlag:Boolean;

		public function PrimitiveQuadrantTreeNode(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:int, _arg6:PrimitiveQuadrantTreeNode=null){
			render_center_length = -1;
			render_center_index = -1;
			maxlevel = 4;
			center = new Array();
			onlysourceFlag = true;
			super();
			this.level = _arg5;
			this.xdiv = _arg1;
			this.ydiv = _arg2;
			halfwidth = (_arg3 / 2);
			halfheight = (_arg4 / 2);
			this.parent = _arg6;
		}
		public function reset(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			this.xdiv = _arg1;
			this.ydiv = _arg2;
			halfwidth = (_arg3 / 2);
			halfheight = (_arg4 / 2);
			lefttopFlag = false;
			leftbottomFlag = false;
			righttopFlag = false;
			rightbottomFlag = false;
			center.length = 0;
			onlysourceFlag = true;
			onlysource = null;
			render_center_length = -1;
			render_center_index = -1;
		}
		public function push(_arg1:DrawPrimitive):void{
			if (onlysourceFlag){
				if (((!((onlysource == null))) && (!((onlysource == _arg1.source))))){
					onlysourceFlag = false;
				};
				onlysource = _arg1.source;
			};
			if (level < maxlevel){
				if (_arg1.maxX <= xdiv){
					if (_arg1.maxY <= ydiv){
						if (lefttop == null){
							lefttopFlag = true;
							lefttop = new PrimitiveQuadrantTreeNode((xdiv - (halfwidth / 2)), (ydiv - (halfheight / 2)), halfwidth, halfheight, (level + 1), this);
						} else {
							if (!lefttopFlag){
								lefttopFlag = true;
								lefttop.reset((xdiv - (halfwidth / 2)), (ydiv - (halfheight / 2)), halfwidth, halfheight);
							};
						};
						lefttop.push(_arg1);
						return;
					} else {
						if (_arg1.minY >= ydiv){
							if (leftbottom == null){
								leftbottomFlag = true;
								leftbottom = new PrimitiveQuadrantTreeNode((xdiv - (halfwidth / 2)), (ydiv + (halfheight / 2)), halfwidth, halfheight, (level + 1), this);
							} else {
								if (!leftbottomFlag){
									leftbottomFlag = true;
									leftbottom.reset((xdiv - (halfwidth / 2)), (ydiv + (halfheight / 2)), halfwidth, halfheight);
								};
							};
							leftbottom.push(_arg1);
							return;
						};
					};
				} else {
					if (_arg1.minX >= xdiv){
						if (_arg1.maxY <= ydiv){
							if (righttop == null){
								righttopFlag = true;
								righttop = new PrimitiveQuadrantTreeNode((xdiv + (halfwidth / 2)), (ydiv - (halfheight / 2)), halfwidth, halfheight, (level + 1), this);
							} else {
								if (!righttopFlag){
									righttopFlag = true;
									righttop.reset((xdiv + (halfwidth / 2)), (ydiv - (halfheight / 2)), halfwidth, halfheight);
								};
							};
							righttop.push(_arg1);
							return;
						} else {
							if (_arg1.minY >= ydiv){
								if (rightbottom == null){
									rightbottomFlag = true;
									rightbottom = new PrimitiveQuadrantTreeNode((xdiv + (halfwidth / 2)), (ydiv + (halfheight / 2)), halfwidth, halfheight, (level + 1), this);
								} else {
									if (!rightbottomFlag){
										rightbottomFlag = true;
										rightbottom.reset((xdiv + (halfwidth / 2)), (ydiv + (halfheight / 2)), halfwidth, halfheight);
									};
								};
								rightbottom.push(_arg1);
								return;
							};
						};
					};
				};
			};
			center.push(_arg1);
			_arg1.quadrant = this;
		}
		public function render(_arg1:Number):void{
			var _local2:DrawPrimitive;
			if (render_center_length == -1){
				render_center_length = center.length;
				if (render_center_length){
					if (render_center_length > 1){
						center.sortOn("screenZ", (Array.DESCENDING | Array.NUMERIC));
					};
				};
				render_center_index = 0;
			};
			while (render_center_index < render_center_length) {
				_local2 = center[render_center_index];
				if (_local2.screenZ < _arg1){
					break;
				};
				render_other(_local2.screenZ);
				_local2.render();
				render_center_index++;
			};
			render_other(_arg1);
		}
		private function render_other(_arg1:Number):void{
			if (lefttopFlag){
				lefttop.render(_arg1);
			};
			if (leftbottomFlag){
				leftbottom.render(_arg1);
			};
			if (righttopFlag){
				righttop.render(_arg1);
			};
			if (rightbottomFlag){
				rightbottom.render(_arg1);
			};
		}

	}
}//package away3d.core.draw 
Section 57
//ScreenVertex (away3d.core.draw.ScreenVertex)
package away3d.core.draw {
	import away3d.core.base.*;

	public final class ScreenVertex {

		public var vx:Number;
		public var vy:Number;
		private var fbz:Number;
		private var my2:Number;
		public var z:Number;
		private var dx:Number;
		private var dy:Number;
		private var faz:Number;
		public var vectorInstructionType:String;
		private var mx2:Number;
		private var ifmz2:Number;
		public var visible:Boolean;
		public var x:Number;
		public var y:Number;
		private var persp:Number;

		public function ScreenVertex(_arg1:Number=0, _arg2:Number=0, _arg3:Number=0){
			vectorInstructionType = VectorInstructionType.LINE;
			super();
			this.x = _arg1;
			this.y = _arg2;
			this.z = _arg3;
			this.visible = false;
		}
		public function distortSqr(_arg1:ScreenVertex, _arg2:Number):Number{
			faz = (_arg2 + z);
			fbz = (_arg2 + z);
			ifmz2 = (2 / (faz + fbz));
			mx2 = (((x * faz) + (_arg1.x * fbz)) * ifmz2);
			my2 = (((y * faz) + (_arg1.y * fbz)) * ifmz2);
			dx = ((x + _arg1.x) - mx2);
			dy = ((y + _arg1.y) - my2);
			return ((50 * (((dx * dx) + dy) + dy)));
		}
		public function toString():String{
			return ((((((("new ScreenVertex(" + x) + ", ") + y) + ", ") + z) + ")"));
		}
		public function distance(_arg1:ScreenVertex):Number{
			return (Math.sqrt((((x - _arg1.x) * (x - _arg1.x)) + ((y - _arg1.y) * (y - _arg1.y)))));
		}

		public static function median(_arg1:Number, _arg2:Number, _arg3:Array, _arg4:Array, _arg5:Number):void{
			var _local6:int;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:int;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			_local6 = (_arg4[_arg1] * 3);
			_local7 = _arg3[_local6];
			_local8 = _arg3[(_local6 + 1)];
			_local9 = _arg3[(_local6 + 2)];
			_local10 = (_arg4[_arg2] * 3);
			_local11 = _arg3[_local10];
			_local12 = _arg3[(_local10 + 1)];
			_local13 = _arg3[(_local10 + 2)];
			_local14 = ((_local9 + _local13) / 2);
			_local15 = (_arg5 + _local9);
			_local16 = (_arg5 + _local13);
			_local17 = ((1 / (_arg5 + _local14)) / 2);
			_arg3[_arg3.length] = (((_local7 * _local15) + (_local11 * _local16)) * _local17);
			_arg3[_arg3.length] = (((_local8 * _local15) + (_local12 * _local16)) * _local17);
			_arg3[_arg3.length] = _local14;
		}
		public static function weighted(_arg1:ScreenVertex, _arg2:ScreenVertex, _arg3:Number, _arg4:Number, _arg5:Number):ScreenVertex{
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Number;
			var _local19:Number;
			var _local20:Number;
			var _local21:Number;
			if ((((_arg4 == 0)) && ((_arg3 == 0)))){
				throw (new Error("Zero weights"));
			};
			if (_arg4 == 0){
				return (new ScreenVertex(_arg1.x, _arg1.y, _arg1.z));
			};
			if (_arg3 == 0){
				return (new ScreenVertex(_arg2.x, _arg2.y, _arg2.z));
			};
			_local6 = (_arg3 + _arg4);
			_local7 = (_arg3 / _local6);
			_local8 = (_arg4 / _local6);
			_local9 = ((_arg1.x * _local7) + (_arg2.x * _local8));
			_local10 = ((_arg1.y * _local7) + (_arg2.y * _local8));
			_local11 = (_arg1.z / _arg5);
			_local12 = (_arg2.z / _arg5);
			_local13 = (1 + _local11);
			_local14 = (1 + _local12);
			_local15 = ((_arg1.x * _local13) - (_local9 * _local11));
			_local16 = ((_arg2.x * _local14) - (_local9 * _local12));
			_local17 = ((_arg1.y * _local13) - (_local10 * _local11));
			_local18 = ((_arg2.y * _local14) - (_local10 * _local12));
			_local19 = ((_local15 * _local18) - (_local16 * _local17));
			_local20 = ((_local9 * _local18) - (_local16 * _local10));
			_local21 = ((_local15 * _local10) - (_local9 * _local17));
			return (new ScreenVertex(_local9, _local10, (((_local20 * _arg1.z) + (_local21 * _arg2.z)) / _local19)));
		}
		public static function distanceSqr(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Number{
			return ((((_arg1 - _arg3) * (_arg1 - _arg3)) + ((_arg2 - _arg4) * (_arg2 - _arg4))));
		}

	}
}//package away3d.core.draw 
Section 58
//FogFilter (away3d.core.filter.FogFilter)
package away3d.core.filter {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.cameras.*;
	import away3d.core.clip.*;
	import away3d.core.utils.*;
	import away3d.materials.*;

	public class FogFilter implements IPrimitiveFilter {

		private var _subdivisions:int;
		private var _material:IFogMaterial;
		private var _fogPrimitives:Array;
		private var _primitives:Array;
		private var _maxZ:int;
		protected var ini:Init;
		private var _materialsDirty:Boolean;// = true
		private var i:int;
		private var _materials:Array;
		private var _minZ:Number;

		public function FogFilter(_arg1:Object=null):void{
			_materialsDirty = true;
			super();
			ini = Init.parse(_arg1);
			_material = (((ini.getMaterial("material") as IFogMaterial)) || (new ColorMaterial(0)));
			_minZ = ini.getNumber("minZ", 1000, {min:0});
			_maxZ = ini.getNumber("maxZ", 5000, {min:0});
			_subdivisions = ini.getInt("subdivisions", 20, {min:1, max:50});
			_materials = ini.getArray("materials");
		}
		public function updateMaterialColor(_arg1:uint):void{
			var _local2:DrawFog;
			for each (_local2 in _fogPrimitives) {
				if ((_local2.material is ColorMaterial)){
					_local2.material = new ColorMaterial(_arg1, {alpha:_local2.material.alpha});
				};
			};
		}
		public function set minZ(_arg1:Number):void{
			if (_minZ == _arg1){
				return;
			};
			_minZ = _arg1;
			_materialsDirty = true;
		}
		public function set subdivisions(_arg1:Number):void{
			if (_subdivisions == _arg1){
				return;
			};
			_subdivisions = _arg1;
			_materialsDirty = true;
		}
		public function get minZ():Number{
			return (_minZ);
		}
		public function set materials(_arg1:Array):void{
			_materials = _arg1;
			_materialsDirty = true;
		}
		private function updateMaterials():void{
			var _local1:int;
			var _local2:DrawFog;
			_materialsDirty = false;
			if (!_materials.length){
				_local1 = _subdivisions;
				i = _local1;
				while (i--) {
					_materials.push(_material.clone());
				};
			} else {
				_local1 = _materials.length;
			};
			i = _local1;
			_fogPrimitives = new Array();
			while (i--) {
				(_materials[i] as IFogMaterial).alpha = ((0.45 * i) / _local1);
				_local2 = new DrawFog();
				_local2.screenZ = (_minZ + (((_maxZ - _minZ) * i) / (_local1 - 1)));
				_local2.material = _materials[i];
				_fogPrimitives.unshift(_local2);
			};
		}
		public function set material(_arg1:IFogMaterial):void{
			if (!(_arg1 is IFogMaterial)){
				throw (new Error("FogFilter requires IFogMaterial"));
			};
			_material = _arg1;
			_materialsDirty = true;
		}
		public function get material():IFogMaterial{
			return (_material);
		}
		public function set maxZ(_arg1:Number):void{
			if (_maxZ == _arg1){
				return;
			};
			_maxZ = _arg1;
			_materialsDirty = true;
		}
		public function get materials():Array{
			return (_materials);
		}
		public function get subdivisions():Number{
			return (_subdivisions);
		}
		public function get maxZ():Number{
			return (_maxZ);
		}
		public function filter(_arg1:Array, _arg2:Scene3D, _arg3:Camera3D, _arg4:Clipping):Array{
			var _local5:DrawFog;
			var _local6:DrawPrimitive;
			if (_materialsDirty){
				updateMaterials();
			};
			if (((((!(_arg1.length)) || (!(_arg1[0].source)))) || (!((_arg1[0].source.session == _arg2.session))))){
				return (_arg1);
			};
			for each (_local5 in _fogPrimitives) {
				_local5.source = _arg2;
				_local5.clip = _arg4;
				_arg1.push(_local5);
			};
			_primitives = [];
			for each (_local6 in _arg1) {
				if (_local6.screenZ < _maxZ){
					_primitives.push(_local6);
				};
			};
			return (_primitives);
		}
		public function toString():String{
			return ("FogFilter");
		}

	}
}//package away3d.core.filter 
Section 59
//IPrimitiveFilter (away3d.core.filter.IPrimitiveFilter)
package away3d.core.filter {
	import away3d.containers.*;
	import away3d.cameras.*;
	import away3d.core.clip.*;

	public interface IPrimitiveFilter {

		function filter(_arg1:Array, _arg2:Scene3D, _arg3:Camera3D, _arg4:Clipping):Array;

	}
}//package away3d.core.filter 
Section 60
//ZSortFilter (away3d.core.filter.ZSortFilter)
package away3d.core.filter {
	import away3d.containers.*;
	import away3d.cameras.*;
	import away3d.core.clip.*;

	public class ZSortFilter implements IPrimitiveFilter {

		public function filter(_arg1:Array, _arg2:Scene3D, _arg3:Camera3D, _arg4:Clipping):Array{
			_arg1.sortOn("screenZ", (Array.DESCENDING | Array.NUMERIC));
			return (_arg1);
		}
		public function toString():String{
			return ("ZSort");
		}

	}
}//package away3d.core.filter 
Section 61
//Frustum (away3d.core.geom.Frustum)
package away3d.core.geom {
	import away3d.core.base.*;
	import away3d.core.math.*;

	public class Frustum {

		private var _matrix:Matrix3D;
		private var _distance:Number;
		public var planes:Array;

		public static const IN:int = 1;
		public static const OUT:int = 0;
		public static const LEFT:int = 0;
		public static const NEAR:int = 4;
		public static const BOTTOM:int = 3;
		public static const TOP:int = 2;
		public static const FAR:int = 5;
		public static const RIGHT:int = 1;
		public static const INTERSECT:int = 2;

		public function Frustum(){
			_matrix = new Matrix3D();
			super();
			planes = new Array(6);
			planes[LEFT] = new Plane3D();
			planes[RIGHT] = new Plane3D();
			planes[TOP] = new Plane3D();
			planes[BOTTOM] = new Plane3D();
			planes[NEAR] = new Plane3D();
			planes[FAR] = new Plane3D();
		}
		public function classifyAABB(_arg1:Array):int{
			var _local2:int;
			var _local3:int;
			var _local4:Plane3D;
			var _local5:int;
			var _local6:int;
			_local2 = 0;
			_local3 = 0;
			while (_local3 < 6) {
				_local4 = Plane3D(planes[_local3]);
				_local5 = 0;
				_local6 = 0;
				while (_local6 < 8) {
					if (_local4.classifyPoint(_arg1[_local6]) == Plane3D.FRONT){
						_local5++;
					};
					_local6++;
				};
				if (_local5 == 0){
					return (OUT);
				};
				if (_local5 == 8){
					_local2++;
				};
				_local3++;
			};
			if (_local2 == 6){
				return (IN);
			};
			return (INTERSECT);
		}
		public function extractFromMatrix(_arg1:Matrix3D):void{
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Plane3D;
			var _local19:Plane3D;
			var _local20:Plane3D;
			var _local21:Plane3D;
			var _local22:Plane3D;
			var _local23:Plane3D;
			_matrix = _arg1;
			_local2 = _arg1.sxx;
			_local3 = _arg1.sxy;
			_local4 = _arg1.sxz;
			_local5 = _arg1.tx;
			_local6 = _arg1.syx;
			_local7 = _arg1.syy;
			_local8 = _arg1.syz;
			_local9 = _arg1.ty;
			_local10 = _arg1.szx;
			_local11 = _arg1.szy;
			_local12 = _arg1.szz;
			_local13 = _arg1.tz;
			_local14 = _arg1.swx;
			_local15 = _arg1.swy;
			_local16 = _arg1.swz;
			_local17 = _arg1.tw;
			_local18 = Plane3D(planes[NEAR]);
			_local18.a = (_local14 + _local10);
			_local18.b = (_local15 + _local11);
			_local18.c = (_local16 + _local12);
			_local18.d = (_local17 + _local13);
			_local18.normalize();
			_local19 = Plane3D(planes[FAR]);
			_local19.a = (-(_local10) + _local14);
			_local19.b = (-(_local11) + _local15);
			_local19.c = (-(_local12) + _local16);
			_local19.d = (-(_local13) + _local17);
			_local19.normalize();
			_local20 = Plane3D(planes[LEFT]);
			_local20.a = (_local14 + _local2);
			_local20.b = (_local15 + _local3);
			_local20.c = (_local16 + _local4);
			_local20.d = (_local17 + _local5);
			_local20.normalize();
			_local21 = Plane3D(planes[RIGHT]);
			_local21.a = (-(_local2) + _local14);
			_local21.b = (-(_local3) + _local15);
			_local21.c = (-(_local4) + _local16);
			_local21.d = (-(_local5) + _local17);
			_local21.normalize();
			_local22 = Plane3D(planes[TOP]);
			_local22.a = (_local14 + _local6);
			_local22.b = (_local15 + _local7);
			_local22.c = (_local16 + _local8);
			_local22.d = (_local17 + _local9);
			_local22.normalize();
			_local23 = Plane3D(planes[BOTTOM]);
			_local23.a = (-(_local6) + _local14);
			_local23.b = (-(_local7) + _local15);
			_local23.c = (-(_local8) + _local16);
			_local23.d = (-(_local9) + _local17);
			_local23.normalize();
		}
		public function classifySphere(_arg1:Number3D, _arg2:Number):int{
			var _local3:Plane3D;
			for each (_local3 in planes) {
				_distance = _local3.distance(_arg1);
				if (_distance < -(_arg2)){
					return (OUT);
				};
				if (Math.abs(_distance) < _arg2){
					return (INTERSECT);
				};
			};
			return (IN);
		}
		public function classifyObject3D(_arg1:Object3D):int{
			return (classifySphere(_arg1.sceneTransform.position, _arg1.boundingRadius));
		}
		public function classifyRadius(_arg1:Number):int{
			var _local2:Plane3D;
			for each (_local2 in planes) {
				if (_local2.d < -(_arg1)){
					return (OUT);
				};
				if (Math.abs(_local2.d) < _arg1){
					return (INTERSECT);
				};
			};
			return (IN);
		}

	}
}//package away3d.core.geom 
Section 62
//Line2D (away3d.core.geom.Line2D)
package away3d.core.geom {
	import away3d.core.draw.*;

	public class Line2D {

		public var a:Number;
		public var c:Number;
		public var b:Number;

		public function Line2D(_arg1:Number, _arg2:Number, _arg3:Number){
			this.a = _arg1;
			this.b = _arg2;
			this.c = _arg3;
		}
		public function toString():String{
			return ((((((("line{ a: " + a) + " b: ") + b) + " c:") + c) + " }"));
		}
		public function distance(_arg1:ScreenVertex):Number{
			return ((sideV(_arg1) / Math.sqrt(((a * a) + (b * b)))));
		}
		public function side(_arg1:Number, _arg2:Number):Number{
			return ((((a * _arg1) + (b * _arg2)) + c));
		}
		public function sideV(_arg1:ScreenVertex):Number{
			return ((((a * _arg1.x) + (b * _arg1.y)) + c));
		}

		public static function cross(_arg1:Line2D, _arg2:Line2D):ScreenVertex{
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			_local3 = ((_arg1.a * _arg2.b) - (_arg1.b * _arg2.a));
			_local4 = ((_arg1.b * _arg2.c) - (_arg1.c * _arg2.b));
			_local5 = ((_arg2.a * _arg1.c) - (_arg1.a * _arg2.c));
			return (new ScreenVertex((_local4 / _local3), (_local5 / _local3), 0));
		}
		public static function from2points(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):Line2D{
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			_local5 = (_arg4 - _arg2);
			_local6 = (_arg1 - _arg3);
			_local7 = -(((_local6 * _arg2) + (_local5 * _arg1)));
			return (new Line2D(_local5, _local6, _local7));
		}

	}
}//package away3d.core.geom 
Section 63
//Plane3D (away3d.core.geom.Plane3D)
package away3d.core.geom {
	import away3d.core.base.*;
	import away3d.core.math.*;

	public class Plane3D {

		private var _point:Number3D;
		private var _len:Number;
		public var a:Number;
		public var b:Number;
		public var c:Number;
		public var d:Number;

		public static const BACK:int = -1;
		public static const FRONT:int = 1;
		public static const EPSILON:Number = 0.001;
		public static const INTERSECT:int = 0;

		public function Plane3D(_arg1:Number=0, _arg2:Number=0, _arg3:Number=0, _arg4:Number=0){
			_point = new Number3D();
			super();
			this.a = _arg1;
			this.b = _arg2;
			this.c = _arg3;
			this.d = _arg4;
		}
		public function closestPointFrom(_arg1:Number3D):Number3D{
			var _local2:Number3D;
			var _local3:Number;
			_point.x = 0;
			_point.y = 0;
			if (c != 0){
				_point.z = (-(d) / c);
			} else {
				_point.z = (-(d) / b);
			};
			_local2 = new Number3D();
			_local2.sub(_arg1, _point);
			_local3 = (((a * _point.x) + (b * _point.y)) + (c * _point.z));
			_local2.x = (_local2.x - (_local3 * a));
			_local2.y = (_local2.y - (_local3 * b));
			_local2.z = (_local2.z - (_local3 * c));
			return (_local2);
		}
		public function from3vertices(_arg1:Vertex, _arg2:Vertex, _arg3:Vertex):void{
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			_local4 = (_arg2.x - _arg1.x);
			_local5 = (_arg2.y - _arg1.y);
			_local6 = (_arg2.z - _arg1.z);
			_local7 = (_arg3.x - _arg1.x);
			_local8 = (_arg3.y - _arg1.y);
			_local9 = (_arg3.z - _arg1.z);
			a = ((_local5 * _local9) - (_local6 * _local8));
			b = ((_local6 * _local7) - (_local4 * _local9));
			c = ((_local4 * _local8) - (_local5 * _local7));
			d = -((((a * _arg1.x) + (b * _arg1.y)) + (c * _arg1.z)));
		}
		public function fromNormalAndPoint(_arg1:Number3D, _arg2:Number3D):void{
			a = _arg1.x;
			b = _arg1.y;
			c = _arg1.z;
			d = -((((a * _arg2.x) + (b * _arg2.y)) + (c * _arg2.z)));
			_point = _arg1;
		}
		public function normalize():Plane3D{
			var _local1:Number;
			_local1 = Math.sqrt((((a * a) + (b * b)) + (c * c)));
			a = (a / _local1);
			b = (b / _local1);
			c = (c / _local1);
			d = (d / _local1);
			return (this);
		}
		public function transform(_arg1:Matrix3D):void{
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			_local2 = a;
			_local3 = b;
			_local4 = c;
			_local5 = d;
			a = ((((_local2 * _arg1.sxx) + (_local3 * _arg1.syx)) + (_local4 * _arg1.szx)) + (_local5 * _arg1.swx));
			b = ((((_local2 * _arg1.sxy) + (_local3 * _arg1.syy)) + (_local4 * _arg1.szy)) + (_local5 * _arg1.swy));
			c = ((((_local2 * _arg1.sxz) + (_local3 * _arg1.syz)) + (_local4 * _arg1.szz)) + (_local5 * _arg1.swz));
			d = ((((_local2 * _arg1.tx) + (_local3 * _arg1.ty)) + (_local4 * _arg1.tz)) + (_local5 * _arg1.tw));
			normalize();
		}
		public function getIntersectionLine(_arg1:Vertex, _arg2:Vertex):Vertex{
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			_local3 = ((((_point.x * _arg1.x) + (_point.y * _arg1.y)) + (_point.z * _arg1.z)) - d);
			_local4 = ((((_point.x * _arg2.x) + (_point.y * _arg2.y)) + (_point.z * _arg2.z)) - d);
			_local5 = (((((_point.x * _arg2.x) + (_point.y * _arg2.y)) + (_point.z * _arg2.z)) - d) / (_local4 - _local3));
			return (new Vertex((_arg2.x + ((_arg1.x - _arg2.x) * _local5)), (_arg2.y + ((_arg1.y - _arg2.y) * _local5)), (_arg2.z + ((_arg1.z - _arg2.z) * _local5))));
		}
		public function classifyPoint(_arg1:Number3D):int{
			var _local2:Number;
			_local2 = ((((a * _arg1.x) + (b * _arg1.y)) + (c * _arg1.z)) + d);
			if ((((_local2 > -(EPSILON))) && ((_local2 < EPSILON)))){
				return (Plane3D.INTERSECT);
			};
			if (_local2 < 0){
				return (Plane3D.BACK);
			};
			if (_local2 > 0){
				return (Plane3D.FRONT);
			};
			return (Plane3D.INTERSECT);
		}
		public function distance(_arg1:Number3D):Number{
			_len = ((((a * _arg1.x) + (b * _arg1.y)) + (c * _arg1.z)) + d);
			if ((((_len > -(EPSILON))) && ((_len < EPSILON)))){
				_len = 0;
			};
			return (_len);
		}
		public function getIntersectionLineNumbers(_arg1:Number3D, _arg2:Number3D):Number3D{
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			_local3 = ((((_point.x * _arg1.x) + (_point.y * _arg1.y)) + (_point.z * _arg1.z)) - d);
			_local4 = ((((_point.x * _arg2.x) + (_point.y * _arg2.y)) + (_point.z * _arg2.z)) - d);
			_local5 = (((((_point.x * _arg2.x) + (_point.y * _arg2.y)) + (_point.z * _arg2.z)) - d) / (_local4 - _local3));
			return (new Number3D((_arg2.x + ((_arg1.x - _arg2.x) * _local5)), (_arg2.y + ((_arg1.y - _arg2.y) * _local5)), (_arg2.z + ((_arg1.z - _arg2.z) * _local5))));
		}
		public function from3points(_arg1:Number3D, _arg2:Number3D, _arg3:Number3D):void{
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			_local4 = (_arg2.x - _arg1.x);
			_local5 = (_arg2.y - _arg1.y);
			_local6 = (_arg2.z - _arg1.z);
			_local7 = (_arg3.x - _arg1.x);
			_local8 = (_arg3.y - _arg1.y);
			_local9 = (_arg3.z - _arg1.z);
			a = ((_local5 * _local9) - (_local6 * _local8));
			b = ((_local6 * _local7) - (_local4 * _local9));
			c = ((_local4 * _local8) - (_local5 * _local7));
			d = -((((a * _arg1.x) + (b * _arg1.y)) + (c * _arg1.z)));
		}

	}
}//package away3d.core.geom 
Section 64
//AmbientLight (away3d.core.light.AmbientLight)
package away3d.core.light {
	import flash.display.*;
	import away3d.lights.*;

	public class AmbientLight extends LightPrimitive {

		public var light:AmbientLight3D;

		public function updateAmbientBitmap(_arg1:Number):void{
			this.ambient = _arg1;
			ambientBitmap = new BitmapData(0x0100, 0x0100, false, ((int(((_arg1 * red) << 16)) | int(((_arg1 * green) << 8))) | int((_arg1 * blue))));
			ambientBitmap.lock();
		}

	}
}//package away3d.core.light 
Section 65
//DirectionalLight (away3d.core.light.DirectionalLight)
package away3d.core.light {
	import flash.geom.*;
	import flash.display.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.math.*;
	import flash.utils.*;
	import away3d.lights.*;
	import away3d.events.*;
	import flash.filters.*;

	public class DirectionalLight extends LightPrimitive {

		private var mod:Number;
		private var _green:Number;
		public var ambientColorTransform:ColorTransform;
		private var _light:DirectionalLight3D;
		private var _shape:Shape;
		public var normalMatrixDiffuseTransform:Dictionary;
		public var diffuseTransform:Dictionary;
		private var _szx:Number;
		private var _blue:Number;
		private var _szy:Number;
		public var normalMatrixSpecularTransform:Dictionary;
		private var cameraTransform:Matrix3D;
		private var nx:Number;
		private var _szz:Number;
		private var halfVector:Number3D;
		private var _red:Number;
		private var _matrix:Matrix;
		private var cameraDirection:Number3D;
		private var ny:Number;
		private var transform:Matrix3D;
		public var diffuseColorTransform:ColorTransform;
		private var _normalMatrix:ColorMatrixFilter;
		public var specularTransform:Dictionary;
		private var halfTransform:Matrix3D;
		private var direction:Number3D;

		public function DirectionalLight(){
			_normalMatrix = new ColorMatrixFilter();
			_matrix = new Matrix();
			_shape = new Shape();
			transform = new Matrix3D();
			cameraDirection = new Number3D();
			halfVector = new Number3D();
			halfTransform = new Matrix3D();
			direction = new Number3D();
			normalMatrixDiffuseTransform = new Dictionary(true);
			normalMatrixSpecularTransform = new Dictionary(true);
			super();
		}
		public function updateAmbientBitmap():void{
			ambientBitmap = new BitmapData(0x0100, 0x0100, false, ((int((((ambient * red) * 0xFF) << 16)) | int((((ambient * green) * 0xFF) << 8))) | int(((ambient * blue) * 0xFF))));
			ambientBitmap.lock();
			ambientColorTransform = new ColorTransform(1, 1, 1, 1, ((ambient * red) * 0xFF), ((ambient * green) * 0xFF), ((ambient * blue) * 0xFF), 0);
		}
		public function setNormalMatrixSpecularTransform(_arg1:Object3D, _arg2:View3D, _arg3:Number, _arg4:Number):void{
			if (!normalMatrixSpecularTransform[_arg1]){
				normalMatrixSpecularTransform[_arg1] = new Dictionary(true);
			};
			_red = (((red * 2) + _arg4) * _arg3);
			_green = (((green * 2) + _arg4) * _arg3);
			_blue = (((blue * 2) + _arg4) * _arg3);
			_szx = specularTransform[_arg1][_arg2].szx;
			_szy = -(specularTransform[_arg1][_arg2].szy);
			_szz = specularTransform[_arg1][_arg2].szz;
			_normalMatrix.matrix = [(_szx * _red), (_green * _szy), (_blue * _szz), 0, (((-(_red) * 127) * ((_szx + _szy) + _szz)) - ((127 * _arg4) * _arg3)), (_szx * _red), (_green * _szy), (_blue * _szz), 0, (((-(_green) * 127) * ((_szx + _szy) + _szz)) - ((127 * _arg4) * _arg3)), (_szx * _red), (_green * _szy), (_blue * _szz), 0, (((-(_blue) * 127) * ((_szx + _szy) + _szz)) - ((127 * _arg4) * _arg3)), 0, 0, 0, 1, 0];
			normalMatrixSpecularTransform[_arg1][_arg2] = _normalMatrix.clone();
		}
		public function get light():DirectionalLight3D{
			return (_light);
		}
		public function setSpecularTransform(_arg1:Object3D, _arg2:View3D):void{
			cameraTransform = _arg2.camera.transform;
			cameraDirection.x = -(cameraTransform.sxz);
			cameraDirection.y = -(cameraTransform.syz);
			cameraDirection.z = -(cameraTransform.szz);
			halfVector.add(cameraDirection, direction);
			halfVector.normalize();
			nx = halfVector.x;
			ny = halfVector.y;
			mod = Math.sqrt(((nx * nx) + (ny * ny)));
			halfTransform.rotationMatrix((-(ny) / mod), (nx / mod), 0, Math.acos(-(halfVector.z)));
			if (!specularTransform[_arg1][_arg2]){
				specularTransform[_arg1][_arg2] = new Matrix3D();
			};
			specularTransform[_arg1][_arg2].multiply3x3(halfTransform, _arg1.sceneTransform);
			specularTransform[_arg1][_arg2].normalize(specularTransform[_arg1][_arg2]);
		}
		public function updateDirection(_arg1:Object3DEvent):void{
			direction.x = _light.x;
			direction.y = _light.y;
			direction.z = _light.z;
			direction.normalize();
			nx = direction.x;
			ny = direction.y;
			mod = Math.sqrt(((nx * nx) + (ny * ny)));
			transform.rotationMatrix((ny / mod), (-(nx) / mod), 0, -(Math.acos(-(direction.z))));
			clearTransform();
		}
		public function clearTransform():void{
			diffuseTransform = new Dictionary(true);
			specularTransform = new Dictionary(true);
			normalMatrixDiffuseTransform = new Dictionary(true);
			normalMatrixSpecularTransform = new Dictionary(true);
		}
		public function setDiffuseTransform(_arg1:Object3D):void{
			if (!diffuseTransform[_arg1]){
				diffuseTransform[_arg1] = new Matrix3D();
			};
			diffuseTransform[_arg1].multiply3x3(transform, _arg1.sceneTransform);
			diffuseTransform[_arg1].normalize(diffuseTransform[_arg1]);
		}
		public function setNormalMatrixDiffuseTransform(_arg1:Object3D):void{
			_red = ((red * 2) * diffuse);
			_green = ((green * 2) * diffuse);
			_blue = ((blue * 2) * diffuse);
			_szx = diffuseTransform[_arg1].szx;
			_szy = -(diffuseTransform[_arg1].szy);
			_szz = diffuseTransform[_arg1].szz;
			_normalMatrix.matrix = [(_szx * _red), (_green * _szy), (_blue * _szz), 0, ((-(_red) * 127) * ((_szx + _szy) + _szz)), (_szx * _red), (_green * _szy), (_blue * _szz), 0, ((-(_green) * 127) * ((_szx + _szy) + _szz)), (_szx * _red), (_green * _szy), (_blue * _szz), 0, ((-(_blue) * 127) * ((_szx + _szy) + _szz)), 0, 0, 0, 1, 0];
			normalMatrixDiffuseTransform[_arg1] = _normalMatrix.clone();
		}
		public function set light(_arg1:DirectionalLight3D):void{
			_light = _arg1;
			_arg1.addOnSceneTransformChange(updateDirection);
		}
		public function updateAmbientDiffuseBitmap():void{
			var _local1:Array;
			var _local2:Array;
			var _local3:Array;
			var _local4:int;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			ambientDiffuseBitmap = new BitmapData(0x0100, 0x0100, false, 0);
			ambientDiffuseBitmap.lock();
			_matrix.createGradientBox(0x0100, 0x0100, 0, 0, 0);
			_local1 = [];
			_local2 = [];
			_local3 = [];
			_local4 = 15;
			while (_local4--) {
				_local5 = (((_local4 * diffuse) / 14) + ambient);
				if (_local5 > 1){
					_local5 = 1;
				};
				_local6 = (((_local4 * diffuse) / 14) + ambient);
				if (_local6 > 1){
					_local6 = 1;
				};
				_local7 = (((_local4 * diffuse) / 14) + ambient);
				if (_local7 > 1){
					_local7 = 1;
				};
				_local1.push((((((_local5 * red) * 0xFF) << 16) | (((_local6 * green) * 0xFF) << 8)) | ((_local7 * blue) * 0xFF)));
				_local2.push(1);
				_local3.push(int((30 + (((225 * 2) * Math.acos((_local4 / 14))) / Math.PI))));
			};
			_shape.graphics.clear();
			_shape.graphics.beginGradientFill(GradientType.LINEAR, _local1, _local2, _local3, _matrix);
			_shape.graphics.drawRect(0, 0, 0x0100, 0x0100);
			ambientDiffuseBitmap.draw(_shape);
		}
		public function updateDiffuseBitmap():void{
			var _local1:Array;
			var _local2:Array;
			var _local3:Array;
			var _local4:int;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			diffuseBitmap = new BitmapData(0x0100, 0x0100, false, 0);
			diffuseBitmap.lock();
			_matrix.createGradientBox(0x0100, 0x0100, 0, 0, 0);
			_local1 = [];
			_local2 = [];
			_local3 = [];
			_local4 = 15;
			while (_local4--) {
				_local5 = ((_local4 * diffuse) / 14);
				if (_local5 > 1){
					_local5 = 1;
				};
				_local6 = ((_local4 * diffuse) / 14);
				if (_local6 > 1){
					_local6 = 1;
				};
				_local7 = ((_local4 * diffuse) / 14);
				if (_local7 > 1){
					_local7 = 1;
				};
				_local1.push((((((_local5 * red) * 0xFF) << 16) | (((_local6 * green) * 0xFF) << 8)) | ((_local7 * blue) * 0xFF)));
				_local2.push(1);
				_local3.push(int((30 + (((225 * 2) * Math.acos((_local4 / 14))) / Math.PI))));
			};
			_shape.graphics.clear();
			_shape.graphics.beginGradientFill(GradientType.LINEAR, _local1, _local2, _local3, _matrix);
			_shape.graphics.drawRect(0, 0, 0x0100, 0x0100);
			diffuseBitmap.draw(_shape);
			diffuseColorTransform = new ColorTransform((diffuse * red), (diffuse * green), (diffuse * blue), 1, 0, 0, 0, 0);
		}
		public function updateSpecularBitmap():void{
			var _local1:Array;
			var _local2:Array;
			var _local3:Array;
			var _local4:int;
			specularBitmap = new BitmapData(0x0200, 0x0200, false, 0);
			specularBitmap.lock();
			_matrix.createGradientBox(0x0200, 0x0200, 0, 0, 0);
			_local1 = [];
			_local2 = [];
			_local3 = [];
			_local4 = 15;
			while (_local4--) {
				_local1.push((((((((_local4 * specular) * red) * 0xFF) / 14) << 16) + (((((_local4 * specular) * green) * 0xFF) / 14) << 8)) + ((((_local4 * specular) * blue) * 0xFF) / 14)));
				_local2.push(1);
				_local3.push(int((30 + (((225 * 2) * Math.acos(Math.pow((_local4 / 14), (1 / 20)))) / Math.PI))));
			};
			_shape.graphics.clear();
			_shape.graphics.beginGradientFill(GradientType.RADIAL, _local1, _local2, _local3, _matrix);
			_shape.graphics.drawCircle(0xFF, 0xFF, 0xFF);
			specularBitmap.draw(_shape);
		}

	}
}//package away3d.core.light 
Section 66
//ILightConsumer (away3d.core.light.ILightConsumer)
package away3d.core.light {

	public interface ILightConsumer {

		function get points():Array;
		function pointLight(_arg1:PointLight):void;
		function get directionals():Array;
		function get numLights():int;
		function directionalLight(_arg1:DirectionalLight):void;
		function clear():void;
		function get ambients():Array;
		function ambientLight(_arg1:AmbientLight):void;

	}
}//package away3d.core.light 
Section 67
//ILightProvider (away3d.core.light.ILightProvider)
package away3d.core.light {
	import away3d.core.base.*;

	public interface ILightProvider {

		function get debug():Boolean;
		function get debugPrimitive():Object3D;
		function light(_arg1:ILightConsumer):void;

	}
}//package away3d.core.light 
Section 68
//LightArray (away3d.core.light.LightArray)
package away3d.core.light {

	public class LightArray implements ILightConsumer {

		private var _points:Array;
		private var _numLights:int;
		private var _directionals:Array;
		private var _ambients:Array;

		public function get numLights():int{
			return (_numLights);
		}
		public function get directionals():Array{
			return (_directionals);
		}
		public function directionalLight(_arg1:DirectionalLight):void{
			_directionals.push(_arg1);
			_numLights++;
		}
		public function clear():void{
			_ambients = [];
			_directionals = [];
			_points = [];
			_numLights = 0;
		}
		public function get ambients():Array{
			return (_ambients);
		}
		public function get points():Array{
			return (_points);
		}
		public function ambientLight(_arg1:AmbientLight):void{
			_ambients.push(_arg1);
			_numLights++;
		}
		public function pointLight(_arg1:PointLight):void{
			_points.push(_arg1);
			_numLights++;
		}

	}
}//package away3d.core.light 
Section 69
//LightPrimitive (away3d.core.light.LightPrimitive)
package away3d.core.light {
	import flash.display.*;

	public class LightPrimitive {

		public var green:Number;
		public var specular:Number;
		public var red:Number;
		public var radius:Number;
		public var ambient:Number;
		public var specularBitmap:BitmapData;
		public var blue:Number;
		public var ambientBitmap:BitmapData;
		public var diffuse:Number;
		public var diffuseBitmap:BitmapData;
		public var ambientDiffuseBitmap:BitmapData;
		public var fallOff:Number;

	}
}//package away3d.core.light 
Section 70
//PointLight (away3d.core.light.PointLight)
package away3d.core.light {
	import away3d.containers.*;
	import away3d.core.math.*;
	import flash.utils.*;
	import away3d.lights.*;
	import away3d.events.*;

	public class PointLight extends LightPrimitive {

		public var viewPositions:Dictionary;
		private var _light:PointLight3D;

		public function get light():PointLight3D{
			return (_light);
		}
		public function updatePosition(_arg1:Object3DEvent):void{
			clearViewPositions();
		}
		public function set light(_arg1:PointLight3D):void{
			_light = _arg1;
			_arg1.addOnSceneTransformChange(updatePosition);
		}
		public function setViewPosition(_arg1:View3D):void{
			if (!viewPositions[_arg1]){
				viewPositions[_arg1] = new Number3D();
			};
			viewPositions[_arg1].clone(_arg1.cameraVarsStore.viewTransformDictionary[_light].position);
		}
		public function clearViewPositions():void{
			viewPositions = new Dictionary(true);
		}

	}
}//package away3d.core.light 
Section 71
//Matrix3D (away3d.core.math.Matrix3D)
package away3d.core.math {

	public final class Matrix3D {

		private var xx:Number;
		private var xy:Number;
		private var xz:Number;
		private var _right:Number3D;
		private var yw:Number;
		private var yy:Number;
		private var yz:Number;
		private var scos:Number;
		private var nCos:Number;
		private var zw:Number;
		private var _up:Number3D;
		private var m211:Number;
		private var m213:Number;
		private var m212:Number;
		private var m214:Number;
		private var suv:Number;
		private var zz:Number;
		private var suw:Number;
		private var su:Number;
		private var sv:Number;
		private var m221:Number;
		private var m222:Number;
		private var m223:Number;
		private var m224:Number;
		private var sw:Number;
		private var d:Number;
		private var w:Number;
		private var x:Number;
		private var y:Number;
		private var z:Number;
		private var svw:Number;
		private var m231:Number;
		private var m111:Number;
		private var m112:Number;
		private var _forward:Number3D;
		private var m114:Number;
		private var _position:Number3D;
		public var tw:Number;// = 1
		private var m232:Number;
		private var m233:Number;
		private var m113:Number;
		public var swz:Number;// = 0
		private var nSin:Number;
		public var swx:Number;// = 0
		public var tx:Number;// = 0
		public var ty:Number;// = 0
		private var m234:Number;
		private var m241:Number;
		private var m121:Number;
		private var m122:Number;
		private var m123:Number;
		private var m124:Number;
		private var m243:Number;
		private var m244:Number;
		private var m242:Number;
		public var sxx:Number;// = 1
		public var sxy:Number;// = 0
		public var sxz:Number;// = 0
		public var swy:Number;// = 0
		public var tz:Number;// = 0
		private var m131:Number;
		private var m132:Number;
		private var m133:Number;
		private var m134:Number;
		public var syx:Number;// = 0
		public var syz:Number;// = 0
		public var syy:Number;// = 1
		private var m141:Number;
		private var m142:Number;
		private var m143:Number;
		private var m144:Number;
		public var szx:Number;// = 0
		public var szz:Number;// = 1
		public var szy:Number;// = 0
		private var xw:Number;

		public function Matrix3D(){
			_position = new Number3D();
			_forward = new Number3D();
			_up = new Number3D();
			_right = new Number3D();
			sxx = 1;
			sxy = 0;
			sxz = 0;
			tx = 0;
			syx = 0;
			syy = 1;
			syz = 0;
			ty = 0;
			szx = 0;
			szy = 0;
			szz = 1;
			tz = 0;
			swx = 0;
			swy = 0;
			swz = 0;
			tw = 1;
			super();
		}
		public function get det():Number{
			return ((((((sxx * syy) - (syx * sxy)) * szz) - (((sxx * szy) - (szx * sxy)) * syz)) + (((syx * szy) - (szx * syy)) * sxz)));
		}
		public function normalize(_arg1:Matrix3D):void{
			d = Math.sqrt((((sxx * sxx) + (sxy * sxy)) + (sxz * sxz)));
			sxx = (sxx / d);
			sxy = (sxy / d);
			sxz = (sxz / d);
			d = Math.sqrt((((syx * syx) + (syy * syy)) + (syz * syz)));
			syx = (syx / d);
			syy = (syy / d);
			syz = (syz / d);
			d = Math.sqrt((((szx * szx) + (szy * szy)) + (szz * szz)));
			szx = (szx / d);
			szy = (szy / d);
			szz = (szz / d);
		}
		public function get right():Number3D{
			_right.x = sxx;
			_right.y = sxy;
			_right.z = sxz;
			return (_right);
		}
		public function get position():Number3D{
			_position.x = tx;
			_position.y = ty;
			_position.z = tz;
			return (_position);
		}
		public function multiply(_arg1:Matrix3D, _arg2:Matrix3D):void{
			m111 = _arg1.sxx;
			m211 = _arg2.sxx;
			m121 = _arg1.syx;
			m221 = _arg2.syx;
			m131 = _arg1.szx;
			m231 = _arg2.szx;
			m112 = _arg1.sxy;
			m212 = _arg2.sxy;
			m122 = _arg1.syy;
			m222 = _arg2.syy;
			m132 = _arg1.szy;
			m232 = _arg2.szy;
			m113 = _arg1.sxz;
			m213 = _arg2.sxz;
			m123 = _arg1.syz;
			m223 = _arg2.syz;
			m133 = _arg1.szz;
			m233 = _arg2.szz;
			m114 = _arg1.tx;
			m214 = _arg2.tx;
			m124 = _arg1.ty;
			m224 = _arg2.ty;
			m134 = _arg1.tz;
			m234 = _arg2.tz;
			sxx = (((m111 * m211) + (m112 * m221)) + (m113 * m231));
			sxy = (((m111 * m212) + (m112 * m222)) + (m113 * m232));
			sxz = (((m111 * m213) + (m112 * m223)) + (m113 * m233));
			tx = ((((m111 * m214) + (m112 * m224)) + (m113 * m234)) + m114);
			syx = (((m121 * m211) + (m122 * m221)) + (m123 * m231));
			syy = (((m121 * m212) + (m122 * m222)) + (m123 * m232));
			syz = (((m121 * m213) + (m122 * m223)) + (m123 * m233));
			ty = ((((m121 * m214) + (m122 * m224)) + (m123 * m234)) + m124);
			szx = (((m131 * m211) + (m132 * m221)) + (m133 * m231));
			szy = (((m131 * m212) + (m132 * m222)) + (m133 * m232));
			szz = (((m131 * m213) + (m132 * m223)) + (m133 * m233));
			tz = ((((m131 * m214) + (m132 * m224)) + (m133 * m234)) + m134);
		}
		public function inverse(_arg1:Matrix3D):void{
			d = _arg1.det;
			if (Math.abs(d) < 0.001){
				return;
			};
			d = (1 / d);
			m111 = _arg1.sxx;
			m121 = _arg1.syx;
			m131 = _arg1.szx;
			m112 = _arg1.sxy;
			m122 = _arg1.syy;
			m132 = _arg1.szy;
			m113 = _arg1.sxz;
			m123 = _arg1.syz;
			m133 = _arg1.szz;
			m114 = _arg1.tx;
			m124 = _arg1.ty;
			m134 = _arg1.tz;
			sxx = (d * ((m122 * m133) - (m132 * m123)));
			sxy = (-(d) * ((m112 * m133) - (m132 * m113)));
			sxz = (d * ((m112 * m123) - (m122 * m113)));
			tx = (-(d) * (((m112 * ((m123 * m134) - (m133 * m124))) - (m122 * ((m113 * m134) - (m133 * m114)))) + (m132 * ((m113 * m124) - (m123 * m114)))));
			syx = (-(d) * ((m121 * m133) - (m131 * m123)));
			syy = (d * ((m111 * m133) - (m131 * m113)));
			syz = (-(d) * ((m111 * m123) - (m121 * m113)));
			ty = (d * (((m111 * ((m123 * m134) - (m133 * m124))) - (m121 * ((m113 * m134) - (m133 * m114)))) + (m131 * ((m113 * m124) - (m123 * m114)))));
			szx = (d * ((m121 * m132) - (m131 * m122)));
			szy = (-(d) * ((m111 * m132) - (m131 * m112)));
			szz = (d * ((m111 * m122) - (m121 * m112)));
			tz = (-(d) * (((m111 * ((m122 * m134) - (m132 * m124))) - (m121 * ((m112 * m134) - (m132 * m114)))) + (m131 * ((m112 * m124) - (m122 * m114)))));
		}
		public function set up(_arg1:Number3D):void{
			this.syx = _arg1.x;
			this.syy = _arg1.y;
			this.syz = _arg1.z;
		}
		public function set right(_arg1:Number3D):void{
			this.sxx = _arg1.x;
			this.sxy = _arg1.y;
			this.sxz = _arg1.z;
		}
		public function multiply4x3(_arg1:Matrix3D, _arg2:Matrix3D):void{
			m111 = _arg1.sxx;
			m211 = _arg2.sxx;
			m121 = _arg1.syx;
			m221 = _arg2.syx;
			m131 = _arg1.szx;
			m231 = _arg2.szx;
			m112 = _arg1.sxy;
			m212 = _arg2.sxy;
			m122 = _arg1.syy;
			m222 = _arg2.syy;
			m132 = _arg1.szy;
			m232 = _arg2.szy;
			m113 = _arg1.sxz;
			m213 = _arg2.sxz;
			m123 = _arg1.syz;
			m223 = _arg2.syz;
			m133 = _arg1.szz;
			m233 = _arg2.szz;
			m114 = _arg1.tx;
			m214 = _arg2.tx;
			m124 = _arg1.ty;
			m224 = _arg2.ty;
			m134 = _arg1.tz;
			m234 = _arg2.tz;
			m141 = _arg1.swx;
			m241 = _arg2.swx;
			m142 = _arg1.swy;
			m242 = _arg2.swy;
			m143 = _arg1.swz;
			m243 = _arg2.swz;
			m144 = _arg1.tw;
			m244 = _arg2.tw;
			sxx = (((m111 * m211) + (m112 * m221)) + (m113 * m231));
			sxy = (((m111 * m212) + (m112 * m222)) + (m113 * m232));
			sxz = (((m111 * m213) + (m112 * m223)) + (m113 * m233));
			tx = ((((m111 * m214) + (m112 * m224)) + (m113 * m234)) + m114);
			syx = (((m121 * m211) + (m122 * m221)) + (m123 * m231));
			syy = (((m121 * m212) + (m122 * m222)) + (m123 * m232));
			syz = (((m121 * m213) + (m122 * m223)) + (m123 * m233));
			ty = ((((m121 * m214) + (m122 * m224)) + (m123 * m234)) + m124);
			szx = (((m131 * m211) + (m132 * m221)) + (m133 * m231));
			szy = (((m131 * m212) + (m132 * m222)) + (m133 * m232));
			szz = (((m131 * m213) + (m132 * m223)) + (m133 * m233));
			tz = ((((m131 * m214) + (m132 * m224)) + (m133 * m234)) + m134);
			swx = (((m141 * m211) + (m142 * m221)) + (m143 * m231));
			swy = (((m141 * m212) + (m142 * m222)) + (m143 * m232));
			swz = (((m141 * m213) + (m142 * m223)) + (m143 * m233));
			tw = ((((m141 * m214) + (m142 * m224)) + (m143 * m234)) + m144);
		}
		public function multiplyVector3x3(_arg1:Number3D):void{
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			_local2 = _arg1.x;
			_local3 = _arg1.y;
			_local4 = _arg1.z;
			_arg1.x = (((_local2 * sxx) + (_local3 * sxy)) + (_local4 * sxz));
			_arg1.y = (((_local2 * syx) + (_local3 * syy)) + (_local4 * syz));
			_arg1.z = (((_local2 * szx) + (_local3 * szy)) + (_local4 * szz));
		}
		public function multiply4x4(_arg1:Matrix3D, _arg2:Matrix3D):void{
			m111 = _arg1.sxx;
			m211 = _arg2.sxx;
			m121 = _arg1.syx;
			m221 = _arg2.syx;
			m131 = _arg1.szx;
			m231 = _arg2.szx;
			m141 = _arg1.swx;
			m241 = _arg2.swx;
			m112 = _arg1.sxy;
			m212 = _arg2.sxy;
			m122 = _arg1.syy;
			m222 = _arg2.syy;
			m132 = _arg1.szy;
			m232 = _arg2.szy;
			m142 = _arg1.swy;
			m242 = _arg2.swy;
			m113 = _arg1.sxz;
			m213 = _arg2.sxz;
			m123 = _arg1.syz;
			m223 = _arg2.syz;
			m133 = _arg1.szz;
			m233 = _arg2.szz;
			m143 = _arg1.swz;
			m243 = _arg2.swz;
			m114 = _arg1.tx;
			m214 = _arg2.tx;
			m124 = _arg1.ty;
			m224 = _arg2.ty;
			m134 = _arg1.tz;
			m234 = _arg2.tz;
			m144 = _arg1.tw;
			m244 = _arg2.tw;
			sxx = ((((m111 * m211) + (m112 * m221)) + (m113 * m231)) + (m114 * m241));
			sxy = ((((m111 * m212) + (m112 * m222)) + (m113 * m232)) + (m114 * m242));
			sxz = ((((m111 * m213) + (m112 * m223)) + (m113 * m233)) + (m114 * m243));
			tx = ((((m111 * m214) + (m112 * m224)) + (m113 * m234)) + (m114 * m244));
			syx = ((((m121 * m211) + (m122 * m221)) + (m123 * m231)) + (m124 * m241));
			syy = ((((m121 * m212) + (m122 * m222)) + (m123 * m232)) + (m124 * m242));
			syz = ((((m121 * m213) + (m122 * m223)) + (m123 * m233)) + (m124 * m243));
			ty = ((((m121 * m214) + (m122 * m224)) + (m123 * m234)) + (m124 * m244));
			szx = ((((m131 * m211) + (m132 * m221)) + (m133 * m231)) + (m134 * m241));
			szy = ((((m131 * m212) + (m132 * m222)) + (m133 * m232)) + (m134 * m242));
			szz = ((((m131 * m213) + (m132 * m223)) + (m133 * m233)) + (m134 * m243));
			tz = ((((m131 * m214) + (m132 * m224)) + (m133 * m234)) + (m134 * m244));
			swx = ((((m141 * m211) + (m142 * m221)) + (m143 * m231)) + (m144 * m241));
			swy = ((((m141 * m212) + (m142 * m222)) + (m143 * m232)) + (m144 * m242));
			swz = ((((m141 * m213) + (m142 * m223)) + (m143 * m233)) + (m144 * m243));
			tw = ((((m141 * m214) + (m142 * m224)) + (m143 * m234)) + (m144 * m244));
		}
		public function scale(_arg1:Matrix3D, _arg2:Number, _arg3:Number, _arg4:Number):void{
			sxx = (_arg1.sxx * _arg2);
			syx = (_arg1.syx * _arg2);
			szx = (_arg1.szx * _arg2);
			sxy = (_arg1.sxy * _arg3);
			syy = (_arg1.syy * _arg3);
			szy = (_arg1.szy * _arg3);
			sxz = (_arg1.sxz * _arg4);
			syz = (_arg1.syz * _arg4);
			szz = (_arg1.szz * _arg4);
		}
		public function perspectiveProjectionMatrix(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			_local5 = ((_arg1 / 2) * (Math.PI / 180));
			_local6 = Math.tan(_local5);
			_local7 = (1 / _local6);
			sxx = (_local7 / _arg2);
			sxy = (sxz = (tx = 0));
			syy = _local7;
			syx = (syz = (ty = 0));
			szx = (szy = 0);
			szz = -(((_arg3 + _arg4) / (_arg3 - _arg4)));
			tz = (((2 * _arg4) * _arg3) / (_arg3 - _arg4));
			swx = (swy = (tw = 0));
			swz = 1;
		}
		public function clone(_arg1:Matrix3D):Matrix3D{
			sxx = _arg1.sxx;
			sxy = _arg1.sxy;
			sxz = _arg1.sxz;
			tx = _arg1.tx;
			syx = _arg1.syx;
			syy = _arg1.syy;
			syz = _arg1.syz;
			ty = _arg1.ty;
			szx = _arg1.szx;
			szy = _arg1.szy;
			szz = _arg1.szz;
			tz = _arg1.tz;
			swx = _arg1.swx;
			swy = _arg1.swy;
			swz = _arg1.swz;
			tw = _arg1.tw;
			return (_arg1);
		}
		public function toString():String{
			var _local1:String;
			_local1 = "";
			_local1 = (_local1 + ((((((((int((sxx * 1000)) / 1000) + "\t\t") + (int((sxy * 1000)) / 1000)) + "\t\t") + (int((sxz * 1000)) / 1000)) + "\t\t") + (int((tx * 1000)) / 1000)) + "\n"));
			_local1 = (_local1 + ((((((((int((syx * 1000)) / 1000) + "\t\t") + (int((syy * 1000)) / 1000)) + "\t\t") + (int((syz * 1000)) / 1000)) + "\t\t") + (int((ty * 1000)) / 1000)) + "\n"));
			_local1 = (_local1 + ((((((((int((szx * 1000)) / 1000) + "\t\t") + (int((szy * 1000)) / 1000)) + "\t\t") + (int((szz * 1000)) / 1000)) + "\t\t") + (int((tz * 1000)) / 1000)) + "\n"));
			_local1 = (_local1 + ((((((((int((swx * 1000)) / 1000) + "\t\t") + (int((swy * 1000)) / 1000)) + "\t\t") + (int((swz * 1000)) / 1000)) + "\t\t") + (int((tw * 1000)) / 1000)) + "\n"));
			return (_local1);
		}
		public function copy3x3(_arg1:Matrix3D):Matrix3D{
			sxx = _arg1.sxx;
			sxy = _arg1.sxy;
			sxz = _arg1.sxz;
			syx = _arg1.syx;
			syy = _arg1.syy;
			syz = _arg1.syz;
			szx = _arg1.szx;
			szy = _arg1.szy;
			szz = _arg1.szz;
			return (this);
		}
		public function clear():void{
			tx = (sxy = (sxz = (syz = (ty = (syz = (szx = (szy = (tz = 0))))))));
			sxx = (syy = (szz = 1));
		}
		public function scaleMatrix(_arg1:Number, _arg2:Number, _arg3:Number):void{
			tx = (sxy = (sxz = 0));
			syz = (ty = (syz = 0));
			szx = (szy = (tz = 0));
			sxx = _arg1;
			syy = _arg2;
			szz = _arg3;
		}
		public function get up():Number3D{
			_up.x = syx;
			_up.y = syy;
			_up.z = syz;
			return (_up);
		}
		public function inverse4x4(_arg1:Matrix3D):void{
			d = _arg1.det4x4;
			if (Math.abs(d) < 0.001){
				return;
			};
			d = (1 / d);
			m111 = _arg1.sxx;
			m121 = _arg1.syx;
			m131 = _arg1.szx;
			m141 = _arg1.swx;
			m112 = _arg1.sxy;
			m122 = _arg1.syy;
			m132 = _arg1.szy;
			m142 = _arg1.swy;
			m113 = _arg1.sxz;
			m123 = _arg1.syz;
			m133 = _arg1.szz;
			m143 = _arg1.swz;
			m114 = _arg1.tx;
			m124 = _arg1.ty;
			m134 = _arg1.tz;
			m144 = _arg1.tw;
			sxx = (d * (((m122 * ((m133 * m144) - (m143 * m134))) - (m132 * ((m123 * m144) - (m143 * m124)))) + (m142 * ((m123 * m134) - (m133 * m124)))));
			sxy = (-(d) * (((m112 * ((m133 * m144) - (m143 * m134))) - (m132 * ((m113 * m144) - (m143 * m114)))) + (m142 * ((m113 * m134) - (m133 * m114)))));
			sxz = (d * (((m112 * ((m123 * m144) - (m143 * m124))) - (m122 * ((m113 * m144) - (m143 * m114)))) + (m142 * ((m113 * m124) - (m123 * m114)))));
			tx = (-(d) * (((m112 * ((m123 * m134) - (m133 * m124))) - (m122 * ((m113 * m134) - (m133 * m114)))) + (m132 * ((m113 * m124) - (m123 * m114)))));
			syx = (-(d) * (((m121 * ((m133 * m144) - (m143 * m134))) - (m131 * ((m123 * m144) - (m143 * m124)))) + (m141 * ((m123 * m134) - (m133 * m124)))));
			syy = (d * (((m111 * ((m133 * m144) - (m143 * m134))) - (m131 * ((m113 * m144) - (m143 * m114)))) + (m141 * ((m113 * m134) - (m133 * m114)))));
			syz = (-(d) * (((m111 * ((m123 * m144) - (m143 * m124))) - (m121 * ((m113 * m144) - (m143 * m114)))) + (m141 * ((m113 * m124) - (m123 * m114)))));
			ty = (d * (((m111 * ((m123 * m134) - (m133 * m124))) - (m121 * ((m113 * m134) - (m133 * m114)))) + (m131 * ((m113 * m124) - (m123 * m114)))));
			szx = (d * (((m121 * ((m132 * m144) - (m142 * m134))) - (m131 * ((m122 * m144) - (m142 * m124)))) + (m141 * ((m122 * m134) - (m132 * m124)))));
			szy = (-(d) * (((m111 * ((m132 * m144) - (m142 * m134))) - (m131 * ((m112 * m144) - (m142 * m114)))) + (m141 * ((m112 * m134) - (m132 * m114)))));
			szz = (d * (((m111 * ((m122 * m144) - (m142 * m124))) - (m121 * ((m112 * m144) - (m142 * m114)))) + (m141 * ((m112 * m124) - (m122 * m114)))));
			tz = (-(d) * (((m111 * ((m122 * m134) - (m132 * m124))) - (m121 * ((m112 * m134) - (m132 * m114)))) + (m131 * ((m112 * m124) - (m122 * m114)))));
			swx = (-(d) * (((m121 * ((m132 * m143) - (m142 * m133))) - (m131 * ((m122 * m143) - (m142 * m123)))) + (m141 * ((m122 * m133) - (m132 * m123)))));
			swy = (d * (((m111 * ((m132 * m143) - (m142 * m133))) - (m131 * ((m112 * m143) - (m142 * m113)))) + (m141 * ((m112 * m133) - (m132 * m113)))));
			swz = (-(d) * (((m111 * ((m122 * m143) - (m142 * m123))) - (m121 * ((m112 * m143) - (m142 * m113)))) + (m141 * ((m112 * m123) - (m122 * m113)))));
			tw = (d * (((m111 * ((m122 * m133) - (m132 * m123))) - (m121 * ((m112 * m133) - (m132 * m113)))) + (m131 * ((m112 * m123) - (m122 * m113)))));
		}
		public function multiply3x3(_arg1:Matrix3D, _arg2:Matrix3D):void{
			m111 = _arg1.sxx;
			m211 = _arg2.sxx;
			m121 = _arg1.syx;
			m221 = _arg2.syx;
			m131 = _arg1.szx;
			m231 = _arg2.szx;
			m112 = _arg1.sxy;
			m212 = _arg2.sxy;
			m122 = _arg1.syy;
			m222 = _arg2.syy;
			m132 = _arg1.szy;
			m232 = _arg2.szy;
			m113 = _arg1.sxz;
			m213 = _arg2.sxz;
			m123 = _arg1.syz;
			m223 = _arg2.syz;
			m133 = _arg1.szz;
			m233 = _arg2.szz;
			sxx = (((m111 * m211) + (m112 * m221)) + (m113 * m231));
			sxy = (((m111 * m212) + (m112 * m222)) + (m113 * m232));
			sxz = (((m111 * m213) + (m112 * m223)) + (m113 * m233));
			syx = (((m121 * m211) + (m122 * m221)) + (m123 * m231));
			syy = (((m121 * m212) + (m122 * m222)) + (m123 * m232));
			syz = (((m121 * m213) + (m122 * m223)) + (m123 * m233));
			szx = (((m131 * m211) + (m132 * m221)) + (m133 * m231));
			szy = (((m131 * m212) + (m132 * m222)) + (m133 * m232));
			szz = (((m131 * m213) + (m132 * m223)) + (m133 * m233));
			tx = _arg1.tx;
			ty = _arg1.ty;
			tz = _arg1.tz;
		}
		public function orthographicProjectionMatrix(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number):void{
			var _local7:Matrix3D;
			sxx = (2 / (_arg2 - _arg1));
			sxy = (sxz = 0);
			tx = ((_arg2 + _arg1) / (_arg2 - _arg1));
			syy = (2 / (_arg4 - _arg3));
			syx = (syz = 0);
			ty = ((_arg4 + _arg3) / (_arg4 - _arg3));
			szx = (szy = 0);
			szz = (-2 / (_arg6 - _arg5));
			tz = ((_arg6 + _arg5) / (_arg6 - _arg5));
			swx = (swy = (swz = 0));
			tw = 1;
			_local7 = new Matrix3D();
			_local7.scaleMatrix(1, 1, -1);
			this.multiply(_local7, this);
		}
		public function translationMatrix(_arg1:Number, _arg2:Number, _arg3:Number):void{
			sxx = (syy = (szz = 1));
			sxy = (sxz = (syz = (syz = (szx = (szy = 0)))));
			tx = _arg1;
			ty = _arg2;
			tz = _arg3;
		}
		public function quaternion2matrix(_arg1:Quaternion):void{
			x = _arg1.x;
			y = _arg1.y;
			z = _arg1.z;
			w = _arg1.w;
			xx = (x * x);
			xy = (x * y);
			xz = (x * z);
			xw = (x * w);
			yy = (y * y);
			yz = (y * z);
			yw = (y * w);
			zz = (z * z);
			zw = (z * w);
			sxx = (1 - (2 * (yy + zz)));
			sxy = (2 * (xy - zw));
			sxz = (2 * (xz + yw));
			syx = (2 * (xy + zw));
			syy = (1 - (2 * (xx + zz)));
			syz = (2 * (yz - xw));
			szx = (2 * (xz - yw));
			szy = (2 * (yz + xw));
			szz = (1 - (2 * (xx + yy)));
		}
		public function get forward():Number3D{
			_forward.x = szx;
			_forward.y = szy;
			_forward.z = szz;
			return (_forward);
		}
		public function set forward(_arg1:Number3D):void{
			this.szx = _arg1.x;
			this.szy = _arg1.y;
			this.szz = _arg1.z;
		}
		public function rotationMatrix(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			nCos = Math.cos(_arg4);
			nSin = Math.sin(_arg4);
			scos = (1 - nCos);
			suv = ((_arg1 * _arg2) * scos);
			svw = ((_arg2 * _arg3) * scos);
			suw = ((_arg1 * _arg3) * scos);
			sw = (nSin * _arg3);
			sv = (nSin * _arg2);
			su = (nSin * _arg1);
			sxx = (nCos + ((_arg1 * _arg1) * scos));
			sxy = (-(sw) + suv);
			sxz = (sv + suw);
			syx = (sw + suv);
			syy = (nCos + ((_arg2 * _arg2) * scos));
			syz = (-(su) + svw);
			szx = (-(sv) + suw);
			szy = (su + svw);
			szz = (nCos + ((_arg3 * _arg3) * scos));
		}
		public function compare(_arg1:Matrix3D):Boolean{
			if (((((((((((((((((((((((!((sxx == _arg1.sxx))) || (!((sxy == _arg1.sxy))))) || (!((sxz == _arg1.sxz))))) || (!((tx == _arg1.tx))))) || (!((syx == _arg1.syx))))) || (!((syy == _arg1.syy))))) || (!((syz == _arg1.syz))))) || (!((ty == _arg1.ty))))) || (!((szx == _arg1.szx))))) || (!((szy == _arg1.szy))))) || (!((szz == _arg1.szz))))) || (!((tz == _arg1.tz))))){
				return (false);
			};
			return (true);
		}
		public function array2matrix(_arg1:Array, _arg2:Boolean, _arg3:Number):void{
			if (_arg1.length >= 12){
				if (_arg2){
					sxx = _arg1[0];
					sxy = -(_arg1[1]);
					sxz = -(_arg1[2]);
					tx = (-(_arg1[3]) * _arg3);
					syx = -(_arg1[4]);
					syy = _arg1[5];
					syz = _arg1[6];
					ty = (_arg1[7] * _arg3);
					szx = -(_arg1[8]);
					szy = _arg1[9];
					szz = _arg1[10];
					tz = (_arg1[11] * _arg3);
				} else {
					sxx = _arg1[0];
					sxz = _arg1[1];
					sxy = _arg1[2];
					tx = (_arg1[3] * _arg3);
					szx = _arg1[4];
					szz = _arg1[5];
					szy = _arg1[6];
					tz = (_arg1[7] * _arg3);
					syx = _arg1[8];
					syz = _arg1[9];
					syy = _arg1[10];
					ty = (_arg1[11] * _arg3);
				};
			};
			if (_arg1.length >= 16){
				swx = _arg1[12];
				swy = _arg1[13];
				swz = _arg1[14];
				tw = _arg1[15];
			} else {
				swx = (swy = (swz = 0));
				tw = 1;
			};
		}
		public function get det4x4():Number{
			return (((((((((sxx * syy) - (syx * sxy)) * ((szz * tw) - (swz * tz))) - (((sxx * szy) - (szx * sxy)) * ((syz * tw) - (swz * ty)))) + (((sxx * swy) - (swx * sxy)) * ((syz * tz) - (szz * ty)))) + (((syx * szy) - (szx * syy)) * ((sxz * tw) - (swz * tx)))) - (((syx * swy) - (swx * syy)) * ((sxz * tz) - (szz * tx)))) + (((szx * swy) - (swx * szy)) * ((sxz * ty) - (syz * tx)))));
		}

	}
}//package away3d.core.math 
Section 72
//Number3D (away3d.core.math.Number3D)
package away3d.core.math {

	public final class Number3D {

		private const MathPI:Number = 3.14159265358979;

		private var vy:Number;
		private var num:Number3D;
		private var mod:Number;
		private var vx:Number;
		private var vz:Number;
		private var m1:Matrix3D;
		private var dist:Number;
		public var x:Number;
		public var y:Number;
		public var z:Number;

		public static var BACKWARD:Number3D = new Number3D(0, 0, -1);
;
		public static var FORWARD:Number3D = new Number3D(0, 0, 1);
;
		public static var LEFT:Number3D = new Number3D(-1, 0, 0);
;
		public static var DOWN:Number3D = new Number3D(0, -1, 0);
;
		public static var UP:Number3D = new Number3D(0, 1, 0);
;
		public static var RIGHT:Number3D = new Number3D(1, 0, 0);
;

		public function Number3D(_arg1:Number=0, _arg2:Number=0, _arg3:Number=0, _arg4:Boolean=false){
			this.x = _arg1;
			this.y = _arg2;
			this.z = _arg3;
			if (_arg4){
				normalize();
			};
		}
		public function sub(_arg1:Number3D, _arg2:Number3D):void{
			x = (_arg1.x - _arg2.x);
			y = (_arg1.y - _arg2.y);
			z = (_arg1.z - _arg2.z);
		}
		public function scale(_arg1:Number3D, _arg2:Number):void{
			x = (_arg1.x * _arg2);
			y = (_arg1.y * _arg2);
			z = (_arg1.z * _arg2);
		}
		public function toString():String{
			return (((((("x:" + x) + " y:") + y) + " z:") + z));
		}
		public function dot(_arg1:Number3D):Number{
			return ((((x * _arg1.x) + (y * _arg1.y)) + (z * _arg1.z)));
		}
		public function normalize(_arg1:Number=1):void{
			mod = (modulo / _arg1);
			if (((!((mod == 0))) && (!((mod == 1))))){
				x = (x / mod);
				y = (y / mod);
				z = (z / mod);
			};
		}
		public function quaternion2euler(_arg1:Quaternion):void{
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			_local2 = ((_arg1.x * _arg1.y) + (_arg1.z * _arg1.w));
			if (_local2 > 0.499){
				x = (2 * Math.atan2(_arg1.x, _arg1.w));
				y = (Math.PI / 2);
				z = 0;
				return;
			};
			if (_local2 < -0.499){
				x = (-2 * Math.atan2(_arg1.x, _arg1.w));
				y = (-(Math.PI) / 2);
				z = 0;
				return;
			};
			_local3 = (_arg1.x * _arg1.x);
			_local4 = (_arg1.y * _arg1.y);
			_local5 = (_arg1.z * _arg1.z);
			x = Math.atan2((((2 * _arg1.y) * _arg1.w) - ((2 * _arg1.x) * _arg1.z)), ((1 - (2 * _local4)) - (2 * _local5)));
			y = Math.asin((2 * _local2));
			z = Math.atan2((((2 * _arg1.x) * _arg1.w) - ((2 * _arg1.y) * _arg1.z)), ((1 - (2 * _local3)) - (2 * _local5)));
		}
		public function cross(_arg1:Number3D, _arg2:Number3D):void{
			if ((((this == _arg1)) || ((this == _arg2)))){
				throw (new Error("resultant cross product cannot be the same instance as an input"));
			};
			x = ((_arg2.y * _arg1.z) - (_arg2.z * _arg1.y));
			y = ((_arg2.z * _arg1.x) - (_arg2.x * _arg1.z));
			z = ((_arg2.x * _arg1.y) - (_arg2.y * _arg1.x));
		}
		public function matrix2scale(_arg1:Matrix3D):void{
			x = Math.sqrt((((_arg1.sxx * _arg1.sxx) + (_arg1.syx * _arg1.syx)) + (_arg1.szx * _arg1.szx)));
			y = Math.sqrt((((_arg1.sxy * _arg1.sxy) + (_arg1.syy * _arg1.syy)) + (_arg1.szy * _arg1.szy)));
			z = Math.sqrt((((_arg1.sxz * _arg1.sxz) + (_arg1.syz * _arg1.syz)) + (_arg1.szz * _arg1.szz)));
		}
		public function matrix2euler(_arg1:Matrix3D):void{
			var _local2:Number;
			if (!m1){
				m1 = new Matrix3D();
			};
			x = -(Math.atan2(_arg1.szy, _arg1.szz));
			m1.rotationMatrix(1, 0, 0, x);
			m1.multiply(_arg1, m1);
			_local2 = Math.sqrt(((m1.sxx * m1.sxx) + (m1.syx * m1.syx)));
			y = Math.atan2(-(m1.szx), _local2);
			z = Math.atan2(-(m1.sxy), m1.syy);
			if (Math.round((z / MathPI)) == 1){
				if (y > 0){
					y = -((y - MathPI));
				} else {
					y = -((y + MathPI));
				};
				z = (z - MathPI);
				if (x > 0){
					x = (x - MathPI);
				} else {
					x = (x + MathPI);
				};
			} else {
				if (Math.round((z / MathPI)) == -1){
					if (y > 0){
						y = -((y - MathPI));
					} else {
						y = -((y + MathPI));
					};
					z = (z + MathPI);
					if (x > 0){
						x = (x - MathPI);
					} else {
						x = (x + MathPI);
					};
				} else {
					if (Math.round((x / MathPI)) == 1){
						if (y > 0){
							y = -((y - MathPI));
						} else {
							y = -((y + MathPI));
						};
						x = (x - MathPI);
						if (z > 0){
							z = (z - MathPI);
						} else {
							z = (z + MathPI);
						};
					} else {
						if (Math.round((x / MathPI)) == -1){
							if (y > 0){
								y = -((y - MathPI));
							} else {
								y = -((y + MathPI));
							};
							x = (x + MathPI);
							if (z > 0){
								z = (z - MathPI);
							} else {
								z = (z + MathPI);
							};
						};
					};
				};
			};
		}
		public function rotate(_arg1:Number3D, _arg2:Matrix3D):void{
			vx = _arg1.x;
			vy = _arg1.y;
			vz = _arg1.z;
			x = (((vx * _arg2.sxx) + (vy * _arg2.sxy)) + (vz * _arg2.sxz));
			y = (((vx * _arg2.syx) + (vy * _arg2.syy)) + (vz * _arg2.syz));
			z = (((vx * _arg2.szx) + (vy * _arg2.szy)) + (vz * _arg2.szz));
		}
		public function clone(_arg1:Number3D):void{
			x = _arg1.x;
			y = _arg1.y;
			z = _arg1.z;
		}
		public function closestPointOnPlane(_arg1:Number3D, _arg2:Number3D, _arg3:Number3D):Number3D{
			if (!num){
				num = new Number3D();
			};
			num.sub(_arg1, _arg2);
			dist = _arg3.dot(num);
			num.scale(_arg3, dist);
			num.sub(_arg1, num);
			return (num);
		}
		public function interpolate(_arg1:Number3D, _arg2:Number):void{
			var _local3:Number3D;
			_local3 = new Number3D();
			_local3.sub(_arg1, this);
			_local3.scale(_local3, _arg2);
			add(this, _local3);
		}
		public function add(_arg1:Number3D, _arg2:Number3D):void{
			x = (_arg1.x + _arg2.x);
			y = (_arg1.y + _arg2.y);
			z = (_arg1.z + _arg2.z);
		}
		public function getAngle(_arg1:Number3D=null):Number{
			if (_arg1 == null){
				_arg1 = new Number3D();
			};
			return (Math.acos((dot(_arg1) / (modulo * _arg1.modulo))));
		}
		public function distance(_arg1:Number3D):Number{
			return (Math.sqrt(((((x - _arg1.x) * (x - _arg1.x)) + ((y - _arg1.y) * (y - _arg1.y))) + ((z - _arg1.z) * (z - _arg1.z)))));
		}
		public function get modulo():Number{
			return (Math.sqrt((((x * x) + (y * y)) + (z * z))));
		}
		public function transform(_arg1:Number3D, _arg2:Matrix3D):void{
			vx = _arg1.x;
			vy = _arg1.y;
			vz = _arg1.z;
			x = ((((vx * _arg2.sxx) + (vy * _arg2.sxy)) + (vz * _arg2.sxz)) + _arg2.tx);
			y = ((((vx * _arg2.syx) + (vy * _arg2.syy)) + (vz * _arg2.syz)) + _arg2.ty);
			z = ((((vx * _arg2.szx) + (vy * _arg2.szy)) + (vz * _arg2.szz)) + _arg2.tz);
		}
		public function get modulo2():Number{
			return ((((x * x) + (y * y)) + (z * z)));
		}
		public function equals(_arg1:Number3D):Boolean{
			return ((((((_arg1.x == x)) && ((_arg1.y == y)))) && ((_arg1.z == z))));
		}

		public static function getInterpolated(_arg1:Number3D, _arg2:Number3D, _arg3:Number):Number3D{
			var _local4:Number3D;
			_local4 = new (Number3D);
			_local4.sub(_arg1, _arg2);
			_local4.scale(_local4, _arg3);
			_local4.add(_local4, _arg2);
			return (_local4);
		}

	}
}//package away3d.core.math 
Section 73
//Quaternion (away3d.core.math.Quaternion)
package away3d.core.math {

	public final class Quaternion {

		private var fSinYaw:Number;
		private var z1:Number;
		public var z:Number;
		private var fCosPitch:Number;
		private var w1:Number;
		private var w2:Number;
		private var z2:Number;
		private var cos_a:Number;
		private var fSinRoll:Number;
		private var x1:Number;
		private var sin_a:Number;
		private var x2:Number;
		private var fCosPitchCosYaw:Number;
		private var fSinPitch:Number;
		private var y1:Number;
		private var y2:Number;
		private var fCosRoll:Number;
		private var fSinPitchSinYaw:Number;
		public var w:Number;
		public var x:Number;
		public var y:Number;
		private var fCosYaw:Number;

		public function normalize(_arg1:Number=1):void{
			var _local2:Number;
			_local2 = (magnitude * _arg1);
			x = (x / _local2);
			y = (y / _local2);
			z = (z / _local2);
			w = (w / _local2);
		}
		public function get magnitude():Number{
			return (Math.sqrt(((((w * w) + (x * x)) + (y * y)) + (z * z))));
		}
		public function axis2quaternion(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			sin_a = Math.sin((_arg4 / 2));
			cos_a = Math.cos((_arg4 / 2));
			this.x = (_arg1 * sin_a);
			this.y = (_arg2 * sin_a);
			this.z = (_arg3 * sin_a);
			w = cos_a;
			normalize();
		}
		public function multiply(_arg1:Quaternion, _arg2:Quaternion):void{
			w1 = _arg1.w;
			x1 = _arg1.x;
			y1 = _arg1.y;
			z1 = _arg1.z;
			w2 = _arg2.w;
			x2 = _arg2.x;
			y2 = _arg2.y;
			z2 = _arg2.z;
			w = ((((w1 * w2) - (x1 * x2)) - (y1 * y2)) - (z1 * z2));
			x = ((((w1 * x2) + (x1 * w2)) + (y1 * z2)) - (z1 * y2));
			y = ((((w1 * y2) + (y1 * w2)) + (z1 * x2)) - (x1 * z2));
			z = ((((w1 * z2) + (z1 * w2)) + (x1 * y2)) - (y1 * x2));
		}
		public function euler2quaternion(_arg1:Number, _arg2:Number, _arg3:Number):void{
			fSinPitch = Math.sin((_arg1 * 0.5));
			fCosPitch = Math.cos((_arg1 * 0.5));
			fSinYaw = Math.sin((_arg2 * 0.5));
			fCosYaw = Math.cos((_arg2 * 0.5));
			fSinRoll = Math.sin((_arg3 * 0.5));
			fCosRoll = Math.cos((_arg3 * 0.5));
			fCosPitchCosYaw = (fCosPitch * fCosYaw);
			fSinPitchSinYaw = (fSinPitch * fSinYaw);
			x = ((fSinRoll * fCosPitchCosYaw) - (fCosRoll * fSinPitchSinYaw));
			y = (((fCosRoll * fSinPitch) * fCosYaw) + ((fSinRoll * fCosPitch) * fSinYaw));
			z = (((fCosRoll * fCosPitch) * fSinYaw) - ((fSinRoll * fSinPitch) * fCosYaw));
			w = ((fCosRoll * fCosPitchCosYaw) + (fSinRoll * fSinPitchSinYaw));
		}
		public function toString():String{
			return ((((((((("{x:" + x) + " y:") + y) + " z:") + z) + " w:") + w) + "}"));
		}

	}
}//package away3d.core.math 
Section 74
//ConvexBlockProjector (away3d.core.project.ConvexBlockProjector)
package away3d.core.project {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.cameras.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.core.block.*;
	import away3d.cameras.lenses.*;
	import away3d.blockers.*;

	public class ConvexBlockProjector implements IBlockerProvider, IPrimitiveProvider {

		private var _points:Array;
		private var _view:View3D;
		private var _baseIndex:Number;
		private var _pointsN:Array;
		private var _pointsS:Array;
		private var _screenVertices:Array;
		private var _convexBlock:ConvexBlock;
		private var _baseX:Number;
		private var _baseY:Number;
		private var _baseZ:Number;
		private var _screenX:Number;
		private var _screenY:Number;
		private var _drawPrimitiveStore:DrawPrimitiveStore;
		private var _camera:Camera3D;
		private var _index:int;
		private var _vertices:Array;
		private var _lens:ILens;
		private var _i:int;
		private var _p:String;
		private var _s:String;

		public function ConvexBlockProjector(){
			_points = [];
			_pointsN = [];
			_pointsS = [];
			super();
		}
		public function get view():View3D{
			return (_view);
		}
		private function cross(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number):Number{
			return ((((_arg3 - _arg1) * (_arg6 - _arg2)) - ((_arg5 - _arg1) * (_arg4 - _arg2))));
		}
		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_drawPrimitiveStore = _view.drawPrimitiveStore;
		}
		public function blockers(_arg1:Object3D, _arg2:Matrix3D, _arg3:IBlockerConsumer):void{
			var _local4:Array;
			var _local5:Number;
			var _local6:int;
			_screenVertices = _drawPrimitiveStore.getScreenVertices(_arg1.id);
			_convexBlock = (_arg1 as ConvexBlock);
			_camera = _view.camera;
			_lens = _camera.lens;
			_vertices = _convexBlock.vertices;
			if (_vertices.length < 3){
				return;
			};
			_points.length = 0;
			_pointsN.length = 0;
			_pointsS.length = 0;
			_baseX = Infinity;
			_baseY = Infinity;
			_baseZ = Infinity;
			_p = "";
			_lens.project(_arg2, _vertices, _screenVertices);
			_index = (_screenVertices.length / 3);
			while (_index--) {
				_screenX = _screenVertices[(_index * 3)];
				_screenY = _screenVertices[((_index * 3) + 1)];
				if ((((_baseY > _screenY)) || ((((_baseY == _screenY)) && ((_baseX > _screenX)))))){
					_baseX = _screenX;
					_baseY = _screenY;
					_baseZ = _screenVertices[((_index * 3) + 2)];
					_baseIndex = _index;
				};
				_points[_points.length] = _baseX;
				_points[_points.length] = _baseY;
				_points[_points.length] = _baseZ;
			};
			_index = (_points.length / 3);
			while (_index--) {
				_pointsN[_index] = ((_points[(_index * 3)] - _baseX) / (_points[((_index * 3) + 1)] - _baseY));
			};
			_pointsN[_baseIndex] = -(Infinity);
			_pointsN = _pointsN.sort((Array.NUMERIC | Array.RETURNINDEXEDARRAY));
			_index = 0;
			while (_index < _pointsN.length) {
				_i = (_pointsN[_index] * 3);
				_pointsS[_pointsS.length] = _points[_i];
				_pointsS[_pointsS.length] = _points[(_i + 1)];
				_pointsS[_pointsS.length] = _points[(_i + 2)];
				_index++;
			};
			_local4 = [_pointsS[0], _pointsS[1], _pointsS[2], _pointsS[3], _pointsS[4], _pointsS[5]];
			_i = 2;
			while (_i < _pointsS.length) {
				_local6 = _local4.length;
				_local5 = cross(_local4[(_local6 - 6)], _local4[(_local6 - 5)], _local4[(_local6 - 3)], _local4[(_local6 - 2)], _pointsS[(_i * 3)], _pointsS[((_i * 3) + 1)]);
				while (_local5 > 0) {
					_local4.pop();
					_local4.pop();
					_local4.pop();
					if (_local4.length == 6){
						break;
					};
					_local6 = _local4.length;
					_local5 = cross(_local4[(_local6 - 6)], _local4[(_local6 - 5)], _local4[(_local6 - 3)], _local4[(_local6 - 2)], _pointsS[(_i * 3)], _pointsS[((_i * 3) + 1)]);
				};
				_local4.push(_pointsS[(_i * 3)], _pointsS[((_i * 3) + 1)], _pointsS[((_i * 3) + 2)]);
				_i++;
			};
			_local6 = _local4.length;
			_local5 = cross(_local4[(_local6 - 6)], _local4[(_local6 - 5)], _local4[(_local6 - 3)], _local4[(_local6 - 2)], _local4[0], _local4[1]);
			if (_local5 > 0){
				_local4.pop();
				_local4.pop();
				_local4.pop();
			};
			_arg3.blocker(_drawPrimitiveStore.createConvexBlocker(_arg1, _local4));
		}
		public function primitives(_arg1:Object3D, _arg2:Matrix3D, _arg3:IPrimitiveConsumer):void{
			_convexBlock = (_arg1 as ConvexBlock);
			if (_convexBlock.debug){
				_arg3.primitive(_drawPrimitiveStore.blockerDictionary[_arg1]);
			};
		}

	}
}//package away3d.core.project 
Section 75
//DirSpriteProjector (away3d.core.project.DirSpriteProjector)
package away3d.core.project {
	import flash.display.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import flash.utils.*;
	import away3d.cameras.lenses.*;
	import away3d.sprites.*;

	public class DirSpriteProjector implements IPrimitiveProvider {

		private var _view:View3D;
		private var _index:int;
		private var _vertices:Array;
		private var _centerScreenVertices:Array;
		private var _dirsprite:DirSprite2D;
		private var _lens:ILens;
		private var _screenVertices:Array;
		private var _bitmaps:Dictionary;
		private var _drawPrimitiveStore:DrawPrimitiveStore;

		public function DirSpriteProjector(){
			_centerScreenVertices = new Array();
			super();
		}
		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_drawPrimitiveStore = view.drawPrimitiveStore;
		}
		public function primitives(_arg1:Object3D, _arg2:Matrix3D, _arg3:IPrimitiveConsumer):void{
			var _local4:Number;
			var _local5:BitmapData;
			var _local6:Number;
			_screenVertices = _drawPrimitiveStore.getScreenVertices(_arg1.id);
			_dirsprite = (_arg1 as DirSprite2D);
			_vertices = _dirsprite.vertices;
			_bitmaps = _dirsprite.bitmaps;
			_lens = _view.camera.lens;
			if (_vertices.length == 0){
				return;
			};
			_local4 = Infinity;
			_local5 = null;
			_lens.project(_arg2, _vertices, _screenVertices);
			_index = (_screenVertices.length / 3);
			while (_index--) {
				_local6 = _screenVertices[((_index * 3) + 2)];
				if (_local6 < _local4){
					_local4 = _local6;
					_local5 = _bitmaps[_vertices[_index]];
				};
			};
			if (_local5 == null){
				return;
			};
			_centerScreenVertices.length = 0;
			_lens.project(_arg2, _dirsprite.center, _centerScreenVertices);
			if (_centerScreenVertices[0] == null){
				return;
			};
			_centerScreenVertices[2] = (_centerScreenVertices[2] + _dirsprite.deltaZ);
			_arg3.primitive(_drawPrimitiveStore.createDrawScaledBitmap(_arg1, _centerScreenVertices, _dirsprite.smooth, _local5, ((_dirsprite.scaling * _view.camera.zoom) / (1 + (_screenVertices[2] / _view.camera.focus))), _dirsprite.rotation));
		}
		public function get view():View3D{
			return (_view);
		}

	}
}//package away3d.core.project 
Section 76
//DofSpriteProjector (away3d.core.project.DofSpriteProjector)
package away3d.core.project {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.cameras.lenses.*;
	import away3d.sprites.*;

	public class DofSpriteProjector implements IPrimitiveProvider {

		private var _view:View3D;
		private var _dofcache:DofCache;
		private var _screenVertices:Array;
		private var _drawPrimitiveStore:DrawPrimitiveStore;
		private var _dofsprite:DofSprite2D;
		private var _lens:ILens;
		private var _screenZ:Number;

		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_drawPrimitiveStore = view.drawPrimitiveStore;
		}
		public function get view():View3D{
			return (_view);
		}
		public function primitives(_arg1:Object3D, _arg2:Matrix3D, _arg3:IPrimitiveConsumer):void{
			_screenVertices = _drawPrimitiveStore.getScreenVertices(_arg1.id);
			_dofsprite = (_arg1 as DofSprite2D);
			_lens = _view.camera.lens;
			_lens.project(_arg2, _dofsprite.center, _screenVertices);
			if (_screenVertices[0] == null){
				return;
			};
			_screenZ = (_screenVertices[2] = (_screenVertices[2] + _dofsprite.deltaZ));
			_dofcache = DofCache.getDofCache(_dofsprite.bitmap);
			_arg3.primitive(_drawPrimitiveStore.createDrawScaledBitmap(_arg1, _screenVertices, _dofsprite.smooth, _dofcache.getBitmap(_screenZ), ((_dofsprite.scaling * _view.camera.zoom) / (1 + (_screenZ / _view.camera.focus))), _dofsprite.rotation));
		}

	}
}//package away3d.core.project 
Section 77
//MeshProjector (away3d.core.project.MeshProjector)
package away3d.core.project {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.cameras.*;
	import away3d.core.clip.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.materials.*;
	import away3d.core.geom.*;
	import flash.utils.*;
	import away3d.cameras.lenses.*;

	public class MeshProjector implements IPrimitiveProvider {

		private var _defaultClippedSegmentVOs:Array;
		private var _sv2y:Number;
		private var _bmaterial:IBillboardMaterial;
		private var _defaultStartIndices:Array;
		private var _billboardMaterial:IBillboardMaterial;
		private var _billboardVOs:Array;
		private var _defaultVertices:Array;
		private var _faceVOs:Array;
		private var _sv2x:Number;
		private var _clipping:Clipping;
		private var _smaterial:ISegmentMaterial;
		private var _backface:Boolean;
		private var _outlineIndices:Dictionary;
		private var _endIndex:int;
		private var _startIndex:int;
		private var _n01:Face;
		private var _cameraVarsStore:CameraVarsStore;
		private var _screenCommands:Array;
		private var _clipFlag:Boolean;
		private var _drawPrimitiveStore:DrawPrimitiveStore;
		private var _defaultClippedFaceVOs:Array;
		private var _face:Face;
		private var _camera:Camera3D;
		private var _segmentMaterial:ISegmentMaterial;
		private var _n12:Face;
		private var _defaultClippedBillboards:Array;
		private var _vertices:Array;
		private var _segmentVOs:Array;
		private var _n20:Face;
		private var _billboardVO:BillboardVO;
		private var _faceMaterial:ITriangleMaterial;
		private var _view:View3D;
		private var _seg:DrawSegment;
		private var _screenIndices:Array;
		private var _screenVertices:Array;
		private var _segmentVO:SegmentVO;
		private var _zoom:Number;
		private var _vertex:Vertex;
		private var _startIndices:Array;
		private var _sv0x:Number;
		private var _sv0y:Number;
		private var _mesh:Mesh;
		private var _focus:Number;
		private var _lens:ILens;
		private var _backmat:ITriangleMaterial;
		private var _index:int;
		private var _sv1x:Number;
		private var _tri:DrawTriangle;
		private var _sv1y:Number;
		private var _segment:Segment;
		private var _faceVO:FaceVO;
		private var _i:int;

		public function MeshProjector(){
			_defaultStartIndices = new Array();
			_defaultVertices = new Array();
			_defaultClippedFaceVOs = new Array();
			_defaultClippedSegmentVOs = new Array();
			_defaultClippedBillboards = new Array();
			_outlineIndices = new Dictionary(true);
			super();
		}
		private function front(_arg1:int):Number{
			_index = (_screenIndices[_arg1] * 3);
			_sv0x = _screenVertices[_index];
			_sv0y = _screenVertices[(_index + 1)];
			_index = (_screenIndices[(_arg1 + 1)] * 3);
			_sv1x = _screenVertices[_index];
			_sv1y = _screenVertices[(_index + 1)];
			_index = (_screenIndices[(_arg1 + 2)] * 3);
			_sv2x = _screenVertices[_index];
			_sv2y = _screenVertices[(_index + 1)];
			return ((((_sv0x * (_sv2y - _sv1y)) + (_sv1x * (_sv0y - _sv2y))) + (_sv2x * (_sv1y - _sv0y))));
		}
		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_drawPrimitiveStore = view.drawPrimitiveStore;
			_cameraVarsStore = view.cameraVarsStore;
		}
		public function primitives(_arg1:Object3D, _arg2:Matrix3D, _arg3:IPrimitiveConsumer):void{
			_cameraVarsStore.createVertexClassificationDictionary(_arg1);
			_mesh = (_arg1 as Mesh);
			_camera = _view.camera;
			_clipping = _view.screenClipping;
			_lens = _camera.lens;
			_focus = _camera.focus;
			_zoom = _camera.zoom;
			_faceMaterial = _mesh.faceMaterial;
			_segmentMaterial = _mesh.segmentMaterial;
			_billboardMaterial = _mesh.billboardMaterial;
			_backmat = ((_mesh.back) || (_faceMaterial));
			_clipFlag = (((_cameraVarsStore.nodeClassificationDictionary[_arg1] == Frustum.INTERSECT)) && (!((_clipping is RectangleClipping))));
			if (_clipFlag){
				_vertices = _defaultVertices;
				_vertices.length = 0;
				_screenCommands = _drawPrimitiveStore.getScreenCommands(_arg1.id);
				_screenCommands.length = 0;
				_screenIndices = _drawPrimitiveStore.getScreenIndices(_arg1.id);
				_screenIndices.length = 0;
				_startIndices = _defaultStartIndices;
				_startIndices.length = 0;
				_faceVOs = _defaultClippedFaceVOs;
				_faceVOs.length = 0;
				_segmentVOs = _defaultClippedSegmentVOs;
				_segmentVOs.length = 0;
				_billboardVOs = _defaultClippedBillboards;
				_billboardVOs.length = 0;
				_clipping.checkElements(_mesh, _faceVOs, _segmentVOs, _billboardVOs, _vertices, _screenCommands, _screenIndices, _startIndices);
			} else {
				_vertices = _mesh.vertices;
				_screenCommands = _mesh.commands;
				_screenIndices = _mesh.indices;
				_startIndices = _mesh.startIndices;
				_faceVOs = _mesh.faceVOs;
				_segmentVOs = _mesh.segmentVOs;
				_billboardVOs = _mesh.billboardVOs;
			};
			_screenVertices = _drawPrimitiveStore.getScreenVertices(_arg1.id);
			_screenVertices.length = 0;
			_lens.project(_arg2, _vertices, _screenVertices);
			if (_mesh.outline){
				_i = _faceVOs.length;
				while (_i--) {
					_outlineIndices[_faceVOs[_i]] = _i;
				};
			};
			_i = 0;
			for each (_faceVO in _faceVOs) {
				_startIndex = _startIndices[_i++];
				_endIndex = _startIndices[_i];
				if (!_clipFlag){
					_index = _startIndex;
					while (((!((_screenVertices[(_screenIndices[_index] * 3)] == null))) && ((_index < _endIndex)))) {
						_index++;
					};
					//unresolved if
				} else {
					_face = _faceVO.face;
					_tri = _drawPrimitiveStore.createDrawTriangle(_arg1, _faceVO, null, _screenVertices, _screenIndices, _screenCommands, _startIndex, _endIndex, _faceVO.uv0, _faceVO.uv1, _faceVO.uv2, _faceVO.generated);
					_backface = (_tri.backface = (_tri.area < 0));
					if (_backface){
						if (!_mesh.bothsides){
							continue;
						};
						_tri.material = _faceVO.back;
						if (!_tri.material){
							_tri.material = _faceVO.material;
						};
					} else {
						_tri.material = _faceVO.material;
					};
					if (!_tri.material){
						if (_backface){
							_tri.material = _backmat;
						} else {
							_tri.material = _faceMaterial;
						};
					};
					if (((_tri.material) && (!(_tri.material.visible)))){
						_tri.material = null;
					};
					if (((!(_mesh.outline)) && (!(_tri.material)))){
					} else {
						if (!_arg3.primitive(_tri)){
						} else {
							if (_mesh.pushback){
								_tri.screenZ = _tri.maxZ;
							};
							if (_mesh.pushfront){
								_tri.screenZ = _tri.minZ;
							};
							_tri.screenZ = (_tri.screenZ + _mesh.screenZOffset);
							if (((_mesh.outline) && (!(_backface)))){
								_n01 = _mesh.geometry.neighbour01(_face);
								if ((((_n01 == null)) || ((front(_startIndices[_outlineIndices[_n01.faceVO]]) <= 0)))){
									_segmentVO = _cameraVarsStore.createSegmentVO(_mesh.outline);
									_startIndex = _screenIndices.length;
									_screenIndices[_screenIndices.length] = _screenIndices[_tri.startIndex];
									_screenIndices[_screenIndices.length] = _screenIndices[(_tri.startIndex + 1)];
									_endIndex = _screenIndices.length;
									_arg3.primitive(_drawPrimitiveStore.createDrawSegment(_arg1, _segmentVO, _mesh.outline, _screenVertices, _screenIndices, _screenCommands, _startIndex, _endIndex));
								};
								_n12 = _mesh.geometry.neighbour12(_face);
								if ((((_n12 == null)) || ((front(_startIndices[_outlineIndices[_n12.faceVO]]) <= 0)))){
									_segmentVO = _cameraVarsStore.createSegmentVO(_mesh.outline);
									_startIndex = _screenIndices.length;
									_screenIndices[_screenIndices.length] = _screenIndices[(_tri.startIndex + 1)];
									_screenIndices[_screenIndices.length] = _screenIndices[(_tri.startIndex + 2)];
									_endIndex = _screenIndices.length;
									_arg3.primitive(_drawPrimitiveStore.createDrawSegment(_arg1, _segmentVO, _mesh.outline, _screenVertices, _screenIndices, _screenCommands, _startIndex, _endIndex));
								};
								_n20 = _mesh.geometry.neighbour20(_face);
								if ((((_n20 == null)) || ((front(_startIndices[_outlineIndices[_n20.faceVO]]) <= 0)))){
									_segmentVO = _cameraVarsStore.createSegmentVO(_mesh.outline);
									_startIndex = _screenIndices.length;
									_screenIndices[_screenIndices.length] = _screenIndices[(_tri.startIndex + 2)];
									_screenIndices[_screenIndices.length] = _screenIndices[_tri.startIndex];
									_endIndex = _screenIndices.length;
									_arg3.primitive(_drawPrimitiveStore.createDrawSegment(_arg1, _segmentVO, _mesh.outline, _screenVertices, _screenIndices, _screenCommands, _startIndex, _endIndex));
								};
							};
						};
					};
				};
			};
			for each (_segmentVO in _segmentVOs) {
				_startIndex = _startIndices[_i++];
				_endIndex = _startIndices[_i];
				if (!_clipFlag){
					_index = _startIndex;
					while (((!((_screenVertices[(_screenIndices[_index] * 3)] == null))) && ((_index < _endIndex)))) {
						_index++;
					};
					//unresolved if
				} else {
					_smaterial = ((_segmentVO.material) || (_segmentMaterial));
					if (!_smaterial.visible){
					} else {
						_seg = _drawPrimitiveStore.createDrawSegment(_arg1, _segmentVO, _smaterial, _screenVertices, _screenIndices, _screenCommands, _startIndex, _endIndex, _segmentVO.generated);
						if (!_arg3.primitive(_seg)){
						} else {
							if (_mesh.pushback){
								_seg.screenZ = _seg.maxZ;
							};
							if (_mesh.pushfront){
								_seg.screenZ = _seg.minZ;
							};
							_seg.screenZ = (_seg.screenZ + _mesh.screenZOffset);
						};
					};
				};
			};
			for each (_billboardVO in _billboardVOs) {
				_index = _startIndices[_i++];
				if (((!(_clipFlag)) && ((_screenVertices[(_screenIndices[_index] * 3)] == null)))){
				} else {
					_bmaterial = ((_billboardVO.material) || (_billboardMaterial));
					if (!_bmaterial.visible){
					} else {
						_arg3.primitive(_drawPrimitiveStore.createDrawBillboard(_arg1, _billboardVO, _bmaterial, _screenVertices, _screenIndices, _index, ((_billboardVO.scaling * _zoom) / (1 + (_screenVertices[((_screenIndices[_index] * 3) + 2)] / _focus)))));
					};
				};
			};
		}
		public function get view():View3D{
			return (_view);
		}

	}
}//package away3d.core.project 
Section 78
//MovieClipSpriteProjector (away3d.core.project.MovieClipSpriteProjector)
package away3d.core.project {
	import flash.display.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.cameras.lenses.*;
	import away3d.sprites.*;

	public class MovieClipSpriteProjector implements IPrimitiveProvider {

		private var _movieclip:DisplayObject;
		private var _view:View3D;
		private var _movieClipSprite:MovieClipSprite;
		private var _lens:ILens;
		private var _screenVertices:Array;
		private var _screenX:Number;
		private var _screenY:Number;
		private var _screenZ:Number;
		private var _drawPrimitiveStore:DrawPrimitiveStore;

		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_drawPrimitiveStore = view.drawPrimitiveStore;
		}
		public function get view():View3D{
			return (_view);
		}
		public function primitives(_arg1:Object3D, _arg2:Matrix3D, _arg3:IPrimitiveConsumer):void{
			_screenVertices = _drawPrimitiveStore.getScreenVertices(_arg1.id);
			_movieClipSprite = (_arg1 as MovieClipSprite);
			_lens = _view.camera.lens;
			_movieclip = _movieClipSprite.movieclip;
			_lens.project(_arg2, _movieClipSprite.center, _screenVertices);
			_screenX = _screenVertices[0];
			_screenY = _screenVertices[1];
			_screenZ = (_screenVertices[2] = (_screenVertices[2] + _movieClipSprite.deltaZ));
			if (_movieClipSprite.align != "none"){
				switch (_movieClipSprite.align){
					case "center":
						_screenX = (_screenX - (_movieclip.width / 2));
						_screenY = (_screenY - (_movieclip.height / 2));
						break;
					case "topcenter":
						_screenX = (_screenX - (_movieclip.width / 2));
						break;
					case "bottomcenter":
						_screenX = (_screenX - (_movieclip.width / 2));
						_screenY = (_screenY - _movieclip.height);
						break;
					case "right":
						_screenX = (_screenX - _movieclip.width);
						_screenY = (_screenY - (_movieclip.height / 2));
						break;
					case "topright":
						_screenX = (_screenX - _movieclip.width);
						break;
					case "bottomright":
						_screenX = (_screenX - _movieclip.width);
						_screenY = (_screenY - _movieclip.height);
						break;
					case "left":
						_screenY = (_screenY - (_movieclip.height / 2));
						break;
					case "topleft":
						break;
					case "bottomleft":
						_screenY = (_screenY - _movieclip.height);
						break;
				};
			};
			if (_movieClipSprite.rescale){
				_movieclip.scaleX = (_movieclip.scaleY = ((_movieClipSprite.scaling * view.camera.zoom) / (1 + (_screenZ / view.camera.focus))));
			};
			_arg3.primitive(_drawPrimitiveStore.createDrawDisplayObject(_arg1, _screenX, _screenY, _screenZ, _movieClipSprite.session, _movieclip));
		}

	}
}//package away3d.core.project 
Section 79
//ObjectContainerProjector (away3d.core.project.ObjectContainerProjector)
package away3d.core.project {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.core.render.*;
	import flash.utils.*;

	public class ObjectContainerProjector implements IPrimitiveProvider {

		private var _container:ObjectContainer3D;
		private var _view:View3D;
		private var _vx:Number;
		private var _vy:Number;
		private var _vz:Number;
		private var _cameraViewMatrix:Matrix3D;
		private var _depthPoint:Number3D;
		private var _drawPrimitiveStore:DrawPrimitiveStore;
		private var _viewTransformDictionary:Dictionary;

		public function ObjectContainerProjector(){
			_depthPoint = new Number3D();
			super();
		}
		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_drawPrimitiveStore = view.drawPrimitiveStore;
		}
		public function get view():View3D{
			return (_view);
		}
		public function primitives(_arg1:Object3D, _arg2:Matrix3D, _arg3:IPrimitiveConsumer):void{
			var _local4:Array;
			var _local5:Object3D;
			_container = (_arg1 as ObjectContainer3D);
			_cameraViewMatrix = _view.camera.viewMatrix;
			_viewTransformDictionary = _view.cameraVarsStore.viewTransformDictionary;
			_local4 = _container.children;
			for each (_local5 in _local4) {
				if (((_local5.ownCanvas) && (_local5.visible))){
					if ((_local5.ownSession is SpriteRenderSession)){
						(_local5.ownSession as SpriteRenderSession).cacheAsBitmap = true;
					};
					_vx = _local5.screenXOffset;
					_vy = _local5.screenYOffset;
					if (!isNaN(_local5.ownSession.screenZ)){
						_vz = _local5.ownSession.screenZ;
					} else {
						if (_local5.scenePivotPoint.modulo){
							_depthPoint.clone(_local5.scenePivotPoint);
							_depthPoint.rotate(_depthPoint, _cameraViewMatrix);
							_depthPoint.add(_viewTransformDictionary[_local5].position, _depthPoint);
							_vz = _depthPoint.modulo;
						} else {
							_vz = _viewTransformDictionary[_local5].position.modulo;
						};
						if (_local5.pushback){
							_vz = (_vz + _local5.parentBoundingRadius);
						};
						if (_local5.pushfront){
							_vz = (_vz - _local5.parentBoundingRadius);
						};
						_vz = (_vz + _local5.screenZOffset);
					};
					_arg3.primitive(_drawPrimitiveStore.createDrawDisplayObject(_arg1, _vx, _vy, _vz, _container.session, _local5.session.getContainer(view)));
				};
			};
		}

	}
}//package away3d.core.project 
Section 80
//ProjectorType (away3d.core.project.ProjectorType)
package away3d.core.project {

	public class ProjectorType {

		public static const OBJECT_CONTAINER:String = "ObjectContainer";
		public static const MOVIE_CLIP_SPRITE:String = "MovieClipSprite";
		public static const DOF_SPRITE:String = "DofSprite";
		public static const SPRITE:String = "Sprite";
		public static const MESH:String = "Mesh";
		public static const CONVEX_BLOCK:String = "ConvexBlock";
		public static const DIR_SPRITE:String = "DirSprite";

	}
}//package away3d.core.project 
Section 81
//SpriteProjector (away3d.core.project.SpriteProjector)
package away3d.core.project {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.cameras.lenses.*;
	import away3d.sprites.*;

	public class SpriteProjector implements IPrimitiveProvider {

		private var _sprite:Sprite2D;
		private var _view:View3D;
		private var _drawPrimitiveStore:DrawPrimitiveStore;
		private var _screenVertices:Array;
		private var _lens:ILens;

		public function get view():View3D{
			return (_view);
		}
		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_drawPrimitiveStore = view.drawPrimitiveStore;
		}
		public function primitives(_arg1:Object3D, _arg2:Matrix3D, _arg3:IPrimitiveConsumer):void{
			_screenVertices = _drawPrimitiveStore.getScreenVertices(_arg1.id);
			_sprite = (_arg1 as Sprite2D);
			_lens = _view.camera.lens;
			_lens.project(_arg2, _sprite.center, _screenVertices);
			if (_screenVertices[0] == null){
				return;
			};
			_screenVertices[2] = (_screenVertices[2] + _sprite.deltaZ);
			_arg3.primitive(_drawPrimitiveStore.createDrawScaledBitmap(_arg1, _screenVertices, _sprite.smooth, _sprite.bitmap, ((_sprite.scaling * _view.camera.zoom) / (1 + (_screenVertices[2] / _view.camera.focus))), _sprite.rotation));
		}

	}
}//package away3d.core.project 
Section 82
//AbstractRenderSession (away3d.core.render.AbstractRenderSession)
package away3d.core.render {
	import flash.geom.*;
	import flash.display.*;
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.clip.*;
	import away3d.materials.*;
	import away3d.core.light.*;
	import flash.utils.*;
	import away3d.events.*;

	public class AbstractRenderSession extends EventDispatcher {

		public var filters:Array;
		private var b2:Number;
		var _spriteActive:Array;
		private var _shapeStores:Dictionary;
		private var _v0:ScreenVertex;
		private var _v1:ScreenVertex;
		private var _v2:ScreenVertex;
		private var _shapeActives:Dictionary;
		private var c2:Number;
		var _renderSource:Object3D;
		private var _renderer:IPrimitiveConsumer;
		private var _dictionary:Dictionary;
		private var v0x:Number;
		private var v0y:Number;
		private var _spriteLayers:Dictionary;
		var _shapeActive:Array;
		private var _consumer:IPrimitiveConsumer;
		private var _array:Array;
		var _spriteStore:Array;
		private var v1y:Number;
		var _shapeStore:Array;
		private var a:Number;
		private var c:Number;
		private var d:Number;
		private var d2:Number;
		private var b:Number;
		private var m:Matrix;
		protected var i:int;
		private var v1x:Number;
		public var primitives:Array;
		private var v2y:Number;
		public var alpha:Number;// = 1
		private var _shapeLayers:Dictionary;
		var _level:int;// = -1
		public var layer:DisplayObject;
		private var _sessionupdated:SessionEvent;
		public var priconsumers:Dictionary;
		private var _renderers:Dictionary;
		public var graphics:Graphics;
		private var tx:Number;
		private var ty:Number;
		var _material:IMaterial;
		public var screenZ:Number;
		public var sessions:Array;
		var _layerDirty:Boolean;
		var _shape:Shape;
		public var blendMode:String;
		private var area:Number;
		private var _lightShapeLayer:Dictionary;
		private var _spriteActives:Dictionary;
		private var _lightShapeLayers:Dictionary;
		var _containers:Dictionary;
		private var v2x:Number;
		private var _spriteStores:Dictionary;
		public var parent:AbstractRenderSession;
		public var updated:Boolean;
		private var _index0:int;
		private var _index2:int;
		private var _index1:int;
		private var _spriteLayer:Dictionary;
		private var _shapeLayer:Dictionary;
		var _sprite:Sprite;
		private var _defaultColorTransform:ColorTransform;
		private var a2:Number;
		public var consumer:IPrimitiveConsumer;

		public function AbstractRenderSession(){
			_containers = new Dictionary(true);
			_level = -1;
			_shapeStores = new Dictionary(true);
			_shapeActives = new Dictionary(true);
			_spriteStores = new Dictionary(true);
			_spriteActives = new Dictionary(true);
			_spriteLayers = new Dictionary(true);
			_shapeLayers = new Dictionary(true);
			_lightShapeLayers = new Dictionary(true);
			_defaultColorTransform = new ColorTransform();
			_renderers = new Dictionary(true);
			m = new Matrix();
			alpha = 1;
			sessions = new Array();
			priconsumers = new Dictionary(true);
			super();
		}
		function internalAddOwnSession(_arg1:Object3D):void{
			_arg1.addEventListener(Object3DEvent.SESSION_UPDATED, onObjectSessionUpdate);
		}
		protected function createShape(_arg1:Sprite):Shape{
			if (_shapeStore.length){
				_shapeActive.push((_shape = _shapeStore.pop()));
			} else {
				_shapeActive.push((_shape = new Shape()));
			};
			_arg1.addChild(_shape);
			_layerDirty = true;
			return (_shape);
		}
		public function renderFogColor(_arg1:Clipping, _arg2:int, _arg3:Number):void{
			if (_layerDirty){
				createLayer();
			};
			graphics.lineStyle();
			graphics.beginFill(_arg2, _arg3);
			graphics.drawRect(_arg1.minX, _arg1.minY, (_arg1.maxX - _arg1.minX), (_arg1.maxY - _arg1.minY));
			graphics.endFill();
		}
		public function addOnSessionUpdate(_arg1:Function):void{
			addEventListener(SessionEvent.SESSION_UPDATED, _arg1, false, 0, false);
		}
		public function getShapeLayer(_arg1:View3D):Dictionary{
			if (!_shapeLayers[_arg1]){
				return ((_shapeLayers[_arg1] = new Dictionary(true)));
			};
			return (_shapeLayers[_arg1]);
		}
		public function addChildSession(_arg1:AbstractRenderSession):void{
			if (sessions.indexOf(_arg1) != -1){
				return;
			};
			sessions.push(_arg1);
			_arg1.addOnSessionUpdate(onSessionUpdate);
			_arg1.parent = this;
		}
		function internalAddSceneSession(_arg1:AbstractRenderSession):void{
			sessions = [_arg1];
			_arg1.addOnSessionUpdate(onSessionUpdate);
		}
		function notifySessionUpdate():void{
			if (!hasEventListener(SessionEvent.SESSION_UPDATED)){
				return;
			};
			if (!_sessionupdated){
				_sessionupdated = new SessionEvent(SessionEvent.SESSION_UPDATED, this);
			};
			dispatchEvent(_sessionupdated);
		}
		public function getLightShape(_arg1:ILayerMaterial, _arg2:int, _arg3:Sprite, _arg4:LightPrimitive):Shape{
			if (!(_dictionary = _lightShapeLayer[_arg1])){
				_dictionary = (_lightShapeLayer[_arg1] = new Dictionary(true));
			};
			if (!(_array = _dictionary[_arg4])){
				_array = (_dictionary[_arg4] = []);
			};
			if ((((_level >= _arg2)) && (_array.length))){
				_shape = _array[0];
			} else {
				_level = _arg2;
				_array.unshift((_shape = createShape(_arg3)));
			};
			return (_shape);
		}
		public function renderTriangleBitmapMask(_arg1:BitmapData, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Array, _arg6:Array, _arg7:Number, _arg8:Number, _arg9:Boolean, _arg10:Boolean, _arg11:Graphics=null):void{
			if (_layerDirty){
				createLayer();
			};
			_index0 = (_arg6[_arg7] * 3);
			_index1 = (_arg6[(_arg7 + 1)] * 3);
			_index2 = (_arg6[(_arg7 + 2)] * 3);
			a2 = ((v1x = _arg5[_index1]) - (v0x = _arg5[_index0]));
			b2 = ((v1y = _arg5[(_index1 + 1)]) - (v0y = _arg5[(_index0 + 1)]));
			c2 = ((v2x = _arg5[_index2]) - v0x);
			d2 = ((v2y = _arg5[(_index2 + 1)]) - v0y);
			m.identity();
			m.scale(_arg4, _arg4);
			m.translate(_arg2, _arg3);
			if (_arg11){
				_arg11.lineStyle();
				_arg11.moveTo(v0x, v0y);
				_arg11.beginBitmapFill(_arg1, m, _arg10, ((_arg9) && (((((v0x * (d2 - b2)) - (v1x * d2)) + (v2x * b2)) > 400))));
				_arg11.lineTo(v1x, v1y);
				_arg11.lineTo(v2x, v2y);
				_arg11.endFill();
			} else {
				graphics.lineStyle();
				graphics.moveTo(v0x, v0y);
				graphics.beginBitmapFill(_arg1, m, _arg10, ((_arg9) && (((((v0x * (d2 - b2)) - (v1x * d2)) + (v2x * b2)) > 400))));
				graphics.lineTo(v1x, v1y);
				graphics.lineTo(v2x, v2y);
				graphics.endFill();
			};
		}
		public function removeOnSessionUpdate(_arg1:Function):void{
			removeEventListener(SessionEvent.SESSION_UPDATED, _arg1, false);
		}
		public function clearRenderers():void{
			_renderers = new Dictionary(true);
		}
		public function renderTriangleColor(_arg1:int, _arg2:Number, _arg3:Array, _arg4:Array, _arg5:Array, _arg6:Number, _arg7:Number, _arg8:Graphics=null):void{
			var _local9:Graphics;
			if (((!(_arg8)) && (_layerDirty))){
				createLayer();
			};
			_local9 = (_arg8) ? _arg8 : graphics;
			if ((_arg7 - _arg6) > 3){
				_local9.lineStyle();
				_local9.beginFill(_arg1, _arg2);
				while (_arg6 < _arg7) {
					_index0 = (_arg5[_arg6] * 3);
					switch (_arg4[_temp2]){
						case "M":
							_local9.moveTo(_arg3[_index0], _arg3[(_index0 + 1)]);
							break;
						case "L":
							_local9.lineTo(_arg3[_index0], _arg3[(_index0 + 1)]);
							break;
						case "C":
							var _temp1 = _arg6;
							_arg6 = (_arg6 + 1);
							_index1 = (_arg5[_temp1] * 3);
							_local9.curveTo(_arg3[_index0], _arg3[(_index0 + 1)], _arg3[_index1], _arg3[(_index1 + 1)]);
							break;
					};
				};
				_local9.endFill();
			} else {
				_index0 = (_arg5[_arg6] * 3);
				_index1 = (_arg5[(_arg6 + 1)] * 3);
				_index2 = (_arg5[(_arg6 + 2)] * 3);
				_local9.lineStyle();
				_local9.moveTo(_arg3[_index0], _arg3[(_index0 + 1)]);
				_local9.beginFill(_arg1, _arg2);
				_local9.lineTo(_arg3[_index1], _arg3[(_index1 + 1)]);
				_local9.lineTo(_arg3[_index2], _arg3[(_index2 + 1)]);
				_local9.endFill();
			};
		}
		public function clear(_arg1:View3D):void{
			var _local2:AbstractRenderSession;
			var _local3:Array;
			var _local4:Dictionary;
			updated = ((((_arg1.updated) || (_arg1.forceUpdate))) || (_arg1.scene.updatedSessions[this]));
			for each (_local2 in sessions) {
				_local2.clear(_arg1);
			};
			if (updated){
				_consumer = getConsumer(_arg1);
				_spriteLayer = getSpriteLayer(_arg1);
				for each (_local3 in _spriteLayer) {
					_local3.length = 0;
				};
				_shapeLayer = getShapeLayer(_arg1);
				for each (_local3 in _shapeLayer) {
					_local3.length = 0;
				};
				_lightShapeLayer = getLightShapeLayer(_arg1);
				for each (_local4 in _lightShapeLayer) {
					for each (_local3 in _local4) {
						_local3.length = 0;
					};
				};
				_level = -1;
				_material = null;
				_shapeStore = getShapeStore(_arg1);
				_shapeActive = getShapeActive(_arg1);
				i = _shapeActive.length;
				while (i--) {
					_shape = _shapeActive.pop();
					_shape.graphics.clear();
					_shape.filters = [];
					_shape.blendMode = BlendMode.NORMAL;
					_shape.transform.colorTransform = _defaultColorTransform;
					_shapeStore.push(_shape);
				};
				_spriteStore = getSpriteStore(_arg1);
				_spriteActive = getSpriteActive(_arg1);
				i = _spriteActive.length;
				while (i--) {
					_sprite = _spriteActive.pop();
					_sprite.graphics.clear();
					_sprite.filters = [];
					while (_sprite.numChildren) {
						_sprite.removeChildAt(0);
					};
					_spriteStore.push(_sprite);
				};
				_consumer.clear(_arg1);
			};
		}
		protected function onSessionUpdate(_arg1:SessionEvent):void{
			dispatchEvent(_arg1);
		}
		public function getSpriteLayer(_arg1:View3D):Dictionary{
			if (!_spriteLayers[_arg1]){
				return ((_spriteLayers[_arg1] = new Dictionary(true)));
			};
			return (_spriteLayers[_arg1]);
		}
		public function renderBitmap(_arg1:BitmapData, _arg2:ScreenVertex, _arg3:Boolean=false):void{
			if (_layerDirty){
				createLayer();
			};
			m.identity();
			m.tx = (_arg2.x - (_arg1.width / 2));
			m.ty = (_arg2.y - (_arg1.height / 2));
			graphics.lineStyle();
			graphics.beginBitmapFill(_arg1, m, false, _arg3);
			graphics.drawRect((_arg2.x - (_arg1.width / 2)), (_arg2.y - (_arg1.height / 2)), _arg1.width, _arg1.height);
			graphics.endFill();
		}
		public function clone():AbstractRenderSession{
			throw (new Error("Not implemented"));
		}
		public function addDisplayObject(_arg1:DisplayObject):void{
			throw (new Error("Not implemented"));
		}
		public function renderTriangleLineFill(_arg1:Number, _arg2:int, _arg3:Number, _arg4:int, _arg5:Number, _arg6:Array, _arg7:Array, _arg8:Array, _arg9:int, _arg10:int):void{
			if (_layerDirty){
				createLayer();
			};
			if (_arg5 > 0){
				graphics.lineStyle(_arg1, _arg4, _arg5);
			} else {
				graphics.lineStyle();
			};
			if (_arg3 > 0){
				graphics.beginFill(_arg2, _arg3);
			};
			if ((_arg10 - _arg9) > 3){
				while (_arg9 < _arg10) {
					_index0 = (_arg8[_arg9] * 3);
					switch (_arg7[_temp2]){
						case "M":
							graphics.moveTo(_arg6[_index0], _arg6[(_index0 + 1)]);
							break;
						case "L":
							graphics.lineTo(_arg6[_index0], _arg6[(_index0 + 1)]);
							break;
						case "C":
							var _temp1 = _arg9;
							_arg9 = (_arg9 + 1);
							_index1 = (_arg8[_temp1] * 3);
							graphics.curveTo(_arg6[_index0], _arg6[(_index0 + 1)], _arg6[_index1], _arg6[(_index1 + 1)]);
							break;
					};
				};
			} else {
				_index0 = (_arg8[_arg9] * 3);
				_index1 = (_arg8[(_arg9 + 1)] * 3);
				_index2 = (_arg8[(_arg9 + 2)] * 3);
				graphics.moveTo((v0x = _arg6[_index0]), (v0y = _arg6[(_index0 + 1)]));
				graphics.lineTo(_arg6[_index1], _arg6[(_index1 + 1)]);
				graphics.lineTo(_arg6[_index2], _arg6[(_index2 + 1)]);
				if (_arg5 > 0){
					graphics.lineTo(v0x, v0y);
				};
			};
			if (_arg3 > 0){
				graphics.endFill();
			};
		}
		public function getConsumer(_arg1:View3D):IPrimitiveConsumer{
			if (_renderers[_arg1]){
				return (_renderers[_arg1]);
			};
			if (_renderer){
				return ((_renderers[_arg1] = _renderer.clone()));
			};
			if (parent){
				return ((_renderers[_arg1] = parent.getConsumer(_arg1).clone()));
			};
			return ((_renderers[_arg1] = (_arg1.session.renderer as IPrimitiveConsumer).clone()));
		}
		private function onObjectSessionUpdate(_arg1:Object3DEvent):void{
			notifySessionUpdate();
		}
		public function clearChildSessions():void{
			var _local1:AbstractRenderSession;
			for each (_local1 in sessions) {
				_local1.removeOnSessionUpdate(onSessionUpdate);
			};
			sessions.length = 0;
		}
		private function getSpriteActive(_arg1:View3D):Array{
			if (!_spriteActives[_arg1]){
				return ((_spriteActives[_arg1] = []));
			};
			return (_spriteActives[_arg1]);
		}
		function internalRemoveSceneSession(_arg1:AbstractRenderSession):void{
			sessions = [];
			_arg1.removeOnSessionUpdate(onSessionUpdate);
		}
		public function render(_arg1:View3D):void{
			var _local2:AbstractRenderSession;
			for each (_local2 in sessions) {
				_local2.render(_arg1);
			};
			if (updated){
				(getConsumer(_arg1) as IRenderer).render(_arg1);
			};
		}
		public function renderTriangleBitmap(_arg1:BitmapData, _arg2:Matrix, _arg3:Array, _arg4:Array, _arg5:Number, _arg6:Number, _arg7:Boolean, _arg8:Boolean, _arg9:Graphics=null):void{
			if (((!(_arg9)) && (_layerDirty))){
				createLayer();
			};
			_index0 = (_arg4[_arg5] * 3);
			_index1 = (_arg4[(_arg5 + 1)] * 3);
			_index2 = (_arg4[(_arg5 + 2)] * 3);
			a2 = ((v1x = _arg3[_index1]) - (v0x = _arg3[_index0]));
			b2 = ((v1y = _arg3[(_index1 + 1)]) - (v0y = _arg3[(_index0 + 1)]));
			c2 = ((v2x = _arg3[_index2]) - v0x);
			d2 = ((v2y = _arg3[(_index2 + 1)]) - v0y);
			m.a = (((a = _arg2.a) * a2) + ((b = _arg2.b) * c2));
			m.b = ((a * b2) + (b * d2));
			m.c = (((c = _arg2.c) * a2) + ((d = _arg2.d) * c2));
			m.d = ((c * b2) + (d * d2));
			m.tx = ((((tx = _arg2.tx) * a2) + ((ty = _arg2.ty) * c2)) + v0x);
			m.ty = (((tx * b2) + (ty * d2)) + v0y);
			area = (((v0x * (d2 - b2)) - (v1x * d2)) + (v2x * b2));
			if (area < 0){
				area = -(area);
			};
			if (_arg9){
				_arg9.lineStyle();
				_arg9.moveTo(v0x, v0y);
				_arg9.beginBitmapFill(_arg1, m, _arg8, ((_arg7) && ((area > 400))));
				_arg9.lineTo(v1x, v1y);
				_arg9.lineTo(v2x, v2y);
				_arg9.endFill();
			} else {
				graphics.lineStyle();
				graphics.moveTo(v0x, v0y);
				graphics.beginBitmapFill(_arg1, m, _arg8, ((_arg7) && ((area > 400))));
				graphics.lineTo(v1x, v1y);
				graphics.lineTo(v2x, v2y);
				graphics.endFill();
			};
		}
		public function getLightShapeLayer(_arg1:View3D):Dictionary{
			if (!_lightShapeLayers[_arg1]){
				return ((_lightShapeLayers[_arg1] = new Dictionary(true)));
			};
			return (_lightShapeLayers[_arg1]);
		}
		public function renderBillboardColor(_arg1:int, _arg2:Number, _arg3:DrawBillboard):void{
			if (_layerDirty){
				createLayer();
			};
			if (_arg3.rotation != 0){
				graphics.beginFill(_arg1, _arg2);
				graphics.moveTo(_arg3.topleftx, _arg3.toplefty);
				graphics.lineTo(_arg3.toprightx, _arg3.toprighty);
				graphics.lineTo(_arg3.bottomrightx, _arg3.bottomrighty);
				graphics.lineTo(_arg3.bottomleftx, _arg3.bottomlefty);
				graphics.lineTo(_arg3.topleftx, _arg3.toplefty);
				graphics.endFill();
			} else {
				graphics.beginFill(_arg1, _arg2);
				graphics.drawRect(_arg3.minX, _arg3.minY, (_arg3.maxX - _arg3.minX), (_arg3.maxY - _arg3.minY));
				graphics.endFill();
			};
		}
		public function set renderer(_arg1:IPrimitiveConsumer):void{
			var _local2:AbstractRenderSession;
			if (_renderer == _arg1){
				return;
			};
			_renderer = _arg1;
			clearRenderers();
			for each (_local2 in sessions) {
				_local2.clearRenderers();
			};
		}
		public function removeChildSession(_arg1:AbstractRenderSession):void{
			var _local2:int;
			_arg1.removeOnSessionUpdate(onSessionUpdate);
			_local2 = sessions.indexOf(_arg1);
			if (_local2 == -1){
				return;
			};
			sessions.splice(_local2, 1);
		}
		function internalRemoveOwnSession(_arg1:Object3D):void{
			_arg1.removeEventListener(Object3DEvent.SESSION_UPDATED, onObjectSessionUpdate);
		}
		public function get renderer():IPrimitiveConsumer{
			return (_renderer);
		}
		public function getContainer(_arg1:View3D):DisplayObject{
			throw (new Error("Not implemented"));
		}
		public function renderLine(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:uint, _arg7:Number):void{
			if (_layerDirty){
				createLayer();
			};
			graphics.lineStyle(_arg5, _arg6, _arg7);
			graphics.moveTo(_arg1, _arg2);
			graphics.lineTo(_arg3, _arg4);
		}
		private function getShapeStore(_arg1:View3D):Array{
			if (!_shapeStores[_arg1]){
				return ((_shapeStores[_arg1] = []));
			};
			return (_shapeStores[_arg1]);
		}
		private function getShapeActive(_arg1:View3D):Array{
			if (!_shapeActives[_arg1]){
				return ((_shapeActives[_arg1] = []));
			};
			return (_shapeActives[_arg1]);
		}
		public function getSprite(_arg1:ILayerMaterial, _arg2:int, _arg3:Sprite=null):Sprite{
			if (!(_array = _spriteLayer[_arg1])){
				_array = (_spriteLayer[_arg1] = []);
			};
			if (((!(_arg3)) && (!((_arg1 == _material))))){
				_level = -1;
				_material = _arg1;
			};
			if ((((_level >= _arg2)) && (_array.length))){
				_sprite = _array[0];
			} else {
				_level = _arg2;
				_array.unshift((_sprite = createSprite(_arg3)));
			};
			return (_sprite);
		}
		protected function createLayer():void{
			throw (new Error("Not implemented"));
		}
		public function renderTriangleLine(_arg1:Number, _arg2:int, _arg3:Number, _arg4:Array, _arg5:Array, _arg6:Array, _arg7:Number, _arg8:Number):void{
			if (_layerDirty){
				createLayer();
			};
			graphics.lineStyle(_arg1, _arg2, _arg3);
			if ((_arg8 - _arg7) > 3){
				while (_arg7 < _arg8) {
					_index0 = (_arg6[_arg7] * 3);
					switch (_arg5[_temp2]){
						case "M":
							graphics.moveTo(_arg4[_index0], _arg4[(_index0 + 1)]);
							break;
						case "L":
							graphics.lineTo(_arg4[_index0], _arg4[(_index0 + 1)]);
							break;
						case "C":
							var _temp1 = _arg7;
							_arg7 = (_arg7 + 1);
							_index1 = (_arg6[_temp1] * 3);
							graphics.curveTo(_arg4[_index0], _arg4[(_index0 + 1)], _arg4[_index1], _arg4[(_index1 + 1)]);
							break;
					};
				};
			} else {
				_index0 = (_arg6[_arg7] * 3);
				_index1 = (_arg6[(_arg7 + 1)] * 3);
				_index2 = (_arg6[(_arg7 + 2)] * 3);
				graphics.moveTo((v0x = _arg4[_index0]), (v0y = _arg4[(_index0 + 1)]));
				graphics.lineTo(_arg4[_index1], _arg4[(_index1 + 1)]);
				graphics.lineTo(_arg4[_index2], _arg4[(_index2 + 1)]);
				graphics.lineTo(v0x, v0y);
			};
		}
		public function renderScaledBitmap(_arg1:DrawScaledBitmap, _arg2:BitmapData, _arg3:Matrix, _arg4:Boolean=false):void{
			if (_layerDirty){
				createLayer();
			};
			graphics.lineStyle();
			if (_arg1.rotation != 0){
				graphics.beginBitmapFill(_arg2, _arg3, false, _arg4);
				graphics.moveTo(_arg1.topleftx, _arg1.toplefty);
				graphics.lineTo(_arg1.toprightx, _arg1.toprighty);
				graphics.lineTo(_arg1.bottomrightx, _arg1.bottomrighty);
				graphics.lineTo(_arg1.bottomleftx, _arg1.bottomlefty);
				graphics.lineTo(_arg1.topleftx, _arg1.toplefty);
				graphics.endFill();
			} else {
				graphics.beginBitmapFill(_arg2, _arg3, false, _arg4);
				graphics.drawRect(_arg1.minX, _arg1.minY, (_arg1.maxX - _arg1.minX), (_arg1.maxY - _arg1.minY));
				graphics.endFill();
			};
		}
		public function getTotalFaces(_arg1:View3D):int{
			var _local2:int;
			var _local3:AbstractRenderSession;
			_local2 = getConsumer(_arg1).list().length;
			for each (_local3 in sessions) {
				_local2 = (_local2 + _local3.getTotalFaces(_arg1));
			};
			return (_local2);
		}
		protected function createSprite(_arg1:Sprite=null):Sprite{
			throw (new Error("Not implemented"));
		}
		private function getSpriteStore(_arg1:View3D):Array{
			if (!_spriteStores[_arg1]){
				return ((_spriteStores[_arg1] = []));
			};
			return (_spriteStores[_arg1]);
		}
		public function renderBillboardBitmap(_arg1:BitmapData, _arg2:DrawBillboard, _arg3:Boolean):void{
			if (_layerDirty){
				createLayer();
			};
			if (_arg2.rotation != 0){
				graphics.beginBitmapFill(_arg1, _arg2.mapping, false, _arg3);
				graphics.moveTo(_arg2.topleftx, _arg2.toplefty);
				graphics.lineTo(_arg2.toprightx, _arg2.toprighty);
				graphics.lineTo(_arg2.bottomrightx, _arg2.bottomrighty);
				graphics.lineTo(_arg2.bottomleftx, _arg2.bottomlefty);
				graphics.lineTo(_arg2.topleftx, _arg2.toplefty);
				graphics.endFill();
			} else {
				graphics.beginBitmapFill(_arg1, _arg2.mapping, false, _arg3);
				graphics.drawRect(_arg2.minX, _arg2.minY, (_arg2.maxX - _arg2.minX), (_arg2.maxY - _arg2.minY));
				graphics.endFill();
			};
		}
		public function getShape(_arg1:ILayerMaterial, _arg2:int, _arg3:Sprite):Shape{
			if (!(_array = _shapeLayer[_arg1])){
				_array = (_shapeLayer[_arg1] = []);
			};
			if ((((_level >= _arg2)) && (_array.length))){
				_shape = _array[0];
			} else {
				_level = _arg2;
				_array.unshift((_shape = createShape(_arg3)));
			};
			return (_shape);
		}

	}
}//package away3d.core.render 
Section 83
//BasicRenderer (away3d.core.render.BasicRenderer)
package away3d.core.render {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.cameras.*;
	import away3d.core.clip.*;
	import away3d.core.block.*;
	import away3d.core.filter.*;

	public class BasicRenderer implements IRenderer, IPrimitiveConsumer {

		private var _camera:Camera3D;
		private var _primitives:Array;
		private var _scene:Scene3D;
		private var _filter:IPrimitiveFilter;
		private var _blockers:Array;
		private var _primitive:DrawPrimitive;
		private var _screenClipping:Clipping;
		private var _filters:Array;

		public function BasicRenderer(... _args){
			_primitives = new Array();
			super();
			_filters = _args;
			_filters.push(new ZSortFilter());
		}
		public function clear(_arg1:View3D):void{
			_primitives.length = 0;
			_scene = _arg1.scene;
			_camera = _arg1.camera;
			_screenClipping = _arg1.screenClipping;
			_blockers = _arg1.blockerarray.list();
		}
		public function render(_arg1:View3D):void{
			for each (_filter in _filters) {
				_primitives = _filter.filter(_primitives, _scene, _camera, _screenClipping);
			};
			for each (_primitive in _primitives) {
				_primitive.render();
			};
		}
		public function list():Array{
			return (_primitives);
		}
		public function clone():IPrimitiveConsumer{
			var _local1:BasicRenderer;
			_local1 = new BasicRenderer();
			_local1.filters = filters;
			return (_local1);
		}
		public function primitive(_arg1:DrawPrimitive):Boolean{
			var _local2:Blocker;
			if (!_screenClipping.checkPrimitive(_arg1)){
				return (false);
			};
			for each (_local2 in _blockers) {
				if (_local2.screenZ > _arg1.minZ){
				} else {
					if (_local2.block(_arg1)){
						return (false);
					};
				};
			};
			_primitives.push(_arg1);
			return (true);
		}
		public function toString():String{
			return ((("Basic [" + _filters.join("+")) + "]"));
		}
		public function get filters():Array{
			return (_filters.slice(0, (_filters.length - 1)));
		}
		public function set filters(_arg1:Array):void{
			_filters = _arg1;
			_filters.push(new ZSortFilter());
		}

	}
}//package away3d.core.render 
Section 84
//BitmapRenderSession (away3d.core.render.BitmapRenderSession)
package away3d.core.render {
	import flash.geom.*;
	import flash.display.*;
	import away3d.containers.*;
	import flash.utils.*;

	public class BitmapRenderSession extends AbstractRenderSession {

		private var _bitmapContainers:Dictionary;
		private var _container:Sprite;
		private var _cm:Matrix;
		private var _cy:Number;
		private var _cx:Number;
		private var _bitmapwidth:int;
		private var layers:Array;
		private var _height:int;
		private var _scale:Number;
		private var _base:BitmapData;
		private var _width:int;
		private var _bitmapContainer:Bitmap;
		private var _bitmapheight:int;

		public function BitmapRenderSession(_arg1:Number=2){
			_bitmapContainers = new Dictionary(true);
			layers = new Array();
			super();
			if (_scale <= 0){
				throw (new Error("scale cannot be negative or zero"));
			};
			_scale = _arg1;
		}
		override public function clear(_arg1:View3D):void{
			super.clear(_arg1);
			if (updated){
				_base = getBitmapData(_arg1);
				_cx = (_bitmapContainer.x = _arg1.screenClipping.minX);
				_cy = (_bitmapContainer.y = _arg1.screenClipping.minY);
				_bitmapContainer.scaleX = _scale;
				_bitmapContainer.scaleY = _scale;
				_cm = new Matrix();
				_cm.scale((1 / _scale), (1 / _scale));
				_cm.translate((-(_arg1.screenClipping.minX) / _scale), (-(_arg1.screenClipping.minY) / _scale));
				_base.lock();
				_base.fillRect(_base.rect, 0);
				layers.length = 0;
				_layerDirty = true;
				layer = null;
			};
			if (((((filters) && (filters.length))) || (((_bitmapContainer.filters) && (_bitmapContainer.filters.length))))){
				_bitmapContainer.filters = filters;
			};
			_bitmapContainer.alpha = ((alpha) || (1));
			_bitmapContainer.blendMode = ((blendMode) || (BlendMode.NORMAL));
		}
		override public function clone():AbstractRenderSession{
			return (new BitmapRenderSession(_scale));
		}
		override public function addDisplayObject(_arg1:DisplayObject):void{
			layers.push(_arg1);
			_arg1.visible = true;
			_layerDirty = true;
		}
		public function getBitmapData(_arg1:View3D):BitmapData{
			_container = (getContainer(_arg1) as Sprite);
			if (!_bitmapContainer.bitmapData){
				_bitmapwidth = int(((_width = (_arg1.screenClipping.maxX - _arg1.screenClipping.minX)) / _scale));
				_bitmapheight = int(((_height = (_arg1.screenClipping.maxY - _arg1.screenClipping.minY)) / _scale));
				return ((_bitmapContainer.bitmapData = new BitmapData(_bitmapwidth, _bitmapheight, true, 0)));
			};
			return (_bitmapContainer.bitmapData);
		}
		override public function render(_arg1:View3D):void{
			var _local2:DisplayObject;
			super.render(_arg1);
			if (updated){
				for each (_local2 in layers) {
					_base.draw(_local2, _cm, _local2.transform.colorTransform, _local2.blendMode, _base.rect);
				};
				_base.unlock();
			};
		}
		override protected function createLayer():void{
			if (_shapeStore.length){
				_shapeActive.push((_shape = _shapeStore.pop()));
			} else {
				_shapeActive.push((_shape = new Shape()));
			};
			layer = _shape;
			graphics = _shape.graphics;
			layers.push(_shape);
			_layerDirty = false;
		}
		override public function getContainer(_arg1:View3D):DisplayObject{
			_bitmapContainer = getBitmapContainer(_arg1);
			if (!_containers[_arg1]){
				_container = (_containers[_arg1] = new Sprite());
				_container.addChild(_bitmapContainer);
				return (_container);
			};
			return (_containers[_arg1]);
		}
		override protected function createSprite(_arg1:Sprite=null):Sprite{
			if (_spriteStore.length){
				_spriteActive.push((_sprite = _spriteStore.pop()));
			} else {
				_spriteActive.push((_sprite = new Sprite()));
			};
			if (_arg1){
				_arg1.addChild(_sprite);
			} else {
				layers.push(_sprite);
			};
			_layerDirty = true;
			return (_sprite);
		}
		public function getBitmapContainer(_arg1:View3D):Bitmap{
			if (!_bitmapContainers[_arg1]){
				return ((_bitmapContainers[_arg1] = new Bitmap()));
			};
			return (_bitmapContainers[_arg1]);
		}

	}
}//package away3d.core.render 
Section 85
//IRenderer (away3d.core.render.IRenderer)
package away3d.core.render {
	import away3d.containers.*;

	public interface IRenderer {

		function render(_arg1:View3D):void;
		function toString():String;

	}
}//package away3d.core.render 
Section 86
//SpriteRenderSession (away3d.core.render.SpriteRenderSession)
package away3d.core.render {
	import flash.geom.*;
	import flash.display.*;
	import away3d.containers.*;
	import away3d.core.clip.*;
	import away3d.events.*;

	public class SpriteRenderSession extends AbstractRenderSession {

		private var _container:Sprite;
		private var _clip:Clipping;
		public var cacheAsBitmap:Boolean;

		public function SpriteRenderSession():void{
		}
		override public function clear(_arg1:View3D):void{
			super.clear(_arg1);
			_container = (getContainer(_arg1) as Sprite);
			if (updated){
				layer = _container;
				graphics = _container.graphics;
				if (this == _arg1.session){
					_clip = _arg1.screenClipping;
					_container.scrollRect = new Rectangle((_clip.minX - 1), (_clip.minY - 1), ((_clip.maxX - _clip.minX) + 2), ((_clip.maxY - _clip.minY) + 2));
					_container.x = (_clip.minX - 1);
					_container.y = (_clip.minY - 1);
				};
				_container.cacheAsBitmap = false;
				graphics.clear();
				while (_container.numChildren) {
					_container.removeChildAt(0);
				};
			} else {
				_container.cacheAsBitmap = cacheAsBitmap;
			};
			if (((((filters) && (filters.length))) || (((_container.filters) && (_container.filters.length))))){
				_container.filters = filters;
			};
			_container.alpha = alpha;
			_container.blendMode = ((blendMode) || (BlendMode.NORMAL));
		}
		override public function clone():AbstractRenderSession{
			return (new SpriteRenderSession());
		}
		override protected function onSessionUpdate(_arg1:SessionEvent):void{
			super.onSessionUpdate(_arg1);
			cacheAsBitmap = false;
		}
		override public function addDisplayObject(_arg1:DisplayObject):void{
			_container.addChild(_arg1);
			_arg1.visible = true;
			layer = null;
			_level = -1;
			_layerDirty = true;
		}
		override protected function createLayer():void{
			if (_shapeStore.length){
				_shapeActive.push((_shape = _shapeStore.pop()));
			} else {
				_shapeActive.push((_shape = new Shape()));
			};
			layer = _shape;
			graphics = _shape.graphics;
			_container.addChild(_shape);
			_layerDirty = false;
			_level = -1;
		}
		override public function getContainer(_arg1:View3D):DisplayObject{
			if (!_containers[_arg1]){
				return ((_containers[_arg1] = new Sprite()));
			};
			return (_containers[_arg1]);
		}
		override protected function createSprite(_arg1:Sprite=null):Sprite{
			if (_spriteStore.length){
				_spriteActive.push((_sprite = _spriteStore.pop()));
			} else {
				_spriteActive.push((_sprite = new Sprite()));
			};
			if (_arg1){
				_arg1.addChild(_sprite);
			} else {
				_container.addChild(_sprite);
				layer = _sprite;
			};
			_layerDirty = true;
			return (_sprite);
		}

	}
}//package away3d.core.render 
Section 87
//Logo (away3d.core.stats.Logo)
package away3d.core.stats {
	import flash.display.*;

	public class Logo extends Shape {

		private var arr:Array;

		public function Logo(){
			var _local1:int;
			var _local2:int;
			arr = [[7, 1, 262151], [8, 1, 3215136], [9, 1, 2033436], [10, 1, 1], [7, 2, 2098723], [8, 2, 5908501], [9, 2, 4922400], [10, 2, 720913], [6, 3, 327691], [7, 3, 6957102], [8, 3, 5975556], [9, 3, 6368779], [10, 3, 4789809], [11, 3, 2], [6, 4, 2361127], [7, 4, 10833686], [8, 4, 4926728], [9, 4, 6239495], [10, 4, 9190690], [11, 4, 1114647], [5, 5, 786453], [6, 5, 7088423], [7, 5, 14055707], [8, 5, 2103310], [9, 5, 3877139], [10, 5, 13134098], [11, 5, 5577773], [12, 5, 131077], [4, 6, 1], [5, 6, 3608110], [6, 6, 11227664], [7, 6, 12748351], [8, 6, 65793], [9, 6, 986379], [10, 6, 14980667], [11, 6, 10044437], [12, 6, 2230306], [4, 7, 0x12001C], [5, 7, 8007967], [6, 7, 14911011], [7, 7, 6509633], [10, 7, 9138771], [11, 7, 13989655], [12, 7, 7350824], [13, 7, 327689], [3, 8, 262153], [4, 8, 4592689], [5, 8, 12016138], [6, 8, 15774570], [7, 8, 855309], [10, 8, 2434083], [11, 8, 16233056], [12, 8, 11489803], [13, 8, 3345958], [3, 9, 1966887], [4, 9, 8665113], [5, 9, 15636021], [6, 9, 6773581], [11, 9, 9140836], [12, 9, 15240489], [13, 9, 8467743], [14, 9, 852240], [2, 10, 458767], [3, 10, 5774639], [4, 10, 13265683], [5, 10, 10845518], [6, 10, 0x0101], [11, 10, 657931], [12, 10, 14396016], [13, 10, 12739344], [14, 10, 5184297], [15, 10, 2], [2, 11, 2557230], [3, 11, 10307863], [4, 11, 12548133], [5, 11, 723464], [12, 11, 1512721], [13, 11, 14651446], [14, 11, 10307352], [15, 11, 1508630], [1, 12, 983068], [2, 12, 7154221], [3, 12, 9522185], [4, 12, 1314568], [6, 12, 131586], [7, 12, 921102], [8, 12, 0x1A1A1A], [9, 12, 0x171717], [10, 12, 657930], [13, 12, 2892051], [14, 12, 12610067], [15, 12, 7220009], [16, 12, 196614], [1, 13, 3936052], [2, 13, 5908749], [3, 13, 1773570], [4, 13, 4402968], [5, 13, 10714191], [6, 13, 12884326], [7, 13, 14396274], [8, 13, 15053429], [9, 13, 14790257], [10, 13, 13935206], [11, 13, 12159571], [12, 13, 9265971], [13, 13, 2759432], [14, 13, 2561537], [15, 13, 8601360], [16, 13, 3346464], [1, 14, 3938326], [2, 14, 5712395], [3, 14, 10900499], [4, 14, 11951126], [5, 14, 11490833], [6, 14, 11358991], [7, 14, 11227662], [8, 14, 11161870], [9, 14, 11030286], [10, 14, 10964497], [11, 14, 10898963], [12, 14, 10833429], [13, 14, 11096344], [14, 14, 8797973], [15, 14, 4595726], [16, 14, 4594459], [17, 14, 327941], [1, 15, 2296596], [2, 15, 3280925], [3, 15, 2821148], [4, 15, 2624284], [5, 15, 2558749], [6, 15, 2624031], [7, 15, 2558496], [8, 15, 2558498], [9, 15, 2492705], [10, 15, 2361630], [11, 15, 2361374], [12, 15, 2295839], [13, 15, 2295840], [14, 15, 2427171], [15, 15, 2624036], [16, 15, 1377300]];
			super();
			graphics.beginFill(0);
			graphics.drawRect(0, 0, 18, 17);
			_local1 = arr.length;
			_local2 = 0;
			while (_local2 < _local1) {
				graphics.beginFill(Number(arr[_local2][2]));
				graphics.drawRect(arr[_local2][0], arr[_local2][1], 1, 1);
				_local2++;
			};
			graphics.endFill();
		}
	}
}//package away3d.core.stats 
Section 88
//StaticTextField (away3d.core.stats.StaticTextField)
package away3d.core.stats {
	import flash.text.*;

	public class StaticTextField extends TextField {

		public var defaultText:String;

		public function StaticTextField(_arg1:String=null, _arg2:TextFormat=null){
			defaultTextFormat = (_arg2) ? _arg2 : new TextFormat("Verdana", 10, 0);
			selectable = false;
			mouseEnabled = false;
			mouseWheelEnabled = false;
			autoSize = "left";
			tabEnabled = false;
			if (_arg1){
				this.htmlText = _arg1;
			};
		}
	}
}//package away3d.core.stats 
Section 89
//Stats (away3d.core.stats.Stats)
package away3d.core.stats {
	import flash.geom.*;
	import flash.display.*;
	import flash.events.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.cameras.*;
	import flash.utils.*;
	import flash.net.*;
	import flash.text.*;
	import flash.system.*;
	import flash.ui.*;

	public class Stats extends Sprite {

		private const APPLICATION_NAME:String = "Away3D.com";
		private const VERSION:String = "2";
		private const REVISION:String = "4.0";

		private var bar:Sprite;
		private var swfframerateLabel:StaticTextField;
		private var cambtn:Sprite;
		private var geomLastAdded:String;
		private var totalElements:int;// = 0
		private var faceRenderLabel:StaticTextField;
		private var defautTF:TextFormat;
		private var camLabel:TextField;
		private var defautTFBold:TextFormat;
		private var bestfps:int;// = 0
		private var stageframerate:Number;
		private var rectclose:Rectangle;
		private var faceLabel:StaticTextField;
		public var stats:String;// = ""
		private var menu0:ContextMenuItem;
		private var menu2:ContextMenuItem;
		public var geomMenu:Sprite;// = null
		private var menu1:ContextMenuItem;
		private var avfpsLabel:StaticTextField;
		private var refreshes:int;// = 0
		private var rectclear:Rectangle;
		private var displayState:int;
		private var clearbtn:Sprite;
		private var meshLabel:StaticTextField;
		private var barscale:int;// = 0
		var type:String;
		private var geomDetailsLabel:TextField;
		public var displayMenu:Sprite;// = null
		public var sourceURL:String;
		private var peakLabel:StaticTextField;
		private var meshes:int;// = 0
		private var closebtn:Sprite;
		var url:String;
		private var rectcam:Rectangle;
		private var ramLabel:StaticTextField;
		private var titleField:StaticTextField;
		private var fpsLabel:StaticTextField;
		private var perfLabel:StaticTextField;
		private var geombtn:Sprite;
		private var barwidth:int;// = 0
		private var lastrender:int;
		var elementcount:int;
		private var camMenu:Sprite;
		private var camProp:Array;
		public var scopeMenu:View3D;// = null
		private var rectdetails:Rectangle;
		private var lowestfps:int;// = 999
		private var fpstotal:int;// = 0

		public function Stats(_arg1:View3D, _arg2:Number=0){
			var _local3:ContextMenu;
			totalElements = 0;
			meshes = 0;
			scopeMenu = null;
			displayMenu = null;
			geomMenu = null;
			fpstotal = 0;
			refreshes = 0;
			bestfps = 0;
			lowestfps = 999;
			barwidth = 0;
			barscale = 0;
			rectclose = new Rectangle(228, 4, 18, 17);
			rectcam = new Rectangle(207, 4, 18, 17);
			rectclear = new Rectangle(186, 4, 18, 17);
			rectdetails = new Rectangle(165, 4, 18, 17);
			defautTF = new TextFormat("Verdana", 10, 0);
			defautTFBold = new TextFormat("Verdana", 10, 0, true);
			stats = "";
			super();
			scopeMenu = _arg1;
			stageframerate = (_arg2) ? _arg2 : 30;
			displayState = 0;
			sourceURL = _arg1.sourceURL;
			tabEnabled = false;
			menu0 = new ContextMenuItem("Away3D Project stats", true, true, true);
			menu1 = new ContextMenuItem("View Source", true, true, true);
			menu2 = new ContextMenuItem(((((APPLICATION_NAME + "\tv") + VERSION) + ".") + REVISION), true, true, true);
			_local3 = new ContextMenu();
			_local3 = new ContextMenu();
			_local3.customItems = (sourceURL) ? [menu0, menu1, menu2] : [menu0, menu2];
			menu0.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, displayStats);
			menu1.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, viewSource);
			menu2.addEventListener(ContextMenuEvent.MENU_ITEM_SELECT, visitWebsite);
			_local3.hideBuiltInItems();
			scopeMenu.contextMenu = _local3;
		}
		public function clearObjects():void{
			stats = "";
			totalElements = 0;
			meshes = 0;
			geomLastAdded = "";
		}
		private function createGeometryMenu():void{
			var _local1:Matrix;
			geomMenu = new Sprite();
			_local1 = new Matrix();
			_local1.rotate(((90 * Math.PI) / 180));
			geomMenu.graphics.beginGradientFill("linear", [3355494, 0xCCCCCC], [1, 1], [0, 0xFF], _local1, "pad", "rgb", 0);
			geomMenu.graphics.drawRect(0, 0, 250, 200);
			displayMenu.addChild(geomMenu);
			geomMenu.y = 26;
			geomDetailsLabel = new TextField();
			geomDetailsLabel.x = 3;
			geomDetailsLabel.y = 3;
			geomDetailsLabel.defaultTextFormat = defautTF;
			geomDetailsLabel.text = stats;
			geomDetailsLabel.height = 200;
			geomDetailsLabel.width = 235;
			geomDetailsLabel.multiline = true;
			geomDetailsLabel.selectable = true;
			geomDetailsLabel.wordWrap = true;
			geomMenu.addChild(geomDetailsLabel);
		}
		private function showGeomInfo():void{
			if (geomMenu == null){
				createGeometryMenu();
			} else {
				displayMenu.addChild(geomMenu);
				geomMenu.y = 26;
			};
		}
		private function clearStats():void{
			fpstotal = 0;
			refreshes = 0;
			bestfps = 0;
			lowestfps = 999;
		}
		private function closeOtherScreen(_arg1:int):void{
			switch (_arg1){
				case 1:
					hideCamInfo();
					break;
				case 2:
					hideGeomInfo();
			};
		}
		private function generateSprite():void{
			var _local1:Matrix;
			var _local2:Sprite;
			var _local3:Graphics;
			var _local4:Graphics;
			var _local5:Graphics;
			var _local6:StaticTextField;
			var _local7:StaticTextField;
			var _local8:StaticTextField;
			var _local9:StaticTextField;
			var _local10:StaticTextField;
			var _local11:StaticTextField;
			var _local12:StaticTextField;
			var _local13:StaticTextField;
			var _local14:StaticTextField;
			displayMenu = new Sprite();
			_local1 = new Matrix();
			_local1.rotate(((90 * Math.PI) / 180));
			displayMenu.graphics.beginGradientFill("linear", [3355494, 0xCCCCCC], [1, 1], [0, 0xFF], _local1, "pad", "rgb", 0);
			displayMenu.graphics.drawRect(0, 0, 250, 86);
			displayMenu.graphics.beginFill(3355494);
			displayMenu.graphics.drawRect(3, 3, 244, 20);
			scopeMenu.addChild(displayMenu);
			displayMenu.x = (displayMenu.x - (displayMenu.width * 0.5));
			displayMenu.y = (displayMenu.y - (displayMenu.height * 0.5));
			closebtn = new Sprite();
			closebtn.graphics.beginFill(0x666666);
			closebtn.graphics.drawRect(0, 0, 18, 17);
			_local2 = new Sprite();
			_local2.graphics.beginFill(13029592);
			_local2.graphics.drawRect(2, 7, 14, 4);
			_local2.graphics.endFill();
			_local2.graphics.beginFill(13029592);
			_local2.graphics.drawRect(7, 2, 4, 14);
			_local2.graphics.endFill();
			_local2.rotation = 45;
			_local2.x = (_local2.x + 9);
			_local2.y = (_local2.y - 4);
			closebtn.addChild(_local2);
			displayMenu.addChild(closebtn);
			closebtn.x = 228;
			closebtn.y = 4;
			cambtn = new Sprite();
			_local3 = cambtn.graphics;
			_local3.beginFill(0x666666);
			_local3.drawRect(0, 0, 18, 17);
			_local3.endFill();
			_local3.beginFill(13029592);
			_local3.moveTo(10, 8);
			_local3.lineTo(16, 4);
			_local3.lineTo(16, 14);
			_local3.lineTo(10, 10);
			_local3.lineTo(10, 8);
			_local3.drawRect(2, 6, 8, 6);
			_local3.endFill();
			displayMenu.addChild(cambtn);
			cambtn.x = 207;
			cambtn.y = 4;
			clearbtn = new Sprite();
			_local4 = clearbtn.graphics;
			_local4.beginFill(0x666666);
			_local4.drawRect(0, 0, 18, 17);
			_local4.endFill();
			_local4.beginFill(13029592);
			_local4.drawRect(6, 6, 6, 6);
			_local4.endFill();
			displayMenu.addChild(clearbtn);
			clearbtn.x = 186;
			clearbtn.y = 4;
			geombtn = new Sprite();
			_local5 = geombtn.graphics;
			_local5.beginFill(0x666666);
			_local5.drawRect(0, 0, 18, 17);
			_local5.endFill();
			_local5.beginFill(13029592, 0.7);
			_local5.moveTo(3, 4);
			_local5.lineTo(11, 2);
			_local5.lineTo(16, 5);
			_local5.lineTo(7, 7);
			_local5.lineTo(3, 4);
			_local5.beginFill(8225929, 0.8);
			_local5.moveTo(3, 4);
			_local5.lineTo(7, 7);
			_local5.lineTo(7, 16);
			_local5.lineTo(3, 12);
			_local5.lineTo(3, 4);
			_local5.beginFill(13029592, 1);
			_local5.moveTo(7, 7);
			_local5.lineTo(16, 5);
			_local5.lineTo(15, 13);
			_local5.lineTo(7, 16);
			_local5.lineTo(7, 7);
			_local5.endFill();
			_local5.endFill();
			displayMenu.addChild(geombtn);
			geombtn.x = 165;
			geombtn.y = 4;
			displayMenu.graphics.beginGradientFill("linear", [0, 0xFFFFFF], [1, 1], [0, 0xFF], new Matrix(), "pad", "rgb", 0);
			displayMenu.graphics.drawRect(3, 22, 244, 4);
			displayMenu.graphics.endFill();
			bar = new Sprite();
			bar.graphics.beginFill(0xFFFFFF);
			bar.graphics.drawRect(0, 0, 244, 4);
			displayMenu.addChild(bar);
			bar.x = 3;
			bar.y = 22;
			barwidth = 244;
			barscale = int((barwidth / stageframerate));
			displayPicto();
			titleField = new StaticTextField("AWAY3D PROJECT", new TextFormat("Verdana", 10, 0xFFFFFF, true));
			titleField.height = 20;
			titleField.width = 140;
			titleField.x = 22;
			titleField.y = 4;
			displayMenu.addChild(titleField);
			_local6 = new StaticTextField("FPS:", defautTFBold);
			fpsLabel = new StaticTextField();
			displayMenu.addChild(_local6);
			displayMenu.addChild(fpsLabel);
			_local6.x = 3;
			_local6.y = (fpsLabel.y = 30);
			fpsLabel.x = ((_local6.x + _local6.width) - 2);
			_local7 = new StaticTextField("AFPS:", defautTFBold);
			avfpsLabel = new StaticTextField();
			displayMenu.addChild(_local7);
			displayMenu.addChild(avfpsLabel);
			_local7.x = 52;
			_local7.y = (avfpsLabel.y = fpsLabel.y);
			avfpsLabel.x = ((_local7.x + _local7.width) - 2);
			_local8 = new StaticTextField("Max:", defautTFBold);
			peakLabel = new StaticTextField();
			displayMenu.addChild(_local8);
			displayMenu.addChild(peakLabel);
			_local8.x = 107;
			_local8.y = (peakLabel.y = avfpsLabel.y);
			_local8.autoSize = "left";
			peakLabel.x = ((_local8.x + _local8.width) - 2);
			_local9 = new StaticTextField("MS:", defautTFBold);
			perfLabel = new StaticTextField();
			perfLabel.defaultTextFormat = defautTF;
			displayMenu.addChild(_local9);
			displayMenu.addChild(perfLabel);
			_local9.x = 177;
			_local9.y = (perfLabel.y = fpsLabel.y);
			_local9.autoSize = "left";
			perfLabel.x = ((_local9.x + _local9.width) - 2);
			_local10 = new StaticTextField("RAM:", defautTFBold);
			ramLabel = new StaticTextField();
			displayMenu.addChild(_local10);
			displayMenu.addChild(ramLabel);
			_local10.x = 3;
			_local10.y = (ramLabel.y = 46);
			_local10.autoSize = "left";
			ramLabel.x = ((_local10.x + _local10.width) - 2);
			_local11 = new StaticTextField("MESHES:", defautTFBold);
			meshLabel = new StaticTextField();
			displayMenu.addChild(_local11);
			displayMenu.addChild(meshLabel);
			_local11.x = 90;
			_local11.y = (meshLabel.y = ramLabel.y);
			_local11.autoSize = "left";
			meshLabel.x = ((_local11.x + _local11.width) - 2);
			_local12 = new StaticTextField("SWF FR:", defautTFBold);
			swfframerateLabel = new StaticTextField();
			displayMenu.addChild(_local12);
			displayMenu.addChild(swfframerateLabel);
			_local12.x = 170;
			_local12.y = (swfframerateLabel.y = ramLabel.y);
			_local12.autoSize = "left";
			swfframerateLabel.x = ((_local12.x + _local12.width) - 2);
			_local13 = new StaticTextField("T ELEMENTS:", defautTFBold);
			faceLabel = new StaticTextField();
			displayMenu.addChild(_local13);
			displayMenu.addChild(faceLabel);
			_local13.x = 3;
			_local13.y = (faceLabel.y = 62);
			_local13.autoSize = "left";
			faceLabel.x = ((_local13.x + _local13.width) - 2);
			_local14 = new StaticTextField("R ELEMENTS:", defautTFBold);
			faceRenderLabel = new StaticTextField();
			displayMenu.addChild(_local14);
			displayMenu.addChild(faceRenderLabel);
			_local14.x = 115;
			_local14.y = (faceRenderLabel.y = faceLabel.y);
			_local14.autoSize = "left";
			faceRenderLabel.x = ((_local14.x + _local14.width) - 2);
		}
		public function visitWebsite(_arg1:ContextMenuEvent):void{
			var url:String;
			var request:URLRequest;
			var e = _arg1;
			url = "http://www.away3d.com";
			request = new URLRequest(url);
			try {
				navigateToURL(request);
			} catch(error:Error) {
			};
		}
		public function displayStats(_arg1:ContextMenuEvent=null):void{
			if (!displayMenu){
				scopeMenu.statsOpen = true;
				generateSprite();
				addEventMouse();
			};
		}
		private function mouseReleased(_arg1:MouseEvent):void{
			displayMenu.stopDrag();
			scopeMenu.removeEventListener(MouseEvent.MOUSE_UP, mouseReleased);
		}
		public function viewSource(_arg1:ContextMenuEvent):void{
			var request:URLRequest;
			var e = _arg1;
			request = new URLRequest(sourceURL);
			try {
				navigateToURL(request, "_blank");
			} catch(error:Error) {
			};
		}
		private function createCamMenu():void{
			var _local1:Matrix;
			var _local2:TextFormat;
			var _local3:TextField;
			var _local4:int;
			var _local5:int;
			camMenu = new Sprite();
			_local1 = new Matrix();
			_local1.rotate(((90 * Math.PI) / 180));
			camMenu.graphics.beginGradientFill("linear", [3355494, 0xCCCCCC], [1, 1], [0, 0xFF], _local1, "pad", "rgb", 0);
			camMenu.graphics.drawRect(0, 0, 250, 220);
			displayMenu.addChild(camMenu);
			camMenu.y = 26;
			camLabel = new TextField();
			camLabel.height = 210;
			camLabel.width = 170;
			camLabel.multiline = true;
			camLabel.selectable = false;
			_local2 = defautTF;
			_local2.leading = 1.5;
			camLabel.defaultTextFormat = _local2;
			camLabel.wordWrap = true;
			camMenu.addChild(camLabel);
			camLabel.x = 100;
			camLabel.y = 3;
			camProp = ["x", "y", "z", "zoom", "focus", "distance", "panangle", "tiltangle", "targetpanangle", "targettiltangle", "mintiltangle", "maxtiltangle", "steps", "target"];
			_local3 = new TextField();
			_local2 = new TextFormat("Verdana", 10, 0, true);
			_local2.leading = 1.5;
			_local2.align = "right";
			_local3.defaultTextFormat = _local2;
			_local3.x = (_local3.y = 3);
			_local3.multiline = true;
			_local3.selectable = false;
			_local3.autoSize = "left";
			_local3.height = 210;
			_local4 = camProp.length;
			_local5 = 0;
			while (_local5 < _local4) {
				_local3.appendText((camProp[_local5] + ":\n"));
				_local5++;
			};
			camMenu.addChild(_local3);
		}
		public function addObject(_arg1:Mesh):void{
			type = _arg1.type;
			elementcount = _arg1.elements.length;
			url = _arg1.url;
			if (((!((type == null))) && (!((elementcount == 0))))){
				stats = (stats + ((((((" - " + type) + " , elements: ") + elementcount) + ", url: ") + url) + "\n"));
				geomLastAdded = ((((((" - " + type) + " , elements: ") + elementcount) + ", url: ") + url) + "\n");
				totalElements = (totalElements + elementcount);
				meshes = (meshes + 1);
			} else {
				stats = (stats + ((((" - " + type) + " , url: ") + url) + "\n"));
				geomLastAdded = ((((" - " + type) + " , url: ") + url) + "\n");
			};
		}
		public function updateStats(_arg1:int, _arg2:Camera3D):void{
			var now:int;
			var perf:int;
			var procent:int;
			var colorTransform:ColorTransform;
			var fps:int;
			var average:int;
			var w:int;
			var caminfo:String;
			var _length:int;
			var i:int;
			var info:String;
			var renderedfaces = _arg1;
			var camera = _arg2;
			now = getTimer();
			perf = (now - lastrender);
			lastrender = now;
			if (perf < 1000){
				fps = int((1000 / (perf + 0.001)));
				fpstotal = (fpstotal + fps);
				refreshes++;
				average = (fpstotal / refreshes);
				bestfps = ((fps)>bestfps) ? fps : bestfps;
				lowestfps = ((fps)<lowestfps) ? fps : lowestfps;
				w = (barscale * fps);
				bar.width = ((w)<=barwidth) ? w : barwidth;
			};
			procent = ((bar.width / barwidth) * 100);
			colorTransform = bar.transform.colorTransform;
			colorTransform.color = ((((0xFF - (2.55 * procent)) << 16) | ((2.55 * procent) << 8)) | 40);
			bar.transform.colorTransform = colorTransform;
			if (displayState == 0){
				avfpsLabel.text = ("" + average);
				ramLabel.text = (("" + (int(((System.totalMemory / 0x0400) / 102.4)) / 10)) + "MB");
				peakLabel.text = ((lowestfps + "/") + bestfps);
				fpsLabel.text = ("" + fps);
				perfLabel.text = ("" + perf);
				faceLabel.text = ("" + totalElements);
				faceRenderLabel.text = ("" + renderedfaces);
				meshLabel.text = ("" + meshes);
				swfframerateLabel.text = ("" + stageframerate);
			} else {
				if (displayState == 1){
					caminfo = "";
					_length = camProp.length;
					i = 0;
					while (i < _length) {
						try {
							if (i > 12){
								caminfo = (caminfo + (String(camera[camProp[i]]) + "\n"));
							} else {
								info = String(camera[camProp[i]]);
								caminfo = (caminfo + (info.substring(0, 19) + "\n"));
							};
						} catch(e:Error) {
							caminfo = (caminfo + "\n");
						};
						i = (i + 1);
					};
					camLabel.text = caminfo;
				} else {
					if (displayState == 2){
						geomDetailsLabel.text = stats;
					};
				};
			};
		}
		private function showCamInfo():void{
			if (camMenu == null){
				createCamMenu();
			} else {
				displayMenu.addChild(camMenu);
				camMenu.y = 26;
			};
		}
		private function hideGeomInfo():void{
			if (geomMenu != null){
				displayMenu.removeChild(geomMenu);
			};
		}
		private function hideCamInfo():void{
			if (camMenu != null){
				displayMenu.removeChild(camMenu);
			};
		}
		private function closeStats():void{
			scopeMenu.statsOpen = false;
			displayState = 0;
			scopeMenu.removeEventListener(MouseEvent.MOUSE_DOWN, onCheckMouse);
			scopeMenu.removeEventListener(MouseEvent.MOUSE_MOVE, updateTips);
			scopeMenu.removeChild(displayMenu);
			displayMenu = null;
		}
		private function updateTips(_arg1:MouseEvent):void{
			var x:Number;
			var y:Number;
			var pt:Point;
			var me = _arg1;
			if (scopeMenu != null){
				x = displayMenu.mouseX;
				y = displayMenu.mouseY;
				pt = new Point(x, y);
				try {
					if (rectcam.containsPoint(pt)){
						titleField.text = "CAMERA INFO";
					} else {
						if (rectclose.containsPoint(pt)){
							titleField.text = "CLOSE STATS";
						} else {
							if (rectclear.containsPoint(pt)){
								titleField.text = "CLEAR AVERAGES";
							} else {
								if (rectdetails.containsPoint(pt)){
									titleField.text = "MESH INFO";
								} else {
									titleField.text = "AWAY3D PROJECT";
								};
							};
						};
					};
				} catch(e:Error) {
				};
			};
		}
		public function addSourceURL(_arg1:String):void{
			var _local2:ContextMenu;
			sourceURL = _arg1;
			_local2 = new ContextMenu();
			_local2.customItems = (sourceURL) ? [menu0, menu1, menu2] : [menu0, menu2];
			scopeMenu.contextMenu = _local2;
		}
		private function addEventMouse():void{
			scopeMenu.addEventListener(MouseEvent.MOUSE_DOWN, onCheckMouse);
			scopeMenu.addEventListener(MouseEvent.MOUSE_MOVE, updateTips);
		}
		private function onCheckMouse(_arg1:MouseEvent):void{
			var _local2:Number;
			var _local3:Number;
			var _local4:Point;
			_local2 = displayMenu.mouseX;
			_local3 = displayMenu.mouseY;
			_local4 = new Point(_local2, _local3);
			if (rectcam.containsPoint(_local4)){
				if (displayState != 1){
					closeOtherScreen(displayState);
					displayState = 1;
					showCamInfo();
				} else {
					displayState = 0;
					hideCamInfo();
				};
			} else {
				if (rectdetails.containsPoint(_local4)){
					if (displayState != 2){
						closeOtherScreen(displayState);
						displayState = 2;
						showGeomInfo();
					} else {
						displayState = 0;
						hideGeomInfo();
					};
				} else {
					if (rectclose.containsPoint(_local4)){
						closeStats();
					} else {
						if (rectclear.containsPoint(_local4)){
							clearStats();
						} else {
							if (displayMenu.mouseY <= 20){
								displayMenu.startDrag();
								scopeMenu.addEventListener(MouseEvent.MOUSE_UP, mouseReleased);
							};
						};
					};
				};
			};
		}
		private function displayPicto():void{
			var _local1:Shape;
			_local1 = new Logo();
			displayMenu.addChild(_local1);
			_local1.x = (_local1.y = 4);
		}

	}
}//package away3d.core.stats 
Section 90
//LightTraverser (away3d.core.traverse.LightTraverser)
package away3d.core.traverse {
	import away3d.core.base.*;
	import away3d.core.light.*;

	public class LightTraverser extends Traverser {

		override public function match(_arg1:Object3D):Boolean{
			return (_arg1.visible);
		}
		override public function apply(_arg1:Object3D):void{
			if (_arg1.ownLights){
				_arg1.lightarray.clear();
			};
			if ((_arg1 is ILightProvider)){
				(_arg1 as ILightProvider).light(_arg1.parent.lightarray);
			};
		}

	}
}//package away3d.core.traverse 
Section 91
//PrimitiveTraverser (away3d.core.traverse.PrimitiveTraverser)
package away3d.core.traverse {
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.clip.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.materials.*;
	import away3d.core.light.*;
	import away3d.core.geom.*;
	import flash.utils.*;
	import away3d.core.project.*;

	public class PrimitiveTraverser extends Traverser {

		private var _view:View3D;
		private var _viewTransform:Matrix3D;
		private var _consumer:IPrimitiveConsumer;
		private var _light:ILightProvider;
		private var _mouseEnableds:Array;
		private var _clipping:Clipping;
		private var _nodeClassification:int;
		private var _cameraVarsStore:CameraVarsStore;
		private var _projectorDictionary:Dictionary;
		private var _mouseEnabled:Boolean;

		public function PrimitiveTraverser(){
			_mouseEnableds = new Array();
			_projectorDictionary = new Dictionary(true);
			super();
		}
		override public function match(_arg1:Object3D):Boolean{
			_clipping = _view.clipping;
			if (((!(_arg1.visible)) || (((_clipping.objectCulling) && (!(_cameraVarsStore.nodeClassificationDictionary[_arg1])))))){
				return (false);
			};
			if ((_arg1 is ILODObject)){
				return ((_arg1 as ILODObject).matchLOD(_view.camera));
			};
			return (true);
		}
		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_mouseEnabled = true;
			_mouseEnableds.length = 0;
			_cameraVarsStore = _view.cameraVarsStore;
			_projectorDictionary[ProjectorType.CONVEX_BLOCK] = _view._convexBlockProjector;
			_projectorDictionary[ProjectorType.DIR_SPRITE] = _view._dirSpriteProjector;
			_projectorDictionary[ProjectorType.DOF_SPRITE] = _view._dofSpriteProjector;
			_projectorDictionary[ProjectorType.MESH] = _view._meshProjector;
			_projectorDictionary[ProjectorType.MOVIE_CLIP_SPRITE] = _view._movieClipSpriteProjector;
			_projectorDictionary[ProjectorType.OBJECT_CONTAINER] = _view._objectContainerProjector;
			_projectorDictionary[ProjectorType.SPRITE] = _view._spriteProjector;
		}
		override public function enter(_arg1:Object3D):void{
			_mouseEnableds.push(_mouseEnabled);
		}
		public function get view():View3D{
			return (_view);
		}
		override public function apply(_arg1:Object3D):void{
			if (_arg1.session.updated){
				_viewTransform = _cameraVarsStore.viewTransformDictionary[_arg1];
				_consumer = _arg1.session.getConsumer(_view);
				if (_arg1.projectorType){
					(_projectorDictionary[_arg1.projectorType] as IPrimitiveProvider).primitives(_arg1, _viewTransform, _consumer);
				};
				if (((_arg1.debugbb) && (_arg1.debugBoundingBox.visible))){
					_arg1.debugBoundingBox._session = _arg1.session;
					if (_clipping.objectCulling){
						_cameraVarsStore.frustumDictionary[_arg1.debugBoundingBox] = _cameraVarsStore.frustumDictionary[_arg1];
						_nodeClassification = _cameraVarsStore.nodeClassificationDictionary[_arg1];
						if (_nodeClassification == Frustum.INTERSECT){
							(_arg1.debugBoundingBox.material as WireframeMaterial).color = 0xFF0000;
						} else {
							(_arg1.debugBoundingBox.material as WireframeMaterial).color = 0x333333;
						};
					};
					_view._meshProjector.primitives(_arg1.debugBoundingBox, _viewTransform, _consumer);
				};
				if (((_arg1.debugbs) && (_arg1.debugBoundingSphere.visible))){
					_arg1.debugBoundingSphere._session = _arg1.session;
					if (_clipping.objectCulling){
						_cameraVarsStore.frustumDictionary[_arg1.debugBoundingSphere] = _cameraVarsStore.frustumDictionary[_arg1];
						_nodeClassification = _cameraVarsStore.nodeClassificationDictionary[_arg1];
						if (_nodeClassification == Frustum.INTERSECT){
							(_arg1.debugBoundingSphere.material as WireframeMaterial).color = 0xFF0000;
						} else {
							(_arg1.debugBoundingSphere.material as WireframeMaterial).color = 0xFFFF;
						};
					};
					_view._meshProjector.primitives(_arg1.debugBoundingSphere, _viewTransform, _consumer);
				};
				if ((_arg1 is ILightProvider)){
					_light = (_arg1 as ILightProvider);
					if (_light.debug){
						_light.debugPrimitive._session = _arg1.session;
						if (_clipping.objectCulling){
							_cameraVarsStore.frustumDictionary[_light.debugPrimitive] = _cameraVarsStore.frustumDictionary[_light];
						};
						_view._meshProjector.primitives(_light.debugPrimitive, _viewTransform, _consumer);
					};
				};
			};
			_mouseEnabled = (_arg1._mouseEnabled = ((_mouseEnabled) && (_arg1.mouseEnabled)));
		}
		override public function leave(_arg1:Object3D):void{
			_mouseEnabled = _mouseEnableds.pop();
		}

	}
}//package away3d.core.traverse 
Section 92
//ProjectionTraverser (away3d.core.traverse.ProjectionTraverser)
package away3d.core.traverse {
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.cameras.*;
	import away3d.core.clip.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.core.geom.*;
	import away3d.cameras.lenses.*;
	import away3d.core.project.*;

	public class ProjectionTraverser extends Traverser {

		private var _view:View3D;
		private var _camera:Camera3D;
		private var _mesh:Mesh;
		private var _viewTransform:Matrix3D;
		private var _lens:ILens;
		private var _clipping:Clipping;
		private var _frustum:Frustum;
		private var _nodeClassification:int;
		private var _cameraViewMatrix:Matrix3D;
		private var _cameraVarsStore:CameraVarsStore;

		override public function match(_arg1:Object3D):Boolean{
			if (!_arg1.visible){
				return (false);
			};
			_viewTransform = _cameraVarsStore.createViewTransform(_arg1);
			_viewTransform.multiply(_cameraViewMatrix, _arg1.sceneTransform);
			if (_clipping.objectCulling){
				_frustum = _lens.getFrustum(_arg1, _viewTransform);
				if ((((_arg1 is Scene3D)) || ((_cameraVarsStore.nodeClassificationDictionary[_arg1.parent] == Frustum.INTERSECT)))){
					if (_arg1.pivotZero){
						_nodeClassification = (_cameraVarsStore.nodeClassificationDictionary[_arg1] = _frustum.classifyRadius(_arg1.boundingRadius));
					} else {
						_nodeClassification = (_cameraVarsStore.nodeClassificationDictionary[_arg1] = _frustum.classifySphere(_arg1.pivotPoint, _arg1.boundingRadius));
					};
				} else {
					_nodeClassification = (_cameraVarsStore.nodeClassificationDictionary[_arg1] = _cameraVarsStore.nodeClassificationDictionary[_arg1.parent]);
				};
				if (_nodeClassification == Frustum.OUT){
					_arg1.updateObject();
					return (false);
				};
			};
			if ((_arg1 is ILODObject)){
				return ((_arg1 as ILODObject).matchLOD(_camera));
			};
			return (true);
		}
		public function set view(_arg1:View3D):void{
			_view = _arg1;
			_cameraVarsStore = _arg1.cameraVarsStore;
			_clipping = _arg1.clipping;
			_camera = _arg1.camera;
			_lens = _camera.lens;
			_cameraViewMatrix = _camera.viewMatrix;
			if (_arg1.statsOpen){
				_arg1.statsPanel.clearObjects();
			};
		}
		override public function enter(_arg1:Object3D):void{
			if (((_view.statsOpen) && ((_arg1 is Mesh)))){
				_view.statsPanel.addObject((_arg1 as Mesh));
			};
		}
		public function get view():View3D{
			return (_view);
		}
		override public function apply(_arg1:Object3D):void{
			if (_arg1.projectorType == ProjectorType.CONVEX_BLOCK){
				_view.blockers[_arg1] = _arg1;
			};
			if ((_mesh = (_arg1 as Mesh))){
				if (!_view.scene.meshes[_arg1]){
					_view.scene.meshes[_arg1] = [];
				};
				_view.scene.meshes[_arg1].push(_view);
				_view.scene.geometries[_mesh.geometry] = _mesh.geometry;
			};
		}
		override public function leave(_arg1:Object3D):void{
			_arg1.updateObject();
		}

	}
}//package away3d.core.traverse 
Section 93
//SessionTraverser (away3d.core.traverse.SessionTraverser)
package away3d.core.traverse {
	import away3d.core.base.*;

	public class SessionTraverser extends Traverser {

		override public function match(_arg1:Object3D):Boolean{
			return (_arg1.visible);
		}
		override public function apply(_arg1:Object3D):void{
			_arg1.updateSession();
		}

	}
}//package away3d.core.traverse 
Section 94
//TickTraverser (away3d.core.traverse.TickTraverser)
package away3d.core.traverse {
	import away3d.core.base.*;

	public class TickTraverser extends Traverser {

		public var now:int;

		override public function enter(_arg1:Object3D):void{
			_arg1.tick(now);
		}

	}
}//package away3d.core.traverse 
Section 95
//Traverser (away3d.core.traverse.Traverser)
package away3d.core.traverse {
	import away3d.core.base.*;

	public class Traverser {

		public function match(_arg1:Object3D):Boolean{
			return (true);
		}
		public function leave(_arg1:Object3D):void{
		}
		public function enter(_arg1:Object3D):void{
		}
		public function apply(_arg1:Object3D):void{
		}

	}
}//package away3d.core.traverse 
Section 96
//BillboardVO (away3d.core.utils.BillboardVO)
package away3d.core.utils {
	import away3d.core.base.*;
	import away3d.materials.*;

	public class BillboardVO {

		public var vertex:Vertex;
		public var width:Number;
		public var material:IBillboardMaterial;
		public var command:String;
		public var scaling:Number;
		public var billboard:Billboard;
		public var rotation:Number;
		public var height:Number;

	}
}//package away3d.core.utils 
Section 97
//CacheStore (away3d.core.utils.CacheStore)
package away3d.core.utils {
	import flash.utils.*;

	public class CacheStore {

		public static var whiteShadingCache:Dictionary = new Dictionary(true);

	}
}//package away3d.core.utils 
Section 98
//CameraVarsStore (away3d.core.utils.CameraVarsStore)
package away3d.core.utils {
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.math.*;
	import away3d.materials.*;
	import away3d.core.geom.*;
	import away3d.core.render.*;
	import flash.utils.*;

	public class CameraVarsStore {

		private var _vtStore:Array;
		private var _uvStore:Array;
		public var frustumDictionary:Dictionary;
		private var _sActive:Array;
		private var _frustum:Frustum;
		public var view:View3D;
		private var _vStore:Array;
		private var _segmentVO:SegmentVO;
		private var _frStore:Array;
		private var _source:Object3D;
		public var viewTransformDictionary:Dictionary;
		public var nodeClassificationDictionary:Dictionary;
		private var _uv:UV;
		private var _vertex:Vertex;
		private var _vtActive:Array;
		private var _vc:VertexClassification;
		private var _fActive:Array;
		private var _frActive:Array;
		private var _fStore:Array;
		private var _session:AbstractRenderSession;
		private var _sStore:Array;
		private var _vt:Matrix3D;
		private var _object:Object;
		private var _vActive:Array;
		private var _sourceDictionary:Dictionary;
		private var _faceVO:FaceVO;
		private var _uvDictionary:Dictionary;
		private var _v:Object;
		private var _uvArray:Array;
		private var _vcStore:Array;
		private var _vertexClassificationDictionary:Dictionary;

		public function CameraVarsStore(){
			_sourceDictionary = new Dictionary(true);
			_vtActive = [];
			_vtStore = [];
			_frActive = [];
			_frStore = [];
			_vActive = [];
			_vStore = [];
			_vcStore = [];
			_uvDictionary = new Dictionary(true);
			_uvStore = [];
			_fActive = [];
			_fStore = [];
			_sActive = [];
			_sStore = [];
			viewTransformDictionary = new Dictionary(true);
			nodeClassificationDictionary = new Dictionary(true);
			frustumDictionary = new Dictionary(true);
			super();
		}
		public function createFaceVO(_arg1:Face, _arg2:ITriangleMaterial, _arg3:ITriangleMaterial, _arg4:UV, _arg5:UV, _arg6:UV):FaceVO{
			if (_fStore.length){
				_fActive.push((_faceVO = _fStore.pop()));
			} else {
				_fActive.push((_faceVO = new FaceVO()));
			};
			_faceVO.face = _arg1;
			_faceVO.uv0 = _arg4;
			_faceVO.uv1 = _arg5;
			_faceVO.uv2 = _arg6;
			_faceVO.material = _arg2;
			_faceVO.back = _arg3;
			_faceVO.generated = true;
			return (_faceVO);
		}
		public function createVertexClassificationDictionary(_arg1:Object3D):Dictionary{
			if (!(_vertexClassificationDictionary = _sourceDictionary[_arg1])){
				_vertexClassificationDictionary = (_sourceDictionary[_arg1] = new Dictionary(true));
			};
			return (_vertexClassificationDictionary);
		}
		public function createSegmentVO(_arg1:ISegmentMaterial):SegmentVO{
			if (_sStore.length){
				_sActive.push((_segmentVO = _sStore.pop()));
			} else {
				_sActive.push((_segmentVO = new SegmentVO()));
			};
			_segmentVO.generated = true;
			return (_segmentVO);
		}
		public function createUV(_arg1:Number, _arg2:Number, _arg3:AbstractRenderSession):UV{
			if (!(_uvArray = _uvDictionary[_arg3])){
				_uvArray = (_uvDictionary[_arg3] = []);
			};
			if (_uvStore.length){
				_uvArray.push((_uv = _uvStore.pop()));
				_uv.u = _arg1;
				_uv.v = _arg2;
			} else {
				_uvArray.push((_uv = new UV(_arg1, _arg2)));
			};
			return (_uv);
		}
		public function createViewTransform(_arg1:Object3D):Matrix3D{
			if (_vtStore.length){
				_vtActive.push((_vt = (viewTransformDictionary[_arg1] = _vtStore.pop())));
			} else {
				_vtActive.push((_vt = (viewTransformDictionary[_arg1] = new Matrix3D())));
			};
			return (_vt);
		}
		public function createVertex(_arg1:Number, _arg2:Number, _arg3:Number):Vertex{
			if (_vStore.length){
				_vActive.push((_vertex = _vStore.pop()));
				_vertex.x = _arg1;
				_vertex.y = _arg2;
				_vertex.z = _arg3;
			} else {
				_vActive.push((_vertex = new Vertex(_arg1, _arg2, _arg3)));
			};
			return (_vertex);
		}
		public function reset():void{
			for (_object in _sourceDictionary) {
				_source = (_object as Object3D);
				if (((_source.session) && (_source.session.updated))){
					for (_v in _sourceDictionary[_source]) {
						_vcStore.push(_sourceDictionary[_source][_v]);
						delete _sourceDictionary[_source][_v];
					};
				};
			};
			nodeClassificationDictionary = new Dictionary(true);
			_vtStore = _vtStore.concat(_vtActive);
			_vtActive.length = 0;
			_frStore = _frStore.concat(_frActive);
			_frActive.length = 0;
			_vStore = _vStore.concat(_vActive);
			_vActive.length = 0;
			for (_object in _uvDictionary) {
				_session = (_object as AbstractRenderSession);
				if (_session.updated){
					_uvArray = (_uvDictionary[_session] as Array);
					_uvStore = _uvStore.concat();
					_uvArray.length = 0;
				};
			};
			_fStore = _fStore.concat(_fActive);
			_fActive.length = 0;
			_sStore = _sStore.concat(_sActive);
			_sActive.length = 0;
		}
		public function createVertexClassification(_arg1:Vertex):VertexClassification{
			if ((_vc = _vertexClassificationDictionary[_arg1])){
				return (_vc);
			};
			if (_vcStore.length){
				_vc = (_vertexClassificationDictionary[_arg1] = _vcStore.pop());
			} else {
				_vc = (_vertexClassificationDictionary[_arg1] = new VertexClassification());
			};
			_vc.vertex = _arg1;
			_vc.plane = null;
			return (_vc);
		}
		public function createFrustum(_arg1:Object3D):Frustum{
			if (_frStore.length){
				_frActive.push((_frustum = (frustumDictionary[_arg1] = _frStore.pop())));
			} else {
				_frActive.push((_frustum = (frustumDictionary[_arg1] = new Frustum())));
			};
			return (_frustum);
		}

	}
}//package away3d.core.utils 
Section 99
//Cast (away3d.core.utils.Cast)
package away3d.core.utils {
	import flash.geom.*;
	import flash.display.*;
	import away3d.materials.*;
	import flash.utils.*;

	public class Cast {

		private static var colornames:Dictionary;
		private static var hexchars:String = "0123456789abcdefABCDEF";
		private static var classes:Dictionary = new Dictionary();
		private static var notclasses:Dictionary = new Dictionary();

		public static function color(_arg1):uint{
			var _local2:uint;
			_local2 = trycolor(_arg1);
			if (_local2 == 4294967295){
				throw (new CastError(("Can't cast to color: " + _arg1)));
			};
			return (_local2);
		}
		public static function material(_arg1):IMaterial{
			var hash:Array;
			var line:Array;
			var bmd:BitmapData;
			var ini:Init;
			var bitmap:BitmapData;
			var color:uint;
			var alpha:Number;
			var lighting:Boolean;
			var wire:WireframeMaterial;
			var smooth:Boolean;
			var precision:Number;
			var data = _arg1;
			if (data == null){
				return (null);
			};
			if ((data is String)){
				data = tryclass(data);
			};
			if ((data is Class)){
				try {
					data = new (data);
				} catch(materialerror:ArgumentError) {
					data = new data(0, 0);
				};
			};
			if ((data is IMaterial)){
				return (data);
			};
			if ((data is int)){
				return (new ColorMaterial(data));
			};
			if ((data is MovieClip)){
				return (new MovieMaterial(data));
			};
			if ((data is String)){
				if (data == ""){
					return (null);
				};
				if ((data as String).indexOf("#") != -1){
					hash = (data as String).split("#");
					if (hash[1] == ""){
						return (new WireColorMaterial(color(hash[0])));
					};
					if (hash[1].indexOf("|") == -1){
						if (hash[0] == ""){
							return (new WireframeMaterial(color(hash[1])));
						};
						return (new WireColorMaterial(color(hash[0]), {wirecolor:color(hash[1])}));
					} else {
						line = hash[1].split("|");
						if (hash[0] == ""){
							return (new WireframeMaterial(color(line[0]), {width:parseFloat(line[1])}));
						};
						return (new WireColorMaterial(color(hash[0]), {wirecolor:color(line[0]), width:parseFloat(line[1])}));
					};
				} else {
					if ((data as String).indexOf("@") != -1){
						hash = (data as String).split("@");
						if (hash[1] == ""){
							return (new ShadingColorMaterial({color:color(hash[0])}));
						};
					} else {
						return (new ColorMaterial(color(data)));
					};
				};
			};
			try {
				bmd = Cast.bitmap(data);
				return (new BitmapMaterial(bmd));
			} catch(error:CastError) {
			};
			if ((data is Object)){
				ini = Init.parse(data);
				bitmap = ini.getBitmap("bitmap");
				color = ini.getColor("color", 4294967295);
				alpha = ini.getNumber("alpha", 1, {min:0, max:1});
				lighting = ini.getBoolean("lighting", false);
				wire = (wirematerial(ini.getObject("wire")) as WireframeMaterial);
				if (((!((bitmap == null))) && (!((color == 4294967295))))){
					throw (new CastError(("Can't create material with color and bitmap: " + data)));
				};
				if (bitmap != null){
					if (wire != null){
						Debug.warning("Bitmap materials do not support wire");
					};
					smooth = ini.getBoolean("smooth", false);
					precision = ini.getNumber("precision", 0);
					if (precision){
						if (lighting){
							return (new WhiteShadingBitmapMaterial(bitmap, {smooth:smooth, precision:precision}));
						};
						if (alpha < 1){
							Debug.warning("Can't create precise bitmap material with alpha (yet)");
						};
						return (new BitmapMaterial(bitmap, {smooth:smooth, precision:precision}));
					};
					if (lighting){
						if (alpha < 1){
							Debug.warning("Can't create bitmap material with lighting and alpha (yet)");
						};
						return (new WhiteShadingBitmapMaterial(bitmap, {smooth:smooth, alpha:alpha}));
					};
					return (new BitmapMaterial(bitmap, {smooth:smooth}));
				};
				if (color != 4294967295){
					if (lighting){
						if (wire != null){
							Debug.warning("Can't create shading material with wire");
						};
						return (new ShadingColorMaterial({color:color, alpha:alpha}));
					};
					if (wire == null){
						return (new ColorMaterial(color, {alpha:alpha}));
					};
					return (new WireColorMaterial(color, {alpha:alpha, wirecolor:wire.color, wirealpha:wire.alpha, width:wire.width}));
				};
				if (wire != null){
					return (wire);
				};
			};
			throw (new CastError(("Can't cast to material: " + data)));
		}
		public static function trycolor(_arg1):uint{
			if ((_arg1 is uint)){
				return ((_arg1 as uint));
			};
			if ((_arg1 is int)){
				return ((_arg1 as uint));
			};
			if ((_arg1 is String)){
				if (_arg1 == "random"){
					return (uint((Math.random() * 16777216)));
				};
				if (colornames == null){
					colornames = new Dictionary();
					colornames["steelblue"] = 4620980;
					colornames["royalblue"] = 267920;
					colornames["cornflowerblue"] = 6591981;
					colornames["lightsteelblue"] = 11584734;
					colornames["mediumslateblue"] = 8087790;
					colornames["slateblue"] = 6970061;
					colornames["darkslateblue"] = 4734347;
					colornames["midnightblue"] = 1644912;
					colornames["navy"] = 128;
					colornames["darkblue"] = 139;
					colornames["mediumblue"] = 205;
					colornames["blue"] = 0xFF;
					colornames["dodgerblue"] = 2003199;
					colornames["deepskyblue"] = 49151;
					colornames["lightskyblue"] = 8900346;
					colornames["skyblue"] = 8900331;
					colornames["lightblue"] = 11393254;
					colornames["powderblue"] = 11591910;
					colornames["azure"] = 15794175;
					colornames["lightcyan"] = 14745599;
					colornames["paleturquoise"] = 11529966;
					colornames["mediumturquoise"] = 4772300;
					colornames["lightseagreen"] = 2142890;
					colornames["darkcyan"] = 0x8B8B;
					colornames["teal"] = 0x8080;
					colornames["cadetblue"] = 6266528;
					colornames["darkturquoise"] = 52945;
					colornames["aqua"] = 0xFFFF;
					colornames["cyan"] = 0xFFFF;
					colornames["turquoise"] = 4251856;
					colornames["aquamarine"] = 8388564;
					colornames["mediumaquamarine"] = 6737322;
					colornames["darkseagreen"] = 9419919;
					colornames["mediumseagreen"] = 3978097;
					colornames["seagreen"] = 3050327;
					colornames["darkgreen"] = 0x6400;
					colornames["green"] = 0x8000;
					colornames["forestgreen"] = 2263842;
					colornames["limegreen"] = 3329330;
					colornames["lime"] = 0xFF00;
					colornames["chartreuse"] = 0x7FFF00;
					colornames["lawngreen"] = 0x7CFC00;
					colornames["greenyellow"] = 11403055;
					colornames["yellowgreen"] = 10145074;
					colornames["palegreen"] = 10025880;
					colornames["lightgreen"] = 9498256;
					colornames["springgreen"] = 65407;
					colornames["mediumspringgreen"] = 64154;
					colornames["darkolivegreen"] = 5597999;
					colornames["olivedrab"] = 7048739;
					colornames["olive"] = 0x808000;
					colornames["darkkhaki"] = 12433259;
					colornames["darkgoldenrod"] = 12092939;
					colornames["goldenrod"] = 14329120;
					colornames["gold"] = 0xFFD700;
					colornames["yellow"] = 0xFFFF00;
					colornames["khaki"] = 15787660;
					colornames["palegoldenrod"] = 15657130;
					colornames["blanchedalmond"] = 16772045;
					colornames["moccasin"] = 16770229;
					colornames["wheat"] = 16113331;
					colornames["navajowhite"] = 16768685;
					colornames["burlywood"] = 14596231;
					colornames["tan"] = 13808780;
					colornames["rosybrown"] = 12357519;
					colornames["sienna"] = 10506797;
					colornames["saddlebrown"] = 9127187;
					colornames["chocolate"] = 13789470;
					colornames["peru"] = 13468991;
					colornames["sandybrown"] = 16032864;
					colornames["darkred"] = 0x8B0000;
					colornames["maroon"] = 0x800000;
					colornames["brown"] = 10824234;
					colornames["firebrick"] = 11674146;
					colornames["indianred"] = 13458524;
					colornames["lightcoral"] = 15761536;
					colornames["salmon"] = 16416882;
					colornames["darksalmon"] = 15308410;
					colornames["lightsalmon"] = 16752762;
					colornames["coral"] = 16744272;
					colornames["tomato"] = 16737095;
					colornames["darkorange"] = 0xFF8C00;
					colornames["orange"] = 0xFFA500;
					colornames["orangered"] = 0xFF4500;
					colornames["crimson"] = 14423100;
					colornames["red"] = 0xFF0000;
					colornames["deeppink"] = 16716947;
					colornames["fuchsia"] = 0xFF00FF;
					colornames["magenta"] = 0xFF00FF;
					colornames["hotpink"] = 16738740;
					colornames["lightpink"] = 16758465;
					colornames["pink"] = 16761035;
					colornames["palevioletred"] = 14381203;
					colornames["mediumvioletred"] = 13047173;
					colornames["purple"] = 0x800080;
					colornames["darkmagenta"] = 0x8B008B;
					colornames["mediumpurple"] = 9662683;
					colornames["blueviolet"] = 9055202;
					colornames["indigo"] = 0x4B0082;
					colornames["darkviolet"] = 0x9400D3;
					colornames["darkorchid"] = 10040012;
					colornames["mediumorchid"] = 12211667;
					colornames["orchid"] = 14315734;
					colornames["violet"] = 15631086;
					colornames["plum"] = 14524637;
					colornames["thistle"] = 14204888;
					colornames["lavender"] = 15132410;
					colornames["ghostwhite"] = 16316671;
					colornames["aliceblue"] = 15792383;
					colornames["mintcream"] = 16121850;
					colornames["honeydew"] = 15794160;
					colornames["lightgoldenrodyellow"] = 16448210;
					colornames["lemonchiffon"] = 16775885;
					colornames["cornsilk"] = 16775388;
					colornames["lightyellow"] = 16777184;
					colornames["ivory"] = 16777200;
					colornames["floralwhite"] = 16775920;
					colornames["linen"] = 16445670;
					colornames["oldlace"] = 16643558;
					colornames["antiquewhite"] = 16444375;
					colornames["bisque"] = 16770244;
					colornames["peachpuff"] = 16767673;
					colornames["papayawhip"] = 16773077;
					colornames["beige"] = 16119260;
					colornames["seashell"] = 16774638;
					colornames["lavenderblush"] = 16773365;
					colornames["mistyrose"] = 16770273;
					colornames["snow"] = 16775930;
					colornames["white"] = 0xFFFFFF;
					colornames["whitesmoke"] = 0xF5F5F5;
					colornames["gainsboro"] = 0xDCDCDC;
					colornames["lightgrey"] = 0xD3D3D3;
					colornames["silver"] = 0xC0C0C0;
					colornames["darkgrey"] = 0xA9A9A9;
					colornames["grey"] = 0x808080;
					colornames["lightslategrey"] = 7833753;
					colornames["slategrey"] = 7372944;
					colornames["dimgrey"] = 0x696969;
					colornames["darkslategrey"] = 3100495;
					colornames["black"] = 0;
					colornames["transparent"] = 4278190080;
				};
				if (colornames[_arg1] != null){
					return (colornames[_arg1]);
				};
				if (((((_arg1 as String).length == 6)) && (hexstring(_arg1)))){
					return (parseInt(("0x" + _arg1)));
				};
			};
			return (0xFFFFFF);
		}
		private static function hexstring(_arg1:String):Boolean{
			var _local2:int;
			var _local3:int;
			_local2 = _arg1.length;
			_local3 = 0;
			while (_local3 < _local2) {
				if (hexchars.indexOf(_arg1.charAt(_local3)) == -1){
					return (false);
				};
				_local3++;
			};
			return (true);
		}
		public static function wirematerial(_arg1):ISegmentMaterial{
			var _local2:Array;
			var _local3:Init;
			var _local4:uint;
			var _local5:Number;
			var _local6:Number;
			if (_arg1 == null){
				return (null);
			};
			if ((_arg1 is ISegmentMaterial)){
				return (_arg1);
			};
			if ((_arg1 is int)){
				return (new WireframeMaterial(_arg1));
			};
			if ((_arg1 is String)){
				if (_arg1 == ""){
					return (null);
				};
				if ((_arg1 as String).indexOf("#") == 0){
					_arg1 = (_arg1 as String).substring(1);
				};
				if ((_arg1 as String).indexOf("|") == -1){
					return (new WireframeMaterial(color(_arg1)));
				};
				_local2 = (_arg1 as String).split("|");
				return (new WireframeMaterial(color(_local2[0]), {width:parseFloat(_local2[1])}));
			};
			if ((_arg1 is Object)){
				_local3 = Init.parse(_arg1);
				_local4 = _local3.getColor("color", 0);
				_local5 = _local3.getNumber("alpha", 1, {min:0, max:1});
				_local6 = _local3.getNumber("width", 1, {min:0});
				return (new WireframeMaterial(_local4, {alpha:_local5, width:_local6}));
			};
			throw (new CastError(("Can't cast to wirematerial: " + _arg1)));
		}
		public static function bitmap(_arg1):BitmapData{
			var ds:DisplayObject;
			var bmd:BitmapData;
			var mat:Matrix;
			var data = _arg1;
			if (data == null){
				return (null);
			};
			if ((data is String)){
				data = tryclass(data);
			};
			if ((data is Class)){
				try {
					data = new (data);
				} catch(bitmaperror:ArgumentError) {
					data = new data(0, 0);
				};
			};
			if ((data is BitmapData)){
				return (data);
			};
			if ((data is Bitmap)){
				if ((data as Bitmap).hasOwnProperty("bitmapData")){
					return ((data as Bitmap).bitmapData);
				};
			};
			if ((data is DisplayObject)){
				ds = (data as DisplayObject);
				bmd = new BitmapData(ds.width, ds.height, true, 0xFFFFFF);
				mat = ds.transform.matrix.clone();
				mat.tx = 0;
				mat.ty = 0;
				bmd.draw(ds, mat, ds.transform.colorTransform, ds.blendMode, bmd.rect, true);
				return (bmd);
			};
			throw (new CastError(("Can't cast to bitmap: " + data)));
		}
		public static function bytearray(_arg1):ByteArray{
			if ((_arg1 is Class)){
				_arg1 = new (_arg1);
			};
			if ((_arg1 is ByteArray)){
				return (_arg1);
			};
			return (ByteArray(_arg1));
		}
		public static function xml(_arg1):XML{
			if ((_arg1 is Class)){
				_arg1 = new (_arg1);
			};
			if ((_arg1 is XML)){
				return (_arg1);
			};
			return (XML(_arg1));
		}
		public static function string(_arg1):String{
			if ((_arg1 is Class)){
				_arg1 = new (_arg1);
			};
			if ((_arg1 is String)){
				return (_arg1);
			};
			return (String(_arg1));
		}
		public static function tryclass(_arg1:String):Object{
			var result:Class;
			var name = _arg1;
			if (notclasses[name]){
				return (name);
			};
			result = classes[name];
			if (result != null){
				return (result);
			};
			try {
				result = (getDefinitionByName(name) as Class);
				classes[name] = result;
				return (result);
			} catch(error:ReferenceError) {
			};
			notclasses[name] = true;
			return (name);
		}

	}
}//package away3d.core.utils 
Section 100
//CastError (away3d.core.utils.CastError)
package away3d.core.utils {

	public class CastError extends Error {

		public function CastError(_arg1:String){
			super(_arg1);
		}
	}
}//package away3d.core.utils 
Section 101
//Color (away3d.core.utils.Color)
package away3d.core.utils {

	public class Color {

		public static const green:int = 0xFF00;
		public static const cyan:int = 0xFFFF;
		public static const white:int = 0xFFFFFF;
		public static const red:int = 0xFF0000;
		public static const blue:int = 0xFF;
		public static const yellow:int = 0xFFFF00;
		public static const purple:int = 0xFF00FF;
		public static const black:int = 0;

		public static function inverseAdd(_arg1:int, _arg2:int):int{
			var _local3:int;
			var _local4:int;
			var _local5:int;
			var _local6:int;
			var _local7:int;
			var _local8:int;
			_local3 = ((0xFF - _arg1) & (0xFF0000 >> 16));
			_local4 = ((0xFF - _arg1) & (0xFF00 >> 8));
			_local5 = ((0xFF - _arg1) & 0xFF);
			_local6 = ((0xFF - _arg2) & (0xFF0000 >> 16));
			_local7 = ((0xFF - _arg2) & (0xFF00 >> 8));
			_local8 = ((0xFF - _arg2) & 0xFF);
			return (fromIntsCheck((0xFF - (_local3 + _local6)), (0xFF - (_local4 + _local7)), (0xFF - (_local5 + _local8))));
		}
		public static function add(_arg1:int, _arg2:int):int{
			var _local3:int;
			var _local4:int;
			var _local5:int;
			var _local6:int;
			var _local7:int;
			var _local8:int;
			_local3 = (_arg1 & (0xFF0000 >> 16));
			_local4 = (_arg1 & (0xFF00 >> 8));
			_local5 = (_arg1 & 0xFF);
			_local6 = (_arg2 & (0xFF0000 >> 16));
			_local7 = (_arg2 & (0xFF00 >> 8));
			_local8 = (_arg2 & 0xFF);
			return (fromIntsCheck((_local3 + _local6), (_local4 + _local7), (_local5 + _local8)));
		}
		public static function multiply(_arg1:int, _arg2:Number):int{
			var _local3:int;
			var _local4:int;
			var _local5:int;
			_local3 = (_arg1 & (0xFF0000 >> 16));
			_local4 = (_arg1 & (0xFF00 >> 8));
			_local5 = (_arg1 & 0xFF);
			return (fromIntsCheck(int((_local3 * _arg2)), int((_local4 * _arg2)), int((_local5 * _arg2))));
		}
		public static function fromIntsCheck(_arg1:int, _arg2:int, _arg3:int):int{
			_arg1 = Math.max(0, Math.min(0xFF, _arg1));
			_arg2 = Math.max(0, Math.min(0xFF, _arg2));
			_arg3 = Math.max(0, Math.min(0xFF, _arg3));
			return ((((65536 * _arg1) + (0x0100 * _arg2)) + _arg3));
		}
		public static function fromFloats(_arg1:Number, _arg2:Number, _arg3:Number):int{
			return ((((65536 * int((_arg1 * 0xFF))) + (0x0100 * int((_arg2 * 0xFF)))) + int((_arg3 * 0xFF))));
		}
		public static function fromInts(_arg1:int, _arg2:int, _arg3:int):int{
			return ((((65536 * _arg1) + (0x0100 * _arg2)) + _arg3));
		}
		public static function fromHSV(_arg1:Number, _arg2:Number, _arg3:Number):int{
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:int;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			_local4 = (((_arg1 % 360) + 360) % 360);
			_local5 = _arg2;
			_local6 = _arg3;
			_local7 = (int((_local4 / 60)) % 6);
			_local8 = ((_local4 / 60) - _local7);
			_local9 = (_local6 * (1 - _local5));
			_local10 = (_local6 * (1 - (_local8 * _local5)));
			_local11 = (_local6 * (1 - ((1 - _local8) * _local5)));
			switch (_local7){
				case 0:
					return (fromFloats(_local6, _local11, _local9));
				case 1:
					return (fromFloats(_local10, _local6, _local9));
				case 2:
					return (fromFloats(_local9, _local6, _local11));
				case 3:
					return (fromFloats(_local9, _local10, _local6));
				case 4:
					return (fromFloats(_local11, _local9, _local6));
				case 5:
					return (fromFloats(_local6, _local9, _local10));
			};
			return (0);
		}

	}
}//package away3d.core.utils 
Section 102
//Debug (away3d.core.utils.Debug)
package away3d.core.utils {

	public class Debug {

		public static var warningsAsErrors:Boolean = false;
		public static var active:Boolean = false;

		public static function warning(_arg1:Object):void{
			if (warningsAsErrors){
				error(_arg1);
				return;
			};
			trace(("WARNING: " + _arg1));
		}
		public static function trace(_arg1:Object):void{
			if (active){
				dotrace(_arg1);
			};
		}
		public static function delimiter():void{
		}
		public static function clear():void{
		}
		public static function error(_arg1:Object):void{
			trace(("ERROR: " + _arg1));
			throw (new Error(_arg1));
		}

	}
}//package away3d.core.utils 

private const dotrace:Function = function (_arg1:Object):void{
		trace(_arg1);
	};
Section 103
//DofCache (away3d.core.utils.DofCache)
package away3d.core.utils {
	import flash.geom.*;
	import flash.display.*;
	import flash.utils.*;
	import flash.filters.*;

	public class DofCache {

		private var minBitmap:BitmapData;
		private var bitmaps:Array;
		private var maxBitmap:BitmapData;
		private var levels:Number;

		public static var doflevels:Number = 16;
		public static var maxblur:Number = 150;
		public static var aperture:Number = 22;
		private static var caches:Dictionary = new Dictionary();
		public static var usedof:Boolean = false;
		public static var focus:Number;

		public function DofCache(_arg1:Number, _arg2:BitmapData){
			var _local3:Matrix;
			var _local4:Point;
			var _local5:Number;
			var _local6:BlurFilter;
			var _local7:int;
			var _local8:BitmapData;
			super();
			this.levels = _arg1;
			_local3 = new Matrix();
			_local4 = new Point(0, 0);
			bitmaps = new Array(_arg1);
			_local5 = 0;
			while (_local5 < _arg1) {
				_local6 = new BlurFilter((2 + ((maxblur * _local5) / _arg1)), (2 + ((maxblur * _local5) / _arg1)), 4);
				_local3.identity();
				_local7 = (_arg2.width * (1 + (_local5 / (_arg1 / 2))));
				_local3.translate((-(_arg2.width) / 2), (-(_arg2.height) / 2));
				_local3.translate((_local7 / 2), (_local7 / 2));
				_local8 = new BitmapData(_local7, _local7, true, 0);
				_local8.draw(_arg2, _local3);
				_local8.applyFilter(_local8, _local8.rect, _local4, _local6);
				bitmaps[_local5] = _local8;
				_local5++;
			};
			minBitmap = bitmaps[0];
			maxBitmap = bitmaps[(bitmaps.length - 1)];
		}
		public function getBitmap(_arg1:Number):BitmapData{
			var _local2:Number;
			_local2 = (focus - _arg1);
			if ((focus - _arg1) < 0){
				_local2 = -(_local2);
			};
			_local2 = (_local2 / aperture);
			_local2 = Math.floor(_local2);
			if (_local2 > (levels - 1)){
				return (maxBitmap);
			};
			if (_local2 < 0){
				return (minBitmap);
			};
			return (bitmaps[_local2]);
		}

		public static function resetDof(_arg1:Boolean):void{
			var _local2:DofCache;
			usedof = _arg1;
			for each (_local2 in caches) {
				if (!_arg1){
					_local2 = new DofCache(1, _local2.bitmaps[0]);
				} else {
					_local2 = new DofCache(doflevels, _local2.bitmaps[0]);
				};
			};
		}
		public static function getDofCache(_arg1:BitmapData):DofCache{
			if (caches[_arg1] == null){
				if (!usedof){
					caches[_arg1] = new DofCache(1, _arg1);
				} else {
					caches[_arg1] = new DofCache(doflevels, _arg1);
				};
			};
			return (caches[_arg1]);
		}

	}
}//package away3d.core.utils 
Section 104
//DrawPrimitiveStore (away3d.core.utils.DrawPrimitiveStore)
package away3d.core.utils {
	import flash.display.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.materials.*;
	import away3d.core.block.*;
	import away3d.core.render.*;
	import flash.utils.*;

	public class DrawPrimitiveStore {

		private var _sv:ScreenVertex;
		private var _cbStore:Array;
		private var _length:int;
		private var _sbArray:Array;
		private var _dbDictionary:Dictionary;
		private var _seg:DrawSegment;
		private var _sbStore:Array;
		private var _screenIndices:Array;
		private var _cblocker:ConvexBlocker;
		private var _sbitmap:DrawScaledBitmap;
		private var _screenVertices:Array;
		private var _dtDictionary:Dictionary;
		private var _sbDictionary:Dictionary;
		public var blockerDictionary:Dictionary;
		private var _screenCommands:Array;
		private var _cbDictionary:Dictionary;
		private var _source:Object3D;
		private var _vertex:Object;
		private var _dbStore:Array;
		public var view:View3D;
		private var _indexDictionary:Dictionary;
		private var _dsArray:Array;
		private var _index:int;
		private var _doArray:Array;
		private var _session:AbstractRenderSession;
		private var _array:Array;
		private var _object:Object;
		private var _dsStore:Array;
		private var _doDictionary:Dictionary;
		private var _dbArray:Array;
		private var _dtArray:Array;
		private var _dobject:DrawDisplayObject;
		private var _tri:DrawTriangle;
		private var _bill:DrawBillboard;
		private var _doStore:Array;
		private var _dtStore:Array;
		private var _dsDictionary:Dictionary;
		private var _svArray:Array;
		private var _cbArray:Array;
		private var _svStore:Array;

		public function DrawPrimitiveStore(){
			_screenVertices = new Array();
			_screenIndices = new Array();
			_screenCommands = new Array();
			_array = new Array();
			_svStore = [];
			_dtDictionary = new Dictionary(true);
			_dtStore = [];
			_dsDictionary = new Dictionary(true);
			_dsStore = [];
			_dbDictionary = new Dictionary(true);
			_dbStore = [];
			_cbDictionary = new Dictionary(true);
			_cbStore = [];
			_sbDictionary = new Dictionary(true);
			_sbStore = [];
			_doDictionary = new Dictionary(true);
			_doStore = [];
			blockerDictionary = new Dictionary(true);
			super();
		}
		public function getScreenCommands(_arg1:int):Array{
			return (((_screenCommands[_arg1]) || ((_screenCommands[_arg1] = []))));
		}
		public function createDrawTriangle(_arg1:Object3D, _arg2:FaceVO, _arg3:ITriangleMaterial, _arg4:Array, _arg5:Array, _arg6:Array, _arg7:int, _arg8:int, _arg9:UV, _arg10:UV, _arg11:UV, _arg12:Boolean=false):DrawTriangle{
			if (!(_dtArray = _dtDictionary[_arg1.session])){
				_dtArray = (_dtDictionary[_arg1.session] = []);
			};
			if (_dtStore.length){
				_dtArray[_dtArray.length] = (_tri = _dtStore.pop());
			} else {
				_dtArray[_dtArray.length] = (_tri = new DrawTriangle());
				_tri.view = view;
				_tri.create = createDrawTriangle;
			};
			_tri.reverseArea = _arg2.reverseArea;
			_tri.generated = _arg12;
			_tri.source = _arg1;
			_tri.faceVO = _arg2;
			_tri.material = _arg3;
			_tri.screenVertices = _arg4;
			_tri.screenIndices = _arg5;
			_tri.screenCommands = _arg6;
			_tri.startIndex = _arg7;
			_tri.endIndex = _arg8;
			_tri.uv0 = _arg9;
			_tri.uv1 = _arg10;
			_tri.uv2 = _arg11;
			_tri.calc();
			return (_tri);
		}
		public function createConvexBlocker(_arg1:Object3D, _arg2:Array):ConvexBlocker{
			if (!(_cbArray = _cbDictionary[_arg1.session])){
				_cbArray = (_cbDictionary[_arg1.session] = []);
			};
			if (_cbStore.length){
				_cbArray[_cbArray.length] = (_cblocker = (blockerDictionary[_arg1] = _cbStore.pop()));
			} else {
				_cbArray[_cbArray.length] = (_cblocker = (blockerDictionary[_arg1] = new ConvexBlocker()));
				_cblocker.view = view;
				_cblocker.create = createConvexBlocker;
			};
			_cblocker.source = _arg1;
			_cblocker.vertices = _arg2;
			_cblocker.calc();
			return (_cblocker);
		}
		public function createDrawDisplayObject(_arg1:Object3D, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:AbstractRenderSession, _arg6:DisplayObject, _arg7:Boolean=false):DrawDisplayObject{
			if (!(_doArray = _doDictionary[_arg1.session])){
				_doArray = (_doDictionary[_arg1.session] = []);
			};
			if (_doStore.length){
				_doArray[_doArray.length] = (_dobject = _doStore.pop());
			} else {
				_doArray[_doArray.length] = (_dobject = new DrawDisplayObject());
				_dobject.view = view;
				_dobject.create = createDrawSegment;
			};
			_dobject.generated = _arg7;
			_dobject.source = _arg1;
			_dobject.vx = _arg2;
			_dobject.vy = _arg3;
			_dobject.vz = _arg4;
			_dobject.session = _arg5;
			_dobject.displayobject = _arg6;
			_dobject.calc();
			return (_dobject);
		}
		public function getScreenVertices(_arg1:int):Array{
			return (((_screenVertices[_arg1]) || ((_screenVertices[_arg1] = []))));
		}
		public function createDrawScaledBitmap(_arg1:Object3D, _arg2:Array, _arg3:Boolean, _arg4:BitmapData, _arg5:Number, _arg6:Number, _arg7:Boolean=false):DrawScaledBitmap{
			if (!(_sbArray = _sbDictionary[_arg1.session])){
				_sbArray = (_sbDictionary[_arg1.session] = []);
			};
			if (_sbStore.length){
				_sbArray[_sbArray.length] = (_sbitmap = _sbStore.pop());
			} else {
				_sbArray[_sbArray.length] = (_sbitmap = new DrawScaledBitmap());
				_sbitmap.view = view;
				_sbitmap.create = createDrawSegment;
			};
			_sbitmap.generated = _arg7;
			_sbitmap.source = _arg1;
			_sbitmap.vx = _arg2[0];
			_sbitmap.vy = _arg2[1];
			_sbitmap.vz = _arg2[2];
			_sbitmap.smooth = _arg3;
			_sbitmap.bitmap = _arg4;
			_sbitmap.scale = _arg5;
			_sbitmap.rotation = _arg6;
			_sbitmap.calc();
			return (_sbitmap);
		}
		public function createDrawBillboard(_arg1:Object3D, _arg2:BillboardVO, _arg3:IBillboardMaterial, _arg4:Array, _arg5:Array, _arg6:uint, _arg7:Number, _arg8:Boolean=false):DrawBillboard{
			if (!(_dbArray = _dbDictionary[_arg1.session])){
				_dbArray = (_dbDictionary[_arg1.session] = []);
			};
			if (_dbStore.length){
				_dbArray.push((_bill = _dbStore.pop()));
			} else {
				_dbArray.push((_bill = new DrawBillboard()));
				_bill.view = view;
				_bill.create = createDrawBillboard;
			};
			_bill.generated = _arg8;
			_bill.source = _arg1;
			_bill.material = _arg3;
			_bill.billboardVO = _arg2;
			_bill.screenVertices = _arg4;
			_bill.screenIndices = _arg5;
			_bill.index = _arg6;
			_bill.width = _arg2.width;
			_bill.height = _arg2.height;
			_bill.rotation = _arg2.rotation;
			_bill.scale = _arg7;
			_bill.calc();
			return (_bill);
		}
		public function createDrawSegment(_arg1:Object3D, _arg2:SegmentVO, _arg3:ISegmentMaterial, _arg4:Array, _arg5:Array, _arg6:Array, _arg7:int, _arg8:int, _arg9:Boolean=false):DrawSegment{
			if (!(_dsArray = _dsDictionary[_arg1.session])){
				_dsArray = (_dsDictionary[_arg1.session] = []);
			};
			if (_dsStore.length){
				_dsArray[_dsArray.length] = (_seg = _dsStore.pop());
			} else {
				_dsArray[_dsArray.length] = (_seg = new DrawSegment());
				_seg.view = view;
				_seg.create = createDrawSegment;
			};
			_seg.generated = _arg9;
			_seg.source = _arg1;
			_seg.segmentVO = _arg2;
			_seg.material = _arg3;
			_seg.screenVertices = _arg4;
			_seg.screenIndices = _arg5;
			_seg.screenCommands = _arg6;
			_seg.startIndex = _arg7;
			_seg.endIndex = _arg8;
			_seg.calc();
			return (_seg);
		}
		public function getScreenIndices(_arg1:int):Array{
			return (((_screenIndices[_arg1]) || ((_screenIndices[_arg1] = []))));
		}
		public function reset():void{
			for (_object in _dtDictionary) {
				_session = (_object as AbstractRenderSession);
				if (_session.updated){
					_dtArray = (_dtDictionary[_session] as Array);
					if (_dtArray.length){
						_dtStore = _dtStore.concat(_dtArray);
						_dtArray.length = 0;
					};
				};
			};
			for (_object in _dsDictionary) {
				_session = (_object as AbstractRenderSession);
				if (_session.updated){
					_dsArray = (_dsDictionary[_session] as Array);
					if (_dsArray.length){
						_dsStore = _dsStore.concat(_dsArray);
						_dsArray.length = 0;
					};
				};
			};
			for (_object in _dbDictionary) {
				_session = (_object as AbstractRenderSession);
				if (_session.updated){
					_dbArray = (_dbDictionary[_session] as Array);
					if (_dbArray.length){
						_dbStore = _dbStore.concat(_dbArray);
						_dbArray.length = 0;
					};
				};
			};
			for (_object in _cbDictionary) {
				_session = (_object as AbstractRenderSession);
				if (_session.updated){
					_cbArray = (_cbDictionary[_session] as Array);
					if (_cbArray.length){
						_cbStore = _cbStore.concat(_cbArray);
						_cbArray.length = 0;
					};
				};
			};
			for (_object in _sbDictionary) {
				_session = (_object as AbstractRenderSession);
				if (_session.updated){
					_sbArray = (_sbDictionary[_session] as Array);
					if (_sbArray.length){
						_sbStore = _sbStore.concat(_sbArray);
						_sbArray.length = 0;
					};
				};
			};
			for (_object in _doDictionary) {
				_session = (_object as AbstractRenderSession);
				if (_session.updated){
					_doArray = (_doDictionary[_session] as Array);
					if (_doArray.length){
						_doStore = _doStore.concat(_doArray);
						_doArray.length = 0;
					};
				};
			};
		}

	}
}//package away3d.core.utils 
Section 105
//FaceMaterialVO (away3d.core.utils.FaceMaterialVO)
package away3d.core.utils {
	import flash.geom.*;
	import flash.display.*;
	import away3d.containers.*;
	import away3d.core.base.*;

	public class FaceMaterialVO {

		public var invtexturemapping:Matrix;
		public var width:int;
		public var invalidated:Boolean;// = true
		public var backface:Boolean;// = false
		public var texturemapping:Matrix;
		public var source:Object3D;
		public var color:uint;
		public var view:View3D;
		public var height:int;
		public var cleared:Boolean;// = true
		public var bitmap:BitmapData;
		public var resized:Boolean;
		public var updated:Boolean;// = false

		public function FaceMaterialVO(_arg1:Object3D=null, _arg2:View3D=null){
			cleared = true;
			updated = false;
			invalidated = true;
			backface = false;
			super();
			this.source = _arg1;
			this.view = _arg2;
		}
		public function clear():void{
			cleared = true;
			updated = true;
		}
		public function resize(_arg1:Number, _arg2:Number, _arg3:Boolean=true):void{
			if ((((this.width == _arg1)) && ((this.height == _arg2)))){
				return;
			};
			resized = true;
			updated = true;
			this.width = _arg1;
			this.height = _arg2;
			this.color = color;
			if (bitmap){
				bitmap.dispose();
			};
			bitmap = new BitmapData(_arg1, _arg2, _arg3, 0);
			bitmap.lock();
		}

	}
}//package away3d.core.utils 
Section 106
//FaceVO (away3d.core.utils.FaceVO)
package away3d.core.utils {
	import flash.geom.*;
	import away3d.core.base.*;
	import away3d.materials.*;

	public class FaceVO {

		public var commands:Array;
		public var generated:Boolean;
		public var face:Face;
		public var reverseArea:Boolean;
		public var material:ITriangleMaterial;
		public var back:ITriangleMaterial;
		public var uv0:UV;
		public var uv1:UV;
		public var uv2:UV;
		public var bitmapRect:Rectangle;
		public var vertices:Array;
		public var v0:Vertex;
		public var v1:Vertex;
		public var v2:Vertex;

		public function FaceVO(){
			commands = new Array();
			vertices = new Array();
			super();
		}
		public function get maxU():Number{
			if (uv0.u > uv1.u){
				if (uv0.u > uv2.u){
					return (uv0.u);
				};
				return (uv2.u);
				//unresolved jump
			};
			if (uv1.u > uv2.u){
				return (uv1.u);
			};
			return (uv2.u);
		}
		public function get minU():Number{
			if (uv0.u < uv1.u){
				if (uv0.u < uv2.u){
					return (uv0.u);
				};
				return (uv2.u);
				//unresolved jump
			};
			if (uv1.u < uv2.u){
				return (uv1.u);
			};
			return (uv2.u);
		}
		public function get minV():Number{
			if (uv0.v < uv1.v){
				if (uv0.v < uv2.v){
					return (uv0.v);
				};
				return (uv2.v);
				//unresolved jump
			};
			if (uv1.v < uv2.v){
				return (uv1.v);
			};
			return (uv2.v);
		}
		public function get maxV():Number{
			if (uv0.v > uv1.v){
				if (uv0.v > uv2.v){
					return (uv0.v);
				};
				return (uv2.v);
				//unresolved jump
			};
			if (uv1.v > uv2.v){
				return (uv1.v);
			};
			return (uv2.v);
		}

	}
}//package away3d.core.utils 
Section 107
//IClonable (away3d.core.utils.IClonable)
package away3d.core.utils {
	import away3d.core.base.*;

	public interface IClonable {

		function clone(_arg1:Object3D=null):Object3D;

	}
}//package away3d.core.utils 
Section 108
//Init (away3d.core.utils.Init)
package away3d.core.utils {
	import flash.display.*;
	import away3d.core.base.*;
	import away3d.core.math.*;
	import away3d.primitives.data.*;
	import away3d.materials.*;

	public class Init {

		var init:Object;

		private static var inits:Array = [];

		public function Init(_arg1:Object){
			this.init = _arg1;
		}
		public function getArray(_arg1:String):Array{
			var _local2:Array;
			if (init == null){
				return ([]);
			};
			if (!init.hasOwnProperty(_arg1)){
				return ([]);
			};
			_local2 = init[_arg1];
			delete init[_arg1];
			return (_local2);
		}
		public function getSegmentMaterial(_arg1:String):ISegmentMaterial{
			var _local2:ISegmentMaterial;
			if (init == null){
				return (null);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (null);
			};
			_local2 = Cast.wirematerial(init[_arg1]);
			delete init[_arg1];
			return (_local2);
		}
		public function getBitmap(_arg1:String):BitmapData{
			var _local2:BitmapData;
			if (init == null){
				return (null);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (null);
			};
			_local2 = Cast.bitmap(init[_arg1]);
			delete init[_arg1];
			return (_local2);
		}
		public function getObject3D(_arg1:String):Object3D{
			return ((getObject(_arg1, Object3D) as Object3D));
		}
		public function getString(_arg1:String, _arg2:String):String{
			var _local3:String;
			if (init == null){
				return (_arg2);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (_arg2);
			};
			_local3 = init[_arg1];
			delete init[_arg1];
			return (_local3);
		}
		public function getObjectOrInit(_arg1:String, _arg2:Class=null):Object{
			var _local3:Object;
			if (init == null){
				return (null);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (null);
			};
			_local3 = init[_arg1];
			delete init[_arg1];
			if (_local3 == null){
				return (null);
			};
			if (_arg2 != null){
				if (!(_local3 is _arg2)){
					return (new _arg2(_local3));
				};
			};
			return (_local3);
		}
		function removeFromCheck():void{
			if (init == null){
				return;
			};
			init["dontCheckUnused"] = true;
		}
		public function getPosition(_arg1:String):Number3D{
			var _local2:Object;
			var _local3:Object3D;
			_local2 = getObject(_arg1);
			if (_local2 == null){
				return (null);
			};
			if ((_local2 is Number3D)){
				return ((_local2 as Number3D));
			};
			if ((_local2 is Object3D)){
				_local3 = (_local2 as Object3D);
				return ((_local3.scene) ? _local3.scenePosition : _local3.position);
			};
			if ((_local2 is String)){
				if (_local2 == "center"){
					return (new Number3D());
				};
			};
			throw (new CastError(("Cast get position of " + _local2)));
		}
		public function getInit(_arg1:String):Init{
			var _local2:Init;
			if (init == null){
				return (new Init(null));
			};
			if (!init.hasOwnProperty(_arg1)){
				return (new Init(null));
			};
			_local2 = Init.parse(init[_arg1]);
			delete init[_arg1];
			return (_local2);
		}
		public function getBoolean(_arg1:String, _arg2:Boolean):Boolean{
			var _local3:Boolean;
			if (init == null){
				return (_arg2);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (_arg2);
			};
			_local3 = init[_arg1];
			delete init[_arg1];
			return (_local3);
		}
		public function getColor(_arg1:String, _arg2:uint):uint{
			var _local3:uint;
			if (init == null){
				return (_arg2);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (_arg2);
			};
			_local3 = Cast.color(init[_arg1]);
			delete init[_arg1];
			return (_local3);
		}
		public function getObject(_arg1:String, _arg2:Class=null):Object{
			var _local3:Object;
			if (init == null){
				return (null);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (null);
			};
			_local3 = init[_arg1];
			delete init[_arg1];
			if (_local3 == null){
				return (null);
			};
			if (_arg2 != null){
				if (!(_local3 is _arg2)){
					throw (new CastError(((((("Parameter \"" + _arg1) + "\" is not of class ") + _arg2) + ": ") + _local3)));
				};
			};
			return (_local3);
		}
		public function getNumber3D(_arg1:String):Number3D{
			return ((getObject(_arg1, Number3D) as Number3D));
		}
		function addForCheck():void{
			if (init == null){
				return;
			};
			init["dontCheckUnused"] = false;
			inits.push(init);
		}
		public function getInt(_arg1:String, _arg2:int, _arg3:Object=null):int{
			var _local4:int;
			var _local5:int;
			var _local6:int;
			if (init == null){
				return (_arg2);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (_arg2);
			};
			_local4 = init[_arg1];
			if (_arg3 != null){
				if (_arg3.hasOwnProperty("min")){
					_local5 = _arg3["min"];
					if (_local4 < _local5){
						_local4 = _local5;
					};
				};
				if (_arg3.hasOwnProperty("max")){
					_local6 = _arg3["max"];
					if (_local4 > _local6){
						_local4 = _local6;
					};
				};
			};
			delete init[_arg1];
			return (_local4);
		}
		public function getCubeMaterials(_arg1:String):CubeMaterialsData{
			var _local2:CubeMaterialsData;
			if (init == null){
				return (null);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (null);
			};
			if ((init[_arg1] is CubeMaterialsData)){
				_local2 = (init[_arg1] as CubeMaterialsData);
			} else {
				if ((init[_arg1] is Object)){
					_local2 = new CubeMaterialsData(init[_arg1]);
				};
			};
			delete init[_arg1];
			return (_local2);
		}
		public function getMaterial(_arg1:String):IMaterial{
			var _local2:IMaterial;
			if (init == null){
				return (null);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (null);
			};
			_local2 = Cast.material(init[_arg1]);
			delete init[_arg1];
			return (_local2);
		}
		public function getNumber(_arg1:String, _arg2:Number, _arg3:Object=null):Number{
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			if (init == null){
				return (_arg2);
			};
			if (!init.hasOwnProperty(_arg1)){
				return (_arg2);
			};
			_local4 = init[_arg1];
			if (_arg3 != null){
				if (_arg3.hasOwnProperty("min")){
					_local5 = _arg3["min"];
					if (_local4 < _local5){
						_local4 = _local5;
					};
				};
				if (_arg3.hasOwnProperty("max")){
					_local6 = _arg3["max"];
					if (_local4 > _local6){
						_local4 = _local6;
					};
				};
			};
			delete init[_arg1];
			return (_local4);
		}

		static function checkUnusedArguments():void{
			var _local1:Array;
			var _local2:Object;
			var _local3:String;
			var _local4:String;
			if (inits.length == 0){
				return;
			};
			_local1 = inits;
			inits = [];
			for each (_local2 in _local1) {
				if (_local2.hasOwnProperty("dontCheckUnused")){
					//unresolved if
				} else {
					_local3 = null;
					for (_local4 in _local2) {
						if (_local4 == "dontCheckUnused"){
						} else {
							if (_local3 == null){
								_local3 = "";
							} else {
								_local3 = (_local3 + ", ");
							};
							_local3 = (_local3 + ((_local4 + ":") + _local2[_local4]));
						};
					};
					if (_local3 != null){
						Debug.warning((("Unused arguments: {" + _local3) + "}"));
					};
				};
			};
		}
		public static function parse(_arg1:Object):Init{
			if (_arg1 == null){
				return (new Init(null));
			};
			if ((_arg1 is Init)){
				return ((_arg1 as Init));
			};
			inits.push(_arg1);
			return (new Init(_arg1));
		}

	}
}//package away3d.core.utils 
Section 109
//SegmentVO (away3d.core.utils.SegmentVO)
package away3d.core.utils {
	import away3d.core.base.*;
	import away3d.materials.*;

	public class SegmentVO {

		public var commands:Array;
		public var material:ISegmentMaterial;
		public var generated:Boolean;
		public var vertices:Array;
		public var v0:Vertex;
		public var v1:Vertex;

		public function SegmentVO(){
			commands = new Array();
			vertices = new Array();
			super();
		}
	}
}//package away3d.core.utils 
Section 110
//ValueObject (away3d.core.utils.ValueObject)
package away3d.core.utils {
	import flash.events.*;

	public class ValueObject extends EventDispatcher {

		private static var changed:Event;

		public function addOnChange(_arg1:Function):void{
			addEventListener("changed", _arg1, false, 0, true);
		}
		public function removeOnChange(_arg1:Function):void{
			removeEventListener("changed", _arg1, false);
		}
		protected function notifyChange():void{
			if (!hasEventListener("changed")){
				return;
			};
			if (changed == null){
				changed = new Event("changed");
			};
			dispatchEvent(changed);
		}

	}
}//package away3d.core.utils 
Section 111
//AnimationEvent (away3d.events.AnimationEvent)
package away3d.events {
	import flash.events.*;
	import away3d.core.base.*;

	public class AnimationEvent extends Event {

		public var animation:Animation;

		public static const SEQUENCE_DONE:String = "sequenceDone";
		public static const CYCLE:String = "cycle";
		public static const SEQUENCE_UPDATE:String = "sequenceUpdate";

		public function AnimationEvent(_arg1:String, _arg2:Animation){
			super(_arg1);
			this.animation = _arg2;
		}
		override public function clone():Event{
			return (new AnimationEvent(type, animation));
		}

	}
}//package away3d.events 
Section 112
//CameraEvent (away3d.events.CameraEvent)
package away3d.events {
	import flash.events.*;
	import away3d.cameras.*;

	public class CameraEvent extends Event {

		public var camera:Camera3D;

		public static const CAMERA_UPDATED:String = "cameraUpdated";

		public function CameraEvent(_arg1:String, _arg2:Camera3D){
			super(_arg1);
			this.camera = _arg2;
		}
		override public function clone():Event{
			return (new CameraEvent(type, camera));
		}

	}
}//package away3d.events 
Section 113
//ClippingEvent (away3d.events.ClippingEvent)
package away3d.events {
	import flash.events.*;
	import away3d.core.clip.*;

	public class ClippingEvent extends Event {

		public var clipping:Clipping;

		public static const SCREEN_UPDATED:String = "screenUpdated";
		public static const CLIPPING_UPDATED:String = "clippingUpdated";

		public function ClippingEvent(_arg1:String, _arg2:Clipping){
			super(_arg1);
			this.clipping = _arg2;
		}
		override public function clone():Event{
			return (new ClippingEvent(type, clipping));
		}

	}
}//package away3d.events 
Section 114
//ElementEvent (away3d.events.ElementEvent)
package away3d.events {
	import flash.events.*;
	import away3d.core.base.*;

	public class ElementEvent extends Event {

		public var element:Element;

		public static const MAPPING_CHANGED:String = "mappingChanged";
		public static const VISIBLE_CHANGED:String = "visibleChanged";
		public static const VERTEX_CHANGED:String = "vertexChanged";
		public static const VERTEXVALUE_CHANGED:String = "vertexvalueChanged";

		public function ElementEvent(_arg1:String, _arg2:Element){
			super(_arg1);
			this.element = _arg2;
		}
		override public function clone():Event{
			return (new ElementEvent(type, element));
		}

	}
}//package away3d.events 
Section 115
//GeometryEvent (away3d.events.GeometryEvent)
package away3d.events {
	import flash.events.*;
	import away3d.core.base.*;

	public class GeometryEvent extends Event {

		public var geometry:Geometry;

		public static const DIMENSIONS_CHANGED:String = "dimensionsChanged";

		public function GeometryEvent(_arg1:String, _arg2:Geometry){
			super(_arg1);
			this.geometry = _arg2;
		}
		override public function clone():Event{
			return (new GeometryEvent(type, geometry));
		}

	}
}//package away3d.events 
Section 116
//MaterialEvent (away3d.events.MaterialEvent)
package away3d.events {
	import flash.events.*;
	import away3d.materials.*;

	public class MaterialEvent extends Event {

		public var extra:Object;
		public var material:IMaterial;

		public static const MATERIAL_UPDATED:String = "materialUpdated";
		public static const LOAD_PROGRESS:String = "loadProgress";
		public static const LOAD_SUCCESS:String = "loadSuccess";
		public static const MATERIAL_CHANGED:String = "materialChanged";
		public static const LOAD_ERROR:String = "loadError";

		public function MaterialEvent(_arg1:String, _arg2:IMaterial){
			super(_arg1);
			this.material = _arg2;
		}
		override public function clone():Event{
			return (new MaterialEvent(type, material));
		}

	}
}//package away3d.events 
Section 117
//MouseEvent3D (away3d.events.MouseEvent3D)
package away3d.events {
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.materials.*;

	public class MouseEvent3D extends Event {

		public var shiftKey:Boolean;
		public var sceneX:Number;
		public var sceneY:Number;
		public var sceneZ:Number;
		public var view:View3D;
		public var uv:UV;
		public var screenY:Number;
		public var screenZ:Number;
		public var drawpri:DrawPrimitive;
		public var screenX:Number;
		public var ctrlKey:Boolean;
		public var material:IUVMaterial;
		public var element:Object;
		public var object:Object3D;

		public static const MOUSE_MOVE:String = "mouseMove3d";
		public static const MOUSE_OVER:String = "mouseOver3d";
		public static const ROLL_OUT:String = "rollOut3d";
		public static const MOUSE_OUT:String = "mouseOut3d";
		public static const MOUSE_UP:String = "mouseUp3d";
		public static const MOUSE_DOWN:String = "mouseDown3d";
		public static const ROLL_OVER:String = "rollOver3d";

		public function MouseEvent3D(_arg1:String){
			super(_arg1, false, true);
		}
		override public function clone():Event{
			var _local1:MouseEvent3D;
			_local1 = new MouseEvent3D(type);
			if (isDefaultPrevented()){
				_local1.preventDefault();
			};
			_local1.screenX = screenX;
			_local1.screenY = screenY;
			_local1.screenZ = screenZ;
			_local1.sceneX = sceneX;
			_local1.sceneY = sceneY;
			_local1.sceneZ = sceneZ;
			_local1.view = view;
			_local1.object = object;
			_local1.element = element;
			_local1.drawpri = drawpri;
			_local1.material = material;
			_local1.uv = uv;
			_local1.ctrlKey = ctrlKey;
			_local1.shiftKey = shiftKey;
			return (_local1);
		}

	}
}//package away3d.events 
Section 118
//Object3DEvent (away3d.events.Object3DEvent)
package away3d.events {
	import flash.events.*;
	import away3d.core.base.*;

	public class Object3DEvent extends Event {

		public var object:Object3D;

		public static const TRANSFORM_CHANGED:String = "transformChanged";
		public static const PARENT_UPDATED:String = "parentUpdated";
		public static const SCENE_CHANGED:String = "sceneChanged";
		public static const SESSION_CHANGED:String = "sessionChanged";
		public static const SESSION_UPDATED:String = "sessionUpdated";
		public static const SCENETRANSFORM_CHANGED:String = "scenetransformChanged";
		public static const DIMENSIONS_CHANGED:String = "dimensionsChanged";

		public function Object3DEvent(_arg1:String, _arg2:Object3D){
			super(_arg1);
			this.object = _arg2;
		}
		override public function clone():Event{
			return (new Object3DEvent(type, object));
		}

	}
}//package away3d.events 
Section 119
//SessionEvent (away3d.events.SessionEvent)
package away3d.events {
	import flash.events.*;
	import away3d.core.render.*;

	public class SessionEvent extends Event {

		public var session:AbstractRenderSession;

		public static const SESSION_UPDATED:String = "sessionUpdated";

		public function SessionEvent(_arg1:String, _arg2:AbstractRenderSession){
			super(_arg1);
			this.session = _arg2;
		}
		override public function clone():Event{
			return (new SessionEvent(type, session));
		}

	}
}//package away3d.events 
Section 120
//ViewEvent (away3d.events.ViewEvent)
package away3d.events {
	import flash.events.*;
	import away3d.containers.*;

	public class ViewEvent extends Event {

		public var view:View3D;

		public static const RENDER_COMPLETE:String = "renderComplete";
		public static const UPDATE_SCENE:String = "updateScene";

		public function ViewEvent(_arg1:String, _arg2:View3D){
			super(_arg1);
			this.view = _arg2;
		}
		override public function clone():Event{
			return (new ViewEvent(type, view));
		}

	}
}//package away3d.events 
Section 121
//Merge (away3d.geom.Merge)
package away3d.geom {
	import away3d.core.base.*;
	import away3d.core.math.*;
	import away3d.materials.*;

	public class Merge {

		private var _unicgeometry:Boolean;
		private var _objectspace:Boolean;
		private var _keepMaterial:Boolean;

		public function Merge(_arg1:Boolean=true, _arg2:Boolean=false, _arg3:Boolean=false):void{
			_objectspace = _arg1;
			_unicgeometry = _arg2;
			_keepMaterial = _arg3;
		}
		public function get unicgeometry():Boolean{
			return (_unicgeometry);
		}
		public function set unicgeometry(_arg1:Boolean):void{
			_unicgeometry = _arg1;
		}
		public function get keepMaterial():Boolean{
			return (_keepMaterial);
		}
		public function apply(_arg1:Mesh, _arg2:Mesh):void{
			merge(_arg1, _arg2);
		}
		public function set keepmaterial(_arg1:Boolean):void{
			_keepMaterial = _arg1;
		}
		public function set objectspace(_arg1:Boolean):void{
			_objectspace = _arg1;
		}
		private function applyPosition(_arg1:Vertex, _arg2:Number3D, _arg3:Number, _arg4:Number, _arg5:Number):Vertex{
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			var _local17:Number;
			var _local18:Number;
			var _local19:Number;
			var _local20:Number;
			_local11 = (Math.PI / 180);
			_local12 = (_arg3 * _local11);
			_local13 = (_arg4 * _local11);
			_local14 = (_arg5 * _local11);
			_local15 = Math.sin(_local12);
			_local16 = Math.cos(_local12);
			_local17 = Math.sin(_local13);
			_local18 = Math.cos(_local13);
			_local19 = Math.sin(_local14);
			_local20 = Math.cos(_local14);
			_local6 = (_arg1.x + _arg2.x);
			_local7 = (_arg1.y + _arg2.y);
			_local8 = (_arg1.z + _arg2.z);
			_local10 = _local7;
			_local7 = ((_local10 * _local16) + (_local8 * -(_local15)));
			_local8 = ((_local10 * _local15) + (_local8 * _local16));
			_local9 = _local6;
			_local6 = ((_local9 * _local18) + (_local8 * _local17));
			_local8 = ((_local9 * -(_local17)) + (_local8 * _local18));
			_local9 = _local6;
			_local6 = ((_local9 * _local20) + (_local7 * -(_local19)));
			_local7 = ((_local9 * _local19) + (_local7 * _local20));
			_arg1.setValue(_local6, _local7, _local8);
			return (_arg1);
		}
		private function merge(_arg1:Mesh, _arg2:Mesh):void{
			var _local3:int;
			var _local4:Vertex;
			var _local5:Vertex;
			var _local6:Vertex;
			var _local7:UV;
			var _local8:UV;
			var _local9:UV;
			var _local10:Face;
			var _local11:ITriangleMaterial;
			if (((_unicgeometry) || (!(_objectspace)))){
				_local3 = 0;
				while (_local3 < _arg2.faces.length) {
					_local10 = _arg2.faces[_local3];
					_local4 = new Vertex(_local10.v0.x, _local10.v0.y, _local10.v0.z);
					_local5 = new Vertex(_local10.v1.x, _local10.v1.y, _local10.v1.z);
					_local6 = new Vertex(_local10.v2.x, _local10.v2.y, _local10.v2.z);
					_local7 = new UV(_local10.uv0.u, _local10.uv0.v);
					_local8 = new UV(_local10.uv1.u, _local10.uv1.v);
					_local9 = new UV(_local10.uv2.u, _local10.uv2.v);
					if (!_objectspace){
						_local4 = applyPosition(_local4, _arg2.scenePosition, _arg2.rotationX, _arg2.rotationY, _arg2.rotationZ);
						_local5 = applyPosition(_local5, _arg2.scenePosition, _arg2.rotationX, _arg2.rotationY, _arg2.rotationZ);
						_local6 = applyPosition(_local6, _arg2.scenePosition, _arg2.rotationX, _arg2.rotationY, _arg2.rotationZ);
					};
					_local11 = (_keepMaterial) ? (_arg2.material as ITriangleMaterial) : (_arg1.material as ITriangleMaterial);
					_arg1.addFace(new Face(_local4, _local5, _local6, _local11, _local7, _local8, _local9));
					_local3++;
				};
			} else {
				_local3 = 0;
				while (_local3 < _arg2.faces.length) {
					_local11 = (_keepMaterial) ? (_arg2.material as ITriangleMaterial) : (_arg1.material as ITriangleMaterial);
					_local10 = _arg2.faces[_local3];
					_arg1.addFace(new Face(_local10.v0, _local10.v1, _local10.v2, _local11, _local10.uv0, _local10.uv1, _local10.uv2));
					_local3++;
				};
			};
		}
		public function get objectspace():Boolean{
			return (_objectspace);
		}

	}
}//package away3d.geom 
Section 122
//AmbientLight3D (away3d.lights.AmbientLight3D)
package away3d.lights {
	import away3d.primitives.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.materials.*;
	import away3d.core.light.*;

	public class AmbientLight3D extends Object3D implements ILightProvider, IClonable {

		private var _green:int;
		private var _ls:AmbientLight;
		private var _color:int;
		private var _debugMaterial:ColorMaterial;
		private var _blue:int;
		private var _ambient:Number;
		private var _debug:Boolean;
		private var _colorDirty:Boolean;
		private var _red:int;
		private var _debugPrimitive:Sphere;
		private var _ambientDirty:Boolean;

		public function AmbientLight3D(_arg1:Object=null){
			_ls = new AmbientLight();
			super(_arg1);
			color = ini.getColor("color", 0xFFFFFF);
			ambient = ini.getNumber("ambient", 0.5, {min:0, max:1});
			debug = ini.getBoolean("debug", false);
		}
		public function get debug():Boolean{
			return (_debug);
		}
		public function get ambient():Number{
			return (_ambient);
		}
		public function set debug(_arg1:Boolean):void{
			_debug = _arg1;
		}
		public function set color(_arg1:int):void{
			_color = _arg1;
			_red = ((_color & 0xFF0000) >> 16);
			_green = ((_color & 0xFF00) >> 8);
			_blue = (_color & 0xFF);
			_colorDirty = true;
		}
		public function set ambient(_arg1:Number):void{
			_ambient = _arg1;
			_ambientDirty = true;
		}
		public function light(_arg1:ILightConsumer):void{
			if (_colorDirty){
				_ls.red = _red;
				_ls.green = _green;
				_ls.blue = _blue;
				_colorDirty = false;
			};
			if (_ambientDirty){
				_ambientDirty = false;
				_ls.updateAmbientBitmap(_ambient);
			};
			_arg1.ambientLight(_ls);
		}
		override public function clone(_arg1:Object3D=null):Object3D{
			var _local2:AmbientLight3D;
			_local2 = (((_arg1 as AmbientLight3D)) || (new AmbientLight3D()));
			super.clone(_local2);
			_local2.color = color;
			_local2.ambient = ambient;
			_local2.debug = debug;
			return (_local2);
		}
		public function get color():int{
			return (_color);
		}
		public function get debugPrimitive():Object3D{
			if (!_debugPrimitive){
				_debugPrimitive = new Sphere();
				_scene.clearId(_id);
			};
			if (!_debugMaterial){
				_debugMaterial = new ColorMaterial();
				_debugPrimitive.material = _debugMaterial;
			};
			_debugMaterial.color = color;
			return (_debugPrimitive);
		}

	}
}//package away3d.lights 
Section 123
//DirectionalLight3D (away3d.lights.DirectionalLight3D)
package away3d.lights {
	import away3d.primitives.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.materials.*;
	import away3d.core.light.*;

	public class DirectionalLight3D extends Object3D implements ILightProvider, IClonable {

		private var _green:Number;
		private var _diffuse:Number;
		private var _ls:DirectionalLight;
		private var _specularDirty:Boolean;
		private var _color:int;
		private var _specular:Number;
		private var _debugMaterial:ColorMaterial;
		private var _blue:Number;
		private var _ambient:Number;
		private var _debug:Boolean;
		private var _diffuseDirty:Boolean;
		private var _colorDirty:Boolean;
		private var _red:Number;
		private var _debugPrimitive:Sphere;
		private var _brightness:Number;
		private var _ambientDirty:Boolean;

		public function DirectionalLight3D(_arg1:Object=null){
			_ls = new DirectionalLight();
			super(_arg1);
			color = ini.getColor("color", 0xFFFFFF);
			ambient = ini.getNumber("ambient", 0.5, {min:0, max:1});
			diffuse = ini.getNumber("diffuse", 0.5, {min:0, max:10});
			specular = ini.getNumber("specular", 1, {min:0, max:1});
			brightness = ini.getNumber("brightness", 1);
			debug = ini.getBoolean("debug", false);
			_ls.light = this;
		}
		public function get brightness():Number{
			return (_brightness);
		}
		public function get debug():Boolean{
			return (_debug);
		}
		public function set specular(_arg1:Number):void{
			if (_arg1 < 0){
				_arg1 = 0;
			};
			_specular = _arg1;
			_specularDirty = true;
		}
		public function get ambient():Number{
			return (_ambient);
		}
		public function set brightness(_arg1:Number):void{
			_brightness = _arg1;
			_ambientDirty = true;
			_diffuseDirty = true;
			_specularDirty = true;
		}
		public function set debug(_arg1:Boolean):void{
			_debug = _arg1;
		}
		public function set color(_arg1:int):void{
			_color = _arg1;
			_red = (((color & 0xFF0000) >> 16) / 0xFF);
			_green = (((color & 0xFF00) >> 8) / 0xFF);
			_blue = ((color & 0xFF) / 0xFF);
			_colorDirty = true;
			_ambientDirty = true;
			_diffuseDirty = true;
			_specularDirty = true;
		}
		public function set diffuse(_arg1:Number):void{
			if (_arg1 < 0){
				_arg1 = 0;
			};
			_diffuse = _arg1;
			_diffuseDirty = true;
		}
		public function set ambient(_arg1:Number):void{
			if (_arg1 < 0){
				_arg1 = 0;
			};
			_ambient = _arg1;
			_ambientDirty = true;
		}
		public function light(_arg1:ILightConsumer):void{
			if (_colorDirty){
				_ls.red = _red;
				_ls.green = _green;
				_ls.blue = _blue;
			};
			_ls.ambient = (_ambient * _brightness);
			_ls.diffuse = (_diffuse * _brightness);
			_ls.specular = (_specular * _brightness);
			if (((_ambientDirty) || (_diffuseDirty))){
				_ls.updateAmbientDiffuseBitmap();
			};
			if (_ambientDirty){
				_ambientDirty = false;
				_ls.updateAmbientBitmap();
			};
			if (_diffuseDirty){
				_diffuseDirty = false;
				_ls.updateDiffuseBitmap();
			};
			if (_specularDirty){
				_specularDirty = false;
				_ls.updateSpecularBitmap();
			};
			_arg1.directionalLight(_ls);
			_colorDirty = false;
		}
		override public function clone(_arg1:Object3D=null):Object3D{
			var _local2:DirectionalLight3D;
			_local2 = (((_arg1 as DirectionalLight3D)) || (new DirectionalLight3D()));
			super.clone(_local2);
			_local2.color = color;
			_local2.brightness = brightness;
			_local2.ambient = ambient;
			_local2.diffuse = diffuse;
			_local2.specular = specular;
			_local2.debug = debug;
			return (_local2);
		}
		public function get diffuse():Number{
			return (_diffuse);
		}
		public function get specular():Number{
			return (_specular);
		}
		public function get color():int{
			return (_color);
		}
		public function get debugPrimitive():Object3D{
			if (!_debugPrimitive){
				_debugPrimitive = new Sphere({radius:10});
				_scene.clearId(_id);
			};
			if (!_debugMaterial){
				_debugMaterial = new ColorMaterial();
				_debugPrimitive.material = _debugMaterial;
			};
			_debugMaterial.color = color;
			return (_debugPrimitive);
		}

	}
}//package away3d.lights 
Section 124
//PointLight3D (away3d.lights.PointLight3D)
package away3d.lights {
	import away3d.primitives.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.materials.*;
	import away3d.core.light.*;
	import away3d.geom.*;

	public class PointLight3D extends Object3D implements ILightProvider, IClonable {

		private var _ls:PointLight;
		public var brightness:Number;
		private var _color:uint;
		public var ambient:Number;
		private var _debugMaterial:ColorMaterial;
		private var _falloff:Number;// = 1000
		public var diffuse:Number;
		private var _debug:Boolean;
		public var specular:Number;
		private var _radius:Number;// = 200
		private var _debugPrimitive:Sphere;

		public function PointLight3D(_arg1:Object=null){
			_ls = new PointLight();
			_radius = 200;
			_falloff = 1000;
			super(_arg1);
			_color = ini.getColor("color", 0xFFFFFF);
			ambient = ini.getNumber("ambient", 1);
			diffuse = ini.getNumber("diffuse", 1);
			specular = ini.getNumber("specular", 1);
			brightness = (ini.getNumber("brightness", 1000) * 0xFF);
			debug = ini.getBoolean("debug", false);
			_radius = ini.getNumber("radius", 50);
			_falloff = ini.getNumber("fallOff", 1000);
			_ls.light = this;
		}
		public function get debug():Boolean{
			return (_debug);
		}
		public function get radius():Number{
			return (_radius);
		}
		public function set debug(_arg1:Boolean):void{
			_debug = _arg1;
		}
		public function set color(_arg1:uint):void{
			_color = _arg1;
			_ls.red = (((_color & 0xFF0000) >> 16) / 0xFF);
			_ls.green = (((_color & 0xFF00) >> 8) / 0xFF);
			_ls.blue = ((_color & 0xFF) / 0xFF);
			_debugPrimitive = null;
		}
		public function set radius(_arg1:Number):void{
			_radius = _arg1;
			_falloff = ((radius)>_falloff) ? (radius + 1) : _falloff;
			_debugPrimitive = null;
		}
		public function light(_arg1:ILightConsumer):void{
			_ls.red = (((_color & 0xFF0000) >> 16) / 0xFF);
			_ls.green = (((_color & 0xFF00) >> 8) / 0xFF);
			_ls.blue = ((_color & 0xFF) / 0xFF);
			_ls.ambient = (ambient * brightness);
			_ls.diffuse = (diffuse * brightness);
			_ls.specular = (specular * brightness);
			_ls.radius = _radius;
			_ls.fallOff = _falloff;
			_arg1.pointLight(_ls);
		}
		override public function clone(_arg1:Object3D=null):Object3D{
			var _local2:PointLight3D;
			_local2 = (((_arg1 as PointLight3D)) || (new PointLight3D()));
			super.clone(_local2);
			_local2.color = _color;
			_local2.ambient = ambient;
			_local2.diffuse = diffuse;
			_local2.specular = specular;
			_local2.debug = debug;
			_local2.radius = _radius;
			_local2.fallOff = _falloff;
			return (_local2);
		}
		public function get color():uint{
			return (_color);
		}
		public function get debugPrimitive():Object3D{
			var _local1:Merge;
			var _local2:Sphere;
			if (!_debugPrimitive){
				_debugPrimitive = new Sphere({radius:radius});
				_scene.setId(_debugPrimitive);
				_debugMaterial = new ColorMaterial();
				_debugPrimitive.material = _debugMaterial;
				_debugMaterial.color = color;
				_debugMaterial.alpha = 0.15;
				_local1 = new Merge(false, true, false);
				_local2 = new Sphere({segmentsW:10, segmentsH:8, material:_debugMaterial, radius:_falloff});
				_local1.apply(_debugPrimitive, _local2);
			};
			return (_debugPrimitive);
		}
		public function set fallOff(_arg1:Number):void{
			_falloff = ((radius)>_falloff) ? (radius + 1) : _arg1;
			_debugPrimitive = null;
			_scene.clearId(_id);
		}
		public function get fallOff():Number{
			return (_falloff);
		}

	}
}//package away3d.lights 
Section 125
//AnimationData (away3d.loaders.data.AnimationData)
package away3d.loaders.data {
	import away3d.containers.*;
	import away3d.core.base.*;
	import flash.utils.*;
	import away3d.animators.*;

	public class AnimationData {

		public var start:Number;// = INF
		public var animation:IMeshAnimation;
		public var channels:Dictionary;
		public var name:String;
		public var end:Number;// = 0
		public var animationType:String;// = "skinAnimation"

		public static const VERTEX_ANIMATION:String = "vertexAnimation";
		public static const SKIN_ANIMATION:String = "skinAnimation";

		public function AnimationData(){
			start = Infinity;
			end = 0;
			animationType = SKIN_ANIMATION;
			channels = new Dictionary(true);
			super();
		}
		public function clone(_arg1:Object3D):AnimationData{
			var _local2:AnimationData;
			_local2 = _arg1.animationLibrary.addAnimation(name);
			_local2.start = start;
			_local2.end = end;
			_local2.animationType = animationType;
			_local2.animation = animation.clone((_arg1 as ObjectContainer3D));
			return (_local2);
		}

	}
}//package away3d.loaders.data 
Section 126
//GeometryData (away3d.loaders.data.GeometryData)
package away3d.loaders.data {
	import away3d.core.base.*;

	public class GeometryData {

		public var vertices:Array;
		public var maxX:Number;
		public var maxZ:Number;
		public var geoXML:XML;
		public var minZ:Number;
		public var geometry:Geometry;
		public var name:String;
		public var minX:Number;
		public var minY:Number;
		public var skinVertices:Array;
		public var skinControllers:Array;
		public var bothsides:Boolean;
		public var uvs:Array;
		public var ctrlXML:XML;
		public var maxY:Number;
		public var materials:Array;
		public var faces:Array;

		public function GeometryData(){
			vertices = [];
			uvs = [];
			faces = [];
			materials = [];
			skinVertices = [];
			skinControllers = [];
			super();
		}
	}
}//package away3d.loaders.data 
Section 127
//MaterialData (away3d.loaders.data.MaterialData)
package away3d.loaders.data {
	import flash.display.*;
	import away3d.core.base.*;
	import away3d.materials.*;

	public class MaterialData {

		private var _material:IMaterial;
		public var materialType:String;// = "wireframeMaterial"
		public var name:String;
		public var shininess:Number;
		public var specularColor:uint;
		public var diffuseColor:uint;
		public var textureFileName:String;
		public var textureBitmap:BitmapData;
		public var ambientColor:uint;
		public var elements:Array;

		public static const COLOR_MATERIAL:String = "colorMaterial";
		public static const TEXTURE_MATERIAL:String = "textureMaterial";
		public static const SHADING_MATERIAL:String = "shadingMaterial";
		public static const WIREFRAME_MATERIAL:String = "wireframeMaterial";

		public function MaterialData(){
			materialType = WIREFRAME_MATERIAL;
			elements = [];
			super();
		}
		public function set material(_arg1:IMaterial):void{
			var _local2:Element;
			if (_material == _arg1){
				return;
			};
			_material = _arg1;
			if ((_material is IUVMaterial)){
				textureBitmap = (_material as IUVMaterial).bitmap;
			};
			if ((_material is ITriangleMaterial)){
				for each (_local2 in elements) {
					(_local2 as Face).material = (_material as ITriangleMaterial);
				};
			} else {
				if ((_material is ISegmentMaterial)){
					for each (_local2 in elements) {
						(_local2 as Segment).material = (_material as ISegmentMaterial);
					};
				};
			};
		}
		public function clone(_arg1:Object3D):MaterialData{
			var _local2:MaterialData;
			var _local3:Element;
			var _local4:Geometry;
			var _local5:Element;
			_local2 = _arg1.materialLibrary.addMaterial(name);
			_local2.materialType = materialType;
			_local2.ambientColor = ambientColor;
			_local2.diffuseColor = diffuseColor;
			_local2.shininess = shininess;
			_local2.specularColor = specularColor;
			_local2.textureBitmap = textureBitmap;
			_local2.textureFileName = textureFileName;
			_local2.material = material;
			for each (_local3 in elements) {
				_local4 = _local3.parent;
				_local5 = _local4.cloneElementDictionary[_local3];
				_local2.elements.push(_local5);
			};
			return (_local2);
		}
		public function get material():IMaterial{
			return (_material);
		}

	}
}//package away3d.loaders.data 
Section 128
//AnimationLibrary (away3d.loaders.utils.AnimationLibrary)
package away3d.loaders.utils {
	import away3d.core.utils.*;
	import flash.utils.*;
	import away3d.loaders.data.*;

	public dynamic class AnimationLibrary extends Dictionary {

		public function addAnimation(_arg1:String):AnimationData{
			var _local2:AnimationData;
			if (this[_arg1]){
				return (this[_arg1]);
			};
			_local2 = new AnimationData();
			var _local3 = (_local2.name = _arg1);
			this[_local3] = _local2;
			return (_local2);
		}
		public function getAnimation(_arg1:String):AnimationData{
			if (this[_arg1]){
				return (this[_arg1]);
			};
			Debug.warning((("Animation '" + _arg1) + "' does not exist"));
			return (null);
		}

	}
}//package away3d.loaders.utils 
Section 129
//GeometryLibrary (away3d.loaders.utils.GeometryLibrary)
package away3d.loaders.utils {
	import away3d.core.utils.*;
	import flash.utils.*;
	import away3d.loaders.data.*;

	public dynamic class GeometryLibrary extends Dictionary {

		private var _geometryArrayDirty:Boolean;
		public var name:String;
		private var _geometryArray:Array;

		public function getGeometry(_arg1:String):GeometryData{
			if (this[_arg1]){
				return (this[_arg1]);
			};
			Debug.warning((("Geometry '" + _arg1) + "' does not exist"));
			return (null);
		}
		public function addGeometry(_arg1:String, _arg2:XML=null, _arg3:XML=null):GeometryData{
			var _local4:GeometryData;
			if (this[_arg1]){
				return (this[_arg1]);
			};
			_geometryArrayDirty = true;
			_local4 = new GeometryData();
			_local4.geoXML = _arg2;
			_local4.ctrlXML = _arg3;
			var _local5 = (_local4.name = _arg1);
			this[_local5] = _local4;
			return (_local4);
		}
		public function getGeometryArray():Array{
			if (_geometryArrayDirty){
				updateGeometryArray();
			};
			return (_geometryArray);
		}
		private function updateGeometryArray():void{
			var _local1:GeometryData;
			_geometryArray = [];
			for each (_local1 in this) {
				_geometryArray.push(_local1);
			};
		}

	}
}//package away3d.loaders.utils 
Section 130
//MaterialLibrary (away3d.loaders.utils.MaterialLibrary)
package away3d.loaders.utils {
	import flash.display.*;
	import away3d.core.utils.*;
	import away3d.materials.*;
	import flash.utils.*;
	import away3d.loaders.data.*;

	public dynamic class MaterialLibrary extends Dictionary {

		public var texturePath:String;
		public var loadRequired:Boolean;
		private var length:int;// = 0

		public function MaterialLibrary(){
			length = 0;
			super();
		}
		public function getMaterial(_arg1:String):MaterialData{
			if (this[_arg1]){
				return (this[_arg1]);
			};
			Debug.warning((("Material '" + _arg1) + "' does not exist"));
			return (null);
		}
		public function addMaterial(_arg1:String):MaterialData{
			var _local2:MaterialData;
			if (this[_arg1]){
				return (this[_arg1]);
			};
			length++;
			_local2 = new MaterialData();
			var _local3 = (_local2.name = _arg1);
			this[_local3] = _local2;
			return (_local2);
		}
		public function texturesLoaded(_arg1:TextureLoadQueue):void{
			var images:Array;
			var _materialData:MaterialData;
			var _image:TextureLoader;
			var loadQueue = _arg1;
			loadRequired = false;
			images = loadQueue.images;
			for each (_materialData in this) {
				for each (_image in images) {
					if ((texturePath + _materialData.textureFileName) == _image.filename){
						try {
							_materialData.textureBitmap = new BitmapData(_image.width, _image.height, true, 0xFFFFFF);
							_materialData.textureBitmap.draw(_image);
							_materialData.material = new BitmapMaterial(_materialData.textureBitmap);
						} catch(e) {
							Debug.warning((("File not found : " + texturePath) + _materialData.textureFileName));
							_materialData.material = new WireframeMaterial();
						};
					};
				};
			};
		}

	}
}//package away3d.loaders.utils 
Section 131
//TextureLoader (away3d.loaders.utils.TextureLoader)
package away3d.loaders.utils {
	import flash.display.*;
	import flash.net.*;
	import flash.system.*;

	public class TextureLoader extends Loader {

		private var _filename:String;

		public function get filename():String{
			return (_filename);
		}
		override public function load(_arg1:URLRequest, _arg2:LoaderContext=null):void{
			_filename = _arg1.url;
			super.load(_arg1, _arg2);
		}

	}
}//package away3d.loaders.utils 
Section 132
//TextureLoadQueue (away3d.loaders.utils.TextureLoadQueue)
package away3d.loaders.utils {
	import flash.events.*;
	import flash.net.*;

	public class TextureLoadQueue extends EventDispatcher {

		private var _queue:Array;
		private var _currentItemIndex:int;

		public function TextureLoadQueue(){
			_queue = [];
		}
		public function get currentURLRequest():URLRequest{
			return ((_queue[currentItemIndex] as LoaderAndRequest).request);
		}
		public function get numItems():int{
			return (_queue.length);
		}
		public function addItem(_arg1:TextureLoader, _arg2:URLRequest):void{
			var _local3:LoaderAndRequest;
			for each (_local3 in _queue) {
				if (_local3.request.url == _arg2.url){
					return;
				};
			};
			_queue.push(new LoaderAndRequest(_arg1, _arg2));
		}
		public function get currentItemIndex():int{
			return (_currentItemIndex);
		}
		private function calcProgress():Number{
			var _local1:Number;
			var _local2:Number;
			_local1 = (currentItemIndex / numItems);
			_local2 = (calcCurrentLoaderAmountLoaded() / numItems);
			_local1 = _local2;
			return (_local1);
		}
		public function start():void{
			_currentItemIndex = 0;
			loadNext();
		}
		public function get percentLoaded():Number{
			return ((progress * 100));
		}
		private function onItemComplete(_arg1:Event):void{
			cleanUpOldItem(currentLoader);
			_currentItemIndex++;
			loadNext();
		}
		private function redispatchEvent(_arg1:Event):void{
			dispatchEvent(_arg1);
		}
		public function get currentLoader():TextureLoader{
			return ((_queue[currentItemIndex] as LoaderAndRequest).loader);
		}
		private function calcCurrentLoaderAmountLoaded():Number{
			if (currentLoader.contentLoaderInfo.bytesLoaded > 0){
				return ((currentLoader.contentLoaderInfo.bytesLoaded / currentLoader.contentLoaderInfo.bytesTotal));
			};
			return (0);
		}
		private function cleanUpOldItem(_arg1:TextureLoader):void{
			currentLoader.removeEventListener(Event.COMPLETE, onItemComplete, false);
			currentLoader.removeEventListener(HTTPStatusEvent.HTTP_STATUS, redispatchEvent, false);
			currentLoader.removeEventListener(IOErrorEvent.IO_ERROR, redispatchEvent, false);
			currentLoader.removeEventListener(ProgressEvent.PROGRESS, redispatchEvent, false);
			currentLoader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, redispatchEvent, false);
		}
		public function get images():Array{
			var _local1:Array;
			var _local2:LoaderAndRequest;
			_local1 = [];
			for each (_local2 in _queue) {
				_local1.push(_local2.loader);
			};
			return (_local1);
		}
		private function loadNext():void{
			var _local1:ProgressEvent;
			if (_currentItemIndex >= numItems){
				dispatchEvent(new Event(Event.COMPLETE));
			} else {
				_local1 = new ProgressEvent(ProgressEvent.PROGRESS);
				_local1.bytesTotal = 100;
				_local1.bytesLoaded = percentLoaded;
				dispatchEvent(_local1);
				if ((((currentLoader.contentLoaderInfo.bytesLoaded > 0)) && ((currentLoader.contentLoaderInfo.bytesLoaded == currentLoader.contentLoaderInfo.bytesTotal)))){
				} else {
					currentLoader.contentLoaderInfo.addEventListener(Event.COMPLETE, onItemComplete, false, int.MIN_VALUE, true);
					currentLoader.contentLoaderInfo.addEventListener(HTTPStatusEvent.HTTP_STATUS, redispatchEvent, false, 0, true);
					currentLoader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, redispatchEvent, false, 0, true);
					currentLoader.contentLoaderInfo.addEventListener(ProgressEvent.PROGRESS, redispatchEvent, false, 0, true);
					currentLoader.contentLoaderInfo.addEventListener(SecurityErrorEvent.SECURITY_ERROR, redispatchEvent, false, 0, true);
					currentLoader.load(currentURLRequest);
				};
			};
		}
		public function get progress():Number{
			return (calcProgress());
		}

	}
}//package away3d.loaders.utils 

import flash.net.*;

class LoaderAndRequest {

	public var loader:TextureLoader;
	public var request:URLRequest;

	private function LoaderAndRequest(_arg1:TextureLoader, _arg2:URLRequest){
		this.loader = _arg1;
		this.request = _arg2;
	}
}
Section 133
//BitmapMaterial (away3d.materials.BitmapMaterial)
package away3d.materials {
	import flash.geom.*;
	import flash.display.*;
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.clip.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.core.render.*;
	import flash.utils.*;
	import away3d.events.*;
	import away3d.cameras.lenses.*;

	public class BitmapMaterial extends EventDispatcher implements ITriangleMaterial, IUVMaterial, ILayerMaterial, IBillboardMaterial {

		var _green:Number;// = 1
		var _blendMode:String;
		var _bitmapDirty:Boolean;
		private var ai:Number;
		private var ax:Number;
		private var ay:Number;
		private var az:Number;
		var _renderBitmap:BitmapData;
		var _zeroPoint:Point;
		var _bitmap:BitmapData;
		private var mcaz:Number;
		private var mcay:Number;
		private var bi:Number;
		private var by:Number;
		private var bz:Number;
		private var mcax:Number;
		private var bx:Number;
		var _alpha:Number;// = 1
		var _color:uint;// = 0xFFFFFF
		private var ci:Number;
		private var cx:Number;
		private var cy:Number;
		private var cz:Number;
		private var x:Number;
		private var y:Number;
		var _faceMaterialVO:FaceMaterialVO;
		private var dmax:Number;
		private var _nn:Number3D;
		private var _shape:Shape;
		private var _screenVertices:Array;
		var _blendModeDirty:Boolean;
		private var _repeat:Boolean;
		private var mbcx:Number;
		private var mbcy:Number;
		private var mbcz:Number;
		private var _smooth:Boolean;
		private var _sv0x:Number;
		private var index:int;
		private var focus:Number;
		private var _sv0y:Number;
		private var _sv1x:Number;
		private var mabx:Number;
		private var maby:Number;
		private var dsab:Number;
		var _materialDirty:Boolean;
		private var dcax:Number;
		private var _showNormals:Boolean;
		private var _sv1y:Number;
		private var mabz:Number;
		private var dcay:Number;
		var _faceDictionary:Dictionary;
		private var _precision:Number;
		private var _near:Number;
		private var dsbc:Number;
		private var faz:Number;
		private var dsca:Number;
		private var _screenCommands:Array;
		var _blue:Number;// = 1
		private var fbz:Number;
		var _bitmapRect:Rectangle;
		private var _debug:Boolean;
		var _session:AbstractRenderSession;
		var _colorTransformDirty:Boolean;
		private var map:Matrix;
		private var fcz:Number;
		var _colorTransform:ColorTransform;
		var _texturemapping:Matrix;
		var _sourceVO:FaceMaterialVO;
		private var _materialupdated:MaterialEvent;
		private var dbcx:Number;
		private var dbcy:Number;
		private var _view:View3D;
		var _mapping:Matrix;
		private var dabx:Number;
		private var _screenIndices:Array;
		private var daby:Number;
		var _id:int;
		var _red:Number;// = 1
		var _graphics:Graphics;
		protected var ini:Init;
		var _s:Shape;

		public function BitmapMaterial(_arg1:BitmapData, _arg2:Object=null){
			_color = 0xFFFFFF;
			_red = 1;
			_green = 1;
			_blue = 1;
			_alpha = 1;
			_faceDictionary = new Dictionary(true);
			_zeroPoint = new Point(0, 0);
			_s = new Shape();
			map = new Matrix();
			_nn = new Number3D();
			super();
			_bitmap = _arg1;
			ini = Init.parse(_arg2);
			smooth = ini.getBoolean("smooth", false);
			debug = ini.getBoolean("debug", false);
			repeat = ini.getBoolean("repeat", false);
			precision = ini.getNumber("precision", 0);
			_blendMode = ini.getString("blendMode", BlendMode.NORMAL);
			alpha = ini.getNumber("alpha", _alpha, {min:0, max:1});
			color = ini.getColor("color", _color);
			colorTransform = (ini.getObject("colorTransform", ColorTransform) as ColorTransform);
			showNormals = ini.getBoolean("showNormals", false);
			_colorTransformDirty = true;
		}
		public function get debug():Boolean{
			return (_debug);
		}
		public function set bitmap(_arg1:BitmapData):void{
			_bitmap = _arg1;
			_bitmapDirty = true;
		}
		public function renderBillboard(_arg1:DrawBillboard):void{
			_arg1.source.session.renderBillboardBitmap(_renderBitmap, _arg1, smooth);
		}
		function notifyMaterialUpdate():void{
			_materialDirty = false;
			if (!hasEventListener(MaterialEvent.MATERIAL_UPDATED)){
				return;
			};
			if (_materialupdated == null){
				_materialupdated = new MaterialEvent(MaterialEvent.MATERIAL_UPDATED, this);
			};
			dispatchEvent(_materialupdated);
		}
		public function get precision():Number{
			return (_precision);
		}
		protected function getMapping(_arg1:DrawTriangle):Matrix{
			if (_arg1.generated){
				_texturemapping = _arg1.transformUV(this).clone();
				_texturemapping.invert();
				return (_texturemapping);
			};
			_faceMaterialVO = getFaceMaterialVO(_arg1.faceVO);
			if (!_faceMaterialVO.invalidated){
				return (_faceMaterialVO.texturemapping);
			};
			_faceMaterialVO.invalidated = false;
			_texturemapping = _arg1.transformUV(this).clone();
			_texturemapping.invert();
			return ((_faceMaterialVO.texturemapping = _texturemapping));
		}
		public function set colorTransform(_arg1:ColorTransform):void{
			_colorTransform = _arg1;
			if (_colorTransform){
				_red = _colorTransform.redMultiplier;
				_green = _colorTransform.greenMultiplier;
				_blue = _colorTransform.blueMultiplier;
				_alpha = _colorTransform.alphaMultiplier;
				_color = ((((_red * 0xFF) << 16) + ((_green * 0xFF) << 8)) + (_blue * 0xFF));
			};
			_colorTransformDirty = true;
		}
		protected function updateColorTransform():void{
			_colorTransformDirty = false;
			_bitmapDirty = true;
			_materialDirty = true;
			if ((((_alpha == 1)) && ((_color == 0xFFFFFF)))){
				_renderBitmap = _bitmap;
				if (((!(_colorTransform)) || (((((!(_colorTransform.redOffset)) && (!(_colorTransform.greenOffset)))) && (!(_colorTransform.blueOffset)))))){
					_colorTransform = null;
					return;
				};
			} else {
				if (!_colorTransform){
					_colorTransform = new ColorTransform();
				};
			};
			_colorTransform.redMultiplier = _red;
			_colorTransform.greenMultiplier = _green;
			_colorTransform.blueMultiplier = _blue;
			_colorTransform.alphaMultiplier = _alpha;
			if (_alpha == 0){
				_renderBitmap = null;
				return;
			};
		}
		public function set debug(_arg1:Boolean):void{
			if (_debug == _arg1){
				return;
			};
			_debug = _arg1;
			_materialDirty = true;
		}
		public function get showNormals():Boolean{
			return (_showNormals);
		}
		public function set alpha(_arg1:Number):void{
			if (_arg1 > 1){
				_arg1 = 1;
			};
			if (_arg1 < 0){
				_arg1 = 0;
			};
			if (_alpha == _arg1){
				return;
			};
			_alpha = _arg1;
			_colorTransformDirty = true;
		}
		public function set color(_arg1:uint):void{
			if (_color == _arg1){
				return;
			};
			_color = _arg1;
			_red = (((_color & 0xFF0000) >> 16) / 0xFF);
			_green = (((_color & 0xFF00) >> 8) / 0xFF);
			_blue = ((_color & 0xFF) / 0xFF);
			_colorTransformDirty = true;
		}
		public function get visible():Boolean{
			return ((_alpha > 0));
		}
		public function set precision(_arg1:Number):void{
			_precision = ((_arg1 * _arg1) * 1.4);
			_materialDirty = true;
		}
		public function updateMaterial(_arg1:Object3D, _arg2:View3D):void{
			_graphics = null;
			if (_colorTransformDirty){
				updateColorTransform();
			};
			if (_bitmapDirty){
				updateRenderBitmap();
			};
			if (((_materialDirty) || (_blendModeDirty))){
				clearFaces(_arg1, _arg2);
			};
			_blendModeDirty = false;
		}
		private function renderRec(_arg1:Number, _arg2:Number):void{
			var _local3:int;
			var _local4:int;
			var _local5:int;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Number;
			var _local12:int;
			var _local13:int;
			var _local14:int;
			_local3 = _screenIndices[_arg1];
			ai = (_local3 * 3);
			ax = _screenVertices[ai];
			ay = _screenVertices[(ai + 1)];
			az = _screenVertices[(ai + 2)];
			_local4 = _screenIndices[(_arg1 + 1)];
			bi = (_local4 * 3);
			bx = _screenVertices[bi];
			by = _screenVertices[(bi + 1)];
			bz = _screenVertices[(bi + 2)];
			_local5 = _screenIndices[(_arg1 + 2)];
			ci = (_local5 * 3);
			cx = _screenVertices[ci];
			cy = _screenVertices[(ci + 1)];
			cz = _screenVertices[(ci + 2)];
			if (((!((_view.screenClipping is FrustumClipping))) && (!(_view.screenClipping.rect(Math.min(ax, Math.min(bx, cx)), Math.min(ay, Math.min(by, cy)), Math.max(ax, Math.max(bx, cx)), Math.max(ay, Math.max(by, cy))))))){
				return;
			};
			if ((((_view.screenClipping is RectangleClipping)) && ((((((az < _near)) || ((bz < _near)))) || ((cz < _near)))))){
				return;
			};
			if ((((((((index >= 1000)) || ((focus == Infinity)))) || (((Math.max(Math.max(ax, bx), cx) - Math.min(Math.min(ax, bx), cx)) < 10)))) || (((Math.max(Math.max(ay, by), cy) - Math.min(Math.min(ay, by), cy)) < 10)))){
				_session.renderTriangleBitmap(_renderBitmap, map, _screenVertices, _screenIndices, _arg1, _arg2, smooth, repeat, _graphics);
				if (debug){
					_session.renderTriangleLine(1, 0xFF00, 1, _screenVertices, _screenCommands, _screenIndices, _arg1, _arg2);
				};
				return;
			};
			faz = (focus + az);
			fbz = (focus + bz);
			fcz = (focus + cz);
			mabz = (2 / (faz + fbz));
			mbcz = (2 / (fbz + fcz));
			mcaz = (2 / (fcz + faz));
			dabx = ((ax + bx) - (mabx = (((ax * faz) + (bx * fbz)) * mabz)));
			daby = ((ay + by) - (maby = (((ay * faz) + (by * fbz)) * mabz)));
			dbcx = ((bx + cx) - (mbcx = (((bx * fbz) + (cx * fcz)) * mbcz)));
			dbcy = ((by + cy) - (mbcy = (((by * fbz) + (cy * fcz)) * mbcz)));
			dcax = ((cx + ax) - (mcax = (((cx * fcz) + (ax * faz)) * mcaz)));
			dcay = ((cy + ay) - (mcay = (((cy * fcz) + (ay * faz)) * mcaz)));
			dsab = ((dabx * dabx) + (daby * daby));
			dsbc = ((dbcx * dbcx) + (dbcy * dbcy));
			dsca = ((dcax * dcax) + (dcay * dcay));
			if ((((((dsab <= precision)) && ((dsca <= precision)))) && ((dsbc <= precision)))){
				_session.renderTriangleBitmap(_renderBitmap, map, _screenVertices, _screenIndices, _arg1, _arg2, smooth, repeat, _graphics);
				if (debug){
					_session.renderTriangleLine(1, 0xFF00, 1, _screenVertices, _screenCommands, _screenIndices, _arg1, _arg2);
				};
				return;
			};
			_local6 = map.a;
			_local7 = map.b;
			_local8 = map.c;
			_local9 = map.d;
			_local10 = map.tx;
			_local11 = map.ty;
			index++;
			_local14 = (_screenVertices.length / 3);
			_screenVertices[_screenVertices.length] = (mbcx / 2);
			_screenVertices[_screenVertices.length] = (mbcy / 2);
			_screenVertices[_screenVertices.length] = ((bz + cz) / 2);
			if ((((((dsab > precision)) && ((dsca > precision)))) && ((dsbc > precision)))){
				index = (index + 2);
				_local12 = (_screenVertices.length / 3);
				_screenVertices[_screenVertices.length] = (mabx / 2);
				_screenVertices[_screenVertices.length] = (maby / 2);
				_screenVertices[_screenVertices.length] = ((az + bz) / 2);
				_local13 = (_screenVertices.length / 3);
				_screenVertices[_screenVertices.length] = (mcax / 2);
				_screenVertices[_screenVertices.length] = (mcay / 2);
				_screenVertices[_screenVertices.length] = ((cz + az) / 2);
				_arg1 = _screenIndices.length;
				var _local15 = _arg1;
				_screenIndices[_local15] = _local3;
				_screenIndices[_screenIndices.length] = _local12;
				_screenIndices[_screenIndices.length] = _local13;
				_arg2 = _screenIndices.length;
				_local6 = (_local6 * 2);
				map.a = _local6;
				_local7 = (_local7 * 2);
				map.b = _local7;
				_local8 = (_local8 * 2);
				map.c = _local8;
				_local9 = (_local9 * 2);
				map.d = _local9;
				_local10 = (_local10 * 2);
				map.tx = _local10;
				_local11 = (_local11 * 2);
				map.ty = _local11;
				renderRec(_arg1, _arg2);
				_arg1 = _screenIndices.length;
				var _local16 = _arg1;
				_screenIndices[_local16] = _local12;
				_screenIndices[_screenIndices.length] = _local4;
				_screenIndices[_screenIndices.length] = _local14;
				_arg2 = _screenIndices.length;
				map.a = _local6;
				map.b = _local7;
				map.c = _local8;
				map.d = _local9;
				map.tx = (_local10 - 1);
				map.ty = _local11;
				renderRec(_arg1, _arg2);
				_arg1 = _screenIndices.length;
				var _local17 = _arg1;
				_screenIndices[_local17] = _local13;
				_screenIndices[_screenIndices.length] = _local14;
				_screenIndices[_screenIndices.length] = _local5;
				_arg2 = _screenIndices.length;
				map.a = _local6;
				map.b = _local7;
				map.c = _local8;
				map.d = _local9;
				map.tx = _local10;
				map.ty = (_local11 - 1);
				renderRec(_arg1, _arg2);
				_arg1 = _screenIndices.length;
				var _local18 = _arg1;
				_screenIndices[_local18] = _local14;
				_screenIndices[_screenIndices.length] = _local13;
				_screenIndices[_screenIndices.length] = _local12;
				_arg2 = _screenIndices.length;
				map.a = -(_local6);
				map.b = -(_local7);
				map.c = -(_local8);
				map.d = -(_local9);
				map.tx = (1 - _local10);
				map.ty = (1 - _local11);
				renderRec(_arg1, _arg2);
				return;
			};
			dmax = Math.max(dsab, Math.max(dsca, dsbc));
			if (dsab == dmax){
				index++;
				_local12 = (_screenVertices.length / 3);
				_screenVertices[_screenVertices.length] = (mabx / 2);
				_screenVertices[_screenVertices.length] = (maby / 2);
				_screenVertices[_screenVertices.length] = ((az + bz) / 2);
				_arg1 = _screenIndices.length;
				_local15 = _arg1;
				_screenIndices[_local15] = _local3;
				_screenIndices[_screenIndices.length] = _local12;
				_screenIndices[_screenIndices.length] = _local5;
				_arg2 = _screenIndices.length;
				_local6 = (_local6 * 2);
				map.a = _local6;
				_local8 = (_local8 * 2);
				map.c = _local8;
				_local10 = (_local10 * 2);
				map.tx = _local10;
				renderRec(_arg1, _arg2);
				_arg1 = _screenIndices.length;
				_local16 = _arg1;
				_screenIndices[_local16] = _local12;
				_screenIndices[_screenIndices.length] = _local4;
				_screenIndices[_screenIndices.length] = _local5;
				_arg2 = _screenIndices.length;
				map.a = (_local6 + _local7);
				map.b = _local7;
				map.c = (_local8 + _local9);
				map.d = _local9;
				map.tx = ((_local10 + _local11) - 1);
				map.ty = _local11;
				renderRec(_arg1, _arg2);
				return;
			};
			if (dsca == dmax){
				index++;
				_local13 = (_screenVertices.length / 3);
				_screenVertices[_screenVertices.length] = (mcax / 2);
				_screenVertices[_screenVertices.length] = (mcay / 2);
				_screenVertices[_screenVertices.length] = ((cz + az) / 2);
				_arg1 = _screenIndices.length;
				_local15 = _arg1;
				_screenIndices[_local15] = _local3;
				_screenIndices[_screenIndices.length] = _local4;
				_screenIndices[_screenIndices.length] = _local13;
				_arg2 = _screenIndices.length;
				_local7 = (_local7 * 2);
				map.b = _local7;
				_local9 = (_local9 * 2);
				map.d = _local9;
				_local11 = (_local11 * 2);
				map.ty = _local11;
				renderRec(_arg1, _arg2);
				_arg1 = _screenIndices.length;
				_local16 = _arg1;
				_screenIndices[_local16] = _local13;
				_screenIndices[_screenIndices.length] = _local4;
				_screenIndices[_screenIndices.length] = _local5;
				_arg2 = _screenIndices.length;
				map.a = _local6;
				map.b = (_local7 + _local6);
				map.c = _local8;
				map.d = (_local9 + _local8);
				map.tx = _local10;
				map.ty = ((_local11 + _local10) - 1);
				renderRec(_arg1, _arg2);
				return;
			};
			_arg1 = _screenIndices.length;
			_local15 = _arg1;
			_screenIndices[_local15] = _local3;
			_screenIndices[_screenIndices.length] = _local4;
			_screenIndices[_screenIndices.length] = _local14;
			_arg2 = _screenIndices.length;
			map.a = (_local6 - _local7);
			map.b = (_local7 * 2);
			map.c = (_local8 - _local9);
			map.d = (_local9 * 2);
			map.tx = (_local10 - _local11);
			map.ty = (_local11 * 2);
			renderRec(_arg1, _arg2);
			_arg1 = _screenIndices.length;
			_local16 = _arg1;
			_screenIndices[_local16] = _local3;
			_screenIndices[_screenIndices.length] = _local14;
			_screenIndices[_screenIndices.length] = _local5;
			_arg2 = _screenIndices.length;
			map.a = (_local6 * 2);
			map.b = (_local7 - _local6);
			map.c = (_local8 * 2);
			map.d = (_local9 - _local8);
			map.tx = (_local10 * 2);
			map.ty = (_local11 - _local10);
			renderRec(_arg1, _arg2);
		}
		public function get id():int{
			return (_id);
		}
		public function get height():Number{
			return (_bitmap.height);
		}
		public function get bitmap():BitmapData{
			return (_bitmap);
		}
		public function getPixel32(_arg1:Number, _arg2:Number):uint{
			if (repeat){
				x = (_arg1 % 1);
				y = (1 - (_arg2 % 1));
			} else {
				x = _arg1;
				y = (1 - _arg2);
			};
			return (_bitmap.getPixel32((x * _bitmap.width), (y * _bitmap.height)));
		}
		public function set blendMode(_arg1:String):void{
			if (_blendMode == _arg1){
				return;
			};
			_blendMode = _arg1;
			_blendModeDirty = true;
		}
		public function removeOnMaterialUpdate(_arg1:Function):void{
			removeEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false);
		}
		public function invalidateFaces(_arg1:Object3D=null, _arg2:View3D=null):void{
			var _local3:FaceMaterialVO;
			_materialDirty = true;
			for each (_local3 in _faceDictionary) {
				_local3.invalidated = true;
			};
		}
		public function set repeat(_arg1:Boolean):void{
			if (_repeat == _arg1){
				return;
			};
			_repeat = _arg1;
			_materialDirty = true;
		}
		public function get colorTransform():ColorTransform{
			return (_colorTransform);
		}
		public function addOnMaterialUpdate(_arg1:Function):void{
			addEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false, 0, true);
		}
		public function getFaceMaterialVO(_arg1:FaceVO, _arg2:Object3D=null, _arg3:View3D=null):FaceMaterialVO{
			if ((_faceMaterialVO = _faceDictionary[_arg1])){
				return (_faceMaterialVO);
			};
			return ((_faceDictionary[_arg1] = new FaceMaterialVO()));
		}
		function renderSource(_arg1:Object3D, _arg2:Rectangle, _arg3:Matrix):void{
			if (!(_sourceVO = _faceDictionary[_arg1])){
				_sourceVO = (_faceDictionary[_arg1] = new FaceMaterialVO());
			};
			_sourceVO.resize(_arg2.width, _arg2.height);
			if (((_sourceVO.invalidated) || (_sourceVO.updated))){
				_arg3.scale((_arg2.width / width), (_arg2.height / height));
				_sourceVO.invalidated = false;
				_sourceVO.cleared = false;
				_sourceVO.updated = false;
				if ((((((((((((_arg3.a == 1)) && ((_arg3.d == 1)))) && ((_arg3.b == 0)))) && ((_arg3.c == 0)))) && ((_arg3.tx == 0)))) && ((_arg3.ty == 0)))){
					_sourceVO.bitmap.copyPixels(_bitmap, _arg2, _zeroPoint);
				} else {
					_graphics = _s.graphics;
					_graphics.clear();
					_graphics.beginBitmapFill(_bitmap, _arg3, repeat, smooth);
					_graphics.drawRect(0, 0, _arg2.width, _arg2.height);
					_graphics.endFill();
					_sourceVO.bitmap.draw(_s, null, _colorTransform, _blendMode, _sourceVO.bitmap.rect);
				};
			};
		}
		public function renderLayer(_arg1:DrawTriangle, _arg2:Sprite, _arg3:int):int{
			if (blendMode == BlendMode.NORMAL){
				_graphics = _arg2.graphics;
			} else {
				_session = _arg1.source.session;
				var _temp1 = _arg3;
				_arg3 = (_arg3 + 1);
				_shape = _session.getShape(this, _temp1, _arg2);
				_shape.blendMode = _blendMode;
				_graphics = _shape.graphics;
			};
			renderTriangle(_arg1);
			return (_arg3);
		}
		public function get alpha():Number{
			return (_alpha);
		}
		public function set smooth(_arg1:Boolean):void{
			if (_smooth == _arg1){
				return;
			};
			_smooth = _arg1;
			_materialDirty = true;
		}
		public function set showNormals(_arg1:Boolean):void{
			if (_showNormals == _arg1){
				return;
			};
			_showNormals = _arg1;
			_materialDirty = true;
		}
		public function clearFaces(_arg1:Object3D=null, _arg2:View3D=null):void{
			var _local3:FaceMaterialVO;
			notifyMaterialUpdate();
			for each (_local3 in _faceDictionary) {
				if (!_local3.cleared){
					_local3.clear();
				};
			};
		}
		public function get color():uint{
			return (_color);
		}
		public function get repeat():Boolean{
			return (_repeat);
		}
		public function get smooth():Boolean{
			return (_smooth);
		}
		public function get blendMode():String{
			return (_blendMode);
		}
		public function renderTriangle(_arg1:DrawTriangle):void{
			_mapping = getMapping(_arg1);
			_session = _arg1.source.session;
			_screenCommands = _arg1.screenCommands;
			_screenVertices = _arg1.screenVertices;
			_screenIndices = _arg1.screenIndices;
			_view = _arg1.view;
			_near = _view.camera.lens.near;
			if (precision){
				if ((_view.camera.lens is ZoomFocusLens)){
					focus = _arg1.view.camera.focus;
				} else {
					focus = 0;
				};
				map.a = _mapping.a;
				map.b = _mapping.b;
				map.c = _mapping.c;
				map.d = _mapping.d;
				map.tx = _mapping.tx;
				map.ty = _mapping.ty;
				index = 0;
				renderRec(_arg1.startIndex, _arg1.endIndex);
			} else {
				_session.renderTriangleBitmap(_renderBitmap, _mapping, _screenVertices, _screenIndices, _arg1.startIndex, _arg1.endIndex, smooth, repeat, _graphics);
			};
			if (debug){
				_session.renderTriangleLine(0, 0xFF, 1, _screenVertices, _arg1.screenCommands, _screenIndices, _arg1.startIndex, _arg1.endIndex);
			};
			if (showNormals){
				_nn.rotate(_arg1.faceVO.face.normal, _arg1.view.cameraVarsStore.viewTransformDictionary[_arg1.source]);
				_sv0x = (((_arg1.v0x + _arg1.v1x) + _arg1.v2x) / 3);
				_sv0y = (((_arg1.v0y + _arg1.v1y) + _arg1.v2y) / 3);
				_sv1x = (_sv0x - (30 * _nn.x));
				_sv1y = (_sv0y - (30 * _nn.y));
				_session.renderLine(_sv0x, _sv0y, _sv1x, _sv1y, 0, 0xFF00FF, 1);
			};
		}
		public function get width():Number{
			return (_bitmap.width);
		}
		protected function updateRenderBitmap():void{
			_bitmapDirty = false;
			if (_colorTransform){
				if (((!(_bitmap.transparent)) && (!((_alpha == 1))))){
					_renderBitmap = new BitmapData(_bitmap.width, _bitmap.height, true);
					_renderBitmap.draw(_bitmap);
				} else {
					_renderBitmap = _bitmap.clone();
				};
				_renderBitmap.colorTransform(_renderBitmap.rect, _colorTransform);
			} else {
				_renderBitmap = _bitmap;
			};
			invalidateFaces();
		}
		public function renderBitmapLayer(_arg1:DrawTriangle, _arg2:Rectangle, _arg3:FaceMaterialVO):FaceMaterialVO{
			renderSource(_arg1.source, _arg2, new Matrix());
			_faceMaterialVO = getFaceMaterialVO(_arg1.faceVO);
			if (_arg3.resized){
				_arg3.resized = false;
				_faceMaterialVO.resized = true;
			};
			_faceMaterialVO.invtexturemapping = _arg3.invtexturemapping;
			if (((((_arg3.updated) || (_faceMaterialVO.invalidated))) || (_faceMaterialVO.updated))){
				_arg3.updated = false;
				_faceMaterialVO.invalidated = false;
				_faceMaterialVO.cleared = false;
				_faceMaterialVO.updated = true;
				_faceMaterialVO.bitmap = _arg3.bitmap.clone();
				_faceMaterialVO.bitmap.copyPixels(_sourceVO.bitmap, _arg1.faceVO.bitmapRect, _zeroPoint, null, null, true);
			};
			return (_faceMaterialVO);
		}

	}
}//package away3d.materials 
Section 134
//BitmapMaterialContainer (away3d.materials.BitmapMaterialContainer)
package away3d.materials {
	import flash.geom.*;
	import flash.display.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import flash.utils.*;
	import away3d.events.*;

	public class BitmapMaterialContainer extends BitmapMaterial implements ITriangleMaterial, ILayerMaterial {

		protected var materials:Array;
		private var _containerDictionary:Dictionary;
		private var _height:Number;
		private var _containerVO:FaceMaterialVO;
		private var _fMaterialVO:FaceMaterialVO;
		public var transparent:Boolean;
		private var _cacheDictionary:Dictionary;
		private var _faceHeight:int;
		private var _width:Number;
		private var _faceWidth:int;
		private var _faceVO:FaceVO;

		public function BitmapMaterialContainer(_arg1:int, _arg2:int, _arg3:Object=null){
			var _local4:ILayerMaterial;
			_containerDictionary = new Dictionary(true);
			_cacheDictionary = new Dictionary(true);
			super(new BitmapData(_arg1, _arg2, true, 0xFFFFFF), _arg3);
			materials = ini.getArray("materials");
			_width = _arg1;
			_height = _arg2;
			_bitmapRect = new Rectangle(0, 0, _width, _height);
			for each (_local4 in materials) {
				_local4.addOnMaterialUpdate(onMaterialUpdate);
			};
			transparent = ini.getBoolean("transparent", true);
		}
		override public function renderBitmapLayer(_arg1:DrawTriangle, _arg2:Rectangle, _arg3:FaceMaterialVO):FaceMaterialVO{
			var _local4:ILayerMaterial;
			_faceMaterialVO = getFaceMaterialVO(_arg1.faceVO);
			_faceWidth = _arg1.faceVO.bitmapRect.width;
			_faceHeight = _arg1.faceVO.bitmapRect.height;
			if (!(_containerVO = _containerDictionary[_arg1])){
				_containerVO = (_containerDictionary[_arg1] = new FaceMaterialVO());
			};
			if (_arg3.resized){
				_arg3.resized = false;
				_containerVO.resize(_faceWidth, _faceHeight, transparent);
			};
			for each (_local4 in materials) {
				_containerVO = _local4.renderBitmapLayer(_arg1, _arg2, _containerVO);
			};
			if (((_arg3.updated) || (_containerVO.updated))){
				_arg3.updated = false;
				_containerVO.updated = false;
				_faceMaterialVO.invalidated = false;
				_faceMaterialVO.cleared = false;
				_faceMaterialVO.updated = true;
				_faceMaterialVO.bitmap = _arg3.bitmap.clone();
				_faceMaterialVO.bitmap.lock();
				_sourceVO = _faceMaterialVO;
				if ((((_blendMode == BlendMode.NORMAL)) && (!(_colorTransform)))){
					_faceMaterialVO.bitmap.copyPixels(_containerVO.bitmap, _containerVO.bitmap.rect, _zeroPoint, null, null, true);
				} else {
					_faceMaterialVO.bitmap.draw(_containerVO.bitmap, null, _colorTransform, _blendMode);
				};
			};
			return (_faceMaterialVO);
		}
		override public function updateMaterial(_arg1:Object3D, _arg2:View3D):void{
			var _local3:ILayerMaterial;
			for each (_local3 in materials) {
				_local3.updateMaterial(_arg1, _arg2);
			};
			if (_colorTransformDirty){
				updateColorTransform();
			};
			if (_bitmapDirty){
				updateRenderBitmap();
			};
			if (((_materialDirty) || (_blendModeDirty))){
				clearFaces();
			};
			_blendModeDirty = false;
		}
		override public function renderLayer(_arg1:DrawTriangle, _arg2:Sprite, _arg3:int):int{
			throw (new Error("Not implemented"));
		}
		public function clearMaterials():void{
			var _local1:int;
			_local1 = materials.length;
			while (_local1--) {
				removeMaterial(materials[_local1]);
			};
		}
		private function onMaterialUpdate(_arg1:MaterialEvent):void{
			_materialDirty = true;
		}
		override protected function getMapping(_arg1:DrawTriangle):Matrix{
			var _local2:ILayerMaterial;
			_faceVO = _arg1.faceVO;
			_faceMaterialVO = getFaceMaterialVO(_arg1.faceVO, _arg1.source, _arg1.view);
			if (((((_arg1.generated) || (_faceMaterialVO.invalidated))) || (_faceMaterialVO.updated))){
				_faceMaterialVO.updated = true;
				_faceMaterialVO.cleared = false;
				if (_faceMaterialVO.invalidated){
					_faceMaterialVO.invalidated = false;
					_faceVO.bitmapRect = new Rectangle(int((_width * _faceVO.minU)), int((_height * (1 - _faceVO.maxV))), int(((_width * (_faceVO.maxU - _faceVO.minU)) + 2)), int(((_height * (_faceVO.maxV - _faceVO.minV)) + 2)));
					_faceWidth = _faceVO.bitmapRect.width;
					_faceHeight = _faceVO.bitmapRect.height;
					_faceMaterialVO.invtexturemapping = _arg1.transformUV(this).clone();
					_faceMaterialVO.texturemapping = _faceMaterialVO.invtexturemapping.clone();
					_faceMaterialVO.texturemapping.invert();
					_faceMaterialVO.resize(_faceWidth, _faceHeight, transparent);
				};
				_fMaterialVO = _faceMaterialVO;
				for each (_local2 in materials) {
					_fMaterialVO = _local2.renderBitmapLayer(_arg1, _bitmapRect, _fMaterialVO);
				};
				_renderBitmap = (_cacheDictionary[_faceVO] = _fMaterialVO.bitmap);
				_fMaterialVO.updated = false;
				return (_faceMaterialVO.texturemapping);
			};
			_renderBitmap = _cacheDictionary[_faceVO];
			if (_faceMaterialVO.invalidated){
				_faceMaterialVO.invalidated = false;
				_faceMaterialVO.invtexturemapping = _arg1.transformUV(this).clone();
				_faceMaterialVO.texturemapping = _faceMaterialVO.invtexturemapping.clone();
				_faceMaterialVO.texturemapping.invert();
			};
			return (_faceMaterialVO.texturemapping);
		}
		public function removeMaterial(_arg1:ILayerMaterial):void{
			var _local2:int;
			_local2 = materials.indexOf(_arg1);
			if (_local2 == -1){
				return;
			};
			_arg1.removeOnMaterialUpdate(onMaterialUpdate);
			materials.splice(_local2, 1);
			_materialDirty = true;
		}
		override protected function updateRenderBitmap():void{
			_bitmapDirty = false;
			invalidateFaces();
			_materialDirty = true;
		}
		public function addMaterial(_arg1:ILayerMaterial):void{
			_arg1.addOnMaterialUpdate(onMaterialUpdate);
			materials.push(_arg1);
			_materialDirty = true;
		}

	}
}//package away3d.materials 
Section 135
//CenterLightingMaterial (away3d.materials.CenterLightingMaterial)
package away3d.materials {
	import flash.display.*;
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;
	import away3d.core.light.*;
	import away3d.core.render.*;
	import flash.utils.*;
	import away3d.events.*;

	public class CenterLightingMaterial extends EventDispatcher implements ITriangleMaterial {

		private var ksb:Number;
		private var draw_fall_k:Number;// = 1
		private var diff:Number;
		private var ksr:Number;
		private var kdb:Number;
		private var kdg:Number;
		private var rf:Number;
		private var draw_reflect_k:Number;// = 1
		private var dfx:Number;
		private var dfy:Number;
		private var dfz:Number;
		private var kdr:Number;
		private var persp:Number;
		private var draw_normal:Boolean;// = false
		public var shininess:Number;// = 20
		private var rz:Number;
		private var sum:Number;
		private var rx:Number;
		private var ry:Number;
		public var ambient_brightness:Number;// = 1
		private var blue:Number;
		private var cx:Number;
		private var cy:Number;
		private var cz:Number;
		private var df:Number;
		private var fade:Number;
		private var _diffuseTransform:Matrix3D;
		private var graphics:Graphics;
		private var red:Number;
		var session:AbstractRenderSession;
		private var draw_reflect:Boolean;// = false
		private var rfx:Number;
		private var rfy:Number;
		private var rfz:Number;
		private var fx:Number;
		private var fy:Number;
		private var fz:Number;
		private var focus:Number;
		private var _viewPosition:Number3D;
		public var specular_brightness:Number;// = 1
		var _materialDirty:Boolean;
		private var pdd:Number;
		private var _specularTransform:Matrix3D;
		private var green:Number;
		private var _source:Mesh;
		private var v0x:Number;
		private var v0y:Number;
		private var v0z:Number;
		public var diffuse_brightness:Number;// = 1
		private var v1x:Number;
		private var v1y:Number;
		private var v1z:Number;
		private var ncx:Number;
		private var ncy:Number;
		private var ncz:Number;
		private var _materialupdated:MaterialEvent;
		private var v2x:Number;
		private var v2y:Number;
		private var v2z:Number;
		private var _view:View3D;
		private var draw_fall:Boolean;// = false
		private var amb:Number;
		private var ffy:Number;
		var _id:int;
		private var spec:Number;
		private var nf:Number;
		private var ffz:Number;
		private var ffx:Number;
		private var nx:Number;
		private var d1x:Number;
		private var d1y:Number;
		private var d1z:Number;
		private var kag:Number;
		private var ny:Number;
		private var zoom:Number;
		private var kab:Number;
		private var kar:Number;
		protected var ini:Init;
		private var d2x:Number;
		private var d2z:Number;
		private var c0z:Number;
		private var nz:Number;
		private var pa:Number;
		private var c0x:Number;
		private var pc:Number;
		private var pb:Number;
		private var d2y:Number;
		private var c0y:Number;
		private var ksg:Number;

		public function CenterLightingMaterial(_arg1:Object=null){
			draw_normal = false;
			draw_fall = false;
			draw_fall_k = 1;
			draw_reflect = false;
			draw_reflect_k = 1;
			ambient_brightness = 1;
			diffuse_brightness = 1;
			specular_brightness = 1;
			shininess = 20;
			super();
			ini = Init.parse(_arg1);
			shininess = ini.getColor("shininess", 20);
		}
		protected function renderTri(_arg1:DrawTriangle, _arg2:AbstractRenderSession, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number, _arg7:Number, _arg8:Number, _arg9:Number, _arg10:Number, _arg11:Number):void{
			throw (new Error("Not implemented"));
		}
		public function get visible():Boolean{
			throw (new Error("Not implemented"));
		}
		function notifyMaterialUpdate():void{
			_materialDirty = false;
			if (!hasEventListener(MaterialEvent.MATERIAL_UPDATED)){
				return;
			};
			if (_materialupdated == null){
				_materialupdated = new MaterialEvent(MaterialEvent.MATERIAL_UPDATED, this);
			};
			dispatchEvent(_materialupdated);
		}
		public function updateMaterial(_arg1:Object3D, _arg2:View3D):void{
			var _local3:Array;
			var _local4:DirectionalLight;
			var _local5:Array;
			var _local6:PointLight;
			_local3 = _arg1.lightarray.directionals;
			for each (_local4 in _local3) {
				if (((!(_local4.diffuseTransform[_arg1])) || (_arg2.scene.updatedObjects[_arg1]))){
					_local4.setDiffuseTransform(_arg1);
					_materialDirty = true;
				};
				if (!_local4.specularTransform[_arg1]){
					_local4.specularTransform[_arg1] = new Dictionary(true);
				};
				if (((((!(_local4.specularTransform[_arg1][_arg2])) || (_arg2.scene.updatedObjects[_arg1]))) || (_arg2.updated))){
					_local4.setSpecularTransform(_arg1, _arg2);
					_materialDirty = true;
				};
			};
			_local5 = _arg1.lightarray.points;
			for each (_local6 in _local5) {
				if (((((!(_local6.viewPositions[_arg2])) || (_arg2.scene.updatedObjects[_arg1]))) || (_arg2.updated))){
					_local6.setViewPosition(_arg2);
					_materialDirty = true;
				};
			};
			if (_materialDirty){
				clearFaces(_arg1, _arg2);
			};
		}
		public function get id():int{
			return (_id);
		}
		public function removeOnMaterialUpdate(_arg1:Function):void{
			removeEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false);
		}
		public function addOnMaterialUpdate(_arg1:Function):void{
			addEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false, 0, true);
		}
		public function clearFaces(_arg1:Object3D=null, _arg2:View3D=null):void{
			notifyMaterialUpdate();
		}
		public function renderTriangle(_arg1:DrawTriangle):void{
			var _local2:DirectionalLight;
			var _local3:Array;
			var _local4:Array;
			var _local5:PointLight;
			var _local6:uint;
			var _local7:uint;
			var _local8:uint;
			var _local9:Array;
			session = _arg1.source.session;
			focus = _arg1.view.camera.focus;
			zoom = _arg1.view.camera.zoom;
			if ((_arg1.endIndex - _arg1.startIndex) > 10){
				_local6 = (_arg1.screenIndices[0] * 3);
				_local7 = (_arg1.screenIndices[5] * 3);
				_local8 = (_arg1.screenIndices[9] * 3);
				v0z = _arg1.screenVertices[(_local6 + 2)];
				persp = ((1 + (v0z / focus)) / zoom);
				v0x = (_arg1.screenVertices[_local6] * persp);
				v0y = (_arg1.screenVertices[(_local6 + 1)] * persp);
				v1z = _arg1.screenVertices[(_local7 + 2)];
				persp = ((1 + (v1z / focus)) / zoom);
				v1x = (_arg1.screenVertices[_local7] * persp);
				v1y = (_arg1.screenVertices[(_local7 + 1)] * persp);
				v2z = _arg1.screenVertices[(_local8 + 2)];
				persp = ((1 + (v2z / focus)) / zoom);
				v2x = (_arg1.screenVertices[_local8] * persp);
				v2y = (_arg1.screenVertices[(_local8 + 1)] * persp);
			} else {
				v0z = _arg1.v0z;
				persp = ((1 + (v0z / focus)) / zoom);
				v0x = (_arg1.v0x * persp);
				v0y = (_arg1.v0y * persp);
				v1z = _arg1.v1z;
				persp = ((1 + (v1z / focus)) / zoom);
				v1x = (_arg1.v1x * persp);
				v1y = (_arg1.v1y * persp);
				v2z = _arg1.v2z;
				persp = ((1 + (v2z / focus)) / zoom);
				v2x = (_arg1.v2x * persp);
				v2y = (_arg1.v2y * persp);
			};
			d1x = (v1x - v0x);
			d1y = (v1y - v0y);
			d1z = (v1z - v0z);
			d2x = (v2x - v0x);
			d2y = (v2y - v0y);
			d2z = (v2z - v0z);
			pa = ((d1y * d2z) - (d1z * d2y));
			pb = ((d1z * d2x) - (d1x * d2z));
			pc = ((d1x * d2y) - (d1y * d2x));
			pdd = Math.sqrt((((pa * pa) + (pb * pb)) + (pc * pc)));
			pa = (pa / pdd);
			pb = (pb / pdd);
			pc = (pc / pdd);
			c0x = (((v0x + v1x) + v2x) / 3);
			c0y = (((v0y + v1y) + v2y) / 3);
			c0z = (((v0z + v1z) + v2z) / 3);
			kar = (kag = (kab = (kdr = (kdg = (kdb = (ksr = (ksg = (ksb = 0))))))));
			_source = (_arg1.source as Mesh);
			_view = _arg1.view;
			_local3 = _arg1.source.lightarray.directionals;
			for each (_local2 in _local3) {
				_diffuseTransform = _local2.diffuseTransform[_source];
				red = _local2.red;
				green = _local2.green;
				blue = _local2.blue;
				dfx = _diffuseTransform.szx;
				dfy = _diffuseTransform.szy;
				dfz = _diffuseTransform.szz;
				nx = _arg1.faceVO.face.normal.x;
				ny = _arg1.faceVO.face.normal.y;
				nz = _arg1.faceVO.face.normal.z;
				amb = (_local2.ambient * ambient_brightness);
				kar = (kar + (red * amb));
				kag = (kag + (green * amb));
				kab = (kab + (blue * amb));
				nf = (((dfx * nx) + (dfy * ny)) + (dfz * nz));
				if (nf < 0){
				} else {
					diff = ((_local2.diffuse * nf) * diffuse_brightness);
					kdr = (kdr + (red * diff));
					kdg = (kdg + (green * diff));
					kdb = (kdb + (blue * diff));
					_specularTransform = _local2.specularTransform[_source][_view];
					rfx = _specularTransform.szx;
					rfy = _specularTransform.szy;
					rfz = _specularTransform.szz;
					rf = (((rfx * nx) + (rfy * ny)) + (rfz * nz));
					spec = ((_local2.specular * Math.pow(rf, shininess)) * specular_brightness);
					ksr = (ksr + (red * spec));
					ksg = (ksg + (green * spec));
					ksb = (ksb + (blue * spec));
				};
			};
			_local4 = _arg1.source.lightarray.points;
			for each (_local5 in _local4) {
				red = _local5.red;
				green = _local5.green;
				blue = _local5.blue;
				_viewPosition = _local5.viewPositions[_arg1.view];
				dfx = (_viewPosition.x - c0x);
				dfy = (_viewPosition.y - c0y);
				dfz = (_viewPosition.z - c0z);
				df = Math.sqrt((((dfx * dfx) + (dfy * dfy)) + (dfz * dfz)));
				dfx = (dfx / df);
				dfy = (dfy / df);
				dfz = (dfz / df);
				fade = ((1 / df) / df);
				amb = ((_local5.ambient * fade) * ambient_brightness);
				kar = (kar + (red * amb));
				kag = (kag + (green * amb));
				kab = (kab + (blue * amb));
				nf = (((dfx * pa) + (dfy * pb)) + (dfz * pc));
				if (nf < 0){
				} else {
					diff = (((_local5.diffuse * fade) * nf) * diffuse_brightness);
					kdr = (kdr + (red * diff));
					kdg = (kdg + (green * diff));
					kdb = (kdb + (blue * diff));
					rfz = (dfz - ((2 * nf) * pc));
					if (rfz < 0){
					} else {
						rfx = (dfx - ((2 * nf) * pa));
						rfy = (dfy - ((2 * nf) * pb));
						spec = (((_local5.specular * fade) * Math.pow(rfz, shininess)) * specular_brightness);
						ksr = (ksr + (red * spec));
						ksg = (ksg + (green * spec));
						ksb = (ksb + (blue * spec));
					};
				};
			};
			renderTri(_arg1, session, kar, kag, kab, kdr, kdg, kdb, ksr, ksg, ksb);
			if (((((draw_fall) || (draw_reflect))) || (draw_normal))){
				graphics = session.graphics;
				cz = c0z;
				cx = ((c0x * zoom) / (1 + (cz / focus)));
				cy = ((c0y * zoom) / (1 + (cz / focus)));
				if (draw_normal){
					ncz = (c0z + (30 * pc));
					ncx = ((((c0x + (30 * pa)) * zoom) * focus) / (focus + ncz));
					ncy = ((((c0y + (30 * pb)) * zoom) * focus) / (focus + ncz));
					graphics.lineStyle(1, 0, 1);
					graphics.moveTo(cx, cy);
					graphics.lineTo(ncx, ncy);
					graphics.moveTo(cx, cy);
					graphics.drawCircle(cx, cy, 2);
				};
				if (((draw_fall) || (draw_reflect))){
					_local9 = _arg1.source.lightarray.points;
					for each (_local5 in _local9) {
						red = _local5.red;
						green = _local5.green;
						blue = _local5.blue;
						sum = (((red + green) + blue) / 0xFF);
						red = (red / sum);
						green = (green / sum);
						blue = (blue / sum);
						dfx = (_viewPosition.x - c0x);
						dfy = (_viewPosition.y - c0y);
						dfz = (_viewPosition.z - c0z);
						df = Math.sqrt((((dfx * dfx) + (dfy * dfy)) + (dfz * dfz)));
						dfx = (dfx / df);
						dfy = (dfy / df);
						dfz = (dfz / df);
						nf = (((dfx * pa) + (dfy * pb)) + (dfz * pc));
						if (nf < 0){
						} else {
							if (draw_fall){
								ffz = (c0z + ((30 * dfz) * (1 - draw_fall_k)));
								ffx = ((((c0x + ((30 * dfx) * (1 - draw_fall_k))) * zoom) * focus) / (focus + ffz));
								ffy = ((((c0y + ((30 * dfy) * (1 - draw_fall_k))) * zoom) * focus) / (focus + ffz));
								fz = (c0z + (30 * dfz));
								fx = ((((c0x + (30 * dfx)) * zoom) * focus) / (focus + fz));
								fy = ((((c0y + (30 * dfy)) * zoom) * focus) / (focus + fz));
								graphics.lineStyle(1, (((int(red) * 65536) + (int(green) * 0x0100)) + int(blue)), 1);
								graphics.moveTo(ffx, ffy);
								graphics.lineTo(fx, fy);
								graphics.moveTo(ffx, ffy);
							};
							if (draw_reflect){
								rfx = (dfx - ((2 * nf) * pa));
								rfy = (dfy - ((2 * nf) * pb));
								rfz = (dfz - ((2 * nf) * pc));
								rz = (c0z - ((30 * rfz) * draw_reflect_k));
								rx = ((((c0x - ((30 * rfx) * draw_reflect_k)) * zoom) * focus) / (focus + rz));
								ry = ((((c0y - ((30 * rfy) * draw_reflect_k)) * zoom) * focus) / (focus + rz));
								graphics.lineStyle(1, (((int((red * 0.5)) * 65536) + (int((green * 0.5)) * 0x0100)) + int((blue * 0.5))), 1);
								graphics.moveTo(cx, cy);
								graphics.lineTo(rx, ry);
								graphics.moveTo(cx, cy);
							};
						};
					};
				};
			};
		}

	}
}//package away3d.materials 
Section 136
//ColorMaterial (away3d.materials.ColorMaterial)
package away3d.materials {
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.events.*;

	public class ColorMaterial extends EventDispatcher implements ITriangleMaterial, IFogMaterial, IBillboardMaterial {

		var _id:int;
		private var _alpha:Number;
		private var _color:uint;
		protected var ini:Init;
		private var _materialDirty:Boolean;
		private var _materialupdated:MaterialEvent;

		public function ColorMaterial(_arg1=null, _arg2:Object=null){
			if (_arg1 == null){
				_arg1 = "random";
			};
			this.color = Cast.trycolor(_arg1);
			ini = Init.parse(_arg2);
			_alpha = ini.getNumber("alpha", 1, {min:0, max:1});
		}
		function notifyMaterialUpdate():void{
			if (!hasEventListener(MaterialEvent.MATERIAL_UPDATED)){
				return;
			};
			if (_materialupdated == null){
				_materialupdated = new MaterialEvent(MaterialEvent.MATERIAL_UPDATED, this);
			};
			dispatchEvent(_materialupdated);
		}
		public function updateMaterial(_arg1:Object3D, _arg2:View3D):void{
			if (_materialDirty){
				_materialDirty = false;
				notifyMaterialUpdate();
			};
		}
		public function get id():int{
			return (_id);
		}
		public function removeOnMaterialUpdate(_arg1:Function):void{
			removeEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false);
		}
		public function renderTriangle(_arg1:DrawTriangle):void{
			_arg1.source.session.renderTriangleColor(_color, _alpha, _arg1.screenVertices, _arg1.screenCommands, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex);
		}
		public function set alpha(_arg1:Number):void{
			if (_alpha == _arg1){
				return;
			};
			_alpha = _arg1;
			_materialDirty = true;
		}
		public function set color(_arg1:uint):void{
			if (_color == _arg1){
				return;
			};
			_color = _arg1;
			_materialDirty = true;
		}
		public function renderBillboard(_arg1:DrawBillboard):void{
			_arg1.source.session.renderBillboardColor(_color, _alpha, _arg1);
		}
		public function clone():IFogMaterial{
			return (new ColorMaterial(_color, {alpha:_alpha}));
		}
		public function get alpha():Number{
			return (_alpha);
		}
		public function renderFog(_arg1:DrawFog):void{
			_arg1.source.session.renderFogColor(_arg1.clip, _color, _alpha);
		}
		public function get color():uint{
			return (_color);
		}
		public function get visible():Boolean{
			return ((alpha > 0));
		}
		public function addOnMaterialUpdate(_arg1:Function):void{
			addEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false, 0, true);
		}

	}
}//package away3d.materials 
Section 137
//IBillboardMaterial (away3d.materials.IBillboardMaterial)
package away3d.materials {
	import away3d.core.draw.*;

	public interface IBillboardMaterial extends IMaterial {

		function renderBillboard(_arg1:DrawBillboard):void;

	}
}//package away3d.materials 
Section 138
//IFogMaterial (away3d.materials.IFogMaterial)
package away3d.materials {
	import away3d.core.draw.*;

	public interface IFogMaterial extends ITriangleMaterial {

		function renderFog(_arg1:DrawFog):void;
		function set alpha(_arg1:Number):void;
		function clone():IFogMaterial;
		function get alpha():Number;

	}
}//package away3d.materials 
Section 139
//ILayerMaterial (away3d.materials.ILayerMaterial)
package away3d.materials {
	import flash.geom.*;
	import flash.display.*;
	import away3d.core.draw.*;
	import away3d.core.utils.*;

	public interface ILayerMaterial extends IMaterial {

		function renderLayer(_arg1:DrawTriangle, _arg2:Sprite, _arg3:int):int;
		function renderBitmapLayer(_arg1:DrawTriangle, _arg2:Rectangle, _arg3:FaceMaterialVO):FaceMaterialVO;

	}
}//package away3d.materials 
Section 140
//IMaterial (away3d.materials.IMaterial)
package away3d.materials {
	import away3d.containers.*;
	import away3d.core.base.*;

	public interface IMaterial {

		function updateMaterial(_arg1:Object3D, _arg2:View3D):void;
		function get visible():Boolean;
		function removeOnMaterialUpdate(_arg1:Function):void;
		function addOnMaterialUpdate(_arg1:Function):void;
		function get id():int;

	}
}//package away3d.materials 
Section 141
//ISegmentMaterial (away3d.materials.ISegmentMaterial)
package away3d.materials {
	import away3d.core.draw.*;

	public interface ISegmentMaterial extends IMaterial {

		function renderSegment(_arg1:DrawSegment):void;

	}
}//package away3d.materials 
Section 142
//ITriangleMaterial (away3d.materials.ITriangleMaterial)
package away3d.materials {
	import away3d.core.draw.*;

	public interface ITriangleMaterial extends IMaterial {

		function renderTriangle(_arg1:DrawTriangle):void;

	}
}//package away3d.materials 
Section 143
//IUVMaterial (away3d.materials.IUVMaterial)
package away3d.materials {
	import flash.display.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;

	public interface IUVMaterial extends IMaterial {

		function invalidateFaces(_arg1:Object3D=null, _arg2:View3D=null):void;
		function get width():Number;
		function clearFaces(_arg1:Object3D=null, _arg2:View3D=null):void;
		function get height():Number;
		function getPixel32(_arg1:Number, _arg2:Number):uint;
		function get bitmap():BitmapData;
		function getFaceMaterialVO(_arg1:FaceVO, _arg2:Object3D=null, _arg3:View3D=null):FaceMaterialVO;

	}
}//package away3d.materials 
Section 144
//MovieMaterial (away3d.materials.MovieMaterial)
package away3d.materials {
	import flash.geom.*;
	import flash.display.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.events.*;

	public class MovieMaterial extends TransformBitmapMaterial implements ITriangleMaterial, IUVMaterial {

		private var _bMode:String;
		private var _movie:Sprite;
		public var autoUpdate:Boolean;
		private var x:Number;
		public var transparent:Boolean;
		private var y:Number;
		private var t:Matrix;
		private var _lockH:Number;
		private var _lockW:Number;
		private var _colTransform:ColorTransform;
		private var _clipRect:Rectangle;
		private var rendered:Boolean;
		public var interactive:Boolean;

		public function MovieMaterial(_arg1:Sprite, _arg2:Object=null){
			ini = Init.parse(_arg2);
			transparent = ini.getBoolean("transparent", true);
			autoUpdate = ini.getBoolean("autoUpdate", true);
			interactive = ini.getBoolean("interactive", false);
			_movie = _arg1;
			_lockW = ini.getNumber("lockW", _arg1.width);
			_lockH = ini.getNumber("lockH", _arg1.height);
			_bitmap = new BitmapData(Math.max(1, _lockW), Math.max(1, _lockH), transparent, (transparent) ? 0xFFFFFF : 0);
			super(_bitmap, ini);
		}
		public function set lockH(_arg1:Number):void{
			_lockH = (((!(isNaN(_arg1))) && ((_arg1 > 1)))) ? _arg1 : _lockH;
			if (_renderBitmap != null){
				_bitmap.dispose();
				_renderBitmap.dispose();
				_bitmap = new BitmapData(Math.max(1, _lockW), Math.max(1, _lockH), transparent, (transparent) ? 0xFFFFFF : 0);
				_renderBitmap = _bitmap.clone();
				update();
			};
		}
		private function resetInteractiveLayer():void{
			movie.x = -10000;
			movie.y = -10000;
		}
		override public function updateMaterial(_arg1:Object3D, _arg2:View3D):void{
			super.updateMaterial(_arg1, _arg2);
			if (autoUpdate){
				update();
			};
			_session = _arg1.session;
			if (interactive){
				if (!_arg2._interactiveLayer.contains(movie)){
					_arg2._interactiveLayer.addChild(movie);
					resetInteractiveLayer();
					_arg1.addOnMouseOver(onMouseOver);
					_arg1.addOnMouseOut(onMouseOut);
				};
			} else {
				if (_arg2._interactiveLayer.contains(movie)){
					_arg2._interactiveLayer.removeChild(movie);
					_arg1.removeOnMouseOver(onMouseOver);
					_arg1.removeOnMouseOut(onMouseOut);
				};
			};
		}
		public function set lockW(_arg1:Number):void{
			_lockW = (((!(isNaN(_arg1))) && ((_arg1 > 1)))) ? _arg1 : _lockW;
			if (_renderBitmap != null){
				_bitmap.dispose();
				_renderBitmap.dispose();
				_bitmap = new BitmapData(Math.max(1, _lockW), Math.max(1, _lockH), transparent, (transparent) ? 0xFFFFFF : 0);
				_renderBitmap = _bitmap.clone();
				update();
			};
		}
		override public function get height():Number{
			return (_renderBitmap.height);
		}
		public function get movie():Sprite{
			return (_movie);
		}
		public function get clipRect():Rectangle{
			return (_clipRect);
		}
		public function get lockH():Number{
			return (_lockH);
		}
		public function get lockW():Number{
			return (_lockW);
		}
		private function onMouseOut(_arg1:MouseEvent3D):void{
			if (_arg1.material == this){
				_arg1.object.removeOnMouseMove(onMouseMove);
				resetInteractiveLayer();
			};
		}
		public function set clipRect(_arg1:Rectangle):void{
			_clipRect = _arg1;
		}
		public function set movie(_arg1:Sprite):void{
			if (_movie == _arg1){
				return;
			};
			if (((_movie) && (_movie.parent))){
				_movie.parent.removeChild(_movie);
			};
			_movie = _arg1;
			if (!autoUpdate){
				update();
			};
		}
		public function update():void{
			var _local1:Rectangle;
			if (_renderBitmap != null){
				notifyMaterialUpdate();
				_local1 = ((((_clipRect == null)) || (!(rendered)))) ? _renderBitmap.rect : _clipRect;
				if (transparent){
					_renderBitmap.fillRect(_local1, 0xFFFFFF);
				};
				if (((!((_alpha == 1))) || (!((_color == 0xFFFFFF))))){
					_colTransform = _colorTransform;
				} else {
					_colTransform = movie.transform.colorTransform;
				};
				if (_blendMode != BlendMode.NORMAL){
					_bMode = _blendMode;
				} else {
					_bMode = movie.blendMode;
				};
				_renderBitmap.draw(movie, new Matrix(movie.scaleX, 0, 0, movie.scaleY), _colTransform, _bMode, _local1);
				if (!rendered){
					rendered = true;
				};
			};
		}
		override protected function updateRenderBitmap():void{
		}
		override public function get width():Number{
			return (_renderBitmap.width);
		}
		private function onMouseOver(_arg1:MouseEvent3D):void{
			if (_arg1.material == this){
				_arg1.object.addOnMouseMove(onMouseMove);
				onMouseMove(_arg1);
			};
		}
		private function onMouseMove(_arg1:MouseEvent3D):void{
			x = (_arg1.uv.u * _renderBitmap.width);
			y = ((1 - _arg1.uv.v) * _renderBitmap.height);
			if (_transform){
				t = _transform.clone();
				t.invert();
				movie.x = (((_arg1.screenX - (x * t.a)) - (y * t.c)) - t.tx);
				movie.y = (((_arg1.screenY - (x * t.b)) - (y * t.d)) - t.ty);
			} else {
				movie.x = (_arg1.screenX - x);
				movie.y = (_arg1.screenY - y);
			};
		}

	}
}//package away3d.materials 
Section 145
//ShadingColorMaterial (away3d.materials.ShadingColorMaterial)
package away3d.materials {
	import away3d.core.draw.*;
	import away3d.core.utils.*;
	import away3d.core.render.*;

	public class ShadingColorMaterial extends CenterLightingMaterial {

		public var cache:Boolean;
		public var ambient:uint;
		private var sfg:int;
		private var fb:int;
		private var fg:int;
		public var specular:uint;
		private var fr:int;
		public var diffuse:uint;
		public var alpha:Number;
		private var _color:uint;
		private var sfb:int;
		private var sfr:int;

		public function ShadingColorMaterial(_arg1=null, _arg2:Object=null){
			color = ((_arg1)==null) ? "random" : _arg1;
			super(_arg2);
			ambient = ini.getColor("ambient", color);
			diffuse = ini.getColor("diffuse", color);
			specular = ini.getColor("specular", color);
			alpha = ini.getNumber("alpha", 1);
			cache = ini.getBoolean("cache", false);
		}
		override protected function renderTri(_arg1:DrawTriangle, _arg2:AbstractRenderSession, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number, _arg7:Number, _arg8:Number, _arg9:Number, _arg10:Number, _arg11:Number):void{
			fr = int((((((ambient & 0xFF0000) * _arg3) + ((diffuse & 0xFF0000) * _arg6)) + ((specular & 0xFF0000) * _arg9)) >> 16));
			fg = int((((((ambient & 0xFF00) * _arg4) + ((diffuse & 0xFF00) * _arg7)) + ((specular & 0xFF00) * _arg10)) >> 8));
			fb = int(((((ambient & 0xFF) * _arg5) + ((diffuse & 0xFF) * _arg8)) + ((specular & 0xFF) * _arg11)));
			if (fr > 0xFF){
				fr = 0xFF;
			};
			if (fg > 0xFF){
				fg = 0xFF;
			};
			if (fb > 0xFF){
				fb = 0xFF;
			};
			_arg2.renderTriangleColor((((fr << 16) | (fg << 8)) | fb), alpha, _arg1.screenVertices, _arg1.screenCommands, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex);
			if (cache){
				if (_arg1.faceVO != null){
					sfr = int(((((ambient & 0xFF0000) * _arg3) + ((diffuse & 0xFF0000) * _arg6)) >> 16));
					sfg = int(((((ambient & 0xFF00) * _arg4) + ((diffuse & 0xFF00) * _arg7)) >> 8));
					sfb = int((((ambient & 0xFF) * _arg5) + ((diffuse & 0xFF) * _arg8)));
					if (sfr > 0xFF){
						sfr = 0xFF;
					};
					if (sfg > 0xFF){
						sfg = 0xFF;
					};
					if (sfb > 0xFF){
						sfb = 0xFF;
					};
					_arg1.faceVO.material = new ColorMaterial((((sfr << 16) | (sfg << 8)) | sfb));
				};
			};
		}
		public function set color(_arg1):void{
			if (_color == Cast.trycolor(_arg1)){
				return;
			};
			_color = Cast.trycolor(_arg1);
			ambient = (diffuse = (specular = _color));
			_materialDirty = true;
		}
		public function get color():uint{
			return (_color);
		}
		override public function get visible():Boolean{
			return (true);
		}

	}
}//package away3d.materials 
Section 146
//TransformBitmapMaterial (away3d.materials.TransformBitmapMaterial)
package away3d.materials {
	import flash.geom.*;
	import flash.display.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.math.*;

	public class TransformBitmapMaterial extends BitmapMaterial implements ITriangleMaterial, IUVMaterial {

		private var line:Point;
		private var py:Number;
		private var px:Number;
		private var normalR:Number3D;
		private var t:Matrix;
		private var _throughProjection:Boolean;
		private var x:Number;
		private var v0:Number3D;
		private var v1:Number3D;
		private var y:Number;
		private var _projectionDirty:Boolean;
		private var mapb:Number;
		private var v2:Number3D;
		private var mapa:Number;
		private var mapc:Number;
		private var mapd:Number;
		private var DOWN:Number3D;
		private var point3:Point;
		private var fPoint1:Point;
		private var fPoint2:Point;
		private var fPoint3:Point;
		private var point1:Point;
		private var _globalProjection:Boolean;
		private var zero:Number;
		private var point2:Point;
		private var _projectionVector:Number3D;
		private var _rotation:Number;// = 0
		private var maptx:Number;
		private var mapty:Number;
		private var _offsetY:Number;// = 0
		private var _offsetX:Number;// = 0
		private var _u1:Number;
		private var _u2:Number;
		private var _u0:Number;
		private var _invtexturemapping:Matrix;
		private var _v0:Number;
		private var _v1:Number;
		private var _v2:Number;
		private var v0y:Number;
		private var v0z:Number;
		private var v0x:Number;
		private var v1x:Number;
		private var v1z:Number;
		private var flag:Boolean;
		private var v1y:Number;
		private var _scaleY:Number;// = 1
		private var mPoint2:Point;
		private var mPoint1:Point;
		private var dot:Number;
		private var mPoint3:Point;
		private var mPoint4:Point;
		private var v2x:Number;
		private var v2y:Number;
		private var v2z:Number;
		private var _scaleX:Number;// = 1
		private var sign:Number;
		private var _N:Number3D;
		private var faceVO:FaceVO;
		private var _M:Number3D;
		private var _transformDirty:Boolean;
		var _transform:Matrix;
		private var RIGHT:Number3D;

		public function TransformBitmapMaterial(_arg1:BitmapData, _arg2:Object=null){
			_transform = new Matrix();
			_scaleX = 1;
			_scaleY = 1;
			_offsetX = 0;
			_offsetY = 0;
			_rotation = 0;
			_N = new Number3D();
			_M = new Number3D();
			DOWN = new Number3D(0, -1, 0);
			RIGHT = new Number3D(1, 0, 0);
			normalR = new Number3D();
			v0 = new Number3D();
			v1 = new Number3D();
			v2 = new Number3D();
			fPoint1 = new Point();
			fPoint2 = new Point();
			fPoint3 = new Point();
			mPoint1 = new Point();
			mPoint2 = new Point();
			mPoint3 = new Point();
			mPoint4 = new Point();
			line = new Point();
			super(_arg1, _arg2);
			transform = (ini.getObject("transform", Matrix) as Matrix);
			scaleX = ini.getNumber("scaleX", _scaleX);
			scaleY = ini.getNumber("scaleY", _scaleY);
			offsetX = ini.getNumber("offsetX", _offsetX);
			offsetY = ini.getNumber("offsetY", _offsetY);
			rotation = ini.getNumber("rotation", _rotation);
			projectionVector = (ini.getObject("projectionVector", Number3D) as Number3D);
			throughProjection = ini.getBoolean("throughProjection", true);
			globalProjection = ini.getBoolean("globalProjection", false);
		}
		public function get offsetX():Number{
			return (_offsetX);
		}
		public function get offsetY():Number{
			return (_offsetY);
		}
		public function set offsetX(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(offsetX)"));
			};
			if (_arg1 == Infinity){
				Debug.warning("offsetX == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("offsetX == -Infinity");
			};
			_offsetX = _arg1;
			_transformDirty = true;
		}
		public function set offsetY(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(offsetY)"));
			};
			if (_arg1 == Infinity){
				Debug.warning("offsetY == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("offsetY == -Infinity");
			};
			_offsetY = _arg1;
			_transformDirty = true;
		}
		public function get scaleY():Number{
			return (_scaleY);
		}
		public function get globalProjection():Boolean{
			return (_globalProjection);
		}
		public function get scaleX():Number{
			return (_scaleX);
		}
		private function getContainerPoints(_arg1:Rectangle):Array{
			return ([_arg1.topLeft, new Point(_arg1.top, _arg1.right), _arg1.bottomRight, new Point(_arg1.bottom, _arg1.left)]);
		}
		override protected function getMapping(_arg1:DrawTriangle):Matrix{
			if (_arg1.generated){
				if (projectionVector){
					_texturemapping = projectUV(_arg1);
				} else {
					_texturemapping = _arg1.transformUV(this).clone();
					_texturemapping.invert();
				};
				if (_transform){
					_mapping = _transform.clone();
					_mapping.concat(_texturemapping);
				} else {
					_mapping = _texturemapping;
				};
				return (_mapping);
			};
			_faceMaterialVO = getFaceMaterialVO(_arg1.faceVO, _arg1.source);
			if (!_faceMaterialVO.invalidated){
				return (_faceMaterialVO.texturemapping);
			};
			_faceMaterialVO.invalidated = false;
			if (projectionVector){
				_texturemapping = projectUV(_arg1);
			} else {
				_texturemapping = _arg1.transformUV(this).clone();
				_texturemapping.invert();
			};
			if (_transform){
				_faceMaterialVO.texturemapping = _transform.clone();
				_faceMaterialVO.texturemapping.concat(_texturemapping);
				return (_faceMaterialVO.texturemapping);
			};
			return ((_faceMaterialVO.texturemapping = _texturemapping));
		}
		public function set scaleY(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(scaleY)"));
			};
			if (_arg1 == Infinity){
				Debug.warning("scaleY == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("scaleY == -Infinity");
			};
			if (_arg1 == 0){
				Debug.warning("scaleY == 0");
			};
			_scaleY = _arg1;
			_transformDirty = true;
		}
		private function updateTransform():void{
			_transformDirty = false;
			if ((((((((((_scaleX == 1)) && ((_scaleY == 1)))) && ((_offsetX == 0)))) && ((_offsetY == 0)))) && ((_rotation == 0)))){
				_transform = null;
			} else {
				_transform = new Matrix();
				_transform.scale(_scaleX, _scaleY);
				_transform.rotate(_rotation);
				_transform.translate(_offsetX, _offsetY);
			};
			_materialDirty = true;
		}
		public function set globalProjection(_arg1:Boolean):void{
			_globalProjection = _arg1;
			_projectionDirty = true;
		}
		public function set scaleX(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(scaleX)"));
			};
			if (_arg1 == Infinity){
				Debug.warning("scaleX == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("scaleX == -Infinity");
			};
			if (_arg1 == 0){
				Debug.warning("scaleX == 0");
			};
			_scaleX = _arg1;
			_transformDirty = true;
		}
		public function get projectionVector():Number3D{
			return (_projectionVector);
		}
		public function set transform(_arg1:Matrix):void{
			_transform = _arg1;
			if (_transform){
				_rotation = Math.atan2(_transform.b, _transform.a);
				_scaleX = (_transform.a / Math.cos(_rotation));
				_scaleY = (_transform.d / Math.cos(_rotation));
				_offsetX = _transform.tx;
				_offsetY = _transform.ty;
			} else {
				_scaleX = (_scaleY = 1);
				_offsetX = (_offsetY = (_rotation = 0));
			};
		}
		private function checkEdge(_arg1:Array, _arg2:Array):Boolean{
			var _local3:int;
			var _local4:String;
			var _local5:Point;
			_local3 = _arg1.length;
			for (_local4 in _arg1) {
				point2 = _arg1[_local4];
				if (int(_local4) == 0){
					point1 = _arg1[(_local3 - 1)];
					point3 = _arg1[(_local3 - 2)];
				} else {
					point1 = _arg1[(int(_local4) - 1)];
					if (int(_local4) == 1){
						point3 = _arg1[(_local3 - 1)];
					} else {
						point3 = _arg1[(int(_local4) - 2)];
					};
				};
				line.x = (point2.y - point1.y);
				line.y = (point1.x - point2.x);
				zero = ((point1.x * line.x) + (point1.y * line.y));
				sign = ((zero - (point3.x * line.x)) - (point3.y * line.y));
				flag = true;
				for each (_local5 in _arg2) {
					dot = ((_local5.x * line.x) + (_local5.y * line.y));
					if ((zero * sign) > (dot * sign)){
						flag = false;
						break;
					};
				};
				if (flag){
					return (true);
				};
			};
			return (false);
		}
		public function set projectionVector(_arg1:Number3D):void{
			_projectionVector = _arg1;
			if (_projectionVector){
				_N.cross(_projectionVector, DOWN);
				if (!_N.modulo){
					_N = RIGHT;
				};
				_M.cross(_N, _projectionVector);
				_N.cross(_M, _projectionVector);
				_N.normalize();
				_M.normalize();
			};
			_projectionDirty = true;
		}
		private function findSeparatingAxis(_arg1:Array, _arg2:Array):Boolean{
			if (checkEdge(_arg1, _arg2)){
				return (true);
			};
			if (checkEdge(_arg2, _arg1)){
				return (true);
			};
			return (false);
		}
		override public function updateMaterial(_arg1:Object3D, _arg2:View3D):void{
			_graphics = null;
			if (_colorTransformDirty){
				updateColorTransform();
			};
			if (_bitmapDirty){
				updateRenderBitmap();
			};
			if (((_projectionDirty) || (_transformDirty))){
				invalidateFaces();
			};
			if (_transformDirty){
				updateTransform();
			};
			if (((_materialDirty) || (_blendModeDirty))){
				clearFaces();
			};
			_projectionDirty = false;
			_blendModeDirty = false;
		}
		public function set rotation(_arg1:Number):void{
			if (isNaN(_arg1)){
				throw (new Error("isNaN(rotation)"));
			};
			if (_arg1 == Infinity){
				Debug.warning("rotation == Infinity");
			};
			if (_arg1 == -(Infinity)){
				Debug.warning("rotation == -Infinity");
			};
			_rotation = _arg1;
			_transformDirty = true;
		}
		public function get throughProjection():Boolean{
			return (_throughProjection);
		}
		override public function getPixel32(_arg1:Number, _arg2:Number):uint{
			if (_transform){
				x = (_arg1 * _bitmap.width);
				y = ((1 - _arg2) * _bitmap.height);
				t = _transform.clone();
				t.invert();
				if (repeat){
					px = ((((x * t.a) + (y * t.c)) + t.tx) % _bitmap.width);
					py = ((((x * t.b) + (y * t.d)) + t.ty) % _bitmap.height);
					if (px < 0){
						px = (px + _bitmap.width);
					};
					if (py < 0){
						py = (py + _bitmap.height);
					};
					return (_bitmap.getPixel32(px, py));
				} else {
					return (_bitmap.getPixel32((((x * t.a) + (y * t.c)) + t.tx), (((x * t.b) + (y * t.d)) + t.ty)));
				};
			};
			return (super.getPixel32(_arg1, _arg2));
		}
		public function get transform():Matrix{
			return (_transform);
		}
		private function projectUV(_arg1:DrawTriangle):Matrix{
			faceVO = _arg1.faceVO;
			if (globalProjection){
				v0.transform(faceVO.v0.position, _arg1.source.sceneTransform);
				v1.transform(faceVO.v1.position, _arg1.source.sceneTransform);
				v2.transform(faceVO.v2.position, _arg1.source.sceneTransform);
			} else {
				v0 = faceVO.v0.position;
				v1 = faceVO.v1.position;
				v2 = faceVO.v2.position;
			};
			v0x = v0.x;
			v0y = v0.y;
			v0z = v0.z;
			v1x = v1.x;
			v1y = v1.y;
			v1z = v1.z;
			v2x = v2.x;
			v2y = v2.y;
			v2z = v2.z;
			_u0 = (((v0x * _N.x) + (v0y * _N.y)) + (v0z * _N.z));
			_u1 = (((v1x * _N.x) + (v1y * _N.y)) + (v1z * _N.z));
			_u2 = (((v2x * _N.x) + (v2y * _N.y)) + (v2z * _N.z));
			_v0 = (((v0x * _M.x) + (v0y * _M.y)) + (v0z * _M.z));
			_v1 = (((v1x * _M.x) + (v1y * _M.y)) + (v1z * _M.z));
			_v2 = (((v2x * _M.x) + (v2y * _M.y)) + (v2z * _M.z));
			if ((((((_u0 == _u1)) && ((_v0 == _v1)))) || ((((_u0 == _u2)) && ((_v0 == _v2)))))){
				if (_u0 > 0.05){
					_u0 = (_u0 - 0.05);
				} else {
					_u0 = (_u0 + 0.05);
				};
				if (_v0 > 0.07){
					_v0 = (_v0 - 0.07);
				} else {
					_v0 = (_v0 + 0.07);
				};
			};
			if ((((_u2 == _u1)) && ((_v2 == _v1)))){
				if (_u2 > 0.04){
					_u2 = (_u2 - 0.04);
				} else {
					_u2 = (_u2 + 0.04);
				};
				if (_v2 > 0.06){
					_v2 = (_v2 - 0.06);
				} else {
					_v2 = (_v2 + 0.06);
				};
			};
			t = new Matrix((_u1 - _u0), (_v1 - _v0), (_u2 - _u0), (_v2 - _v0), _u0, _v0);
			t.invert();
			return (t);
		}
		private function getFacePoints(_arg1:Matrix):Array{
			fPoint1.x = (_u0 = _arg1.tx);
			fPoint2.x = (_arg1.a + _u0);
			fPoint3.x = (_arg1.c + _u0);
			fPoint1.y = (_v0 = _arg1.ty);
			fPoint2.y = (_arg1.b + _v0);
			fPoint3.y = (_arg1.d + _v0);
			return ([fPoint1, fPoint2, fPoint3]);
		}
		public function get rotation():Number{
			return (_rotation);
		}
		private function getMappingPoints(_arg1:Matrix):Array{
			mapa = (_arg1.a * width);
			mapb = (_arg1.b * width);
			mapc = (_arg1.c * height);
			mapd = (_arg1.d * height);
			maptx = _arg1.tx;
			mapty = _arg1.ty;
			mPoint1.x = maptx;
			mPoint1.y = mapty;
			mPoint2.x = (maptx + mapc);
			mPoint2.y = (mapty + mapd);
			mPoint3.x = ((maptx + mapa) + mapc);
			mPoint3.y = ((mapty + mapb) + mapd);
			mPoint4.x = (maptx + mapa);
			mPoint4.y = (mapty + mapb);
			return ([mPoint1, mPoint2, mPoint3, mPoint4]);
		}
		override public function renderTriangle(_arg1:DrawTriangle):void{
			if (((_projectionVector) && (!(throughProjection)))){
				if (globalProjection){
					normalR.rotate(_arg1.faceVO.face.normal, _arg1.source.sceneTransform);
					if (normalR.dot(_projectionVector) < 0){
						return;
					};
				} else {
					if (_arg1.faceVO.face.normal.dot(_projectionVector) < 0){
						return;
					};
				};
			};
			super.renderTriangle(_arg1);
		}
		override public function renderBitmapLayer(_arg1:DrawTriangle, _arg2:Rectangle, _arg3:FaceMaterialVO):FaceMaterialVO{
			if (_transform){
				_mapping = _transform.clone();
			} else {
				_mapping = new Matrix();
			};
			if (!_projectionVector){
				renderSource(_arg1.source, _arg2, _mapping);
			};
			_faceMaterialVO = getFaceMaterialVO(_arg1.faceVO);
			if (_arg3.resized){
				_arg3.resized = false;
				_faceMaterialVO.resized = true;
			};
			_faceMaterialVO.invtexturemapping = _arg3.invtexturemapping;
			if (((((_arg3.updated) || (_faceMaterialVO.invalidated))) || (_faceMaterialVO.updated))){
				_arg3.updated = false;
				_bitmapRect = _arg1.faceVO.bitmapRect;
				if (_faceMaterialVO.invalidated){
					_faceMaterialVO.invalidated = false;
				} else {
					_faceMaterialVO.updated = true;
				};
				_faceMaterialVO.bitmap = _arg3.bitmap.clone();
				if (_projectionVector){
					_invtexturemapping = _faceMaterialVO.invtexturemapping;
					_mapping.concat(projectUV(_arg1));
					_mapping.concat(_invtexturemapping);
					normalR.clone(_arg1.faceVO.face.normal);
					if (_globalProjection){
						normalR.rotate(normalR, _arg1.source.sceneTransform);
					};
					if (((((throughProjection) || ((normalR.dot(_projectionVector) >= 0)))) && (((repeat) || (!(findSeparatingAxis(getFacePoints(_invtexturemapping), getMappingPoints(_mapping)))))))){
						if (_faceMaterialVO.cleared){
							_faceMaterialVO.bitmap = _arg3.bitmap.clone();
						};
						_faceMaterialVO.cleared = false;
						_faceMaterialVO.updated = true;
						_graphics = _s.graphics;
						_graphics.clear();
						_graphics.beginBitmapFill(_bitmap, _mapping, repeat, smooth);
						_graphics.drawRect(0, 0, _bitmapRect.width, _bitmapRect.height);
						_graphics.endFill();
						_faceMaterialVO.bitmap.draw(_s, null, _colorTransform, _blendMode, _faceMaterialVO.bitmap.rect);
					};
				} else {
					if (((repeat) && (!(findSeparatingAxis(getContainerPoints(_arg2), getMappingPoints(_mapping)))))){
						_faceMaterialVO.cleared = false;
						_faceMaterialVO.updated = true;
						_faceMaterialVO.bitmap.copyPixels(_sourceVO.bitmap, _bitmapRect, _zeroPoint, null, null, true);
					};
				};
			};
			return (_faceMaterialVO);
		}
		public function set throughProjection(_arg1:Boolean):void{
			_throughProjection = _arg1;
			_projectionDirty = true;
		}

	}
}//package away3d.materials 
Section 147
//WhiteShadingBitmapMaterial (away3d.materials.WhiteShadingBitmapMaterial)
package away3d.materials {
	import flash.geom.*;
	import flash.display.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.core.render.*;
	import flash.utils.*;
	import flash.filters.*;

	public class WhiteShadingBitmapMaterial extends CenterLightingMaterial implements IUVMaterial {

		private var cache:Dictionary;
		private var _faceDictionary:Dictionary;
		private var bitmapPoint:Point;
		public var smooth:Boolean;
		public var repeat:Boolean;
		private var step:int;// = 1
		private var _bitmap:BitmapData;
		private var mapping:Matrix;
		private var colorTransform:ColorMatrixFilter;
		private var whitek:Number;// = 0.2
		private var br:Number;
		private var blackrender:Boolean;
		private var _texturemapping:Matrix;
		private var _faceMaterialVO:FaceMaterialVO;
		private var whiterender:Boolean;

		public function WhiteShadingBitmapMaterial(_arg1:BitmapData, _arg2:Object=null){
			_faceDictionary = new Dictionary(true);
			whitek = 0.2;
			bitmapPoint = new Point(0, 0);
			colorTransform = new ColorMatrixFilter();
			step = 1;
			_bitmap = _arg1;
			super(_arg2);
			smooth = ini.getBoolean("smooth", false);
			repeat = ini.getBoolean("repeat", false);
			if (!CacheStore.whiteShadingCache[_bitmap]){
				CacheStore.whiteShadingCache[_bitmap] = new Dictionary(true);
			};
			cache = CacheStore.whiteShadingCache[_bitmap];
		}
		override public function get visible():Boolean{
			return (true);
		}
		public function doubleStepTo(_arg1:int):void{
			if (step < _arg1){
				step = (step * 2);
			};
		}
		protected function getMapping(_arg1:DrawTriangle):Matrix{
			if (_arg1.generated){
				_texturemapping = _arg1.transformUV(this).clone();
				_texturemapping.invert();
				return (_texturemapping);
			};
			_faceMaterialVO = getFaceMaterialVO(_arg1.faceVO, _arg1.source, _arg1.view);
			if (!_faceMaterialVO.invalidated){
				return (_faceMaterialVO.texturemapping);
			};
			_texturemapping = _arg1.transformUV(this).clone();
			_texturemapping.invert();
			return ((_faceMaterialVO.texturemapping = _texturemapping));
		}
		public function get height():Number{
			return (_bitmap.height);
		}
		private function ladder(_arg1:Number):Number{
			if (_arg1 < (1 / 0xFF)){
				return (0);
			};
			if (_arg1 > 0xFF){
				_arg1 = 0xFF;
			};
			return (Math.exp((Math.round((Math.log(_arg1) * step)) / step)));
		}
		public function get bitmap():BitmapData{
			return (_bitmap);
		}
		override protected function renderTri(_arg1:DrawTriangle, _arg2:AbstractRenderSession, _arg3:Number, _arg4:Number, _arg5:Number, _arg6:Number, _arg7:Number, _arg8:Number, _arg9:Number, _arg10:Number, _arg11:Number):void{
			var _local12:Number;
			var _local13:BitmapData;
			br = (((((((((_arg3 + _arg4) + _arg5) + _arg6) + _arg7) + _arg8) + _arg9) + _arg10) + _arg11) / 3);
			mapping = getMapping(_arg1);
			if ((((br < 1)) && (((blackrender) || ((((step < 16)) && (!(_bitmap.transparent)))))))){
				_arg2.renderTriangleBitmap(_bitmap, mapping, _arg1.screenVertices, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex, smooth, repeat);
				_arg2.renderTriangleColor(0, (1 - br), _arg1.screenVertices, _arg1.screenCommands, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex);
			} else {
				if ((((br > 1)) && (whiterender))){
					_arg2.renderTriangleBitmap(_bitmap, mapping, _arg1.screenVertices, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex, smooth, repeat);
					_arg2.renderTriangleColor(0xFFFFFF, ((br - 1) * whitek), _arg1.screenVertices, _arg1.screenCommands, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex);
				} else {
					if (step < 64){
						if (Math.random() < 0.01){
							doubleStepTo(64);
						};
					};
					_local12 = ladder(br);
					_local13 = cache[_local12];
					if (_local13 == null){
						_local13 = new BitmapData(_bitmap.width, _bitmap.height, true, 0);
						colorTransform.matrix = [_local12, 0, 0, 0, 0, 0, _local12, 0, 0, 0, 0, 0, _local12, 0, 0, 0, 0, 0, 1, 0];
						_local13.applyFilter(_bitmap, _local13.rect, bitmapPoint, colorTransform);
						cache[_local12] = _local13;
					};
					_arg2.renderTriangleBitmap(_local13, mapping, _arg1.screenVertices, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex, smooth, repeat);
				};
			};
		}
		public function invalidateFaces(_arg1:Object3D=null, _arg2:View3D=null):void{
			var _local3:FaceMaterialVO;
			for each (_local3 in _faceDictionary) {
				_local3.invalidated = true;
			};
		}
		public function getPixel32(_arg1:Number, _arg2:Number):uint{
			return (_bitmap.getPixel32((_arg1 * _bitmap.width), ((1 - _arg2) * _bitmap.height)));
		}
		public function getFaceMaterialVO(_arg1:FaceVO, _arg2:Object3D=null, _arg3:View3D=null):FaceMaterialVO{
			if ((_faceMaterialVO = _faceDictionary[_arg1])){
				return (_faceMaterialVO);
			};
			return ((_faceDictionary[_arg1] = new FaceMaterialVO()));
		}
		public function get width():Number{
			return (_bitmap.width);
		}
		override public function clearFaces(_arg1:Object3D=null, _arg2:View3D=null):void{
			var _local3:FaceMaterialVO;
			for each (_local3 in _faceDictionary) {
				if (!_local3.cleared){
					_local3.clear();
				};
			};
		}

	}
}//package away3d.materials 
Section 148
//WireColorMaterial (away3d.materials.WireColorMaterial)
package away3d.materials {
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.events.*;

	public class WireColorMaterial extends EventDispatcher implements ITriangleMaterial {

		public var width:Number;
		public var color:int;
		protected var ini:Init;
		public var alpha:Number;
		public var wirealpha:Number;
		var _id:int;
		public var wirecolor:int;

		public function WireColorMaterial(_arg1=null, _arg2:Object=null){
			if (_arg1 == null){
				_arg1 = "random";
			};
			this.color = Cast.trycolor(_arg1);
			ini = Init.parse(_arg2);
			alpha = ini.getNumber("alpha", 1, {min:0, max:1});
			wirecolor = ini.getColor("wirecolor", 0);
			width = ini.getNumber("width", 1, {min:0});
			wirealpha = ini.getNumber("wirealpha", 1, {min:0, max:1});
		}
		public function removeOnMaterialUpdate(_arg1:Function):void{
			removeEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false);
		}
		public function renderTriangle(_arg1:DrawTriangle):void{
			_arg1.source.session.renderTriangleLineFill(width, color, alpha, wirecolor, wirealpha, _arg1.screenVertices, _arg1.screenCommands, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex);
		}
		public function updateMaterial(_arg1:Object3D, _arg2:View3D):void{
		}
		public function get id():int{
			return (_id);
		}
		public function get visible():Boolean{
			return ((((alpha > 0)) || ((wirealpha > 0))));
		}
		public function addOnMaterialUpdate(_arg1:Function):void{
			addEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false, 0, true);
		}

	}
}//package away3d.materials 
Section 149
//WireframeMaterial (away3d.materials.WireframeMaterial)
package away3d.materials {
	import flash.events.*;
	import away3d.core.draw.*;
	import away3d.containers.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.events.*;

	public class WireframeMaterial extends EventDispatcher implements ITriangleMaterial, ISegmentMaterial {

		public var width:Number;
		public var color:int;
		protected var ini:Init;
		public var alpha:Number;
		var _id:int;

		public function WireframeMaterial(_arg1=null, _arg2:Object=null){
			if (_arg1 == null){
				_arg1 = "random";
			};
			this.color = Cast.trycolor(_arg1);
			ini = Init.parse(_arg2);
			alpha = ini.getNumber("alpha", 1, {min:0, max:1});
			width = ini.getNumber("width", 1, {min:0});
		}
		public function removeOnMaterialUpdate(_arg1:Function):void{
			removeEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false);
		}
		public function updateMaterial(_arg1:Object3D, _arg2:View3D):void{
		}
		public function get id():int{
			return (_id);
		}
		public function addOnMaterialUpdate(_arg1:Function):void{
			addEventListener(MaterialEvent.MATERIAL_UPDATED, _arg1, false, 0, true);
		}
		public function get visible():Boolean{
			return ((alpha > 0));
		}
		public function renderSegment(_arg1:DrawSegment):void{
			if (alpha <= 0){
				return;
			};
			_arg1.source.session.renderLine(_arg1.v0x, _arg1.v0y, _arg1.v1x, _arg1.v1y, width, color, alpha);
		}
		public function renderTriangle(_arg1:DrawTriangle):void{
			if (alpha <= 0){
				return;
			};
			_arg1.source.session.renderTriangleLine(width, color, alpha, _arg1.screenVertices, _arg1.screenCommands, _arg1.screenIndices, _arg1.startIndex, _arg1.endIndex);
		}

	}
}//package away3d.materials 
Section 150
//IOverlay (away3d.overlays.IOverlay)
package away3d.overlays {

	public interface IOverlay {

		function update():void;

	}
}//package away3d.overlays 
Section 151
//CubeMaterialsData (away3d.primitives.data.CubeMaterialsData)
package away3d.primitives.data {
	import flash.events.*;
	import away3d.core.utils.*;
	import away3d.materials.*;
	import away3d.events.*;

	public class CubeMaterialsData extends EventDispatcher {

		private var _top:ITriangleMaterial;
		private var _bottom:ITriangleMaterial;
		private var _right:ITriangleMaterial;
		private var _back:ITriangleMaterial;
		protected var ini:Init;
		private var _left:ITriangleMaterial;
		private var _front:ITriangleMaterial;
		private var _materialchanged:MaterialEvent;

		public function CubeMaterialsData(_arg1:Object=null){
			ini = Init.parse(_arg1);
			_left = (ini.getMaterial("left") as ITriangleMaterial);
			_right = (ini.getMaterial("right") as ITriangleMaterial);
			_bottom = (ini.getMaterial("bottom") as ITriangleMaterial);
			_top = (ini.getMaterial("top") as ITriangleMaterial);
			_front = (ini.getMaterial("front") as ITriangleMaterial);
			_back = (ini.getMaterial("back") as ITriangleMaterial);
		}
		public function set bottom(_arg1:ITriangleMaterial):void{
			if (_bottom == _arg1){
				return;
			};
			_bottom = _arg1;
			notifyMaterialChange(_bottom, "bottom");
		}
		public function set front(_arg1:ITriangleMaterial):void{
			if (_front == _arg1){
				return;
			};
			_front = _arg1;
			notifyMaterialChange(_front, "front");
		}
		public function removeOnMaterialChange(_arg1:Function):void{
			removeEventListener(MaterialEvent.MATERIAL_CHANGED, _arg1, false);
		}
		public function get left():ITriangleMaterial{
			return (_left);
		}
		private function notifyMaterialChange(_arg1:ITriangleMaterial, _arg2:String):void{
			if (!hasEventListener(MaterialEvent.MATERIAL_CHANGED)){
				return;
			};
			_materialchanged = new MaterialEvent(MaterialEvent.MATERIAL_CHANGED, _arg1);
			_materialchanged.extra = _arg2;
			dispatchEvent(_materialchanged);
		}
		public function set back(_arg1:ITriangleMaterial):void{
			if (_back == _arg1){
				return;
			};
			_back = _arg1;
			notifyMaterialChange(_back, "back");
		}
		public function get right():ITriangleMaterial{
			return (_right);
		}
		public function get back():ITriangleMaterial{
			return (_back);
		}
		public function get front():ITriangleMaterial{
			return (_front);
		}
		public function get bottom():ITriangleMaterial{
			return (_bottom);
		}
		public function get top():ITriangleMaterial{
			return (_top);
		}
		public function set left(_arg1:ITriangleMaterial):void{
			if (_left == _arg1){
				return;
			};
			_left = _arg1;
			notifyMaterialChange(_left, "left");
		}
		public function set top(_arg1:ITriangleMaterial):void{
			if (_top == _arg1){
				return;
			};
			_top = _arg1;
			notifyMaterialChange(_top, "top");
		}
		public function addOnMaterialChange(_arg1:Function):void{
			addEventListener(MaterialEvent.MATERIAL_CHANGED, _arg1, false, 0, false);
		}
		public function set right(_arg1:ITriangleMaterial):void{
			if (_right == _arg1){
				return;
			};
			_right = _arg1;
			notifyMaterialChange(_right, "right");
		}

	}
}//package away3d.primitives.data 
Section 152
//AbstractPrimitive (away3d.primitives.AbstractPrimitive)
package away3d.primitives {
	import away3d.core.base.*;
	import away3d.materials.*;

	public class AbstractPrimitive extends Mesh {

		var _segmentActive:Array;
		var _uvActive:Array;
		var _faceStore:Array;
		var _vStore:Array;
		var _face:Face;
		var _uv:UV;
		var _faceActive:Array;
		var _segmentStore:Array;
		var _uvStore:Array;
		var _primitiveDirty:Boolean;
		var _vActive:Array;
		var _segment:Segment;
		private var _index:int;
		var _v:Vertex;

		public function AbstractPrimitive(_arg1:Object=null){
			_vStore = [];
			_vActive = [];
			_uvStore = [];
			_uvActive = [];
			_faceStore = [];
			_faceActive = [];
			_segmentStore = [];
			_segmentActive = [];
			super(_arg1);
			_primitiveDirty = true;
		}
		protected function buildPrimitive():void{
			_primitiveDirty = false;
			_objectDirty = true;
			_index = faces.length;
			while (_index--) {
				removeFace(faces[_index]);
			};
			_index = segments.length;
			while (_index--) {
				removeSegment(segments[_index]);
			};
			_vStore = _vStore.concat(_vActive);
			_vActive = [];
			_uvStore = _uvStore.concat(_uvActive);
			_uvActive = [];
			_faceStore = _faceStore.concat(_faceActive);
			_faceActive = [];
			_segmentStore = _segmentStore.concat(_segmentActive);
			_segmentActive = [];
		}
		protected function updatePrimitive():void{
			var _local1:int;
			buildPrimitive();
			_local1 = geometry.quarterFacesTotal;
			while (_local1--) {
				quarterFaces();
			};
		}
		override public function get minX():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.minX);
		}
		override public function get minY():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.minY);
		}
		override public function get minZ():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.minZ);
		}
		override public function get geometry():Geometry{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (_geometry);
		}
		function createUV(_arg1:Number=0, _arg2:Number=0):UV{
			if (_uvStore.length){
				_uvActive.push((_uv = _uvStore.pop()));
				_uv.u = _arg1;
				_uv.v = _arg2;
			} else {
				_uvActive.push((_uv = new UV(_arg1, _arg2)));
			};
			return (_uv);
		}
		override public function get objectDepth():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.objectDepth);
		}
		override public function get elements():Array{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (_geometry.elements);
		}
		function createSegment(_arg1:Vertex, _arg2:Vertex, _arg3:ISegmentMaterial=null):Segment{
			if (_segmentStore.length){
				_segmentActive.push((_segment = _segmentStore.pop()));
				_segment.v0 = _arg1;
				_segment.v1 = _arg2;
				_segment.material = _arg3;
			} else {
				_segmentActive.push((_segment = new Segment(_arg1, _arg2, _arg3)));
			};
			return (_segment);
		}
		override public function get billboards():Array{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (_geometry.billboards);
		}
		override public function get objectHeight():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.objectHeight);
		}
		override public function get boundingRadius():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.boundingRadius);
		}
		override public function updateObject():void{
			if (_primitiveDirty){
				updatePrimitive();
			};
			super.updateObject();
		}
		function createFace(_arg1:Vertex, _arg2:Vertex, _arg3:Vertex, _arg4:ITriangleMaterial=null, _arg5:UV=null, _arg6:UV=null, _arg7:UV=null):Face{
			if (_faceStore.length){
				_faceActive.push((_face = _faceStore.pop()));
				_face.v0 = _arg1;
				_face.v1 = _arg2;
				_face.v2 = _arg3;
				_face.material = _arg4;
				_face.uv0 = _arg5;
				_face.uv1 = _arg6;
				_face.uv2 = _arg7;
			} else {
				_faceActive.push((_face = new Face(_arg1, _arg2, _arg3, _arg4, _arg5, _arg6, _arg7)));
			};
			return (_face);
		}
		override public function get maxX():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.maxX);
		}
		override public function get maxY():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.maxY);
		}
		override public function get maxZ():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.maxZ);
		}
		override public function get segments():Array{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (_geometry.segments);
		}
		override public function get faces():Array{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (_geometry.faces);
		}
		function createVertex(_arg1:Number=0, _arg2:Number=0, _arg3:Number=0):Vertex{
			if (_vStore.length){
				_vActive.push((_v = _vStore.pop()));
				_v.x = _arg1;
				_v.y = _arg2;
				_v.z = _arg3;
			} else {
				_vActive.push((_v = new Vertex(_arg1, _arg2, _arg3)));
			};
			return (_v);
		}
		override public function get objectWidth():Number{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (super.objectWidth);
		}
		override public function get vertices():Array{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (_geometry.vertices);
		}

	}
}//package away3d.primitives 
Section 153
//Cube (away3d.primitives.Cube)
package away3d.primitives {
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import away3d.primitives.data.*;
	import away3d.materials.*;
	import away3d.events.*;

	public class Cube extends AbstractPrimitive {

		private var _dbv:Array;
		private var _height:Number;
		private var _leftFaces:Array;
		private var _frontFaces:Array;
		private var _width:Number;
		private var _topFaces:Array;
		private var _bottomFaces:Array;
		private var _dbu:Array;
		private var _segmentsH:int;
		private var _segmentsW:int;
		private var _rightFaces:Array;
		private var _flip:Boolean;
		private var _backFaces:Array;
		private var _cubeMaterials:CubeMaterialsData;
		private var _cubeFaceArray:Array;
		private var _offset:Number;// = 0.333333333333333
		private var _map6:Boolean;
		private var _depth:Number;

		public function Cube(_arg1:Object=null){
			_offset = (1 / 3);
			super(_arg1);
			_width = ini.getNumber("width", 100, {min:0});
			_height = ini.getNumber("height", 100, {min:0});
			_depth = ini.getNumber("depth", 100, {min:0});
			_flip = ini.getBoolean("flip", false);
			_cubeMaterials = ini.getCubeMaterials("faces");
			_segmentsW = ini.getInt("segmentsW", 1, {min:1});
			_segmentsH = ini.getInt("segmentsH", 1, {min:1});
			_map6 = ini.getBoolean("map6", false);
			if (!_cubeMaterials){
				_cubeMaterials = ini.getCubeMaterials("cubeMaterials");
			};
			if (!_cubeMaterials){
				_cubeMaterials = new CubeMaterialsData();
			};
			_cubeMaterials.addOnMaterialChange(onCubeMaterialChange);
			type = "Cube";
			url = "primitive";
		}
		override protected function buildPrimitive():void{
			var _local1:Array;
			var _local2:Array;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			var _local6:int;
			var _local7:Vertex;
			var _local8:Vertex;
			var _local9:Vertex;
			var _local10:UV;
			var _local11:UV;
			var _local12:UV;
			var _local13:Face;
			var _local14:Number;
			var _local15:Number;
			var _local16:Number;
			super.buildPrimitive();
			_leftFaces = [];
			_rightFaces = [];
			_bottomFaces = [];
			_topFaces = [];
			_frontFaces = [];
			_backFaces = [];
			_local1 = [];
			_local2 = [];
			_local3 = (_width * 0.5);
			_local4 = (_height * 0.5);
			_local5 = (_depth * 0.5);
			_dbv = [];
			_dbu = [];
			_local14 = (_width / _segmentsW);
			_local6 = 0;
			while (_local6 <= _segmentsW) {
				_local1[_local6] = createVertex((-(_local3) + (_local6 * _local14)), _local4, -(_local5));
				_local2[_local6] = createVertex((-(_local3) + (_local6 * _local14)), -(_local4), -(_local5));
				_local6++;
			};
			buildSide([_local2, _local1], _cubeMaterials.back, _backFaces, "b");
			_local2 = [];
			_local1 = [];
			_local15 = (_map6) ? _offset : 0;
			_local16 = (_map6) ? 0.5 : 0;
			_local6 = 0;
			while (_local6 < _backFaces.length) {
				_local13 = _backFaces[_local6];
				_local7 = makeVertex(_local13.v0.x, _local13.v0.y, -(_local13.v0.z));
				_local8 = makeVertex(_local13.v1.x, _local13.v1.y, -(_local13.v1.z));
				_local9 = makeVertex(_local13.v2.x, _local13.v2.y, -(_local13.v2.z));
				_local10 = makeUV((1 - (_local13.uv0.u + _local15)), (_local13.uv0.v + _local16));
				_local11 = makeUV((1 - (_local13.uv1.u + _local15)), (_local13.uv1.v + _local16));
				_local12 = makeUV((1 - (_local13.uv2.u + _local15)), (_local13.uv2.v + _local16));
				addFace(createFace(_local8, _local7, _local9, _cubeMaterials.front, _local11, _local10, _local12));
				_frontFaces.push(faces[(faces.length - 1)]);
				_local6++;
			};
			_local14 = (_depth / _segmentsW);
			_local6 = 0;
			while (_local6 <= _segmentsW) {
				_local1[_local6] = makeVertex(_local3, _local4, (-(_local5) + (_local6 * _local14)));
				_local2[_local6] = makeVertex(_local3, -(_local4), (-(_local5) + (_local6 * _local14)));
				_local6++;
			};
			buildSide([_local2, _local1], _cubeMaterials.left, _leftFaces, "l");
			_local1 = [];
			_local2 = [];
			_local15 = (_map6) ? 0.5 : 0;
			_local6 = 0;
			while (_local6 < _leftFaces.length) {
				_local13 = _leftFaces[_local6];
				_local7 = makeVertex(-(_local13.v0.x), _local13.v0.y, _local13.v0.z);
				_local8 = makeVertex(-(_local13.v1.x), _local13.v1.y, _local13.v1.z);
				_local9 = makeVertex(-(_local13.v2.x), _local13.v2.y, _local13.v2.z);
				_local10 = makeUV((1 - _local13.uv0.u), _local13.uv0.v);
				_local11 = makeUV((1 - _local13.uv1.u), _local13.uv1.v);
				_local12 = makeUV((1 - _local13.uv2.u), _local13.uv2.v);
				addFace(createFace(_local8, _local7, _local9, _cubeMaterials.right, _local11, _local10, _local12));
				_rightFaces.push(faces[(faces.length - 1)]);
				_local6++;
			};
			_local14 = (_map6) ? (_depth / _segmentsW) : (_width / _segmentsW);
			_local6 = 0;
			while (_local6 <= _segmentsW) {
				if (_map6){
					_local1[_local6] = makeVertex(-(_local3), _local4, (_local5 - (_local6 * _local14)));
					_local2[_local6] = makeVertex(_local3, _local4, (_local5 - (_local6 * _local14)));
				} else {
					_local1[_local6] = makeVertex((_local3 - (_local6 * _local14)), _local4, _local5);
					_local2[_local6] = makeVertex((_local3 - (_local6 * _local14)), _local4, -(_local5));
				};
				_local6++;
			};
			buildSide([_local1, _local2], _cubeMaterials.top, _topFaces, "t");
			_local15 = (_map6) ? _offset : 0;
			_local6 = 0;
			while (_local6 < _topFaces.length) {
				_local13 = _topFaces[_local6];
				_local7 = makeVertex(_local13.v0.x, -(_local13.v0.y), _local13.v0.z);
				_local8 = makeVertex(_local13.v1.x, -(_local13.v1.y), _local13.v1.z);
				_local9 = makeVertex(_local13.v2.x, -(_local13.v2.y), _local13.v2.z);
				_local10 = makeUV(((1 - _local13.uv0.u) + _local15), _local13.uv0.v);
				_local11 = makeUV(((1 - _local13.uv1.u) + _local15), _local13.uv1.v);
				_local12 = makeUV(((1 - _local13.uv2.u) + _local15), _local13.uv2.v);
				addFace(createFace(_local8, _local7, _local9, _cubeMaterials.bottom, _local11, _local10, _local12));
				_bottomFaces.push(faces[(faces.length - 1)]);
				_local6++;
			};
			_local2 = (_dbv = (_dbu = null));
			_local1 = _local2;
		}
		public function get map6():Boolean{
			return (_map6);
		}
		public function set height(_arg1:Number):void{
			if (_height == _arg1){
				return;
			};
			_height = _arg1;
			_primitiveDirty = true;
		}
		public function get flip():Boolean{
			return (_flip);
		}
		public function set map6(_arg1:Boolean):void{
			_map6 = _arg1;
		}
		public function get depth():Number{
			return (_depth);
		}
		public function get segmentsH():Number{
			return (_segmentsH);
		}
		public function get segmentsW():Number{
			return (_segmentsW);
		}
		private function buildSide(_arg1:Array, _arg2:ITriangleMaterial, _arg3:Array, _arg4:String):void{
			var _local5:int;
			var _local6:int;
			_local5 = (_arg1.length - 1);
			_local6 = 0;
			while (_local6 < _local5) {
				generateFaces(_arg1[_local6], _arg1[(_local6 + 1)], ((1 / _local5) * _local6), _local5, _arg2, _arg3, _arg4);
				_local6++;
			};
		}
		public function set cubeMaterials(_arg1:CubeMaterialsData):void{
			if (_cubeMaterials == _arg1){
				return;
			};
			if (_cubeMaterials){
				_cubeMaterials.addOnMaterialChange(onCubeMaterialChange);
			};
			_cubeMaterials = _arg1;
			_cubeMaterials.addOnMaterialChange(onCubeMaterialChange);
		}
		public function get height():Number{
			return (_height);
		}
		public function set flip(_arg1:Boolean):void{
			_flip = _arg1;
		}
		private function makeUV(_arg1:Number, _arg2:Number):UV{
			var _local3:int;
			var _local4:UV;
			_local3 = 0;
			while (_local3 < _dbu.length) {
				if ((((_dbu[_local3].u == _arg1)) && ((_dbu[_local3].v == _arg2)))){
					return (_dbu[_local3]);
				};
				_local3++;
			};
			_local4 = createUV(_arg1, _arg2);
			_dbu[_dbu.length] = _local4;
			return (_local4);
		}
		public function set segmentsH(_arg1:Number):void{
			if (_segmentsH == _arg1){
				return;
			};
			_segmentsH = _arg1;
			_primitiveDirty = true;
		}
		public function get cubeMaterials():CubeMaterialsData{
			return (_cubeMaterials);
		}
		private function onCubeMaterialChange(_arg1:MaterialEvent):void{
			var _local2:Face;
			switch (_arg1.extra){
				case "left":
					_cubeFaceArray = _leftFaces;
					break;
				case "right":
					_cubeFaceArray = _rightFaces;
					break;
				case "bottom":
					_cubeFaceArray = _bottomFaces;
					break;
				case "top":
					_cubeFaceArray = _topFaces;
					break;
				case "front":
					_cubeFaceArray = _frontFaces;
					break;
				case "back":
					_cubeFaceArray = _backFaces;
			};
			for each (_local2 in _cubeFaceArray) {
				_local2.material = (_arg1.material as ITriangleMaterial);
			};
		}
		public function set width(_arg1:Number):void{
			if (_width == _arg1){
				return;
			};
			_width = _arg1;
			_primitiveDirty = true;
		}
		public function set depth(_arg1:Number):void{
			if (_depth == _arg1){
				return;
			};
			_depth = _arg1;
			_primitiveDirty = true;
		}
		public function set segmentsW(_arg1:Number):void{
			if (_segmentsW == _arg1){
				return;
			};
			_segmentsW = _arg1;
			_primitiveDirty = true;
		}
		private function generateFaces(_arg1:Array, _arg2:Array, _arg3:Number, _arg4:int, _arg5:ITriangleMaterial, _arg6:Array, _arg7:String):void{
			var _local8:Array;
			var _local9:int;
			var _local10:int;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:UV;
			var _local15:UV;
			var _local16:UV;
			var _local17:UV;
			var _local18:Vertex;
			var _local19:Vertex;
			var _local20:Vertex;
			var _local21:Vertex;
			var _local22:Number;
			var _local23:Number;
			var _local24:int;
			var _local25:Number;
			var _local26:Number;
			var _local27:Number;
			var _local28:Number;
			_local8 = [];
			_local24 = 0;
			_local25 = 0;
			_local26 = (1 / (_arg1.length - 1));
			_local27 = 0;
			_local28 = 0;
			_local9 = 0;
			while (_local9 < _arg1.length) {
				_local11 = ((_arg2[_local9].x - _arg1[_local9].x) / _segmentsH);
				_local12 = ((_arg2[_local9].y - _arg1[_local9].y) / _segmentsH);
				_local13 = ((_arg2[_local9].z - _arg1[_local9].z) / _segmentsH);
				_local10 = 0;
				while (_local10 < (_segmentsH + 1)) {
					_local8.push(makeVertex((_arg1[_local9].x + (_local11 * _local10)), (_arg1[_local9].y + (_local12 * _local10)), (_arg1[_local9].z + (_local13 * _local10))));
					_local10++;
				};
				_local9++;
			};
			_local9 = 0;
			while (_local9 < (_arg1.length - 1)) {
				_local22 = _local25;
				_local25 = (_local25 + _local26);
				_local23 = _local25;
				if (_map6){
					switch (_arg7){
						case "b":
							_local22 = (_local22 * _offset);
							_local23 = (_local23 * _offset);
							break;
						case "l":
							_local22 = (_local22 * _offset);
							_local23 = (_local23 * _offset);
							break;
						default:
							_local22 = ((_local22 * _offset) + _offset);
							_local23 = ((_local23 * _offset) + _offset);
					};
				};
				_local10 = 0;
				while (_local10 < _segmentsH) {
					_local27 = (_arg3 + ((_local10 / _segmentsH) / _arg4));
					_local28 = (_arg3 + (((_local10 + 1) / _segmentsH) / _arg4));
					if (_map6){
						switch (_arg7){
							case "b":
								_local27 = (_local27 * 0.5);
								_local28 = (_local28 * 0.5);
								break;
							case "l":
								_local27 = ((_local27 * 0.5) + 0.5);
								_local28 = ((_local28 * 0.5) + 0.5);
								break;
							case "t":
								_local27 = (_local27 * 0.5);
								_local28 = (_local28 * 0.5);
								break;
						};
					};
					_local14 = makeUV(_local22, _local27);
					_local15 = makeUV(_local22, _local28);
					_local16 = makeUV(_local23, _local28);
					_local17 = makeUV(_local23, _local27);
					_local18 = _local8[(_local24 + _local10)];
					_local19 = _local8[((_local24 + _local10) + 1)];
					_local20 = _local8[((_local24 + _local10) + (_segmentsH + 2))];
					_local21 = _local8[((_local24 + _local10) + (_segmentsH + 1))];
					if (_flip){
						addFace(createFace(_local18, _local19, _local20, _arg5, _local14, _local15, _local16));
						addFace(createFace(_local18, _local20, _local21, _arg5, _local14, _local16, _local17));
					} else {
						addFace(createFace(_local19, _local18, _local20, _arg5, _local15, _local14, _local16));
						addFace(createFace(_local20, _local18, _local21, _arg5, _local16, _local14, _local17));
					};
					_arg6.push(faces[(faces.length - 2)], faces[(faces.length - 1)]);
					_local10++;
				};
				_local24 = (_local24 + (_segmentsH + 1));
				_local9++;
			};
		}
		private function makeVertex(_arg1:Number, _arg2:Number, _arg3:Number):Vertex{
			var _local4:int;
			var _local5:Vertex;
			_local4 = 0;
			while (_local4 < _dbv.length) {
				if ((((((_dbv[_local4].x == _arg1)) && ((_dbv[_local4].y == _arg2)))) && ((_dbv[_local4].z == _arg3)))){
					return (_dbv[_local4]);
				};
				_local4++;
			};
			_local5 = createVertex(_arg1, _arg2, _arg3);
			_dbv[_dbv.length] = _local5;
			return (_local5);
		}
		public function get width():Number{
			return (_width);
		}

	}
}//package away3d.primitives 
Section 154
//Sphere (away3d.primitives.Sphere)
package away3d.primitives {
	import away3d.core.base.*;

	public class Sphere extends AbstractPrimitive {

		private var _yUp:Boolean;
		private var _segmentsH:int;
		private var _segmentsW:int;
		private var grid:Array;
		private var _radius:Number;

		public function Sphere(_arg1:Object=null){
			super(_arg1);
			_radius = ini.getNumber("radius", 100, {min:0});
			_segmentsW = ini.getInt("segmentsW", 8, {min:3});
			_segmentsH = ini.getInt("segmentsH", 6, {min:2});
			_yUp = ini.getBoolean("yUp", true);
			type = "Sphere";
			url = "primitive";
		}
		override protected function buildPrimitive():void{
			var _local1:int;
			var _local2:int;
			var _local3:Vertex;
			var _local4:Vertex;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Vertex;
			var _local12:Vertex;
			var _local13:Vertex;
			var _local14:Vertex;
			var _local15:int;
			var _local16:Number;
			var _local17:Number;
			var _local18:Number;
			var _local19:Number;
			var _local20:UV;
			var _local21:UV;
			var _local22:UV;
			var _local23:UV;
			super.buildPrimitive();
			grid = new Array((_segmentsH + 1));
			_local3 = (_yUp) ? createVertex(0, -(_radius), 0) : createVertex(0, 0, -(_radius));
			grid[0] = new Array(_segmentsW);
			_local1 = 0;
			while (_local1 < _segmentsW) {
				grid[0][_local1] = _local3;
				_local1++;
			};
			_local2 = 1;
			while (_local2 < _segmentsH) {
				_local5 = ((_local2 / _segmentsH) * Math.PI);
				_local6 = (-(_radius) * Math.cos(_local5));
				_local7 = (_radius * Math.sin(_local5));
				grid[_local2] = new Array(_segmentsW);
				_local1 = 0;
				while (_local1 < _segmentsW) {
					_local8 = (((2 * _local1) / _segmentsW) * Math.PI);
					_local9 = (_local7 * Math.sin(_local8));
					_local10 = (_local7 * Math.cos(_local8));
					if (_yUp){
						grid[_local2][_local1] = createVertex(_local10, _local6, _local9);
					} else {
						grid[_local2][_local1] = createVertex(_local10, -(_local9), _local6);
					};
					_local1++;
				};
				_local2++;
			};
			_local4 = (_yUp) ? createVertex(0, _radius, 0) : createVertex(0, 0, _radius);
			grid[_segmentsH] = new Array(_segmentsW);
			_local1 = 0;
			while (_local1 < _segmentsW) {
				grid[_segmentsH][_local1] = _local4;
				_local1++;
			};
			_local2 = 1;
			while (_local2 <= _segmentsH) {
				_local1 = 0;
				while (_local1 < _segmentsW) {
					_local11 = grid[_local2][_local1];
					_local12 = grid[_local2][(((_local1 - 1) + _segmentsW) % _segmentsW)];
					_local13 = grid[(_local2 - 1)][(((_local1 - 1) + _segmentsW) % _segmentsW)];
					_local14 = grid[(_local2 - 1)][_local1];
					_local15 = _local1;
					if (_local1 == 0){
						_local15 = _segmentsW;
					};
					_local16 = (_local2 / _segmentsH);
					_local17 = ((_local2 - 1) / _segmentsH);
					_local18 = (_local15 / _segmentsW);
					_local19 = ((_local15 - 1) / _segmentsW);
					_local20 = createUV(_local18, _local16);
					_local21 = createUV(_local19, _local16);
					_local22 = createUV(_local19, _local17);
					_local23 = createUV(_local18, _local17);
					if (_local2 < _segmentsH){
						addFace(createFace(_local11, _local12, _local13, null, _local20, _local21, _local22));
					};
					if (_local2 > 1){
						addFace(createFace(_local11, _local13, _local14, null, _local20, _local22, _local23));
					};
					_local1++;
				};
				_local2++;
			};
		}
		public function get radius():Number{
			return (_radius);
		}
		public function get segmentsH():Number{
			return (_segmentsH);
		}
		public function get segmentsW():Number{
			return (_segmentsW);
		}
		public function set segmentsH(_arg1:Number):void{
			if (_segmentsH == _arg1){
				return;
			};
			_segmentsH = _arg1;
			_primitiveDirty = true;
		}
		public function get yUp():Boolean{
			return (_yUp);
		}
		public function set radius(_arg1:Number):void{
			if (_radius == _arg1){
				return;
			};
			_radius = _arg1;
			_primitiveDirty = true;
		}
		public function vertex(_arg1:int, _arg2:int):Vertex{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (grid[_arg2][_arg1]);
		}
		public function set segmentsW(_arg1:Number):void{
			if (_segmentsW == _arg1){
				return;
			};
			_segmentsW = _arg1;
			_primitiveDirty = true;
		}
		public function set yUp(_arg1:Boolean):void{
			if (_yUp == _arg1){
				return;
			};
			_yUp = _arg1;
			_primitiveDirty = true;
		}

	}
}//package away3d.primitives 
Section 155
//WireCube (away3d.primitives.WireCube)
package away3d.primitives {
	import away3d.core.base.*;

	public class WireCube extends AbstractPrimitive {

		public var v001:Vertex;
		public var v110:Vertex;
		public var v010:Vertex;
		public var v011:Vertex;
		private var _height:Number;
		private var _width:Number;
		public var v100:Vertex;
		private var _depth:Number;
		public var v101:Vertex;
		public var v111:Vertex;
		public var v000:Vertex;

		public function WireCube(_arg1:Object=null){
			super(_arg1);
			_width = ini.getNumber("width", 100, {min:0});
			_height = ini.getNumber("height", 100, {min:0});
			_depth = ini.getNumber("depth", 100, {min:0});
			type = "WireCube";
			url = "primitive";
		}
		override protected function buildPrimitive():void{
			super.buildPrimitive();
			v000 = createVertex((-(_width) / 2), (-(_height) / 2), (-(_depth) / 2));
			v001 = createVertex((-(_width) / 2), (-(_height) / 2), (_depth / 2));
			v010 = createVertex((-(_width) / 2), (_height / 2), (-(_depth) / 2));
			v011 = createVertex((-(_width) / 2), (_height / 2), (_depth / 2));
			v100 = createVertex((_width / 2), (-(_height) / 2), (-(_depth) / 2));
			v101 = createVertex((_width / 2), (-(_height) / 2), (_depth / 2));
			v110 = createVertex((_width / 2), (_height / 2), (-(_depth) / 2));
			v111 = createVertex((_width / 2), (_height / 2), (_depth / 2));
			addSegment(createSegment(v000, v001));
			addSegment(createSegment(v011, v001));
			addSegment(createSegment(v011, v010));
			addSegment(createSegment(v000, v010));
			addSegment(createSegment(v100, v000));
			addSegment(createSegment(v101, v001));
			addSegment(createSegment(v111, v011));
			addSegment(createSegment(v110, v010));
			addSegment(createSegment(v100, v101));
			addSegment(createSegment(v111, v101));
			addSegment(createSegment(v111, v110));
			addSegment(createSegment(v100, v110));
		}
		public function set height(_arg1:Number):void{
			if (_height == _arg1){
				return;
			};
			_height = _arg1;
			_primitiveDirty = true;
		}
		public function get depth():Number{
			return (_depth);
		}
		public function get height():Number{
			return (_height);
		}
		public function set width(_arg1:Number):void{
			if (_width == _arg1){
				return;
			};
			_width = _arg1;
			_primitiveDirty = true;
		}
		public function set depth(_arg1:Number):void{
			if (_depth == _arg1){
				return;
			};
			_depth = _arg1;
			_primitiveDirty = true;
		}
		public function get width():Number{
			return (_width);
		}

	}
}//package away3d.primitives 
Section 156
//WireSphere (away3d.primitives.WireSphere)
package away3d.primitives {
	import away3d.core.base.*;

	public class WireSphere extends AbstractPrimitive {

		private var _yUp:Boolean;
		private var _segmentsH:int;
		private var _segmentsW:int;
		private var grid:Array;
		private var _radius:Number;

		public function WireSphere(_arg1:Object=null){
			super(_arg1);
			_radius = ini.getNumber("radius", 100, {min:0});
			_segmentsW = ini.getInt("segmentsW", 8, {min:3});
			_segmentsH = ini.getInt("segmentsH", 6, {min:2});
			_yUp = ini.getBoolean("yUp", true);
			type = "WireSphere";
			url = "primitive";
		}
		override protected function buildPrimitive():void{
			var _local1:int;
			var _local2:int;
			var _local3:Vertex;
			var _local4:Vertex;
			var _local5:Number;
			var _local6:Number;
			var _local7:Number;
			var _local8:Number;
			var _local9:Number;
			var _local10:Number;
			var _local11:Vertex;
			var _local12:Vertex;
			var _local13:Vertex;
			var _local14:Vertex;
			super.buildPrimitive();
			grid = new Array((_segmentsH + 1));
			_local3 = (_yUp) ? createVertex(0, -(_radius), 0) : createVertex(0, 0, -(_radius));
			grid[0] = new Array(_segmentsW);
			_local1 = 0;
			while (_local1 < _segmentsW) {
				grid[0][_local1] = _local3;
				_local1++;
			};
			_local2 = 1;
			while (_local2 < _segmentsH) {
				_local5 = ((_local2 / _segmentsH) * Math.PI);
				_local6 = (-(_radius) * Math.cos(_local5));
				_local7 = (_radius * Math.sin(_local5));
				grid[_local2] = new Array(_segmentsW);
				_local1 = 0;
				while (_local1 < _segmentsW) {
					_local8 = (((2 * _local1) / _segmentsW) * Math.PI);
					_local9 = (_local7 * Math.sin(_local8));
					_local10 = (_local7 * Math.cos(_local8));
					if (_yUp){
						grid[_local2][_local1] = createVertex(_local10, _local6, _local9);
					} else {
						grid[_local2][_local1] = createVertex(_local10, -(_local9), _local6);
					};
					_local1++;
				};
				_local2++;
			};
			_local4 = (_yUp) ? createVertex(0, _radius, 0) : createVertex(0, 0, _radius);
			grid[_segmentsH] = new Array(_segmentsW);
			_local1 = 0;
			while (_local1 < _segmentsW) {
				grid[_segmentsH][_local1] = _local4;
				_local1++;
			};
			_local2 = 1;
			while (_local2 <= _segmentsH) {
				_local1 = 0;
				while (_local1 < _segmentsW) {
					_local11 = grid[_local2][_local1];
					_local12 = grid[_local2][(((_local1 - 1) + _segmentsW) % _segmentsW)];
					_local13 = grid[(_local2 - 1)][(((_local1 - 1) + _segmentsW) % _segmentsW)];
					_local14 = grid[(_local2 - 1)][_local1];
					addSegment(createSegment(_local11, _local14));
					addSegment(createSegment(_local12, _local13));
					if (_local2 < _segmentsH){
						addSegment(createSegment(_local11, _local12));
					};
					_local1++;
				};
				_local2++;
			};
		}
		public function get radius():Number{
			return (_radius);
		}
		public function get segmentsH():Number{
			return (_segmentsH);
		}
		public function get segmentsW():Number{
			return (_segmentsW);
		}
		public function set segmentsH(_arg1:Number):void{
			if (_segmentsH == _arg1){
				return;
			};
			_segmentsH = _arg1;
			_primitiveDirty = true;
		}
		public function get yUp():Boolean{
			return (_yUp);
		}
		public function set radius(_arg1:Number):void{
			if (_radius == _arg1){
				return;
			};
			_radius = _arg1;
			_primitiveDirty = true;
		}
		public function vertex(_arg1:int, _arg2:int):Vertex{
			if (_primitiveDirty){
				updatePrimitive();
			};
			return (grid[_arg2][_arg1]);
		}
		public function set segmentsW(_arg1:Number):void{
			if (_segmentsW == _arg1){
				return;
			};
			_segmentsW = _arg1;
			_primitiveDirty = true;
		}
		public function set yUp(_arg1:Boolean):void{
			if (_yUp == _arg1){
				return;
			};
			_yUp = _arg1;
			_primitiveDirty = true;
		}

	}
}//package away3d.primitives 
Section 157
//DirSprite2D (away3d.sprites.DirSprite2D)
package away3d.sprites {
	import flash.display.*;
	import away3d.core.base.*;
	import away3d.core.utils.*;
	import flash.utils.*;
	import away3d.core.project.*;

	public class DirSprite2D extends Object3D {

		private var _vertices:Array;
		public var rotation:Number;
		public var scaling:Number;
		public var deltaZ:Number;
		public var smooth:Boolean;
		private var _bitmaps:Dictionary;

		public function DirSprite2D(_arg1:Object=null){
			var _local2:Array;
			var _local3:Init;
			var _local4:Number;
			var _local5:Number;
			var _local6:Number;
			var _local7:BitmapData;
			_vertices = [];
			_bitmaps = new Dictionary(true);
			super(_arg1);
			scaling = ini.getNumber("scaling", 1, {min:0});
			rotation = ini.getNumber("rotation", 0);
			smooth = ini.getBoolean("smooth", false);
			deltaZ = ini.getNumber("deltaZ", 0);
			_local2 = ini.getArray("bitmaps");
			for each (_local3 in _local2) {
				_local3 = Init.parse(_local3);
				_local4 = _local3.getNumber("x", 0);
				_local5 = _local3.getNumber("y", 0);
				_local6 = _local3.getNumber("z", 0);
				_local7 = _local3.getBitmap("bitmap");
				add(_local4, _local5, _local6, _local7);
			};
			projectorType = ProjectorType.DIR_SPRITE;
		}
		public function add(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:BitmapData):void{
			var _local5:Vertex;
			var _local6:Vertex;
			if (_arg4){
				for each (_local6 in _vertices) {
					if ((((((_local6.x == _arg1)) && ((_local6.y == _arg2)))) && ((_local6.z == _arg3)))){
						Debug.warning(("Same base point for two bitmaps: " + _local6));
						return;
					};
				};
			};
			_local5 = new Vertex(_arg1, _arg2, _arg3);
			_vertices.push(_local5);
			_bitmaps[_local5] = _arg4;
		}
		public function get bitmaps():Dictionary{
			return (_bitmaps);
		}
		public function get vertices():Array{
			return (_vertices);
		}

	}
}//package away3d.sprites 
Section 158
//DofSprite2D (away3d.sprites.DofSprite2D)
package away3d.sprites {
	import flash.display.*;
	import away3d.core.base.*;
	import away3d.core.project.*;

	public class DofSprite2D extends Object3D {

		public var bitmap:BitmapData;
		public var rotation:Number;
		public var scaling:Number;
		public var deltaZ:Number;
		public var smooth:Boolean;

		public function DofSprite2D(_arg1:BitmapData, _arg2:Object=null){
			this.bitmap = _arg1;
			super(_arg2);
			scaling = ini.getNumber("scaling", 1, {min:0});
			rotation = ini.getNumber("rotation", 0);
			smooth = ini.getBoolean("smooth", false);
			deltaZ = ini.getNumber("deltaZ", 0);
			projectorType = ProjectorType.DOF_SPRITE;
		}
	}
}//package away3d.sprites 
Section 159
//MovieClipSprite (away3d.sprites.MovieClipSprite)
package away3d.sprites {
	import flash.display.*;
	import away3d.core.base.*;
	import away3d.core.project.*;

	public class MovieClipSprite extends Object3D {

		public var movieclip:DisplayObject;
		public var rescale:Boolean;
		public var align:String;
		public var scaling:Number;
		public var deltaZ:Number;

		public function MovieClipSprite(_arg1:DisplayObject, _arg2:Object=null){
			super(_arg2);
			this.movieclip = _arg1;
			scaling = ini.getNumber("scaling", 1);
			deltaZ = ini.getNumber("deltaZ", 0);
			rescale = ini.getBoolean("rescale", false);
			align = ini.getString("align", "center");
			projectorType = ProjectorType.MOVIE_CLIP_SPRITE;
		}
	}
}//package away3d.sprites 
Section 160
//Sprite2D (away3d.sprites.Sprite2D)
package away3d.sprites {
	import flash.display.*;
	import away3d.core.base.*;
	import away3d.core.project.*;

	public class Sprite2D extends Object3D {

		public var bitmap:BitmapData;
		public var rotation:Number;
		public var scaling:Number;
		public var deltaZ:Number;
		public var smooth:Boolean;

		public function Sprite2D(_arg1:BitmapData, _arg2:Object=null){
			this.bitmap = _arg1;
			super(_arg2);
			scaling = ini.getNumber("scaling", 1, {min:0});
			rotation = ini.getNumber("rotation", 0);
			smooth = ini.getBoolean("smooth", false);
			deltaZ = ini.getNumber("deltaZ", 0);
			projectorType = ProjectorType.SPRITE;
		}
	}
}//package away3d.sprites 
Section 161
//arcane (away3d.arcane)
package away3d {

	public namespace arcane;
}//package away3d 
Section 162
//MuteUnmuteBtn_8 (cub_fla.MuteUnmuteBtn_8)
package cub_fla {
	import flash.display.*;
	import flash.events.*;

	public dynamic class MuteUnmuteBtn_8 extends MovieClip {

		public var muteBtn:SimpleButton;
		public var unmuteBtn:SimpleButton;

		public function MuteUnmuteBtn_8(){
			addFrameScript(0, frame1, 1, frame2);
		}
		public function unmuteBtn_clickHandler(_arg1:MouseEvent):void{
			Application.soundOn(Application.soundVol);
			gotoAndStop("mute");
		}
		function frame1(){
			stop();
			if (!Application.isSoundOn){
				gotoAndStop("unmute");
			};
			muteBtn.addEventListener(MouseEvent.CLICK, muteBtn_clickHandler);
		}
		function frame2(){
			stop();
			unmuteBtn.addEventListener(MouseEvent.CLICK, unmuteBtn_clickHandler);
		}
		public function muteBtn_clickHandler(_arg1:MouseEvent):void{
			Application.soundOff();
			gotoAndStop("unmute");
		}

	}
}//package cub_fla 
Section 163
//MochiAd (mochi.as3.MochiAd)
package mochi.as3 {
	import flash.display.*;
	import flash.events.*;
	import flash.utils.*;
	import flash.net.*;
	import flash.system.*;

	public class MochiAd {

		public static function getVersion():String{
			return (MochiServices.getVersion());
		}
		public static function showClickAwayAd(_arg1:Object):void{
			var DEFAULTS:Object;
			var clip:Object;
			var ad_timeout:Number;
			var mc:MovieClip;
			var wh:Array;
			var w:Number;
			var h:Number;
			var chk:MovieClip;
			var sendHostProgress:Boolean;
			var options = _arg1;
			DEFAULTS = {ad_timeout:2000, regpt:"o", method:"showClickAwayAd", res:"300x250", no_bg:true, ad_started:function ():void{
			}, ad_finished:function ():void{
			}, ad_loaded:function (_arg1:Number, _arg2:Number):void{
			}, ad_failed:function ():void{
				trace("[MochiAd] Couldn't load an ad, make sure your game's local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
			}, ad_skipped:function ():void{
			}};
			options = MochiAd._parseOptions(options, DEFAULTS);
			clip = options.clip;
			ad_timeout = options.ad_timeout;
			delete options.ad_timeout;
			if (!MochiAd.load(options)){
				options.ad_failed();
				options.ad_finished();
				return;
			};
			options.ad_started();
			mc = clip._mochiad;
			mc["onUnload"] = function ():void{
				MochiAd._cleanup(mc);
				options.ad_finished();
			};
			wh = MochiAd._getRes(options, clip);
			w = wh[0];
			h = wh[1];
			mc.x = (w * 0.5);
			mc.y = (h * 0.5);
			chk = createEmptyMovieClip(mc, "_mochiad_wait", 3);
			chk.ad_timeout = ad_timeout;
			chk.started = getTimer();
			chk.showing = false;
			mc.unloadAd = function ():void{
				MochiAd.unload(clip);
			};
			mc.adLoaded = options.ad_loaded;
			mc.adSkipped = options.ad_skipped;
			mc.rpc = function (_arg1:Number, _arg2:Object):void{
				MochiAd.rpc(clip, _arg1, _arg2);
			};
			sendHostProgress = false;
			mc.regContLC = function (_arg1:String):void{
				mc._containerLCName = _arg1;
			};
			chk["onEnterFrame"] = function ():void{
				var _local1:Object;
				var _local2:Number;
				var _local3:Boolean;
				var _local4:Number;
				if (!this.parent){
					delete this.onEnterFrame;
					return;
				};
				_local1 = this.parent._mochiad_ctr;
				_local2 = (getTimer() - this.started);
				_local3 = false;
				if (!chk.showing){
					_local4 = this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal;
					if (_local4 > 0){
						chk.showing = true;
						_local3 = true;
						chk.started = getTimer();
					} else {
						if (_local2 > chk.ad_timeout){
							options.ad_failed();
							_local3 = true;
						};
					};
				};
				if (this.root == null){
					_local3 = true;
				};
				if (_local3){
					delete this.onEnterFrame;
				};
			};
			doOnEnterFrame(chk);
		}
		public static function _isNetworkAvailable():Boolean{
			return (!((Security.sandboxType == "localWithFile")));
		}
		public static function _allowDomains(_arg1:String):String{
			var _local2:String;
			_local2 = _arg1.split("/")[2].split(":")[0];
			if (Security.sandboxType == "application"){
				return (_local2);
			};
			Security.allowDomain("*");
			Security.allowDomain(_local2);
			Security.allowInsecureDomain("*");
			Security.allowInsecureDomain(_local2);
			return (_local2);
		}
		public static function unload(_arg1:Object):Boolean{
			if (((_arg1.clip) && (_arg1.clip._mochiad))){
				_arg1 = _arg1.clip;
			};
			if (_arg1.origFrameRate != undefined){
				_arg1.stage.frameRate = _arg1.origFrameRate;
			};
			if (!_arg1._mochiad){
				return (false);
			};
			if (_arg1._mochiad._containerLCName != undefined){
				_arg1._mochiad.lc.send(_arg1._mochiad._containerLCName, "notify", {id:"unload"});
			};
			if (_arg1._mochiad.onUnload){
				_arg1._mochiad.onUnload();
			};
			delete _arg1._mochiad_loaded;
			delete _arg1._mochiad;
			return (true);
		}
		public static function showInterLevelAd(_arg1:Object):void{
			var DEFAULTS:Object;
			var clip:Object;
			var ad_msec:Number;
			var ad_timeout:Number;
			var fadeout_time:Number;
			var mc:MovieClip;
			var wh:Array;
			var w:Number;
			var h:Number;
			var chk:MovieClip;
			var options = _arg1;
			DEFAULTS = {ad_timeout:2000, fadeout_time:250, regpt:"o", method:"showTimedAd", ad_started:function ():void{
				if ((this.clip is MovieClip)){
					this.clip.stop();
				} else {
					throw (new Error("MochiAd.showInterLevelAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers."));
				};
			}, ad_finished:function ():void{
				if ((this.clip is MovieClip)){
					this.clip.play();
				} else {
					throw (new Error("MochiAd.showInterLevelAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers."));
				};
			}, ad_loaded:function (_arg1:Number, _arg2:Number):void{
			}, ad_failed:function ():void{
				trace("[MochiAd] Couldn't load an ad, make sure your game's local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
			}, ad_skipped:function ():void{
			}};
			options = MochiAd._parseOptions(options, DEFAULTS);
			clip = options.clip;
			ad_msec = 11000;
			ad_timeout = options.ad_timeout;
			delete options.ad_timeout;
			fadeout_time = options.fadeout_time;
			delete options.fadeout_time;
			if (!MochiAd.load(options)){
				options.ad_failed();
				options.ad_finished();
				return;
			};
			options.ad_started();
			mc = clip._mochiad;
			mc["onUnload"] = function ():void{
				MochiAd._cleanup(mc);
				options.ad_finished();
			};
			wh = MochiAd._getRes(options, clip);
			w = wh[0];
			h = wh[1];
			mc.x = (w * 0.5);
			mc.y = (h * 0.5);
			chk = createEmptyMovieClip(mc, "_mochiad_wait", 3);
			chk.ad_msec = ad_msec;
			chk.ad_timeout = ad_timeout;
			chk.started = getTimer();
			chk.showing = false;
			chk.fadeout_time = fadeout_time;
			chk.fadeFunction = function ():void{
				var _local1:Number;
				if (!this.parent){
					delete this.onEnterFrame;
					delete this.fadeFunction;
					return;
				};
				_local1 = (100 * (1 - ((getTimer() - this.fadeout_start) / this.fadeout_time)));
				if (_local1 > 0){
					this.parent.alpha = (_local1 * 0.01);
				} else {
					MochiAd.unload(clip);
					delete this["onEnterFrame"];
				};
			};
			mc.unloadAd = function ():void{
				MochiAd.unload(clip);
			};
			mc.adLoaded = options.ad_loaded;
			mc.adSkipped = options.ad_skipped;
			mc.adjustProgress = function (_arg1:Number):void{
				var _local2:Object;
				_local2 = mc._mochiad_wait;
				_local2.server_control = true;
				_local2.showing = true;
				_local2.started = getTimer();
				_local2.ad_msec = (_arg1 - 250);
			};
			mc.rpc = function (_arg1:Number, _arg2:Object):void{
				MochiAd.rpc(clip, _arg1, _arg2);
			};
			chk["onEnterFrame"] = function ():void{
				var _local1:Object;
				var _local2:Number;
				var _local3:Boolean;
				var _local4:Number;
				if (!this.parent){
					delete this.onEnterFrame;
					delete this.fadeFunction;
					return;
				};
				_local1 = this.parent._mochiad_ctr;
				_local2 = (getTimer() - this.started);
				_local3 = false;
				if (!chk.showing){
					_local4 = this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal;
					if (_local4 > 0){
						chk.showing = true;
						chk.started = getTimer();
						MochiAd.adShowing(clip);
					} else {
						if (_local2 > chk.ad_timeout){
							options.ad_failed();
							_local3 = true;
						};
					};
				};
				if (_local2 > chk.ad_msec){
					_local3 = true;
				};
				if (_local3){
					if (this.server_control){
						delete this.onEnterFrame;
					} else {
						this.fadeout_start = getTimer();
						this.onEnterFrame = this.fadeFunction;
					};
				};
			};
			doOnEnterFrame(chk);
		}
		public static function _parseOptions(_arg1:Object, _arg2:Object):Object{
			var _local3:Object;
			var _local4:String;
			var _local5:Array;
			var _local6:Number;
			var _local7:Array;
			_local3 = {};
			for (_local4 in _arg2) {
				_local3[_local4] = _arg2[_local4];
			};
			if (_arg1){
				for (_local4 in _arg1) {
					_local3[_local4] = _arg1[_local4];
				};
			};
			if (_local3.clip == undefined){
				throw (new Error("MochiAd is missing the 'clip' parameter.  This should be a MovieClip, Sprite or an instance of a class that extends MovieClip or Sprite."));
			};
			_arg1 = _local3.clip.loaderInfo.parameters.mochiad_options;
			if (_arg1){
				_local5 = _arg1.split("&");
				_local6 = 0;
				while (_local6 < _local5.length) {
					_local7 = _local5[_local6].split("=");
					_local3[unescape(_local7[0])] = unescape(_local7[1]);
					_local6++;
				};
			};
			if (_local3.id == "test"){
				trace("[MochiAd] WARNING: Using the MochiAds test identifier, make sure to use the code from your dashboard, not this example!");
			};
			return (_local3);
		}
		public static function _cleanup(_arg1:Object):void{
			var idx:Number;
			var k:String;
			var lc:LocalConnection;
			var f:Function;
			var mc = _arg1;
			if (("lc" in mc)){
				lc = mc.lc;
				f = function ():void{
					try {
						lc.client = null;
						lc.close();
					} catch(e:Error) {
					};
				};
				setTimeout(f, 0);
			};
			idx = DisplayObjectContainer(mc).numChildren;
			while (idx > 0) {
				idx = (idx - 1);
				DisplayObjectContainer(mc).removeChildAt(idx);
			};
			for (k in mc) {
				delete mc[k];
			};
		}
		public static function load(_arg1:Object):MovieClip{
			var DEFAULTS:Object;
			var clip:Object;
			var depth:Number;
			var mc:MovieClip;
			var wh:Array;
			var lv:URLVariables;
			var k:String;
			var server:String;
			var hostname:String;
			var lc:LocalConnection;
			var name:String;
			var loader:Loader;
			var g:Function;
			var req:URLRequest;
			var v:Object;
			var options = _arg1;
			DEFAULTS = {server:"http://x.mochiads.com/srv/1/", method:"load", depth:10333, id:"_UNKNOWN_"};
			options = MochiAd._parseOptions(options, DEFAULTS);
			options.swfv = 9;
			options.mav = MochiAd.getVersion();
			clip = options.clip;
			if (!(clip is DisplayObject)){
				trace("Warning: Object passed as container clip not a descendant of the DisplayObject type");
				return (null);
			};
			if (MovieClip(clip).stage == null){
				trace("Warning: Container clip for ad is not attached to the stage");
				return (null);
			};
			if (!MochiAd._isNetworkAvailable()){
				return (null);
			};
			try {
				if (clip._mochiad_loaded){
					return (null);
				};
			} catch(e:Error) {
				throw (new Error("MochiAd requires a clip that is an instance of a dynamic class.  If your class extends Sprite or MovieClip, you must make it dynamic."));
			};
			depth = options.depth;
			delete options.depth;
			mc = createEmptyMovieClip(clip, "_mochiad", depth);
			wh = MochiAd._getRes(options, clip);
			options.res = ((wh[0] + "x") + wh[1]);
			options.server = (options.server + options.id);
			delete options.id;
			clip._mochiad_loaded = true;
			if (clip.loaderInfo.loaderURL.indexOf("http") == 0){
				options.as3_swf = clip.loaderInfo.loaderURL;
			} else {
				trace("[MochiAd] NOTE: Security Sandbox Violation errors below are normal");
			};
			lv = new URLVariables();
			for (k in options) {
				v = options[k];
				if (!(v is Function)){
					lv[k] = v;
				};
			};
			server = lv.server;
			delete lv.server;
			hostname = _allowDomains(server);
			lc = new LocalConnection();
			lc.client = mc;
			name = ["", Math.floor(new Date().getTime()), Math.floor((Math.random() * 999999))].join("_");
			lc.allowDomain("*", "localhost");
			lc.allowInsecureDomain("*", "localhost");
			lc.connect(name);
			mc.lc = lc;
			mc.lcName = name;
			lv.lc = name;
			lv.st = getTimer();
			loader = new Loader();
			g = function (_arg1:Object):void{
				_arg1.target.removeEventListener(_arg1.type, arguments.callee);
				MochiAd.unload(clip);
			};
			loader.contentLoaderInfo.addEventListener(Event.UNLOAD, g);
			req = new URLRequest(((server + ".swf?cacheBust=") + new Date().getTime()));
			req.contentType = "application/x-www-form-urlencoded";
			req.method = URLRequestMethod.POST;
			req.data = lv;
			loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, function (_arg1:IOErrorEvent):void{
				trace("[MochiAds] Blocked URL");
			});
			if (!options.skip){
				loader.load(req);
			};
			mc.addChild(loader);
			mc._mochiad_ctr = loader;
			return (mc);
		}
		public static function runMethod(_arg1:Object, _arg2:String, _arg3:Array):Object{
			var _local4:Array;
			var _local5:Number;
			_local4 = _arg2.split(".");
			_local5 = 0;
			while (_local5 < (_local4.length - 1)) {
				if ((((_arg1[_local4[_local5]] == undefined)) || ((_arg1[_local4[_local5]] == null)))){
					return (undefined);
				};
				_arg1 = _arg1[_local4[_local5]];
				_local5++;
			};
			if (typeof(_arg1[_local4[_local5]]) == "function"){
				return (_arg1[_local4[_local5]].apply(_arg1, _arg3));
			};
			return (undefined);
		}
		public static function createEmptyMovieClip(_arg1:Object, _arg2:String, _arg3:Number):MovieClip{
			var _local4:MovieClip;
			_local4 = new MovieClip();
			if (((false) && (_arg3))){
				_arg1.addChildAt(_local4, _arg3);
			} else {
				_arg1.addChild(_local4);
			};
			_arg1[_arg2] = _local4;
			_local4["_name"] = _arg2;
			return (_local4);
		}
		public static function _getRes(_arg1:Object, _arg2:Object):Array{
			var _local3:Object;
			var _local4:Number;
			var _local5:Number;
			var _local6:Array;
			_local3 = _arg2.getBounds(_arg2.root);
			_local4 = 0;
			_local5 = 0;
			if (typeof(_arg1.res) != "undefined"){
				_local6 = _arg1.res.split("x");
				_local4 = parseFloat(_local6[0]);
				_local5 = parseFloat(_local6[1]);
			} else {
				_local4 = (_local3.xMax - _local3.xMin);
				_local5 = (_local3.yMax - _local3.yMin);
			};
			if ((((_local4 == 0)) || ((_local5 == 0)))){
				_local4 = _arg2.stage.stageWidth;
				_local5 = _arg2.stage.stageHeight;
			};
			return ([_local4, _local5]);
		}
		public static function adShowing(_arg1:Object):void{
			_arg1.origFrameRate = _arg1.stage.frameRate;
			_arg1.stage.frameRate = 30;
		}
		public static function getValue(_arg1:Object, _arg2:String):Object{
			var _local3:Array;
			var _local4:Number;
			_local3 = _arg2.split(".");
			_local4 = 0;
			while (_local4 < (_local3.length - 1)) {
				if ((((_arg1[_local3[_local4]] == undefined)) || ((_arg1[_local3[_local4]] == null)))){
					return (undefined);
				};
				_arg1 = _arg1[_local3[_local4]];
				_local4++;
			};
			return (_arg1[_local3[_local4]]);
		}
		public static function rpc(_arg1:Object, _arg2:Number, _arg3:Object):void{
			var _local4:Object;
			var _local5:Object;
			switch (_arg3.id){
				case "setValue":
					MochiAd.setValue(_arg1, _arg3.objectName, _arg3.value);
					break;
				case "getValue":
					_local4 = MochiAd.getValue(_arg1, _arg3.objectName);
					_arg1._mochiad.lc.send(_arg1._mochiad._containerLCName, "rpcResult", _arg2, _local4);
					break;
				case "runMethod":
					_local5 = MochiAd.runMethod(_arg1, _arg3.method, _arg3.args);
					_arg1._mochiad.lc.send(_arg1._mochiad._containerLCName, "rpcResult", _arg2, _local5);
					break;
				default:
					trace(("[mochiads rpc] unknown rpc id: " + _arg3.id));
			};
		}
		public static function setValue(_arg1:Object, _arg2:String, _arg3:Object):void{
			var _local4:Array;
			var _local5:Number;
			_local4 = _arg2.split(".");
			_local5 = 0;
			while (_local5 < (_local4.length - 1)) {
				if ((((_arg1[_local4[_local5]] == undefined)) || ((_arg1[_local4[_local5]] == null)))){
					return;
				};
				_arg1 = _arg1[_local4[_local5]];
				_local5++;
			};
			_arg1[_local4[_local5]] = _arg3;
		}
		public static function showPreGameAd(_arg1:Object):void{
			var DEFAULTS:Object;
			var clip:Object;
			var ad_msec:Number;
			var ad_timeout:Number;
			var fadeout_time:Number;
			var mc:MovieClip;
			var wh:Array;
			var w:Number;
			var h:Number;
			var chk:MovieClip;
			var bar:MovieClip;
			var bar_w:Number;
			var bar_color:Number;
			var bar_background:Number;
			var bar_outline:Number;
			var backing_mc:MovieClip;
			var backing:Object;
			var inside_mc:MovieClip;
			var inside:Object;
			var outline_mc:MovieClip;
			var outline:Object;
			var complete:Boolean;
			var unloaded:Boolean;
			var progress:Number;
			var f:Function;
			var sendHostProgress:Boolean;
			var fn:Function;
			var r:MovieClip;
			var options = _arg1;
			DEFAULTS = {ad_timeout:3000, fadeout_time:250, regpt:"o", method:"showPreloaderAd", color:0xFF8A00, background:16777161, outline:13994812, no_progress_bar:false, ad_started:function ():void{
				if ((this.clip is MovieClip)){
					this.clip.stop();
				} else {
					throw (new Error("MochiAd.showPreGameAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers."));
				};
			}, ad_finished:function ():void{
				if ((this.clip is MovieClip)){
					this.clip.play();
				} else {
					throw (new Error("MochiAd.showPreGameAd requires a clip that is a MovieClip or is an instance of a class that extends MovieClip.  If your clip is a Sprite, then you must provide custom ad_started and ad_finished handlers."));
				};
			}, ad_loaded:function (_arg1:Number, _arg2:Number):void{
			}, ad_failed:function ():void{
				trace("[MochiAd] Couldn't load an ad, make sure your game's local security sandbox is configured for Access Network Only and that you are not using ad blocking software");
			}, ad_skipped:function ():void{
			}, ad_progress:function (_arg1:Number):void{
			}, progress_override:function (_arg1:Object):Number{
				return (NaN);
			}, bar_offset:0};
			options = MochiAd._parseOptions(options, DEFAULTS);
			if ("c862232051e0a94e1c3609b3916ddb17".substr(0) == "dfeada81ac97cde83665f81c12da7def"){
				options.ad_started();
				fn = function ():void{
					options.ad_finished();
				};
				setTimeout(fn, 100);
				return;
			};
			clip = options.clip;
			ad_msec = 11000;
			ad_timeout = options.ad_timeout;
			if (options.skip){
				ad_timeout = 0;
			};
			delete options.ad_timeout;
			fadeout_time = options.fadeout_time;
			delete options.fadeout_time;
			if (!MochiAd.load(options)){
				options.ad_failed();
				options.ad_finished();
				return;
			};
			options.ad_started();
			mc = clip._mochiad;
			mc["onUnload"] = function ():void{
				var fn:Function;
				MochiAd._cleanup(mc);
				fn = function ():void{
					options.ad_finished();
				};
				setTimeout(fn, 100);
			};
			wh = MochiAd._getRes(options, clip);
			w = wh[0];
			h = wh[1];
			mc.x = (w * 0.5);
			mc.y = (h * 0.5);
			chk = createEmptyMovieClip(mc, "_mochiad_wait", 3);
			chk.x = (w * -0.5);
			chk.y = (h * -0.5);
			bar = createEmptyMovieClip(chk, "_mochiad_bar", 4);
			if (options.no_progress_bar){
				bar.visible = false;
				delete options.no_progress_bar;
			} else {
				bar.x = (10 + options.bar_offset);
				bar.y = (h - 20);
			};
			bar_w = ((w - bar.x) - 10);
			bar_color = options.color;
			delete options.color;
			bar_background = options.background;
			delete options.background;
			bar_outline = options.outline;
			delete options.outline;
			backing_mc = createEmptyMovieClip(bar, "_outline", 1);
			backing = backing_mc.graphics;
			backing.beginFill(bar_background);
			backing.moveTo(0, 0);
			backing.lineTo(bar_w, 0);
			backing.lineTo(bar_w, 10);
			backing.lineTo(0, 10);
			backing.lineTo(0, 0);
			backing.endFill();
			inside_mc = createEmptyMovieClip(bar, "_inside", 2);
			inside = inside_mc.graphics;
			inside.beginFill(bar_color);
			inside.moveTo(0, 0);
			inside.lineTo(bar_w, 0);
			inside.lineTo(bar_w, 10);
			inside.lineTo(0, 10);
			inside.lineTo(0, 0);
			inside.endFill();
			inside_mc.scaleX = 0;
			outline_mc = createEmptyMovieClip(bar, "_outline", 3);
			outline = outline_mc.graphics;
			outline.lineStyle(0, bar_outline, 100);
			outline.moveTo(0, 0);
			outline.lineTo(bar_w, 0);
			outline.lineTo(bar_w, 10);
			outline.lineTo(0, 10);
			outline.lineTo(0, 0);
			chk.ad_msec = ad_msec;
			chk.ad_timeout = ad_timeout;
			chk.started = getTimer();
			chk.showing = false;
			chk.last_pcnt = 0;
			chk.fadeout_time = fadeout_time;
			chk.fadeFunction = function ():void{
				var _local1:Number;
				_local1 = (100 * (1 - ((getTimer() - this.fadeout_start) / this.fadeout_time)));
				if (_local1 > 0){
					this.parent.alpha = (_local1 * 0.01);
				} else {
					MochiAd.unload(clip);
					delete this["onEnterFrame"];
				};
			};
			complete = false;
			unloaded = false;
			progress = Math.min(1, options.progress_override(clip));
			f = function (_arg1:Event):void{
				_arg1.target.removeEventListener(_arg1.type, arguments.callee);
				complete = true;
				if (unloaded){
					MochiAd.unload(clip);
				};
			};
			if (!isNaN(progress)){
				complete = (progress == 1);
			} else {
				if (clip.loaderInfo.bytesLoaded == clip.loaderInfo.bytesTotal){
					complete = true;
				} else {
					if ((clip.root is MovieClip)){
						r = (clip.root as MovieClip);
						if (r.framesLoaded >= r.totalFrames){
							complete = true;
						} else {
							clip.loaderInfo.addEventListener(Event.COMPLETE, f);
						};
					} else {
						clip.loaderInfo.addEventListener(Event.COMPLETE, f);
					};
				};
			};
			mc.unloadAd = function ():void{
				unloaded = true;
				if (complete){
					MochiAd.unload(clip);
				};
			};
			mc.adLoaded = options.ad_loaded;
			mc.adSkipped = options.ad_skipped;
			mc.adjustProgress = function (_arg1:Number):void{
				var _local2:Object;
				_local2 = mc._mochiad_wait;
				_local2.server_control = true;
				_local2.showing = true;
				_local2.started = getTimer();
				_local2.ad_msec = _arg1;
			};
			mc.rpc = function (_arg1:Number, _arg2:Object):void{
				MochiAd.rpc(clip, _arg1, _arg2);
			};
			mc.rpcTestFn = function (_arg1:String):Object{
				trace(("[MOCHIAD rpcTestFn] " + _arg1));
				return (_arg1);
			};
			mc.regContLC = function (_arg1:String):void{
				mc._containerLCName = _arg1;
			};
			sendHostProgress = false;
			mc.sendHostLoadProgress = function (_arg1:String):void{
				sendHostProgress = true;
			};
			chk["onEnterFrame"] = function ():void{
				var _local1:Object;
				var _local2:Object;
				var _local3:Number;
				var _local4:Boolean;
				var _local5:Number;
				var _local6:Number;
				var _local7:Number;
				var _local8:Number;
				var _local9:Number;
				var _local10:Object;
				var _local11:Number;
				var _local12:Number;
				if (((!(this.parent)) || (!(this.parent.parent)))){
					delete this["onEnterFrame"];
					return;
				};
				_local1 = this.parent.parent.root;
				_local2 = this.parent._mochiad_ctr;
				_local3 = (getTimer() - this.started);
				_local4 = false;
				_local5 = _local1.loaderInfo.bytesTotal;
				_local6 = _local1.loaderInfo.bytesLoaded;
				_local7 = Math.min(1, options.progress_override(_local1));
				if (_local7 == 1){
					complete = true;
				};
				if (complete){
					_local6 = Math.max(1, _local6);
					_local5 = _local6;
				};
				_local8 = ((100 * _local6) / _local5);
				if (!isNaN(_local7)){
					_local8 = (100 * _local7);
				};
				_local9 = ((100 * _local3) / chk.ad_msec);
				_local10 = this._mochiad_bar._inside;
				_local11 = Math.min(100, Math.min(((_local8) || (0)), _local9));
				_local11 = Math.max(this.last_pcnt, _local11);
				this.last_pcnt = _local11;
				_local10.scaleX = (_local11 * 0.01);
				options.ad_progress(_local11);
				if (sendHostProgress){
					clip._mochiad.lc.send(clip._mochiad._containerLCName, "notify", {id:"hostLoadPcnt", pcnt:_local8});
					if (_local8 >= 100){
						sendHostProgress = false;
					};
				};
				if (!chk.showing){
					_local12 = this.parent._mochiad_ctr.contentLoaderInfo.bytesTotal;
					if (_local12 > 0){
						chk.showing = true;
						chk.started = getTimer();
						MochiAd.adShowing(clip);
					} else {
						if ((((_local3 > chk.ad_timeout)) && ((_local8 == 100)))){
							options.ad_failed();
							_local4 = true;
						};
					};
				};
				if (_local3 > chk.ad_msec){
					_local4 = true;
				};
				if (((complete) && (_local4))){
					if (unloaded){
						MochiAd.unload(_local1);
					} else {
						if (this.server_control){
							delete this.onEnterFrame;
						} else {
							this.fadeout_start = getTimer();
							this.onEnterFrame = chk.fadeFunction;
						};
					};
				};
			};
			doOnEnterFrame(chk);
		}
		public static function showPreloaderAd(_arg1:Object):void{
			trace("[MochiAd] DEPRECATED: showPreloaderAd was renamed to showPreGameAd in 2.0");
			MochiAd.showPreGameAd(_arg1);
		}
		public static function showTimedAd(_arg1:Object):void{
			trace("[MochiAd] DEPRECATED: showTimedAd was renamed to showInterLevelAd in 2.0");
			MochiAd.showInterLevelAd(_arg1);
		}
		public static function doOnEnterFrame(_arg1:MovieClip):void{
			var f:Function;
			var mc = _arg1;
			f = function (_arg1:Object):void{
				if (((("onEnterFrame" in mc)) && (mc.onEnterFrame))){
					mc.onEnterFrame();
				} else {
					_arg1.target.removeEventListener(_arg1.type, arguments.callee);
				};
			};
			mc.addEventListener(Event.ENTER_FRAME, f);
		}

	}
}//package mochi.as3 
Section 164
//MochiCoins (mochi.as3.MochiCoins)
package mochi.as3 {

	public class MochiCoins {

		public static const STORE_HIDE:String = "StoreHide";
		public static const NO_USER:String = "NoUser";
		public static const IO_ERROR:String = "IOError";
		public static const ITEM_NEW:String = "ItemNew";
		public static const ITEM_OWNED:String = "ItemOwned";
		public static const STORE_ITEMS:String = "StoreItems";
		public static const ERROR:String = "Error";
		public static const STORE_SHOW:String = "StoreShow";

		public static var _inventory:MochiInventory;

		public static function triggerEvent(_arg1:String, _arg2:Object):void{
			MochiSocial.triggerEvent(_arg1, _arg2);
		}
		public static function removeEventListener(_arg1:String, _arg2:Function):void{
			MochiSocial.removeEventListener(_arg1, _arg2);
		}
		public static function addEventListener(_arg1:String, _arg2:Function):void{
			MochiSocial.addEventListener(_arg1, _arg2);
		}
		public static function getStoreItems():void{
			MochiServices.send("coins_getStoreItems");
		}
		public static function get inventory():MochiInventory{
			return (_inventory);
		}
		public static function showStore(_arg1:Object=null):void{
			MochiServices.bringToTop();
			MochiServices.send("coins_showStore", {options:_arg1}, null, null);
		}
		public static function showItem(_arg1:Object=null):void{
			if (((!(_arg1)) || (!((typeof(_arg1.item) == "string"))))){
				trace("ERROR: showItem call must pass an Object with an item key");
				return;
			};
			MochiServices.bringToTop();
			MochiServices.send("coins_showItem", {options:_arg1}, null, null);
		}
		public static function getVersion():String{
			return (MochiServices.getVersion());
		}
		public static function showVideo(_arg1:Object=null):void{
			if (((!(_arg1)) || (!((typeof(_arg1.item) == "string"))))){
				trace("ERROR: showVideo call must pass an Object with an item key");
				return;
			};
			MochiServices.bringToTop();
			MochiServices.send("coins_showVideo", {options:_arg1}, null, null);
		}

		MochiSocial.addEventListener(MochiSocial.LOGGED_IN, function (_arg1:Object):void{
			_inventory = new MochiInventory();
		});
		MochiSocial.addEventListener(MochiSocial.LOGGED_OUT, function (_arg1:Object):void{
			_inventory = null;
		});
	}
}//package mochi.as3 
Section 165
//MochiDigits (mochi.as3.MochiDigits)
package mochi.as3 {

	public final class MochiDigits {

		private var Sibling:MochiDigits;
		private var Fragment:Number;
		private var Encoder:Number;

		public function MochiDigits(_arg1:Number=0, _arg2:uint=0):void{
			Encoder = 0;
			setValue(_arg1, _arg2);
		}
		public function set value(_arg1:Number):void{
			setValue(_arg1);
		}
		public function reencode():void{
			var _local1:uint;
			_local1 = int((2147483647 * Math.random()));
			Fragment = (Fragment ^ (_local1 ^ Encoder));
			Encoder = _local1;
		}
		public function toString():String{
			var _local1:String;
			_local1 = String.fromCharCode((Fragment ^ Encoder));
			if (Sibling != null){
				_local1 = (_local1 + Sibling.toString());
			};
			return (_local1);
		}
		public function get value():Number{
			return (Number(this.toString()));
		}
		public function setValue(_arg1:Number=0, _arg2:uint=0):void{
			var _local3:String;
			_local3 = _arg1.toString();
			var _temp1 = _arg2;
			_arg2 = (_arg2 + 1);
			Fragment = (_local3.charCodeAt(_temp1) ^ Encoder);
			if (_arg2 < _local3.length){
				Sibling = new MochiDigits(_arg1, _arg2);
			} else {
				Sibling = null;
			};
			reencode();
		}
		public function addValue(_arg1:Number):void{
			value = (value + _arg1);
		}

	}
}//package mochi.as3 
Section 166
//MochiEventDispatcher (mochi.as3.MochiEventDispatcher)
package mochi.as3 {

	public class MochiEventDispatcher {

		private var eventTable:Object;

		public function MochiEventDispatcher():void{
			eventTable = {};
		}
		public function triggerEvent(_arg1:String, _arg2:Object):void{
			var _local3:Object;
			if (eventTable[_arg1] == undefined){
				return;
			};
			for (_local3 in eventTable[_arg1]) {
				var _local6 = eventTable[_arg1];
				_local6[_local3](_arg2);
			};
		}
		public function removeEventListener(_arg1:String, _arg2:Function):void{
			var _local3:Object;
			if (eventTable[_arg1] == undefined){
				eventTable[_arg1] = [];
				return;
			};
			for (_local3 in eventTable[_arg1]) {
				if (eventTable[_arg1][_local3] != _arg2){
				} else {
					eventTable[_arg1].splice(Number(_local3), 1);
				};
			};
		}
		public function addEventListener(_arg1:String, _arg2:Function):void{
			removeEventListener(_arg1, _arg2);
			eventTable[_arg1].push(_arg2);
		}

	}
}//package mochi.as3 
Section 167
//MochiEvents (mochi.as3.MochiEvents)
package mochi.as3 {
	import flash.display.*;

	public class MochiEvents {

		public static const ALIGN_BOTTOM_LEFT:String = "ALIGN_BL";
		public static const FORMAT_LONG:String = "LongForm";
		public static const ALIGN_BOTTOM:String = "ALIGN_B";
		public static const ACHIEVEMENT_RECEIVED:String = "AchievementReceived";
		public static const FORMAT_SHORT:String = "ShortForm";
		public static const ALIGN_TOP_RIGHT:String = "ALIGN_TR";
		public static const ALIGN_BOTTOM_RIGHT:String = "ALIGN_BR";
		public static const ALIGN_TOP:String = "ALIGN_T";
		public static const ALIGN_LEFT:String = "ALIGN_L";
		public static const ALIGN_RIGHT:String = "ALIGN_R";
		public static const ALIGN_TOP_LEFT:String = "ALIGN_TL";
		public static const ALIGN_CENTER:String = "ALIGN_C";

		private static var _dispatcher:MochiEventDispatcher = new MochiEventDispatcher();
		private static var gameStart:Number;
		private static var levelStart:Number;

		public static function addEventListener(_arg1:String, _arg2:Function):void{
			_dispatcher.addEventListener(_arg1, _arg2);
		}
		public static function removeEventListener(_arg1:String, _arg2:Function):void{
			_dispatcher.removeEventListener(_arg1, _arg2);
		}
		public static function startSession(_arg1:String):void{
			MochiServices.send("events_beginSession", {achievementID:_arg1}, null, null);
		}
		public static function triggerEvent(_arg1:String, _arg2:Object):void{
			_dispatcher.triggerEvent(_arg1, _arg2);
		}
		public static function setNotifications(_arg1:MovieClip, _arg2:Object):void{
			var _local3:Object;
			var _local4:Object;
			_local3 = {};
			for (_local4 in _arg2) {
				_local3[_local4] = _arg2[_local4];
			};
			_local3.clip = _arg1;
			MochiServices.send("events_setNotifications", _local3, null, null);
		}
		public static function endGame():void{
			var _local1:Number;
			_local1 = (new Date().time - gameStart);
			trigger("end_game", {time:_local1});
		}
		public static function startGame():void{
			gameStart = new Date().time;
			trigger("start_game");
		}
		public static function trigger(_arg1:String, _arg2:Object=null):void{
			if (_arg2 == null){
				_arg2 = {};
			} else {
				if (_arg2["kind"] != undefined){
					trace("WARNING: optional arguments package contains key 'id', it will be overwritten");
					_arg2["kind"] = _arg1;
				};
			};
			MochiServices.send("events_triggerEvent", {eventObject:_arg2}, null, null);
		}
		public static function getVersion():String{
			return (MochiServices.getVersion());
		}
		public static function startLevel():void{
			levelStart = new Date().time;
			trigger("start_level");
		}
		public static function endLevel():void{
			var _local1:Number;
			_local1 = (new Date().time - levelStart);
			trigger("end_level", {time:_local1});
		}

	}
}//package mochi.as3 
Section 168
//MochiInventory (mochi.as3.MochiInventory)
package mochi.as3 {
	import flash.events.*;
	import flash.utils.*;

	public dynamic class MochiInventory extends Proxy {

		private var _timer:Timer;
		private var _names:Array;
		private var _consumableProperties:Object;
		private var _syncID:Number;
		private var _storeSync:Object;
		private var _outstandingID:Number;
		private var _syncPending:Boolean;

		public static const READY:String = "InvReady";
		public static const ERROR:String = "Error";
		public static const IO_ERROR:String = "IoError";
		private static const KEY_SALT:String = " syncMaint
";
		public static const WRITTEN:String = "InvWritten";
		public static const NOT_READY:String = "InvNotReady";
		public static const VALUE_ERROR:String = "InvValueError";
		private static const CONSUMER_KEY:String = "MochiConsumables";

		private static var _dispatcher:MochiEventDispatcher = new MochiEventDispatcher();

		public function MochiInventory():void{
			MochiCoins.addEventListener(MochiCoins.ITEM_OWNED, itemOwned);
			MochiCoins.addEventListener(MochiCoins.ITEM_NEW, newItems);
			MochiSocial.addEventListener(MochiSocial.LOGGED_IN, loggedIn);
			MochiSocial.addEventListener(MochiSocial.LOGGED_OUT, loggedOut);
			_storeSync = new Object();
			_syncPending = false;
			_outstandingID = 0;
			_syncID = 0;
			_timer = new Timer(1000);
			_timer.addEventListener(TimerEvent.TIMER, sync);
			_timer.start();
			if (MochiSocial.loggedIn){
				loggedIn();
			} else {
				loggedOut();
			};
		}
		private function newItems(_arg1:Object):void{
			if (!this[(_arg1.id + KEY_SALT)]){
				this[(_arg1.id + KEY_SALT)] = 0;
			};
			if (!this[_arg1.id]){
				this[_arg1.id] = 0;
			};
			this[(_arg1.id + KEY_SALT)] = (this[(_arg1.id + KEY_SALT)] + _arg1.count);
			this[_arg1.id] = (this[_arg1.id] + _arg1.count);
			if (_arg1.privateProperties.consumable){
				if (!this[_arg1.privateProperties.tag]){
					this[_arg1.privateProperties.tag] = 0;
				};
				this[_arg1.privateProperties.tag] = (this[_arg1.privateProperties.tag] + (_arg1.privateProperties.inc * _arg1.count));
			};
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function getProperty(_arg1){
			if (_consumableProperties == null){
				triggerEvent(ERROR, {type:NOT_READY});
				return (-1);
			};
			if (_consumableProperties[_arg1]){
				return (MochiDigits(_consumableProperties[_arg1]).value);
			};
			return (undefined);
		}
		public function release():void{
			MochiCoins.removeEventListener(MochiCoins.ITEM_NEW, newItems);
			MochiSocial.removeEventListener(MochiSocial.LOGGED_IN, loggedIn);
			MochiSocial.removeEventListener(MochiSocial.LOGGED_OUT, loggedOut);
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function hasProperty(_arg1):Boolean{
			if (_consumableProperties == null){
				triggerEvent(ERROR, {type:NOT_READY});
				return (false);
			};
			if (_consumableProperties[_arg1] == undefined){
				return (false);
			};
			return (true);
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function nextNameIndex(_arg1:int):int{
			return (((_arg1)>=_names.length) ? 0 : (_arg1 + 1));
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function setProperty(_arg1, _arg2):void{
			var _local3:MochiDigits;
			if (_consumableProperties == null){
				triggerEvent(ERROR, {type:NOT_READY});
				return;
			};
			if (!(_arg2 is Number)){
				triggerEvent(ERROR, {type:VALUE_ERROR, error:"Invalid type", arg:_arg2});
				return;
			};
			if (_consumableProperties[_arg1]){
				_local3 = MochiDigits(_consumableProperties[_arg1]);
				if (_local3.value == _arg2){
					return;
				};
				_local3.value = _arg2;
			} else {
				_names.push(_arg1);
				_consumableProperties[_arg1] = new MochiDigits(_arg2);
			};
			_syncID++;
		}
		private function sync(_arg1:Event=null):void{
			var _local2:Object;
			var _local3:String;
			if (((_syncPending) || ((_syncID == _outstandingID)))){
				return;
			};
			_outstandingID = _syncID;
			_local2 = {};
			for (_local3 in _consumableProperties) {
				_local2[_local3] = MochiDigits(_consumableProperties[_local3]).value;
			};
			MochiUserData.put(CONSUMER_KEY, _local2, putConsumableBag);
			_syncPending = true;
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function nextName(_arg1:int):String{
			return (_names[(_arg1 - 1)]);
		}
		private function loggedIn(_arg1:Object=null):void{
			MochiUserData.get(CONSUMER_KEY, getConsumableBag);
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function deleteProperty(_arg1):Boolean{
			if (!_consumableProperties[_arg1]){
				return (false);
			};
			_names.splice(_names.indexOf(_arg1), 1);
			delete _consumableProperties[_arg1];
			return (true);
		}
		private function itemOwned(_arg1:Object):void{
			_storeSync[_arg1.id] = {properties:_arg1.properties, count:_arg1.count};
		}
		private function putConsumableBag(_arg1:MochiUserData):void{
			_syncPending = false;
			if (_arg1.error){
				triggerEvent(ERROR, {type:IO_ERROR, error:_arg1.error});
				_outstandingID = -1;
			};
			triggerEvent(WRITTEN, {});
		}
		private function getConsumableBag(_arg1:MochiUserData):void{
			var _local2:String;
			var _local3:Number;
			if (_arg1.error){
				triggerEvent(ERROR, {type:IO_ERROR, error:_arg1.error});
				return;
			};
			_consumableProperties = {};
			_names = new Array();
			if (_arg1.data){
				for (_local2 in _arg1.data) {
					_names.push(_local2);
					_consumableProperties[_local2] = new MochiDigits(_arg1.data[_local2]);
				};
			};
			for (_local2 in _storeSync) {
				_local3 = _storeSync[_local2].count;
				if (_consumableProperties[(_local2 + KEY_SALT)]){
					_local3 = (_local3 - _consumableProperties[_local2]);
				};
				if (_local3 == 0){
				} else {
					newItems({id:_local2, count:_local3, properties:_storeSync[_local2].properties});
				};
			};
			triggerEvent(READY, {});
		}
		private function loggedOut(_arg1:Object=null):void{
			_consumableProperties = null;
		}

		public static function triggerEvent(_arg1:String, _arg2:Object):void{
			_dispatcher.triggerEvent(_arg1, _arg2);
		}
		public static function removeEventListener(_arg1:String, _arg2:Function):void{
			_dispatcher.removeEventListener(_arg1, _arg2);
		}
		public static function addEventListener(_arg1:String, _arg2:Function):void{
			_dispatcher.addEventListener(_arg1, _arg2);
		}

	}
}//package mochi.as3 
Section 169
//MochiServices (mochi.as3.MochiServices)
package mochi.as3 {
	import flash.geom.*;
	import flash.display.*;
	import flash.events.*;
	import flash.utils.*;
	import flash.net.*;
	import flash.system.*;

	public class MochiServices {

		private static var _container:Object;
		private static var _connected:Boolean = false;
		private static var _swfVersion:String;
		private static var _preserved:Object;
		public static var netupAttempted:Boolean = false;
		private static var _sendChannel:LocalConnection;
		public static var servicesSync:MochiSync = new MochiSync();
		private static var _clip:MovieClip;
		private static var _id:String;
		private static var _services:String = "services.swf";
		private static var _servURL:String = "http://www.mochiads.com/static/lib/services/";
		public static var widget:Boolean = false;
		private static var _timer:Timer;
		private static var _sendChannelName:String;
		private static var _loader:Loader;
		private static var _connecting:Boolean = false;
		private static var _mochiLocalConnection:MovieClip;
		private static var _listenChannelName:String = "__ms_";
		public static var onError:Object;
		public static var netup:Boolean = true;
		private static var _mochiLC:String = "MochiLC.swf";

		public static function isNetworkAvailable():Boolean{
			return (!((Security.sandboxType == "localWithFile")));
		}
		public static function get connected():Boolean{
			return (_connected);
		}
		private static function onReceive(_arg1:Object):void{
			var cb:String;
			var cblst:Object;
			var method:*;
			var methodName:String;
			var obj:Object;
			var pkg = _arg1;
			cb = pkg.callbackID;
			cblst = _clip._callbacks[cb];
			if (!cblst){
				return;
			};
			method = cblst.callbackMethod;
			methodName = "";
			obj = cblst.callbackObject;
			if (((obj) && ((typeof(method) == "string")))){
				methodName = method;
				if (obj[method] != null){
					method = obj[method];
				} else {
					trace((("Error: Method  " + method) + " does not exist."));
				};
			};
			if (method != undefined){
				try {
					method.apply(obj, pkg.args);
				} catch(error:Error) {
					trace(((("Error invoking callback method '" + methodName) + "': ") + error.toString()));
				};
			} else {
				if (obj != null){
					try {
						obj(pkg.args);
					} catch(error:Error) {
						trace(("Error invoking method on object: " + error.toString()));
					};
				};
			};
			delete _clip._callbacks[cb];
		}
		public static function get childClip():Object{
			return (_clip);
		}
		public static function send(_arg1:String, _arg2:Object=null, _arg3:Object=null, _arg4:Object=null):void{
			if (_connected){
				_mochiLocalConnection.send(_sendChannelName, "onReceive", {methodName:_arg1, args:_arg2, callbackID:_clip._nextcallbackID});
			} else {
				if ((((_clip == null)) || (!(_connecting)))){
					trace(("Error: MochiServices not connected.   Please call MochiServices.connect().  Function: " + _arg1));
					handleError(_arg2, _arg3, _arg4);
					flush(true);
					return;
				};
				_clip._queue.push({methodName:_arg1, args:_arg2, callbackID:_clip._nextcallbackID});
			};
			if (_clip != null){
				if (((!((_clip._callbacks == null))) && (!((_clip._nextcallbackID == null))))){
					_clip._callbacks[_clip._nextcallbackID] = {callbackObject:_arg3, callbackMethod:_arg4};
					_clip._nextcallbackID++;
				};
			};
		}
		private static function init(_arg1:String, _arg2:Object):void{
			_id = _arg1;
			if (_arg2 != null){
				_container = _arg2;
				loadCommunicator(_arg1, _container);
			};
		}
		private static function clickMovie(_arg1:String, _arg2:Function):MovieClip{
			var _local3:Array;
			var _local4:int;
			var _local5:Array;
			var _local6:Array;
			var _local7:MovieClip;
			var _local8:LocalConnection;
			var _local9:String;
			var _local10:ByteArray;
			var _local11:ByteArray;
			var _local12:uint;
			var _local13:uint;
			var _local14:Loader;
			_local3 = [150, 21, 0, 7, 1, 0, 0, 0, 0, 98, 116, 110, 0, 7, 2, 0, 0, 0, 0, 116, 104, 105, 115, 0, 28, 150, 22, 0, 0, 99, 114, 101, 97, 116, 101, 69, 109, 112, 116, 121, 77, 111, 118, 105, 101, 67, 108, 105, 112, 0, 82, 135, 1, 0, 0, 23, 150, 13, 0, 4, 0, 0, 111, 110, 82, 101, 108, 101, 97, 115, 101, 0, 142, 8, 0, 0, 0, 0, 2, 42, 0, 114, 0, 150, 17, 0, 0, 32, 0, 7, 1, 0, 0, 0, 8, 0, 0, 115, 112, 108, 105, 116, 0, 82, 135, 1, 0, 1, 23, 150, 7, 0, 4, 1, 7, 0, 0, 0, 0, 78, 150, 8, 0, 0, 95, 98, 108, 97, 110, 107, 0, 154, 1, 0, 0, 150, 7, 0, 0, 99, 108, 105, 99, 107, 0, 150, 7, 0, 4, 1, 7, 1, 0, 0, 0, 78, 150, 27, 0, 7, 2, 0, 0, 0, 7, 0, 0, 0, 0, 0, 76, 111, 99, 97, 108, 67, 111, 110, 110, 101, 99, 116, 105, 111, 110, 0, 64, 150, 6, 0, 0, 115, 101, 110, 100, 0, 82, 79, 150, 15, 0, 4, 0, 0, 95, 97, 108, 112, 104, 97, 0, 7, 0, 0, 0, 0, 79, 150, 23, 0, 7, 0xFF, 0, 0xFF, 0, 7, 1, 0, 0, 0, 4, 0, 0, 98, 101, 103, 105, 110, 70, 105, 108, 108, 0, 82, 23, 150, 25, 0, 7, 0, 0, 0, 0, 7, 0, 0, 0, 0, 7, 2, 0, 0, 0, 4, 0, 0, 109, 111, 118, 101, 84, 111, 0, 82, 23, 150, 25, 0, 7, 100, 0, 0, 0, 7, 0, 0, 0, 0, 7, 2, 0, 0, 0, 4, 0, 0, 108, 105, 110, 101, 84, 111, 0, 82, 23, 150, 25, 0, 7, 100, 0, 0, 0, 7, 100, 0, 0, 0, 7, 2, 0, 0, 0, 4, 0, 0, 108, 105, 110, 101, 84, 111, 0, 82, 23, 150, 25, 0, 7, 0, 0, 0, 0, 7, 100, 0, 0, 0, 7, 2, 0, 0, 0, 4, 0, 0, 108, 105, 110, 101, 84, 111, 0, 82, 23, 150, 25, 0, 7, 0, 0, 0, 0, 7, 0, 0, 0, 0, 7, 2, 0, 0, 0, 4, 0, 0, 108, 105, 110, 101, 84, 111, 0, 82, 23, 150, 16, 0, 7, 0, 0, 0, 0, 4, 0, 0, 101, 110, 100, 70, 105, 108, 108, 0, 82, 23];
			_local5 = [104, 0, 31, 64, 0, 7, 208, 0, 0, 12, 1, 0, 67, 2, 0xFF, 0xFF, 0xFF, 63, 3];
			_local6 = [0, 64, 0, 0, 0];
			_local7 = new MovieClip();
			_local8 = new LocalConnection();
			_local9 = ((("_click_" + Math.floor((Math.random() * 999999))) + "_") + Math.floor(new Date().time));
			_local8 = new LocalConnection();
			_local7.lc = _local8;
			_local7.click = _arg2;
			_local8.client = _local7;
			_local8.connect(_local9);
			_local10 = new ByteArray();
			_local11 = new ByteArray();
			_local11.endian = Endian.LITTLE_ENDIAN;
			_local11.writeShort(1);
			_local11.writeUTFBytes(((_arg1 + " ") + _local9));
			_local11.writeByte(0);
			_local12 = ((_local3.length + _local11.length) + 4);
			_local13 = (_local12 + 35);
			_local10.endian = Endian.LITTLE_ENDIAN;
			_local10.writeUTFBytes("FWS");
			_local10.writeByte(8);
			_local10.writeUnsignedInt(_local13);
			for each (_local4 in _local5) {
				_local10.writeByte(_local4);
			};
			_local10.writeUnsignedInt(_local12);
			_local10.writeByte(136);
			_local10.writeShort(_local11.length);
			_local10.writeBytes(_local11);
			for each (_local4 in _local3) {
				_local10.writeByte(_local4);
			};
			for each (_local4 in _local6) {
				_local10.writeByte(_local4);
			};
			_local14 = new Loader();
			_local14.loadBytes(_local10);
			_local7.addChild(_local14);
			return (_local7);
		}
		public static function stayOnTop():void{
			_container.addEventListener(Event.ENTER_FRAME, MochiServices.bringToTop, false, 0, true);
			if (_clip != null){
				_clip.visible = true;
			};
		}
		public static function addLinkEvent(_arg1:String, _arg2:String, _arg3:DisplayObjectContainer, _arg4:Function=null):void{
			var vars:Object;
			var avm1Click:DisplayObject;
			var s:String;
			var i:Number;
			var x:String;
			var req:URLRequest;
			var loader:Loader;
			var setURL:Function;
			var err:Function;
			var complete:Function;
			var url = _arg1;
			var burl = _arg2;
			var btn = _arg3;
			var onClick = _arg4;
			vars = new Object();
			vars["mav"] = getVersion();
			vars["swfv"] = "9";
			vars["swfurl"] = btn.loaderInfo.loaderURL;
			vars["fv"] = Capabilities.version;
			vars["os"] = Capabilities.os;
			vars["lang"] = Capabilities.language;
			vars["scres"] = ((Capabilities.screenResolutionX + "x") + Capabilities.screenResolutionY);
			s = "?";
			i = 0;
			for (x in vars) {
				if (i != 0){
					s = (s + "&");
				};
				i = (i + 1);
				s = (((s + x) + "=") + escape(vars[x]));
			};
			req = new URLRequest("http://x.mochiads.com/linkping.swf");
			loader = new Loader();
			setURL = function (_arg1:String):void{
				var _local2:Rectangle;
				if (avm1Click){
					btn.removeChild(avm1Click);
				};
				avm1Click = clickMovie(_arg1, onClick);
				_local2 = btn.getBounds(btn);
				btn.addChild(avm1Click);
				avm1Click.x = _local2.x;
				avm1Click.y = _local2.y;
				avm1Click.scaleX = (0.01 * _local2.width);
				avm1Click.scaleY = (0.01 * _local2.height);
			};
			err = function (_arg1:Object):void{
				netup = false;
				_arg1.target.removeEventListener(_arg1.type, arguments.callee);
				setURL(burl);
			};
			complete = function (_arg1:Object):void{
				_arg1.target.removeEventListener(_arg1.type, arguments.callee);
			};
			if (netup){
				setURL((url + s));
			} else {
				setURL(burl);
			};
			if (!((netupAttempted) || (_connected))){
				netupAttempted = true;
				loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, err);
				loader.contentLoaderInfo.addEventListener(Event.COMPLETE, complete);
				loader.load(req);
			};
		}
		public static function warnID(_arg1:String, _arg2:Boolean):void{
			var _local3:Number;
			_arg1 = _arg1.toLowerCase();
			if (_arg1.length != 16){
				trace((("WARNING: " + (_arg2) ? "board" : "game") + " ID is not the appropriate length"));
				return;
			} else {
				if (_arg1 == "1e113c7239048b3f"){
					if (_arg2){
						trace("WARNING: Using testing board ID");
					} else {
						trace("WARNING: Using testing board ID as game ID");
					};
					return;
				} else {
					if (_arg1 == "84993a1de4031cd8"){
						if (_arg2){
							trace("WARNING: Using testing game ID as board ID");
						} else {
							trace("WARNING: Using testing game ID");
						};
						return;
					};
				};
			};
			_local3 = 0;
			while (_local3 < _arg1.length) {
				switch (_arg1.charAt(_local3)){
					case "0":
					case "1":
					case "2":
					case "3":
					case "4":
					case "5":
					case "6":
					case "7":
					case "8":
					case "9":
					case "a":
					case "b":
					case "c":
					case "d":
					case "e":
					case "f":
						break;
					default:
						trace(("WARNING: Board ID contains illegal characters: " + _arg1));
						return;
				};
				_local3++;
			};
		}
		public static function disconnect():void{
			if (((_connected) || (_connecting))){
				if (_clip != null){
					if (_clip.parent != null){
						if ((_clip.parent is Sprite)){
							Sprite(_clip.parent).removeChild(_clip);
							_clip = null;
						};
					};
				};
				_connecting = (_connected = false);
				flush(true);
				try {
					_mochiLocalConnection.close();
				} catch(error:Error) {
				};
			};
			if (_timer != null){
				try {
					_timer.stop();
				} catch(error:Error) {
				};
			};
		}
		public static function allowDomains(_arg1:String):String{
			var _local2:String;
			if (Security.sandboxType != "application"){
				Security.allowDomain("*");
				Security.allowInsecureDomain("*");
			};
			if (_arg1.indexOf("http://") != -1){
				_local2 = _arg1.split("/")[2].split(":")[0];
				if (Security.sandboxType != "application"){
					Security.allowDomain(_local2);
					Security.allowInsecureDomain(_local2);
				};
			};
			return (_local2);
		}
		public static function getVersion():String{
			return ("3.7 as3");
		}
		public static function doClose():void{
			_container.removeEventListener(Event.ENTER_FRAME, MochiServices.bringToTop);
		}
		private static function flush(_arg1:Boolean):void{
			var _local2:Object;
			var _local3:Object;
			if (((_clip) && (_clip._queue))){
				while (_clip._queue.length > 0) {
					_local2 = _clip._queue.shift();
					_local3 = null;
					if (_local2 != null){
						if (_local2.callbackID != null){
							_local3 = _clip._callbacks[_local2.callbackID];
						};
						delete _clip._callbacks[_local2.callbackID];
						if (((_arg1) && (!((_local3 == null))))){
							handleError(_local2.args, _local3.callbackObject, _local3.callbackMethod);
						};
					};
				};
			};
		}
		public static function get id():String{
			return (_id);
		}
		private static function onEvent(_arg1:Object):void{
			var _local2:String;
			var _local3:String;
			_local2 = _arg1.target;
			_local3 = _arg1.event;
			switch (_local2){
				case "events":
					MochiEvents.triggerEvent(_arg1.event, _arg1.args);
					break;
				case "coins":
					MochiCoins.triggerEvent(_arg1.event, _arg1.args);
					break;
				case "sync":
					servicesSync.triggerEvent(_arg1.event, _arg1.args);
					break;
			};
		}
		private static function urlOptions(_arg1:Object):Object{
			var _local2:Object;
			var _local3:String;
			var _local4:Array;
			var _local5:Number;
			var _local6:Array;
			_local2 = {};
			if (_arg1.stage){
				_local3 = _arg1.stage.loaderInfo.parameters.mochiad_options;
			} else {
				_local3 = _arg1.loaderInfo.parameters.mochiad_options;
			};
			if (_local3){
				_local4 = _local3.split("&");
				_local5 = 0;
				while (_local5 < _local4.length) {
					_local6 = _local4[_local5].split("=");
					_local2[unescape(_local6[0])] = unescape(_local6[1]);
					_local5++;
				};
			};
			return (_local2);
		}
		public static function setContainer(_arg1:Object=null, _arg2:Boolean=true):void{
			if (_arg1 != null){
				if ((_arg1 is Sprite)){
					_container = _arg1;
				};
			};
			if (_arg2){
				if ((_container is Sprite)){
					Sprite(_container).addChild(_clip);
				};
			};
		}
		private static function handleError(_arg1:Object, _arg2:Object, _arg3:Object):void{
			var args = _arg1;
			var callbackObject = _arg2;
			var callbackMethod = _arg3;
			if (args != null){
				if (args.onError != null){
					args.onError.apply(null, ["NotConnected"]);
				};
				if (((!((args.options == null))) && (!((args.options.onError == null))))){
					args.options.onError.apply(null, ["NotConnected"]);
				};
			};
			if (callbackMethod != null){
				args = {};
				args.error = true;
				args.errorCode = "NotConnected";
				if (((!((callbackObject == null))) && ((callbackMethod is String)))){
					try {
						var _local5 = callbackObject;
						_local5[callbackMethod](args);
					} catch(error:Error) {
					};
				} else {
					if (callbackMethod != null){
						try {
							callbackMethod.apply(args);
						} catch(error:Error) {
						};
					};
				};
			};
		}
		private static function loadError(_arg1:Object):void{
			_clip._mochiad_ctr_failed = true;
			trace("MochiServices could not load.");
			MochiServices.disconnect();
			MochiServices.onError("IOError");
		}
		private static function initComChannels():void{
			if (!_connected){
				trace("[SERVICES_API] connected!");
				_connecting = false;
				_connected = true;
				_mochiLocalConnection.send(_sendChannelName, "onReceive", {methodName:"handshakeDone"});
				_mochiLocalConnection.send(_sendChannelName, "onReceive", {methodName:"registerGame", preserved:_preserved, id:_id, version:getVersion(), parentURL:_container.loaderInfo.loaderURL});
				_clip.onReceive = onReceive;
				_clip.onEvent = onEvent;
				_clip.onError = function ():void{
					MochiServices.onError("IOError");
				};
				while (_clip._queue.length > 0) {
					_mochiLocalConnection.send(_sendChannelName, "onReceive", _clip._queue.shift());
				};
			};
		}
		private static function loadLCBridge(_arg1:Object):void{
			var loader:Loader;
			var mochiLCURL:String;
			var req:URLRequest;
			var complete:Function;
			var clip = _arg1;
			loader = new Loader();
			mochiLCURL = (_servURL + _mochiLC);
			req = new URLRequest(mochiLCURL);
			complete = function (_arg1:Object):void{
				_mochiLocalConnection = MovieClip(loader.content);
				listen();
			};
			loader.contentLoaderInfo.addEventListener(Event.COMPLETE, complete);
			loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, loadError);
			loader.load(req);
			clip.addChild(loader);
		}
		private static function listen():void{
			_mochiLocalConnection.connect(_listenChannelName);
			_clip.handshake = function (_arg1:Object):void{
				MochiServices.comChannelName = _arg1.newChannel;
			};
			trace("Waiting for MochiAds services to connect...");
		}
		public static function get clip():Object{
			return (_container);
		}
		public static function set comChannelName(_arg1:String):void{
			if (_arg1 != null){
				if (_arg1.length > 3){
					_sendChannelName = (_arg1 + "_fromgame");
					initComChannels();
				};
			};
		}
		private static function loadCommunicator(_arg1:String, _arg2:Object):MovieClip{
			var _local3:String;
			var _local4:String;
			var _local5:URLRequest;
			var _local6:URLVariables;
			_local3 = ("_mochiservices_com_" + _arg1);
			if (_clip != null){
				return (_clip);
			};
			if (!MochiServices.isNetworkAvailable()){
				return (null);
			};
			if (urlOptions(_arg2).servURL){
				_servURL = urlOptions(_arg2).servURL;
			};
			_local4 = (_servURL + _services);
			if (urlOptions(_arg2).servicesURL){
				_local4 = urlOptions(_arg2).servicesURL;
			};
			_listenChannelName = (_listenChannelName + ((Math.floor(new Date().time) + "_") + Math.floor((Math.random() * 99999))));
			MochiServices.allowDomains(_local4);
			_clip = createEmptyMovieClip(_arg2, _local3, 10336, false);
			loadLCBridge(_clip);
			_loader = new Loader();
			_loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, loadError);
			_local5 = new URLRequest(_local4);
			_local6 = new URLVariables();
			_local6.listenLC = _listenChannelName;
			_local6.mochiad_options = _arg2.loaderInfo.parameters.mochiad_options;
			_local6.api_version = getVersion();
			if (widget){
				_local6.widget = true;
			};
			_local5.data = _local6;
			_loader.load(_local5);
			_clip.addChild(_loader);
			_clip._mochiservices_com = _loader;
			_sendChannel = new LocalConnection();
			_clip._queue = [];
			_clip._nextcallbackID = 0;
			_clip._callbacks = {};
			_timer = new Timer(10000, 1);
			_timer.addEventListener(TimerEvent.TIMER, connectWait);
			_timer.start();
			return (_clip);
		}
		public static function connect(_arg1:String, _arg2:Object, _arg3:Object=null):void{
			var id = _arg1;
			var clip = _arg2;
			var onError = _arg3;
			warnID(id, false);
			if ((clip is DisplayObject)){
				if (clip.stage == null){
					trace("MochiServices connect requires the containing clip be attached to the stage");
				};
				if (((!(_connected)) && ((_clip == null)))){
					trace("MochiServices Connecting...");
					_connecting = true;
					init(id, clip);
				};
			} else {
				trace("Error, MochiServices requires a Sprite, Movieclip or instance of the stage.");
			};
			if (onError != null){
				MochiServices.onError = onError;
			} else {
				if (MochiServices.onError == null){
					MochiServices.onError = function (_arg1:String):void{
						trace(_arg1);
					};
				};
			};
		}
		public static function createEmptyMovieClip(_arg1:Object, _arg2:String, _arg3:Number, _arg4:Boolean=true):MovieClip{
			var mc:MovieClip;
			var parent = _arg1;
			var name = _arg2;
			var depth = _arg3;
			var doAdd = _arg4;
			mc = new MovieClip();
			if (doAdd){
				if (((false) && (depth))){
					parent.addChildAt(mc, depth);
				} else {
					parent.addChild(mc);
				};
			};
			try {
				parent[name] = mc;
			} catch(e:Error) {
				throw (new Error("MochiServices requires a clip that is an instance of a dynamic class.  If your class extends Sprite or MovieClip, you must make it dynamic."));
			};
			mc["_name"] = name;
			return (mc);
		}
		public static function bringToTop(_arg1:Event=null):void{
			var e = _arg1;
			if (((!((MochiServices.clip == null))) && (!((MochiServices.childClip == null))))){
				try {
					if (MochiServices.clip.numChildren > 1){
						MochiServices.clip.setChildIndex(MochiServices.childClip, (MochiServices.clip.numChildren - 1));
					};
				} catch(errorObject:Error) {
					trace("Warning: Depth sort error.");
					_container.removeEventListener(Event.ENTER_FRAME, MochiServices.bringToTop);
				};
			};
		}
		public static function connectWait(_arg1:TimerEvent):void{
			if (!_connected){
				_clip._mochiad_ctr_failed = true;
				trace("MochiServices could not load. (timeout)");
				MochiServices.disconnect();
				MochiServices.onError("IOError");
			};
		}

	}
}//package mochi.as3 
Section 170
//MochiSocial (mochi.as3.MochiSocial)
package mochi.as3 {

	public class MochiSocial {

		public static const LOGGED_IN:String = "LoggedIn";
		public static const PROFILE_HIDE:String = "ProfileHide";
		public static const NO_USER:String = "NoUser";
		public static const PROPERTIES_SIZE:String = "PropertiesSize";
		public static const IO_ERROR:String = "IOError";
		public static const PROPERTIES_SAVED:String = "PropertySaved";
		public static const WIDGET_LOADED:String = "WidgetLoaded";
		public static const USER_INFO:String = "UserInfo";
		public static const ERROR:String = "Error";
		public static const LOGIN_SHOW:String = "LoginShow";
		public static const LOGGED_OUT:String = "LoggedOut";
		public static const PROFILE_SHOW:String = "ProfileShow";
		public static const LOGIN_SHOWN:String = "LoginShown";
		public static const LOGIN_HIDE:String = "LoginHide";

		private static var _dispatcher:MochiEventDispatcher = new MochiEventDispatcher();
		public static var _user_info:Object = null;

		public static function getVersion():String{
			return (MochiServices.getVersion());
		}
		public static function saveUserProperties(_arg1:Object):void{
			MochiServices.send("coins_saveUserProperties", _arg1);
		}
		public static function get loggedIn():Boolean{
			return (!((_user_info == null)));
		}
		public static function triggerEvent(_arg1:String, _arg2:Object):void{
			_dispatcher.triggerEvent(_arg1, _arg2);
		}
		public static function addEventListener(_arg1:String, _arg2:Function):void{
			_dispatcher.addEventListener(_arg1, _arg2);
		}
		public static function getUserInfo():void{
			MochiServices.send("coins_getUserInfo");
		}
		public static function showLoginWidget(_arg1:Object=null):void{
			MochiServices.setContainer();
			MochiServices.bringToTop();
			MochiServices.send("coins_showLoginWidget", {options:_arg1});
		}
		public static function removeEventListener(_arg1:String, _arg2:Function):void{
			_dispatcher.removeEventListener(_arg1, _arg2);
		}
		public static function requestLogin():void{
			MochiServices.send("coins_requestLogin");
		}
		public static function getAPIURL():String{
			if (!_user_info){
				return (null);
			};
			return (_user_info.api_url);
		}
		public static function hideLoginWidget():void{
			MochiServices.send("coins_hideLoginWidget");
		}
		public static function getAPIToken():String{
			if (!_user_info){
				return (null);
			};
			return (_user_info.api_token);
		}

		MochiSocial.addEventListener(MochiSocial.LOGGED_IN, function (_arg1:Object):void{
			_user_info = _arg1;
		});
		MochiSocial.addEventListener(MochiSocial.LOGGED_OUT, function (_arg1:Object):void{
			_user_info = null;
		});
	}
}//package mochi.as3 
Section 171
//MochiSync (mochi.as3.MochiSync)
package mochi.as3 {
	import flash.utils.*;

	public dynamic class MochiSync extends Proxy {

		private var _syncContainer:Object;

		public static var SYNC_PROPERTY:String = "UpdateProperty";
		public static var SYNC_REQUEST:String = "SyncRequest";

		public function MochiSync():void{
			_syncContainer = {};
		}
		public function triggerEvent(_arg1:String, _arg2:Object):void{
			switch (_arg1){
				case SYNC_REQUEST:
					MochiServices.send("sync_syncronize", _syncContainer);
					break;
				case SYNC_PROPERTY:
					_syncContainer[_arg2.name] = _arg2.value;
					break;
			};
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function getProperty(_arg1){
			return (_syncContainer[_arg1]);
		}
		override "http://www.adobe.com/2006/actionscript/flash/proxy"?? function setProperty(_arg1, _arg2):void{
			var _local3:String;
			if (_syncContainer[_arg1] == _arg2){
				return;
			};
			_local3 = _arg1.toString();
			_syncContainer[_local3] = _arg2;
			MochiServices.send("sync_propUpdate", {name:_local3, value:_arg2});
		}

	}
}//package mochi.as3 
Section 172
//MochiUserData (mochi.as3.MochiUserData)
package mochi.as3 {
	import flash.events.*;
	import flash.utils.*;
	import flash.net.*;

	public class MochiUserData extends EventDispatcher {

		public var callback:Function;// = null
		public var error:Event;// = null
		public var key:String;// = null
		public var operation:String;// = null
		public var data;// = null
		public var _loader:URLLoader;

		public function MochiUserData(_arg1:String="", _arg2:Function=null){
			key = null;
			data = null;
			error = null;
			operation = null;
			callback = null;
			super();
			this.key = _arg1;
			this.callback = _arg2;
		}
		public function securityErrorHandler(_arg1:SecurityErrorEvent):void{
			errorHandler(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, ("security error: " + _arg1.toString())));
		}
		public function putEvent(_arg1):void{
			request("put", serialize(_arg1));
		}
		public function request(_arg1:String, _arg2:ByteArray):void{
			var api_url:String;
			var api_token:String;
			var args:URLVariables;
			var req:URLRequest;
			var _operation = _arg1;
			var _data = _arg2;
			operation = _operation;
			api_url = MochiSocial.getAPIURL();
			api_token = MochiSocial.getAPIToken();
			if ((((api_url == null)) || ((api_token == null)))){
				errorHandler(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, "not logged in"));
				return;
			};
			_loader = new URLLoader();
			args = new URLVariables();
			args.op = _operation;
			args.key = key;
			req = new URLRequest((((MochiSocial.getAPIURL() + "/") + "MochiUserData?") + args.toString()));
			req.method = URLRequestMethod.POST;
			req.contentType = "application/x-mochi-userdata";
			req.requestHeaders = [new URLRequestHeader("x-mochi-services-version", MochiServices.getVersion()), new URLRequestHeader("x-mochi-api-token", api_token)];
			req.data = _data;
			_loader.dataFormat = URLLoaderDataFormat.BINARY;
			_loader.addEventListener(Event.COMPLETE, completeHandler);
			_loader.addEventListener(IOErrorEvent.IO_ERROR, errorHandler);
			_loader.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
			try {
				_loader.load(req);
			} catch(e:SecurityError) {
				errorHandler(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, ("security error: " + e.toString())));
			};
		}
		public function completeHandler(_arg1:Event):void{
			var event = _arg1;
			try {
				if (_loader.data.length){
					data = deserialize(_loader.data);
				} else {
					data = null;
				};
			} catch(e:Error) {
				errorHandler(new IOErrorEvent(IOErrorEvent.IO_ERROR, false, false, ("deserialize error: " + e.toString())));
				return;
			};
			if (callback != null){
				performCallback();
			} else {
				dispatchEvent(event);
			};
			close();
		}
		public function performCallback():void{
			try {
				callback(this);
			} catch(e:Error) {
				trace(("[MochiUserData] exception during callback: " + e));
			};
		}
		public function serialize(_arg1):ByteArray{
			var _local2:ByteArray;
			_local2 = new ByteArray();
			_local2.objectEncoding = ObjectEncoding.AMF3;
			_local2.writeObject(_arg1);
			_local2.compress();
			return (_local2);
		}
		public function errorHandler(_arg1:IOErrorEvent):void{
			data = null;
			error = _arg1;
			if (callback != null){
				performCallback();
			} else {
				dispatchEvent(_arg1);
			};
			close();
		}
		public function getEvent():void{
			request("get", serialize(null));
		}
		override public function toString():String{
			return ((((((((("[MochiUserData operation=" + operation) + " key=\"") + key) + "\" data=") + data) + " error=\"") + error) + "\"]"));
		}
		public function close():void{
			if (_loader){
				_loader.removeEventListener(Event.COMPLETE, completeHandler);
				_loader.removeEventListener(IOErrorEvent.IO_ERROR, errorHandler);
				_loader.removeEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
				_loader.close();
				_loader = null;
			};
			error = null;
			callback = null;
		}
		public function deserialize(_arg1:ByteArray){
			_arg1.objectEncoding = ObjectEncoding.AMF3;
			_arg1.uncompress();
			return (_arg1.readObject());
		}

		public static function get(_arg1:String, _arg2:Function):void{
			var _local3:MochiUserData;
			_local3 = new MochiUserData(_arg1, _arg2);
			_local3.getEvent();
		}
		public static function put(_arg1:String, _arg2, _arg3:Function):void{
			var _local4:MochiUserData;
			_local4 = new MochiUserData(_arg1, _arg3);
			_local4.putEvent(_arg2);
		}

	}
}//package mochi.as3 
Section 173
//Application (Application)
package {
	import away3d.primitives.*;
	import flash.display.*;
	import flash.events.*;
	import away3d.containers.*;
	import away3d.cameras.*;
	import away3d.primitives.data.*;
	import away3d.materials.*;
	import away3d.core.render.*;
	import flash.utils.*;
	import mochi.as3.*;
	import away3d.events.*;
	import flash.net.*;
	import flash.text.*;
	import flash.media.*;
	import away3d.core.filter.*;
	import fl.transitions.easing.*;

	public class Application extends MovieClip {

		private var rotationIndex:Number;// = 0
		private var lastTiltAngle:Number;
		public var startView:StartViewMc;
		private var cubePressed:Boolean;// = false
		private var rotationQueue:Array;
		private var delMouseX:Number;
		private var delMouseY:Number;
		private var center:Number;// = 0
		public var timeTxt:TextField;
		private var rotationInterval:Number;// = 0
		private var scene:Scene3D;
		private var lastMouseY:Number;
		public var nextLevelView:NextLevelViewMc;
		private var lastMouseX:Number;
		public var shuffleBtn:SimpleButton;
		private var view:View3D;
		private var centerExtremum:Number;// = 0
		public var cubeDimension:Number;// = 0
		private var cubesArr:Array;
		public var vscroll:VScroll;
		private var renderer:BasicRenderer;
		private var currentAngle:Number;// = 0
		public var back:MovieClip;
		private var lastPanAngle:Number;
		public var stopBtn:SimpleButton;
		private var camera:HoverCamera3D;
		private var curTime:Number;// = 0
		public var hscroll:HScroll;
		private var cubesObj:Object;
		private var cubesSpan:Number;// = 2
		private var cubeSideSize:Number;// = 0
		private var maxCubeSize:Number;// = 150
		private var timeTimerInterval:Number;// = 0
		private var stepAngle:Number;// = 5
		private var gameStopped:Boolean;// = false
		private var timerStarted:Boolean;// = false
		public var saveBtn:SimpleButton;
		private var minMouseDel:Number;// = 100
		private var lastPart:Number;
		public var instructions:InstructionsMc;
		public var muteUnmute:MovieClip;
		private var posExtremum:Number;// = 0
		private var lastCubePressed:Cube;
		private var cubRots:Array;
		private var lst:Number;// = 0
		private var move:Boolean;// = false
		public var loadGame:LoadGame;
		private var rotationAngle:Number;

		public static var app:Application;
		public static var isSoundOn:Boolean = true;
		private static var levelSound:Sound = null;
		private static var mainSoundChannel:SoundChannel = null;
		private static var _rotationSoundChannel:SoundChannel = null;
		private static var _rotationSound:Sound = null;
		public static var soundVol:Number = 1;
		private static var mainSound:Sound = null;

		public function Application(){
			maxCubeSize = 150;
			cubeSideSize = 0;
			cubeDimension = 0;
			cubesSpan = 2;
			posExtremum = 0;
			centerExtremum = 0;
			center = 0;
			lst = 0;
			move = false;
			cubePressed = false;
			minMouseDel = 100;
			rotationInterval = 0;
			currentAngle = 0;
			stepAngle = 5;
			rotationIndex = 0;
			timerStarted = false;
			timeTimerInterval = 0;
			curTime = 0;
			gameStopped = false;
			super();
			app = this;
			stage.align = StageAlign.TOP_LEFT;
			stage.scaleMode = StageScaleMode.EXACT_FIT;
			cubesArr = new Array();
			cubesObj = new Object();
			rotationQueue = new Array();
			initEngine();
			initListeners();
			camera.hover();
			view.render();
			hscroll.visible = false;
			vscroll.visible = false;
			timeTxt.visible = false;
			stopBtn.visible = false;
			shuffleBtn.visible = false;
			saveBtn.visible = false;
			muteUnmute.visible = false;
			stopBtn.addEventListener(MouseEvent.CLICK, stopBtnClickHandler);
			shuffleBtn.addEventListener(MouseEvent.CLICK, shuffleBtnClickHandler);
			saveBtn.addEventListener(MouseEvent.CLICK, saveBtnClickHandler);
			mainSound = new MainSound();
			levelSound = new LevelSound();
			soundOn();
			MochiAd.showPreGameAd({clip:startView, id:"51c1df8a6e4df379", res:"600x500", background:0xD5AA00, color:26367, outline:0xB30000, no_bg:false});
		}
		public function showMenu():void{
			removeCube();
			startView.x = 0;
			startView.y = 0;
			hscroll.visible = false;
			vscroll.visible = false;
			timeTxt.visible = false;
			stopBtn.visible = false;
			shuffleBtn.visible = false;
			saveBtn.visible = false;
			muteUnmute.visible = false;
		}
		private function enterFrameHandler(_arg1:Event=null):void{
			if (((!(cubePressed)) && (move))){
				camera.targetpanangle = ((0.5 * (back.mouseX - lastMouseX)) + lastPanAngle);
				camera.targettiltangle = ((0.5 * (back.mouseY - lastMouseY)) + lastTiltAngle);
				if (camera.targetpanangle > 0){
					rotationIndex = Math.floor(((camera.targetpanangle + 180) / 360));
				} else {
					rotationIndex = Math.ceil(((camera.targetpanangle - 180) / 360));
				};
				hscroll.percent = ((camera.targetpanangle % 360) / 360);
				vscroll.percent = (Math.min(Math.max(camera.targettiltangle, -90), 90) / 180);
			};
			camera.hover();
			view.render();
		}
		private function cubePropsArr():Array{
			var _local1:Array;
			var _local2:Number;
			_local1 = new Array();
			_local2 = 0;
			while (_local2 < cubesArr.length) {
				_local1.push(getCubePropsByCube(cubesArr[_local2]));
				_local2++;
			};
			return (_local1);
		}
		private function startTimeTimer():void{
			timeTimerInterval = setInterval(timeTimer, 10);
		}
		private function stageCubeMouseUpHandler(_arg1:MouseEvent=null):void{
			removeEventListener(MouseEvent.MOUSE_MOVE, stageCubeMouseMoveHandler);
			removeEventListener(MouseEvent.MOUSE_UP, stageCubeMouseUpHandler);
		}
		public function changeCamX(_arg1:Number):void{
			var _local2:Number;
			_local2 = ((_arg1 - 0.5) * 360);
			camera.targetpanangle = ((360 * rotationIndex) + _local2);
		}
		public function changeCamY(_arg1:Number):void{
			var _local2:Number;
			_local2 = ((_arg1 - 0.5) * 180);
			camera.targettiltangle = _local2;
		}
		private function getRandomRotation():Object{
			var _local1:Object;
			var _local2:Number;
			_local1 = new Object();
			_local2 = Math.round((Math.random() * 2));
			_local1.keyPar = ((_local2 == 0)) ? "x" : ((_local2 == 1)) ? "y" : "z";
			_local1.rPar = ("rotation" + String(_local1.keyPar).toUpperCase());
			_local2 = Math.round((Math.random() * (cubeDimension - 1)));
			_local1.keyParVal = ((_local2 - center) * (cubeSideSize + cubesSpan));
			_local2 = Math.round((Math.random() * 1));
			_local1.angle = ((_local2 == 0)) ? 90 : -90;
			switch (_local1.keyPar){
				case "x":
					_local1.xPar = "y";
					_local1.yPar = "z";
					break;
				case "y":
					_local1.xPar = "x";
					_local1.yPar = "z";
					break;
				case "z":
					_local1.xPar = "y";
					_local1.yPar = "x";
					break;
			};
			return (_local1);
		}
		private function getPart(_arg1:Number, _arg2:Number, _arg3:Number):Number{
			if (Math.round(_arg3) == posExtremum){
				return (1);
			};
			if (Math.round(_arg3) == -(posExtremum)){
				return (2);
			};
			if (Math.round(_arg1) == posExtremum){
				return (3);
			};
			if (Math.round(_arg1) == -(posExtremum)){
				return (4);
			};
			if (Math.round(_arg2) == posExtremum){
				return (5);
			};
			if (Math.round(_arg2) == -(posExtremum)){
				return (6);
			};
			return (0);
		}
		private function timeTimer():void{
			var _local1:Number;
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			curTime = (curTime + 10);
			_local1 = Math.floor((curTime / ((1000 * 60) * 60)));
			_local2 = Math.floor((curTime / (1000 * 60)));
			_local3 = Math.floor((curTime / 1000));
			_local4 = Math.round(((curTime % 1000) / 100));
			timeTxt.text = ((((((((_local1 > 9)) ? ("" + _local1) : ("0" + _local1) + ":") + ((_local2 > 9)) ? ("" + _local2) : ("0" + _local2)) + ":") + ((_local3 > 9)) ? ("" + _local3) : ("0" + _local3)) + ":") + ((_local4 > 9)) ? ("" + _local4) : ("0" + _local4));
		}
		private function getCubeMaterialByString(_arg1:String):ColorMaterial{
			switch (_arg1){
				case "white":
					return (new ColorMaterial(0xF0F0F0));
				case "red":
					return (new ColorMaterial(0xB30000));
				case "blue":
					return (new ColorMaterial(26367));
				case "green":
					return (new ColorMaterial(0x4800));
				case "yello":
					return (new ColorMaterial(0xD5AA00));
				case "lilac":
					return (new ColorMaterial(0x330066));
				case "inviz":
					return (new ColorMaterial(0));
			};
			return (new ColorMaterial(0));
		}
		private function getStringByColorMaterial(_arg1:ITriangleMaterial):String{
			switch (_arg1["color"]){
				case 0xF0F0F0:
					return ("white");
				case 0xB30000:
					return ("red");
				case 26367:
					return ("blue");
				case 0x4800:
					return ("green");
				case 0xD5AA00:
					return ("yello");
				case 0x330066:
					return ("lilac");
				case 0:
					return ("inviz");
			};
			return ("inviz");
		}
		private function stopTimeTimer():void{
			clearInterval(timeTimerInterval);
			curTime = 0;
		}
		private function cubeMouseUpHandler(_arg1:MouseEvent3D):void{
			stageCubeMouseUpHandler();
			mouseUpHandler();
		}
		private function stageMouseLeaveHandler(_arg1:Event):void{
			move = false;
			stage.removeEventListener(Event.MOUSE_LEAVE, stageMouseLeaveHandler);
		}
		private function mouseDownHandler(_arg1:MouseEvent):void{
			lastPanAngle = camera.targetpanangle;
			lastTiltAngle = camera.targettiltangle;
			lastMouseX = back.mouseX;
			lastMouseY = back.mouseY;
			move = true;
			stage.addEventListener(Event.MOUSE_LEAVE, stageMouseLeaveHandler);
		}
		private function finishLevel():void{
			rotationQueue = new Array();
			stopTimeTimer();
			timerStarted = false;
			curTime = 0;
			hscroll.visible = false;
			vscroll.visible = false;
			timeTxt.visible = false;
			stopBtn.visible = false;
			shuffleBtn.visible = false;
			saveBtn.visible = false;
			muteUnmute.visible = false;
			if (app.getChildAt((app.numChildren - 1)) != nextLevelView){
				app.swapChildren(nextLevelView, app.getChildAt((app.numChildren - 1)));
			};
			nextLevelView.x = 0;
			nextLevelView.y = 0;
			nextLevelView.refresh();
			timeTxt.text = "00:00:00:00";
			gameStopped = true;
		}
		private function cubeMouseDownHandler(_arg1:MouseEvent3D):void{
			lastPart = getPart(_arg1.sceneX, _arg1.sceneY, _arg1.sceneZ);
			lastCubePressed = (_arg1.object as Cube);
			cubePressed = true;
			lastMouseX = back.mouseX;
			lastMouseY = back.mouseY;
			addEventListener(MouseEvent.MOUSE_MOVE, stageCubeMouseMoveHandler);
			addEventListener(MouseEvent.MOUSE_UP, stageCubeMouseUpHandler);
		}
		private function stageCubeMouseMoveHandler(_arg1:MouseEvent):void{
			var _local2:Number;
			var _local3:Number;
			var _local4:Number;
			var _local5:Number;
			delMouseX = (back.mouseX - lastMouseX);
			delMouseY = (back.mouseY - lastMouseY);
			if ((((Math.abs(delMouseX) < minMouseDel)) && ((Math.abs(delMouseY) < minMouseDel)))){
				return;
			};
			_local2 = 90;
			_local3 = 90;
			if (delMouseX > 0){
				_local2 = -90;
			};
			if (delMouseY > 0){
				_local3 = -90;
			};
			switch (lastPart){
				case 1:
					case1(delMouseX, delMouseY, _local2, _local3);
					break;
				case 2:
					case2(delMouseX, delMouseY, _local2, _local3);
					break;
				case 3:
					case3(delMouseX, delMouseY, _local2, _local3);
					break;
				case 4:
					case4(delMouseX, delMouseY, _local2, _local3);
					break;
				case 5:
					_local4 = (((camera.targetpanangle % 360) + 360) % 360);
					case5(delMouseX, delMouseY, _local2, _local3, _local4);
					break;
				case 6:
					_local5 = (((camera.targetpanangle % 360) + 360) % 360);
					case6(delMouseX, delMouseY, _local2, _local3, _local5);
					break;
			};
			stageCubeMouseUpHandler();
		}
		private function checkForReadiness():void{
			var _local1:Array;
			var _local2:Array;
			var _local3:Array;
			var _local4:Array;
			var _local5:Array;
			var _local6:Array;
			var _local7:Number;
			var _local8:Boolean;
			_local1 = new Array();
			_local2 = new Array();
			_local3 = new Array();
			_local4 = new Array();
			_local5 = new Array();
			_local6 = new Array();
			_local7 = 0;
			while (_local7 < cubesArr.length) {
				if (cubesArr[_local7].x == centerExtremum){
					_local2.push(cubesArr[_local7]);
				};
				if (cubesArr[_local7].x == -(centerExtremum)){
					_local4.push(cubesArr[_local7]);
				};
				if (cubesArr[_local7].y == centerExtremum){
					_local5.push(cubesArr[_local7]);
				};
				if (cubesArr[_local7].y == -(centerExtremum)){
					_local6.push(cubesArr[_local7]);
				};
				if (cubesArr[_local7].z == centerExtremum){
					_local1.push(cubesArr[_local7]);
				};
				if (cubesArr[_local7].z == -(centerExtremum)){
					_local3.push(cubesArr[_local7]);
				};
				_local7++;
			};
			_local8 = true;
			_local8 = ((_local8) && (sideColorIdentity(_local1, "front")));
			_local8 = ((_local8) && (sideColorIdentity(_local2, "left")));
			_local8 = ((_local8) && (sideColorIdentity(_local3, "back")));
			_local8 = ((_local8) && (sideColorIdentity(_local4, "right")));
			_local8 = ((_local8) && (sideColorIdentity(_local5, "top")));
			_local8 = ((_local8) && (sideColorIdentity(_local6, "bottom")));
			if (_local8){
				if (isSoundOn){
					levelSound.play();
				};
				finishLevel();
			};
		}
		private function stopBtnClickHandler(_arg1:MouseEvent):void{
			finishLevel();
		}
		private function removeCube():void{
			var _local1:Number;
			_local1 = 0;
			while (_local1 < cubesArr.length) {
				scene.removeChild(cubesArr[_local1]);
				_local1++;
			};
			cubesArr = new Array();
			rotationQueue = new Array();
		}
		private function shuffleBtnClickHandler(_arg1:MouseEvent):void{
			shuffle(10);
		}
		private function shuffle(_arg1:Number=10):void{
			var _local2:Number;
			var _local3:Object;
			_local2 = 0;
			while (_local2 < _arg1) {
				rotationQueue.push(getRandomRotation());
				_local2++;
			};
			_local3 = rotationQueue.shift();
			rotate(_local3.keyPar, _local3.keyParVal, _local3.angle, _local3.xPar, _local3.yPar, _local3.rPar);
		}
		private function case4(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			if (Math.abs(_arg1) >= Math.abs(_arg2)){
				rotate("y", lastCubePressed.y, _arg3, "x", "z", "rotationY");
			} else {
				rotate("z", lastCubePressed.z, -(_arg4), "y", "x", "rotationZ");
			};
		}
		private function case5(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number):void{
			if ((((_arg5 >= 315)) || ((_arg5 <= 45)))){
				if (Math.abs(_arg1) >= Math.abs(_arg2)){
					rotate("z", lastCubePressed.z, -(_arg3), "y", "x", "rotationZ");
				} else {
					rotate("x", lastCubePressed.x, _arg4, "y", "z", "rotationX");
				};
			} else {
				if ((((_arg5 >= 45)) && ((_arg5 <= 135)))){
					if (Math.abs(_arg1) >= Math.abs(_arg2)){
						rotate("x", lastCubePressed.x, ((_arg1 > 0)) ? -90 : 90, "y", "z", "rotationX");
					} else {
						rotate("z", lastCubePressed.z, ((_arg2 > 0)) ? -90 : 90, "y", "x", "rotationZ");
					};
				} else {
					if ((((_arg5 >= 135)) && ((_arg5 <= 225)))){
						if (Math.abs(_arg1) >= Math.abs(_arg2)){
							rotate("z", lastCubePressed.z, _arg3, "y", "x", "rotationZ");
						} else {
							rotate("x", lastCubePressed.x, -(_arg4), "y", "z", "rotationX");
						};
					} else {
						if (Math.abs(_arg1) >= Math.abs(_arg2)){
							rotate("x", lastCubePressed.x, ((_arg1 > 0)) ? 90 : -90, "y", "z", "rotationX");
						} else {
							rotate("z", lastCubePressed.z, ((_arg2 > 0)) ? 90 : -90, "y", "x", "rotationZ");
						};
					};
				};
			};
		}
		private function case6(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number, _arg5:Number):void{
			if ((((_arg5 >= 315)) || ((_arg5 <= 45)))){
				if (Math.abs(_arg1) >= Math.abs(_arg2)){
					rotate("z", lastCubePressed.z, _arg3, "y", "x", "rotationZ");
				} else {
					rotate("x", lastCubePressed.x, _arg4, "y", "z", "rotationX");
				};
			} else {
				if ((((_arg5 >= 45)) && ((_arg5 <= 135)))){
					if (Math.abs(_arg1) >= Math.abs(_arg2)){
						rotate("x", lastCubePressed.x, ((_arg1 > 0)) ? 90 : -90, "y", "z", "rotationX");
					} else {
						rotate("z", lastCubePressed.z, ((_arg2 > 0)) ? -90 : 90, "y", "x", "rotationZ");
					};
				} else {
					if ((((_arg5 >= 135)) && ((_arg5 <= 225)))){
						if (Math.abs(_arg1) >= Math.abs(_arg2)){
							rotate("z", lastCubePressed.z, -(_arg3), "y", "x", "rotationZ");
						} else {
							rotate("x", lastCubePressed.x, -(_arg4), "y", "z", "rotationX");
						};
					} else {
						if (Math.abs(_arg1) >= Math.abs(_arg2)){
							rotate("x", lastCubePressed.x, ((_arg1 > 0)) ? -90 : 90, "y", "z", "rotationX");
						} else {
							rotate("z", lastCubePressed.z, ((_arg2 > 0)) ? 90 : -90, "y", "x", "rotationZ");
						};
					};
				};
			};
		}
		private function case1(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			if (Math.abs(_arg1) >= Math.abs(_arg2)){
				rotate("y", lastCubePressed.y, _arg3, "x", "z", "rotationY");
			} else {
				rotate("x", lastCubePressed.x, _arg4, "y", "z", "rotationX");
			};
		}
		private function case2(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			if (Math.abs(_arg1) >= Math.abs(_arg2)){
				rotate("y", lastCubePressed.y, _arg3, "x", "z", "rotationY");
			} else {
				rotate("x", lastCubePressed.x, -(_arg4), "y", "z", "rotationX");
			};
		}
		public function getGameHistory():Object{
			var _local1:SharedObject;
			_local1 = SharedObject.getLocal("cubic_rubic");
			return (_local1.data.gameHistory);
		}
		private function mouseUpHandler(_arg1:MouseEvent=null):void{
			if (cubePressed){
				cubePressed = false;
			};
			move = false;
			if (stage.hasEventListener(Event.MOUSE_LEAVE)){
				stage.removeEventListener(Event.MOUSE_LEAVE, stageMouseLeaveHandler);
			};
		}
		private function case3(_arg1:Number, _arg2:Number, _arg3:Number, _arg4:Number):void{
			if (Math.abs(_arg1) >= Math.abs(_arg2)){
				rotate("y", lastCubePressed.y, _arg3, "x", "z", "rotationY");
			} else {
				rotate("z", lastCubePressed.z, _arg4, "y", "x", "rotationZ");
			};
		}
		private function initListeners():void{
			back.addEventListener(Event.ENTER_FRAME, enterFrameHandler);
			back.addEventListener(MouseEvent.MOUSE_DOWN, mouseDownHandler);
			back.addEventListener(MouseEvent.MOUSE_UP, mouseUpHandler);
			back.addEventListener(Event.RESIZE, resizeHandler);
			resizeHandler();
		}
		private function getCubePropsByCube(_arg1:Cube):CubeProps{
			var _local2:CubeProps;
			_local2 = new CubeProps();
			_local2.x = _arg1.x;
			_local2.y = _arg1.y;
			_local2.z = _arg1.z;
			_local2.back = getStringByColorMaterial(_arg1.cubeMaterials.back);
			_local2.front = getStringByColorMaterial(_arg1.cubeMaterials.front);
			_local2.bottom = getStringByColorMaterial(_arg1.cubeMaterials.bottom);
			_local2.top = getStringByColorMaterial(_arg1.cubeMaterials.top);
			_local2.right = getStringByColorMaterial(_arg1.cubeMaterials.right);
			_local2.left = getStringByColorMaterial(_arg1.cubeMaterials.left);
			return (_local2);
		}
		private function sideColorIdentity(_arg1:Array, _arg2:String):Boolean{
			var _local3:Boolean;
			var _local4:*;
			_local3 = true;
			_local4 = 1;
			while (_local4 < _arg1.length) {
				_local3 = ((_local3) && ((_arg1[_local4].cubeMaterials[_arg2] == _arg1[0].cubeMaterials[_arg2])));
				_local4++;
			};
			return (_local3);
		}
		public function saveGame():void{
			var _local1:Object;
			var _local2:SharedObject;
			var _local3:Object;
			var _local4:Object;
			_local1 = new Object();
			_local1.cubesProperties = cubePropsArr();
			_local1.curTime = curTime;
			_local1.targetpanangle = (camera.targetpanangle % 360);
			_local1.targettiltangle = (camera.targettiltangle % 360);
			_local2 = SharedObject.getLocal("cubic_rubic");
			_local3 = _local2.data.gameHistory;
			if (_local3 == null){
				_local3 = new Object();
			};
			_local3[("d" + cubeDimension)] = _local1;
			_local2.data.gameHistory = _local3;
			_local4 = _local2.flush();
		}
		public function createCube(_arg1:Number):void{
			var _local2:Number;
			var _local3:ColorMaterial;
			var _local4:ColorMaterial;
			var _local5:ColorMaterial;
			var _local6:ColorMaterial;
			var _local7:ColorMaterial;
			var _local8:ColorMaterial;
			var _local9:ColorMaterial;
			var _local10:CubeMaterialsData;
			var _local11:Number;
			var _local12:Number;
			var _local13:Number;
			var _local14:Cube;
			gameStopped = false;
			removeCube();
			camera.targetpanangle = (camera.panangle = -20);
			camera.targettiltangle = (camera.tiltangle = 20);
			cubeDimension = _arg1;
			cubeSideSize = (maxCubeSize / cubeDimension);
			center = ((cubeDimension / 2) - 0.5);
			lst = (_arg1 - 1);
			posExtremum = ((center * (cubeSideSize + cubesSpan)) + (cubeSideSize / 2));
			centerExtremum = (center * (cubeSideSize + cubesSpan));
			cubRots = new Array();
			cubesArr = new Array();
			_local2 = 0;
			while (_local2 < (_arg1 * _arg1)) {
				cubRots.push(new CubeRotation());
				_local2++;
			};
			_local3 = new ColorMaterial(0xF0F0F0);
			_local4 = new ColorMaterial(0xB30000);
			_local5 = new ColorMaterial(26367);
			_local6 = new ColorMaterial(0x4800);
			_local7 = new ColorMaterial(0xD5AA00);
			_local8 = new ColorMaterial(0x330066);
			_local9 = new ColorMaterial(0);
			_local11 = 0;
			while (_local11 < _arg1) {
				_local12 = 0;
				while (_local12 < _arg1) {
					_local13 = 0;
					while (_local13 < _arg1) {
						if (((((((!((_local11 == 0))) && (!((_local11 == lst))))) && (((!((_local12 == 0))) && (!((_local12 == lst))))))) && (((!((_local13 == 0))) && (!((_local13 == lst))))))){
						} else {
							_local14 = new Cube({width:cubeSideSize, height:cubeSideSize, depth:cubeSideSize});
							_local14.x = ((_local13 - center) * (cubeSideSize + cubesSpan));
							_local14.y = ((_local12 - center) * (cubeSideSize + cubesSpan));
							_local14.z = ((_local11 - center) * (cubeSideSize + cubesSpan));
							_local10 = new CubeMaterialsData({front:_local9, left:_local9, right:_local9, top:_local9, bottom:_local9, back:_local9});
							if (_local11 == 0){
								_local10.back = _local8;
							};
							if (_local11 == lst){
								_local10.front = _local4;
							};
							if (_local12 == 0){
								_local10.bottom = _local7;
							};
							if (_local12 == lst){
								_local10.top = _local3;
							};
							if (_local13 == 0){
								_local10.right = _local5;
							};
							if (_local13 == lst){
								_local10.left = _local6;
							};
							_local14.cubeMaterials = _local10;
							_local14.addEventListener(MouseEvent3D.MOUSE_DOWN, cubeMouseDownHandler);
							_local14.addEventListener(MouseEvent3D.MOUSE_UP, cubeMouseUpHandler);
							_local14.useHandCursor = true;
							scene.addChild(_local14);
							cubesArr.push(_local14);
							cubesObj[((((_local13 + "x") + _local12) + "x") + _local11)] = _local14;
						};
						_local13++;
					};
					_local12++;
				};
				_local11++;
			};
			shuffle(20);
			hscroll.visible = true;
			vscroll.visible = true;
			timeTxt.visible = true;
			stopBtn.visible = true;
			shuffleBtn.visible = true;
			saveBtn.visible = true;
			muteUnmute.visible = true;
			if (isSoundOn){
				soundOn(0.1);
			} else {
				soundVol = 0.1;
			};
		}
		private function rotate(_arg1:String, _arg2:Number, _arg3:Number, _arg4:String, _arg5:String, _arg6:String):void{
			var _local7:Number;
			var _local8:Object;
			var _local9:Number;
			var _local10:CubeRotation;
			if (rotationInterval != 0){
				return;
			};
			_local7 = 0;
			_local8 = new Object();
			_local9 = 0;
			while (_local9 < cubesArr.length) {
				if (cubesArr[_local9][_arg1] == _arg2){
					if (_local8[((cubesArr[_local9][_arg4] + "x") + cubesArr[_local9][_arg5])] != undefined){
					} else {
						_local8[((cubesArr[_local9][_arg4] + "x") + cubesArr[_local9][_arg5])] = 1;
						var _temp1 = _local7;
						_local7 = (_local7 + 1);
						_local10 = cubRots[_temp1];
						_local10.init(cubesArr[_local9], _arg4, _arg5, _arg6);
					};
				};
				_local9++;
			};
			if (_arg3 > 0){
				stepAngle = Math.abs(stepAngle);
			} else {
				stepAngle = (Math.abs(stepAngle) * -1);
			};
			rotationAngle = _arg3;
			currentAngle = 0;
			rotationInterval = setInterval(rotateGroup, 15);
			if (isSoundOn){
				_rotationSoundChannel = rotationSound.play();
			};
		}
		private function initEngine():void{
			var _local1:FogFilter;
			scene = new Scene3D();
			camera = new HoverCamera3D();
			camera.yfactor = 1;
			camera.focus = 50;
			camera.distance = 300;
			camera.mintiltangle = -90;
			camera.maxtiltangle = 90;
			camera.targetpanangle = (camera.panangle = -20);
			camera.targettiltangle = (camera.tiltangle = 20);
			hscroll.percent = (camera.targetpanangle / 360);
			vscroll.percent = (camera.targettiltangle / 180);
			_local1 = new FogFilter();
			_local1.material = new ColorMaterial(0x666666);
			_local1.minZ = 500;
			_local1.maxZ = 2000;
			renderer = new BasicRenderer();
			view = new View3D();
			view.scene = scene;
			view.camera = camera;
			view.renderer = renderer;
			addChild(view);
		}
		public function restoreGame(_arg1:Number):void{
			var _local2:SharedObject;
			var _local3:Object;
			var _local4:Array;
			var _local5:Cube;
			var _local6:Number;
			var _local7:Number;
			_local2 = SharedObject.getLocal("cubic_rubic");
			_local3 = _local2.data.gameHistory;
			if (_local3[("d" + _arg1)] == null){
				return;
			};
			camera.targetpanangle = _local3[("d" + _arg1)].targetpanangle;
			camera.targettiltangle = _local3[("d" + _arg1)].targettiltangle;
			_local4 = _local3[("d" + _arg1)].cubesProperties;
			if ((((_local4 == null)) || ((_local4.length == 0)))){
				return;
			};
			gameStopped = false;
			removeCube();
			cubeDimension = _arg1;
			cubeSideSize = (maxCubeSize / cubeDimension);
			center = ((cubeDimension / 2) - 0.5);
			lst = (_arg1 - 1);
			posExtremum = ((center * (cubeSideSize + cubesSpan)) + (cubeSideSize / 2));
			centerExtremum = (center * (cubeSideSize + cubesSpan));
			cubRots = new Array();
			_local6 = 0;
			while (_local6 < (_arg1 * _arg1)) {
				cubRots.push(new CubeRotation());
				_local6++;
			};
			cubesArr = new Array();
			cubesObj = new Object();
			_local7 = 0;
			while (_local7 < _local4.length) {
				_local5 = getCubeByCubeProps(_local4[_local7]);
				_local5.addEventListener(MouseEvent3D.MOUSE_DOWN, cubeMouseDownHandler);
				_local5.addEventListener(MouseEvent3D.MOUSE_UP, cubeMouseUpHandler);
				_local5.useHandCursor = true;
				scene.addChild(_local5);
				cubesArr.push(_local5);
				cubesObj[((((_local5.x + "x") + _local5.y) + "x") + _local5.z)] = _local5;
				_local7++;
			};
			hscroll.visible = true;
			vscroll.visible = true;
			timeTxt.visible = true;
			stopBtn.visible = true;
			shuffleBtn.visible = true;
			saveBtn.visible = true;
			muteUnmute.visible = true;
			if (isSoundOn){
				soundOn(0.1);
			};
			startTimeTimer();
			timerStarted = true;
			curTime = _local3[("d" + _arg1)].curTime;
		}
		private function saveBtnClickHandler(_arg1:MouseEvent):void{
			if (rotationQueue.length == 0){
				saveGame();
			};
		}
		private function rotateGroup():void{
			var _local1:Number;
			var _local2:Object;
			currentAngle = (currentAngle + stepAngle);
			if (Math.abs(currentAngle) > Math.abs(rotationAngle)){
				currentAngle = rotationAngle;
			};
			_local1 = 0;
			while (_local1 < cubRots.length) {
				if (cubRots[_local1].done){
				} else {
					cubRots[_local1].angle = (cubRots[_local1].startAngle - currentAngle);
				};
				_local1++;
			};
			if (_rotationSoundChannel != null){
				_rotationSoundChannel.stop();
			};
			if (currentAngle == rotationAngle){
				clearInterval(rotationInterval);
				rotationInterval = 0;
				_local1 = 0;
				while (_local1 < cubRots.length) {
					if (cubRots[_local1].done){
					} else {
						cubRots[_local1].finalize(rotationAngle, ((cubeSideSize + cubesSpan) / 2));
					};
					_local1++;
				};
				if (rotationQueue.length > 0){
					_local2 = rotationQueue.shift();
					rotate(_local2.keyPar, _local2.keyParVal, _local2.angle, _local2.xPar, _local2.yPar, _local2.rPar);
				} else {
					if (!gameStopped){
						if (!timerStarted){
							startTimeTimer();
							timerStarted = true;
						};
						checkForReadiness();
					};
				};
			} else {
				if (isSoundOn){
					_rotationSoundChannel = rotationSound.play(((rotationSound.length * Math.abs(currentAngle)) / Math.abs(rotationAngle)));
				};
			};
		}
		private function getCubeByCubeProps(_arg1:Object):Cube{
			var _local2:Cube;
			var _local3:CubeMaterialsData;
			_local2 = new Cube({width:cubeSideSize, height:cubeSideSize, depth:cubeSideSize});
			_local2.x = _arg1["x"];
			_local2.y = _arg1["y"];
			_local2.z = _arg1["z"];
			_local3 = new CubeMaterialsData({front:getCubeMaterialByString(_arg1["front"]), left:getCubeMaterialByString(_arg1["left"]), right:getCubeMaterialByString(_arg1["right"]), top:getCubeMaterialByString(_arg1["top"]), bottom:getCubeMaterialByString(_arg1["bottom"]), back:getCubeMaterialByString(_arg1["back"])});
			_local2.cubeMaterials = _local3;
			return (_local2);
		}
		private function resizeHandler(_arg1:Event=null):void{
			view.x = (back.width / 2);
			view.y = (back.height / 2);
		}

		public static function soundOff():void{
			if (mainSoundChannel != null){
				mainSoundChannel.stop();
				mainSoundChannel = null;
			};
			isSoundOn = false;
		}
		public static function soundOn(_arg1:Number=1):void{
			var _local2:SoundTransform;
			soundVol = _arg1;
			if (mainSoundChannel == null){
				mainSoundChannel = mainSound.play(0, int.MAX_VALUE, new SoundTransform(soundVol));
			};
			_local2 = mainSoundChannel.soundTransform;
			_local2.volume = soundVol;
			mainSoundChannel.soundTransform = _local2;
			isSoundOn = true;
		}
		public static function get rotationSound():Sound{
			if (_rotationSound == null){
				_rotationSound = new RotationSound();
			};
			return (_rotationSound);
		}
		public static function get rotationSoundChannel():SoundChannel{
			if (_rotationSoundChannel == null){
				_rotationSoundChannel = rotationSound.play(0, int.MAX_VALUE);
			};
			return (_rotationSoundChannel);
		}

	}
}//package 
Section 174
//CubeProps (CubeProps)
package {

	public class CubeProps {

		public var back:String;
		public var front:String;
		public var bottom:String;
		public var left:String;
		public var top:String;
		public var x:Number;
		public var y:Number;
		public var z:Number;
		public var right:String;

		public function CubeProps(){
			x = 0;
			y = 0;
			z = 0;
			top = "inviz";
			bottom = "inviz";
			left = "inviz";
			right = "inviz";
			front = "inviz";
			back = "inviz";
		}
	}
}//package 
Section 175
//CubeRotation (CubeRotation)
package {
	import away3d.primitives.*;
	import flash.geom.*;
	import away3d.primitives.data.*;
	import away3d.materials.*;

	public class CubeRotation {

		public var done:Boolean;// = true
		private var rParName:String;
		public var startAngle:Number;// = 0
		private var yParName:String;
		private var _angle:Number;
		private var r:Number;
		private var xParName:String;
		private var cube:Cube;// = null
		private var startRParam:Number;// = 0

		public function CubeRotation(){
			cube = null;
			startAngle = 0;
			startRParam = 0;
			done = true;
			super();
		}
		private function rotateZMaterials(_arg1:Number):void{
			var _local2:CubeMaterialsData;
			var _local3:ITriangleMaterial;
			_local2 = cube.cubeMaterials;
			if (_arg1 == 90){
				_local3 = _local2.top;
				_local2.top = _local2.left;
				_local2.left = _local2.bottom;
				_local2.bottom = _local2.right;
				_local2.right = _local3;
			} else {
				if (_arg1 == -90){
					_local3 = _local2.top;
					_local2.top = _local2.right;
					_local2.right = _local2.bottom;
					_local2.bottom = _local2.left;
					_local2.left = _local3;
				};
			};
			cube.cubeMaterials = _local2;
			cube.rotationZ = 0;
		}
		public function init(_arg1:Cube, _arg2:String, _arg3:String, _arg4:String):void{
			this.cube = _arg1;
			this.xParName = _arg2;
			this.yParName = _arg3;
			this.rParName = _arg4;
			this.r = Math.sqrt(((_arg1[_arg2] * _arg1[_arg2]) + (_arg1[_arg3] * _arg1[_arg3])));
			startAngle = angle;
			startRParam = (5 * Math.round((_arg1[_arg4] / 5)));
			done = false;
		}
		private function getPointOnAngle(_arg1:Number):Point{
			var _local2:Number;
			var _local3:Number;
			var _local4:Point;
			_local2 = (r * Math.cos(((_arg1 / 180) * Math.PI)));
			_local3 = (r * Math.sin(((_arg1 / 180) * Math.PI)));
			_local4 = new Point(Math.round(_local2), Math.round(_local3));
			return (_local4);
		}
		private function rotateXMaterials(_arg1:Number):void{
			var _local2:CubeMaterialsData;
			var _local3:ITriangleMaterial;
			_local2 = cube.cubeMaterials;
			if (_arg1 == 90){
				_local3 = _local2.top;
				_local2.top = _local2.front;
				_local2.front = _local2.bottom;
				_local2.bottom = _local2.back;
				_local2.back = _local3;
			} else {
				if (_arg1 == -90){
					_local3 = _local2.top;
					_local2.top = _local2.back;
					_local2.back = _local2.bottom;
					_local2.bottom = _local2.front;
					_local2.front = _local3;
				};
			};
			cube.cubeMaterials = _local2;
			cube.rotationX = 0;
		}
		public function get angle():Number{
			var _local1:Number;
			_local1 = ((r)==0) ? cube[rParName] : angleOfPoint(cube[xParName], cube[yParName]);
			return (_local1);
		}
		public function finalize(_arg1:Number, _arg2:Number):void{
			done = true;
			cube[xParName] = (Math.round((cube[xParName] / _arg2)) * _arg2);
			cube[yParName] = (Math.round((cube[yParName] / _arg2)) * _arg2);
			switch (rParName){
				case "rotationX":
					rotateXMaterials(_arg1);
					break;
				case "rotationY":
					rotateYMaterials(_arg1);
					break;
				case "rotationZ":
					rotateZMaterials(_arg1);
					break;
			};
		}
		public function set angle(_arg1:Number):void{
			var _local2:Point;
			_arg1 = ((_arg1 + Math.round(360)) % 360);
			_angle = _arg1;
			_local2 = getPointOnAngle(_arg1);
			cube[xParName] = _local2.x;
			cube[yParName] = _local2.y;
			cube[rParName] = (startRParam - (_arg1 - startAngle));
		}
		private function rotateYMaterials(_arg1:Number):void{
			var _local2:CubeMaterialsData;
			var _local3:ITriangleMaterial;
			_local2 = cube.cubeMaterials;
			if (_arg1 == 90){
				_local3 = _local2.front;
				_local2.front = _local2.right;
				_local2.right = _local2.back;
				_local2.back = _local2.left;
				_local2.left = _local3;
			} else {
				if (_arg1 == -90){
					_local3 = _local2.front;
					_local2.front = _local2.left;
					_local2.left = _local2.back;
					_local2.back = _local2.right;
					_local2.right = _local3;
				};
			};
			cube.cubeMaterials = _local2;
			cube.rotationY = 0;
		}
		private function angleOfPoint(_arg1:Number, _arg2:Number):Number{
			var _local3:Number;
			_local3 = ((Math.atan((_arg2 / _arg1)) / Math.PI) * 180);
			if (_arg1 < 0){
				_local3 = (_local3 + 180);
			} else {
				if (_arg2 < 0){
					_local3 = (_local3 + 360);
				};
			};
			return (_local3);
		}

	}
}//package 
Section 176
//CustomHScroll (CustomHScroll)
package {
	import flash.geom.*;
	import flash.display.*;
	import flash.events.*;

	public class CustomHScroll extends MovieClip {

		public var scrollBar:MovieClip;
		public var scrollBase:MovieClip;

		public function CustomHScroll(){
			scrollBar.useHandCursor = true;
			scrollBar.buttonMode = true;
			scrollBar.addEventListener(MouseEvent.MOUSE_DOWN, scrollMouseDown);
		}
		public function set percent(_arg1:Number):void{
			if (_arg1 < -0.5){
				_arg1 = (_arg1 + 1);
			} else {
				if (_arg1 > 0.5){
					_arg1--;
				};
			};
			scrollBar.x = (scrollBase.width * _arg1);
		}
		private function scrollMouseDown(_arg1:MouseEvent):void{
			var _local2:Rectangle;
			_local2 = new Rectangle(-((scrollBase.width / 2)), 0, scrollBase.width, 0);
			scrollBar.startDrag(false, _local2);
			Application.app.addEventListener(MouseEvent.MOUSE_UP, scrollMouseUp);
			Application.app.addEventListener(MouseEvent.MOUSE_MOVE, scrollMouseMove);
		}
		private function scrollMouseUp(_arg1:MouseEvent):void{
			scrollBar.stopDrag();
			Application.app.removeEventListener(MouseEvent.MOUSE_UP, scrollMouseUp);
			Application.app.removeEventListener(MouseEvent.MOUSE_MOVE, scrollMouseMove);
		}
		private function scrollMouseMove(_arg1:MouseEvent):void{
			var _local2:Number;
			_local2 = ((scrollBar.x + (scrollBase.width / 2)) / scrollBase.width);
			_local2 = (Math.round((_local2 * 100)) / 100);
			Application.app.changeCamX(_local2);
		}

	}
}//package 
Section 177
//CustomVScroll (CustomVScroll)
package {
	import flash.geom.*;
	import flash.display.*;
	import flash.events.*;

	public class CustomVScroll extends MovieClip {

		public var scrollBar:MovieClip;
		public var scrollBase:MovieClip;

		public function CustomVScroll(){
			scrollBar.useHandCursor = true;
			scrollBar.buttonMode = true;
			scrollBar.addEventListener(MouseEvent.MOUSE_DOWN, scrollMouseDown);
		}
		public function set percent(_arg1:Number):void{
			scrollBar.y = (scrollBase.height * _arg1);
		}
		private function scrollMouseDown(_arg1:MouseEvent):void{
			var _local2:Rectangle;
			_local2 = new Rectangle(0, -((scrollBase.height / 2)), 0, scrollBase.height);
			scrollBar.startDrag(false, _local2);
			Application.app.addEventListener(MouseEvent.MOUSE_UP, scrollMouseUp);
			Application.app.addEventListener(MouseEvent.MOUSE_MOVE, scrollMouseMove);
		}
		private function scrollMouseUp(_arg1:MouseEvent):void{
			scrollBar.stopDrag();
			Application.app.removeEventListener(MouseEvent.MOUSE_UP, scrollMouseUp);
			Application.app.removeEventListener(MouseEvent.MOUSE_MOVE, scrollMouseMove);
		}
		private function scrollMouseMove(_arg1:MouseEvent):void{
			var _local2:Number;
			_local2 = ((scrollBar.y + (scrollBase.height / 2)) / scrollBase.height);
			_local2 = (Math.round((_local2 * 100)) / 100);
			Application.app.changeCamY(_local2);
		}

	}
}//package 
Section 178
//HScroll (HScroll)
package {

	public dynamic class HScroll extends CustomHScroll {

	}
}//package 
Section 179
//Instructions (Instructions)
package {
	import flash.display.*;
	import flash.events.*;

	public class Instructions extends MovieClip {

		public var menuBtn:SimpleButton;

		public function Instructions(){
			menuBtn.addEventListener(MouseEvent.CLICK, menuBtnClick);
		}
		private function menuBtnClick(_arg1:MouseEvent):void{
			this.x = -600;
			this.y = -500;
			Application.app.startView.x = 0;
			Application.app.startView.y = 0;
		}

	}
}//package 
Section 180
//InstructionsMc (InstructionsMc)
package {

	public dynamic class InstructionsMc extends Instructions {

	}
}//package 
Section 181
//LevelSound (LevelSound)
package {
	import flash.media.*;

	public dynamic class LevelSound extends Sound {

	}
}//package 
Section 182
//LoadGame (LoadGame)
package {

	public dynamic class LoadGame extends LoadGameView {

	}
}//package 
Section 183
//LoadGameView (LoadGameView)
package {
	import flash.display.*;
	import flash.events.*;

	public class LoadGameView extends MovieClip {

		public var normalBtn:SimpleButton;
		public var easyBtn:SimpleButton;
		public var veryHardBtn:SimpleButton;
		public var hardBtn:SimpleButton;
		public var menuBtn:SimpleButton;

		public function LoadGameView(){
			easyBtn.addEventListener(MouseEvent.CLICK, easyBtnClick);
			normalBtn.addEventListener(MouseEvent.CLICK, normalBtnClick);
			hardBtn.addEventListener(MouseEvent.CLICK, hardBtnClick);
			veryHardBtn.addEventListener(MouseEvent.CLICK, veryHardBtnClick);
			menuBtn.addEventListener(MouseEvent.CLICK, menuBtnClick);
		}
		private function menuBtnClick(_arg1:MouseEvent):void{
			this.x = 605;
			Application.app.showMenu();
		}
		public function refreshList():void{
			var _local1:Object;
			_local1 = Application.app.getGameHistory();
			if (_local1 == null){
				_local1 = new Object();
			};
			if (_local1["d2"] == undefined){
				easyBtn.visible = false;
			} else {
				easyBtn.visible = true;
			};
			if (_local1["d3"] == undefined){
				normalBtn.visible = false;
			} else {
				normalBtn.visible = true;
			};
			if (_local1["d4"] == undefined){
				hardBtn.visible = false;
			} else {
				hardBtn.visible = true;
			};
			if (_local1["d5"] == undefined){
				veryHardBtn.visible = false;
			} else {
				veryHardBtn.visible = true;
			};
		}
		private function hardBtnClick(_arg1:MouseEvent):void{
			loadGame(4);
		}
		private function normalBtnClick(_arg1:MouseEvent):void{
			loadGame(3);
		}
		private function easyBtnClick(_arg1:MouseEvent):void{
			loadGame(2);
		}
		private function veryHardBtnClick(_arg1:MouseEvent):void{
			loadGame(5);
		}
		private function loadGame(_arg1:Number):void{
			this.x = 605;
			Application.app.restoreGame(_arg1);
		}

	}
}//package 
Section 184
//MainSound (MainSound)
package {
	import flash.media.*;

	public dynamic class MainSound extends Sound {

	}
}//package 
Section 185
//NextLevelView (NextLevelView)
package {
	import flash.display.*;
	import flash.events.*;
	import flash.text.*;

	public class NextLevelView extends MovieClip {

		public var replayBtn:SimpleButton;
		public var timeTxt:TextField;
		public var nextLevelBtn:SimpleButton;
		public var menuBtn:SimpleButton;

		public function NextLevelView(){
			nextLevelBtn.addEventListener(MouseEvent.CLICK, nextLevelBtnClick);
			replayBtn.addEventListener(MouseEvent.CLICK, replayBtnClick);
			menuBtn.addEventListener(MouseEvent.CLICK, menuBtnClick);
		}
		private function menuBtnClick(_arg1:MouseEvent):void{
			this.x = -600;
			this.y = -500;
			Application.app.showMenu();
		}
		private function replayBtnClick(_arg1:MouseEvent):void{
			this.x = -600;
			this.y = -500;
			Application.app.createCube(Application.app.cubeDimension);
		}
		public function refresh():void{
			timeTxt.text = Application.app.timeTxt.text;
		}
		private function nextLevelBtnClick(_arg1:MouseEvent):void{
			this.x = -600;
			this.y = -500;
			Application.app.createCube(Math.min(++Application.app.cubeDimension, 5));
		}

	}
}//package 
Section 186
//NextLevelViewMc (NextLevelViewMc)
package {

	public dynamic class NextLevelViewMc extends NextLevelView {

	}
}//package 
Section 187
//RotationSound (RotationSound)
package {
	import flash.media.*;

	public dynamic class RotationSound extends Sound {

	}
}//package 
Section 188
//StartView (StartView)
package {
	import flash.display.*;
	import flash.events.*;

	public class StartView extends MovieClip {

		public var easyBtn:SimpleButton;
		public var normalBtn:SimpleButton;
		public var loadGameBtn:SimpleButton;
		public var veryHardBtn:SimpleButton;
		public var hardBtn:SimpleButton;
		public var instructionsBtn:SimpleButton;

		public function StartView(){
			easyBtn.addEventListener(MouseEvent.CLICK, easyBtnClick);
			normalBtn.addEventListener(MouseEvent.CLICK, normalBtnClick);
			hardBtn.addEventListener(MouseEvent.CLICK, hardBtnClick);
			veryHardBtn.addEventListener(MouseEvent.CLICK, veryHardBtnClick);
			loadGameBtn.addEventListener(MouseEvent.CLICK, loadGameBtnClick);
			instructionsBtn.addEventListener(MouseEvent.CLICK, instructionsBtnClick);
		}
		private function instructionsBtnClick(_arg1:MouseEvent):void{
			this.x = -600;
			this.y = -500;
			Application.app.instructions.x = 0;
			Application.app.instructions.y = 0;
		}
		private function startGame(_arg1:Number):void{
			this.x = -600;
			this.y = -500;
			Application.app.createCube(_arg1);
		}
		private function normalBtnClick(_arg1:MouseEvent):void{
			startGame(3);
		}
		private function hardBtnClick(_arg1:MouseEvent):void{
			startGame(4);
		}
		private function loadGameBtnClick(_arg1:MouseEvent):void{
			this.x = -600;
			this.y = -500;
			Application.app.loadGame.refreshList();
			Application.app.loadGame.x = 0;
			Application.app.loadGame.y = 0;
		}
		private function easyBtnClick(_arg1:MouseEvent):void{
			startGame(2);
		}
		private function veryHardBtnClick(_arg1:MouseEvent):void{
			startGame(5);
		}

	}
}//package 
Section 189
//StartViewMc (StartViewMc)
package {

	public dynamic class StartViewMc extends StartView {

	}
}//package 
Section 190
//VScroll (VScroll)
package {

	public dynamic class VScroll extends CustomVScroll {

	}
}//package