dae.as

一个可以解析Collada文件格式的AS3类库

			for( var i:int = 0; i < node.nodes.length; i++ )
				buildScene(node.nodes[i], instance);
				
			instance.copyTransform( buildMatrix(node) );

			return instance;
		}
				
		/**
		 * 
		 * @param	node
		 * @param	controller
		 * @return
		 */
		private function buildSkin( node:DaeNode, controller:DaeInstanceController ):DisplayObject3D
		{
			var skinCtrl:DaeController = _document.controllers[controller.url];
			
			if( !skinCtrl || !skinCtrl.skin )
				return new DisplayObject3D(node.id);
				
			var skin:DaeSkin = skinCtrl.skin;
			var skinnedMesh:Skin3D = new Skin3D(new WireframeMaterial(), new Array(), new Array(), node.id);
			
			var geom:DaeGeometry = _document.geometries[ skin.source ];
				
			if( !geom )
			{
				if( _document.controllers[skin.source] )
				{
					var morhpCtrl:DaeController = _document.controllers[skin.source];
					if( morhpCtrl.morph )
						geom = _document.geometries[ morhpCtrl.morph.source ];
				}				
				if( !geom )
					throw new Error("Can't find geometry: " + skin.source );
			}
			
			for each( var m:DaeInstanceMaterial in controller.materials )
				buildMaterial( m );
						
			skinnedMesh.materials = this.materials;

			skinnedMesh.geometry = buildGeometry(geom.mesh);
			skinnedMesh.geometry.ready = true;
			
			skinnedMesh.bindPose = new Matrix3D(skin.bind_shape_matrix);
			
			_skins[ skinnedMesh ] = skin;
			
			skinnedMesh.transformVertices(skinnedMesh.bindPose);
			
			return skinnedMesh;
		}
		
		/**
		 * 
		 * @param	id
		 * @return
		 */
		private function findAnimationChannelsByID( id:String ):Array
		{
			var channels:Array = new Array();
		
			for each( var animation:DaeAnimation in _document.animations )
			{
				for each( var channel:DaeChannel in animation.channels )
				{
					var target:String = channel.target.split("/").shift() as String;
					if( target == id )
						channels.push(channel);
				}
			}
			return channels;
		}
		
		/**
		 * 
		 * @param	node
		 * @param	name
		 * @return
		 */
		private function findChildByName(node:DisplayObject3D, name:String):DisplayObject3D
		{
			if( node.name == name )
				return node;
				
			for each(var child:DisplayObject3D in node.children ) 
			{
				var n:DisplayObject3D = findChildByName(child, name);
				if( n )
					return n;
			}
			
			return null;
		}
		
		/**
		 * 
		 * @param	node
		 * @param	name
		 * @return
		 */
		private function findChildBySID(node:DisplayObject3D, sid:String):DisplayObject3D
		{
			if( node is Node3D && Node3D(node).sid == sid )
				return node;
				
			for each(var child:DisplayObject3D in node.children ) 
			{
				var n:DisplayObject3D = findChildBySID(child, sid);
				if( n )
					return n;
			}
			
			return null;
		}
		
		/**
		 * 
		 * @param	node
		 * @return
		 */
		private function findSkinController( node:DaeNode ):DaeInstanceController
		{
			for each( var controller:DaeInstanceController in node.controllers )
			{
				var control:DaeController = _document.controllers[controller.url];
				if( control.skin )
					return controller;
			}
			return null;
		}
		
		/**
		 * 
		 * @param	node
		 * @return
		 */
		private function linkAnimations( node:DisplayObject3D ):void
		{
			if( node is Node3D )
			{
				var joint:Node3D = node as Node3D;

				var channels:Array = findAnimationChannelsByID(node.name);
				
				if( channels && channels.length )
				{
					var controller:AnimationController = new AnimationController();
					
					for each( var channel:DaeChannel in channels )
					{
						var keys:Array = channel.input;
						var values:Array = channel.output;
						var interpolations:Array = channel.interpolations;
						
						var targetObject:String = channel.target.split("/")[1];
						
						Logger.trace( node.name + " => " + targetObject );
						
						if( keys.length && keys.length == values.length )
						{
							var c:AnimationChannel = new AnimationChannel();
							
							switch( targetObject )
							{
								case "transform":
									c.addMatrixCurves( node.transform, keys, values, interpolations );
									controller.addChannel( c );
									break;
								default:
									break;
							}
						}
					}
					
					joint.controllers.push( controller );
				}
			}
			for each( var child:DisplayObject3D in node.children )
				linkAnimations( child );
		}
		
		/**
		 * 
		 * @param	node
		 * @return
		 */
		private function linkSkeletons( node:DisplayObject3D ):void
		{
			if( node is Skin3D )
			{
				var skinned:Skin3D = node as Skin3D;
				
				skinned.joints = new Array();
				
				var skin:DaeSkin = _skins[ skinned ];
				
				if( skin )
				{
					for( var i:int = 0; i < skin.joints.length; i++ )
					{
						var jid:String = skin.joints[i];
						
						if( !jid || !jid.length ) continue;
						
						var joint:DisplayObject3D = findChildByName(this, jid);
						if( !joint )
							joint = findChildBySID(this, jid);
							
						var bind:Array = skin.findJointBindMatrix2(jid);

						Node3D(joint).bindMatrix = new Matrix3D(bind);
						Node3D(joint).blendVerts = skin.findJointVertexWeightsByIDOrSID(jid);

						skinned.joints.push(joint);
					}
				}
			}
			
			for each( var child:DisplayObject3D in node.children )
				linkSkeletons( child );
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function animationCompleteHandler( event:Event ):void
		{
			linkAnimations(this);
			_dt = getTimer();
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function animationProgressHandler( event:ProgressEvent ):void
		{
			dispatchEvent(event);
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function geometryCompleteHandler( event:Event ):void
		{
			var i:int;
			
			var root:DisplayObject3D = addChild(new DisplayObject3D());
			
			for( i = 0; i < _document.vscene.nodes.length; i++ )
			{
				var node:DaeNode = _document.vscene.nodes[i];
				//if( node.type == DaeNode.TYPE_NODE )
					var obj:DisplayObject3D = buildScene( node, root );
			}
			
			//Logger.trace(dumpHierarchy(root));
			
			_dt = getTimer();
			
			try
			{
				linkSkeletons(this);
			}
			catch( e:Error )
			{
				Logger.trace( "[ERROR] while linking skeletons: " + e.toString() );
			}
			
			// should have something to show now...
			dispatchEvent(new Event(Event.COMPLETE));
					
			// but... there may be animations left to parse...
			_reader.addEventListener( Event.COMPLETE, animationCompleteHandler );
			_reader.addEventListener( ProgressEvent.PROGRESS, animationProgressHandler );
			
			_reader.readAnimations();
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function geometryProgressHandler( event:ProgressEvent ):void
		{
			dispatchEvent(event);
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function delayedLoadHandler( event:TimerEvent ):void
		{
			loadProgressHandler(new ProgressEvent(ProgressEvent.PROGRESS,false,false,1,1));
			
			var timer:Timer = Timer(event.target);
			timer.stop();
			timer.removeEventListener(TimerEvent.TIMER, delayedLoadHandler);
			
			_reader.loadDocument(_asset);
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function loadProgressHandler( event:ProgressEvent ):void
		{
			dispatchEvent(event);
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function materialCompleteHandler( event:Event ):void
		{
			
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function materialErrorHandler( event:FileLoadEvent ):void
		{
			var materialName:String = _queuedBitmaps[ event.file ];
			
			resetMaterial( this, materialName );
			
			Logger.trace( "[ERROR] material failed to load! " + materialName + " " + event.file );
		}
		
		/**
		 * 
		 * @param	node
		 * @param	materialName
		 * @param	newMaterial
		 * @return
		 */
		private function resetMaterial( node:DisplayObject3D, materialName:String, newMaterial:MaterialObject3D = null ):void
		{
			newMaterial = newMaterial || new ShadedColorMaterial(0xff0000);
			
			node.materials = node.materials || new MaterialsList();
			
			var mat:MaterialObject3D = node.materials.getMaterialByName(materialName);
			if( mat )
				node.materials.removeMaterialByName(materialName);
			
			node.materials.addMaterial(newMaterial, materialName);
			
			if( node.geometry )
			{
				for each( var face:Face3D in node.geometry.faces )
					face.material = newMaterial;
			}
			
			for each(var child:DisplayObject3D in node.children )
				resetMaterial( child, materialName, newMaterial );
		}
		
		/**
		 * 
		 * @param	node
		 * @param	indent
		 * @return
		 */
		private function dumpHierarchy(node:DisplayObject3D = null, indent:String = ""):String
		{
			node = node || this;
			
			var geom:GeometryObject3D = node.geometry;
			var sg:String = geom ? " v:"+geom.vertices.length + " f:" + geom.faces.length : "";
			
			var s:String = indent + node.name + sg + "\n";
			for each(var child:DisplayObject3D in node.children )
			{
				
				s += dumpHierarchy(child, indent + " -> ");		
			}
			return s;
		}
		
		/**
		 * 
		 * @return
		 */
		public override function toString():String
		{
			return dumpHierarchy();
		}
				
		private var _document:DaeDocument;
		
		private var _reader:DaeReader;
		
		private var _scaling:Number = 1;
		
		private var _queuedBitmaps:Object;
				
		private var _asset:*;
		
		// keep track of skins
		private var _skins:Dictionary;
		
		private var _dt:Number = getTimer();
	}
}