{
				// Swap z & y for Max (to make Y up and Z depth)
				var vert:Object = semVertices[ i ];
				var x :Number = Number( vert.X ) * scaling;
				var y :Number = Number( vert.Y ) * scaling;
				var z :Number = Number( vert.Z ) * scaling;
	
				if( this._yUp )
					vertices.push( new Vertex3D( -x, y, z ) );
				else
					vertices.push( new Vertex3D(  x, z, y ) );
			}
	
			// Faces
			var faces    :Array = instance.geometry.faces = new Array();
			var semFaces :Array = semantics.triangles;
			len = semFaces.length;
		
			for( i=0; i < len; i++ )
			{
				// Triangle
				var tri :Array = semFaces[i].VERTEX;
				var a   :Vertex3D = vertices[ accVerts + tri[ 0 ] ];
				var b   :Vertex3D = vertices[ accVerts + tri[ 1 ] ];
				var c   :Vertex3D = vertices[ accVerts + tri[ 2 ] ];
	
				var faceList :Array = [ a, b, c ];
	
				var tex :Array = semantics.TEXCOORD;
				var uv  :Array = semFaces[i].TEXCOORD;
	
				var uvList :Array, uvA :NumberUV, uvB :NumberUV, uvC :NumberUV;
	
				if( uv && tex )
				{
					uvA = new NumberUV( tex[ uv[0] ].S, tex[ uv[0] ].T );
					uvB = new NumberUV( tex[ uv[1] ].S, tex[ uv[1] ].T );
					uvC = new NumberUV( tex[ uv[2] ].S, tex[ uv[2] ].T );
	
					uvList = [ uvA, uvB, uvC ];
				}
				else uvList = null;

				var materialName:String = semFaces[i].material || null;
				var face:Triangle3D = new Triangle3D(instance, faceList, _materials.getMaterialByName(materialName), uvList );
				faces.push( face );
			}
			
	
			// Activate object
			instance.geometry.ready = true;
	
			matrix.n14 *= scaling;
			matrix.n24 *= scaling;
			matrix.n34 *= scaling;
	
			//instance.material = MaterialObject3D.DEFAULT;
	
			instance.visible  = true;
		}
	
	
		private function getArray( spaced:String ):Array
		{
			var strings :Array = spaced.split(" ");
			var numbers :Array = new Array();
	
			var totalStrings:Number = strings.length;
	
			for( var i:Number=0; i < totalStrings; i++ )
				numbers[i] = Number( strings[i] );
	
			return numbers;
		}
	
	
		private function addMaterial( instance:DisplayObject3D, name:String, bindMaterial:Object ):void
		{
			//trace( "Collada: addMaterial: " + instance.name + " > " + name ); // DEBUG
			var material:MaterialObject3D;
		
			if( this._materials ){
				material = this._materials.getMaterialByName( name );
			}else{
				_materials = new MaterialsList();
			}
			
			if( ! material )
			{
				// Find object path
				var path :String = this._filename.slice( 0, this._filename.lastIndexOf("/") +1 );
	
				// Retrieve texture url
				var filename :String = getTexture( bindMaterial[name] );
	
				if( filename )
				{
					// Load relative to the object
					materialsToLoad++;
					material = new BitmapFileMaterial( path + filename );
					material.addEventListener(FileLoadEvent.LOAD_COMPLETE, onMaterialLoadComplete);
					material.addEventListener(FileLoadEvent.LOAD_ERROR, onMaterialLoadError);
				}
				else
				{
					material = MaterialObject3D.DEFAULT;
					Papervision3D.log( "Collada material " + name + " not found." ); // TODO: WARNING
				}
	
				material.name = name;
			}
			_materials.addMaterial(material);
	
			if( ! instance.materials ) instance.materials = new MaterialsList();
			material.registerObject(instance);
			instance.materials.addMaterial( material, name );
		}
		
		private function onMaterialLoadComplete(event:FileLoadEvent):void
		{
			materialsToLoad--;
			if(materialsToLoad == 0){
				materials = new MaterialsList();
				dispatchEvent(new FileLoadEvent(FileLoadEvent.COLLADA_MATERIALS_DONE));
			}
		}
		
		private function onMaterialLoadError(event:FileLoadEvent):void
		{
			var mat:BitmapFileMaterial = event.target as BitmapFileMaterial;
			trace("Colllada failed to load material : " +mat);
			//Do error handling here.
			materialsToLoad--;
			if(materialsToLoad == 0){
				dispatchEvent(new FileLoadEvent(FileLoadEvent.COLLADA_MATERIALS_DONE));
			}
		}
	
	
		// Retrieves the filename of a material
		private function getTexture( name:String ):String
		{
			var filename :String = null;
	
			var material:XML = COLLADA.library_materials.material.(@id == name)[0];
	
			if( material )
			{
				var effectId:String = getId( material.instance_effect.@url );
				var effect:XML = COLLADA.library_effects.effect.(@id == effectId)[0];
	
				if (effect..texture.length() == 0) return null;
	
				var textureId:String = effect..texture[0].@texture;
	
				var sampler:XML =  effect..newparam.(@sid == textureId)[0];
	
				// Blender
				var imageId:String = textureId;
	
				// Not Blender
				if( sampler )
				{
					var sourceId:String = sampler..source[0];
					var source:XML =  effect..newparam.(@sid == sourceId)[0];
	
					imageId = source..init_from[0];
				}
	
				var image:XML = COLLADA.library_images.image.(@id == imageId)[0];
	
				filename = image.init_from;
	
				if (filename.substr(0, 2) == "./")
				{
					filename = filename.substr( 2 );
				}
			}
	
			return filename;
		}
	
	
		// _______________________________________________________________________
		//                                                                Matrices
	
		private function rotateMatrix( vector:Array ):Matrix3D
		{
			if( this._yUp )
				return Matrix3D.rotationMatrix( vector[0], vector[1], vector[2], -vector[3] *toRADIANS );
			else
				return Matrix3D.rotationMatrix( vector[0], vector[2], vector[1], -vector[3] *toRADIANS );
		}
	
	
		private function translateMatrix( vector:Array ):Matrix3D
		{
			if( this._yUp )
				return Matrix3D.translationMatrix( -vector[0] *this._scaling, vector[1] *this._scaling, vector[2] *this._scaling );
			else
				return Matrix3D.translationMatrix(  vector[0] *this._scaling, vector[2] *this._scaling, vector[1] *this._scaling );
		}
	
	
		private function scaleMatrix( vector:Array ):Matrix3D
		{
			if( this._yUp )
				return Matrix3D.scaleMatrix( vector[0], vector[1], vector[2] );
			else
				return Matrix3D.scaleMatrix( vector[0], vector[2], vector[1] );
		}
	
		private function bakedMatrix( matrix:Matrix3D ):Matrix3D
		{
			matrix.n14 *= _scaling;
			matrix.n24 *= _scaling;
			matrix.n34 *= _scaling;
			
			return matrix;
		}
	
		// _______________________________________________________________________
		//                                                                     XML
	
		private function deserialize( input:XML, geo:XML ):Array
		{
			var output :Array = new Array();
			var id     :String = input.@source.split("#")[1];
	
			// Source?
			var acc:XMLList = geo..source.(@id == id).technique_common.accessor;
			
			if( acc != new XMLList(null) )
			{
				// Build source floats array
				var floId  :String  = acc.@source.split("#")[1];
				var floXML :XMLList = COLLADA..float_array.(@id == floId);
				var floStr :String  = floXML.toString();
				var floats :Array   = floStr.split(" ");
	
				// Build params array
				var params :Array = new Array();
	
				for each( var par:XML in acc.param )
					params.push( par.@name );
	
				// Build output array
				var count  :int = acc.@count;
				var stride :int = acc.@stride;
	
				for( var i:int=0; i < count; i++ )
				{
					var element :Object = new Object();
	
					for( var j:int=0; j < stride; j++ )
						element[ params[j] ] = floats.shift();
	
					//for( j=0; j < stride; j++ ) trace( params[j] + " " + element[ params[j] ] ); // DEBUG
	
					output.push( element );
				}
			}
			else
			{
				// Store indexes if no source
				var recursive :XMLList = geo..vertices.(@id == id)[INPUTTAG];
	
				output = deserialize( recursive[0], geo );
			}
	
			return output;
		}
	
		public function getMaterialsList():MaterialsList
		{
			return _materials;
		}
	
		private function getId( url:String ):String
		{
			return url.split("#")[1];
		}
	
		// _______________________________________________________________________
		//                                                       COLLADA tag names
	
		private static var COLLADASECTION  :String = "COLLADA";
		private static var LIBRARYSECTION  :String = "library";
		private static var ASSETSECTION    :String = "asset";
		private static var SCENESECTION    :String = "scene";
	
		private static var LIGHTPREFAB     :String = "light";
		private static var CAMERAPREFAB    :String = "camera";
		private static var MATERIALSECTION :String = "material";
		private static var GEOMETRYSECTION :String = "geometry";
	
		private static var MESHSECTION     :String = "mesh";
		private static var SOURCESECTION   :String = "source";
		private static var ARRAYSECTION    :String = "array";
		private static var ACCESSORSECTION :String = "accessor";
		private static var VERTICESSECTION :String = "vertices";
		private static var INPUTTAG        :String = "input";
		private static var POLYGONSSECTION :String = "polygons";
		private static var POLYGON         :String = "p";
		private static var NODESECTION     :String = "node";
		private static var LOOKATNODE      :String = "lookat";
		private static var MATRIXNODE      :String = "matrix";
		private static var PERSPECTIVENODE :String = "perspective";
		private static var ROTATENODE      :String = "rotate";
		private static var SCALENODE       :String = "scale";
		private static var TRANSLATENODE   :String = "translate";
		private static var SKEWNODE        :String = "skew";
		private static var INSTANCENODE    :String = "instance";
		private static var INSTACESCENE    :String = "instance_visual_scene";
	
		private static var PARAMTAG        :String = "param";
	
		private static var POSITIONINPUT   :String = "POSITION";
		private static var VERTEXINPUT     :String = "VERTEX";
		private static var NORMALINPUT     :String = "NORMAL";
		private static var TEXCOORDINPUT   :String = "TEXCOORD";
		private static var UVINPUT         :String = "UV";
		private static var TANGENTINPUT    :String = "TANGENT";
	
		// _______________________________________________________________________
	
		private var COLLADA     :XML;
		private var _container  :DisplayObjectContainer3D;
		private var _geometries :Object;
	
		private var _loader     :URLLoader;
	
		private var _filename   :String;
		private var _materials  :MaterialsList;
		private var _scaling    :Number;
	
		private var _yUp        :Boolean;
	
		static private var toDEGREES :Number = 180/Math.PI;
		static private var toRADIANS :Number = Math.PI/180;
	}
}