dae.as

flash 360全景浏览

		}
		
		/**
		 * 
		 * @param	id
		 * @return
		 */
		private function findAnimationChannelsByID( id:String ):Array
		{
			var channels:Array = new Array();
		
			try
			{
				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);
					}
				}
			}
			catch( e:Error )
			{
				
			}
			return channels;
		}
		
		/**
		 * 
		 * @param	channels
		 * @param	sid
		 * @param	time
		 * @return
		 */
		private function findChannelMatrix( channels:Array, sid:String, time:Number = 0 ):Matrix3D
		{
			try
			{
				for( var i:int = 0; i < channels.length; i++ )
				{
					var channel:DaeChannel = channels[i];
					if( channel.syntax.targetSID == sid )
					{
						for( var j:int = 0; j < channel.input.length; j++ )
						{
							var t:Number = channel.input[j];
													
							if( t == time )
								return new Matrix3D(channel.output[j]);
								
							if( t > time )
								break;
						}
					}
				}
			}
			catch( e:Error )
			{
				Papervision3D.log( "[WARNING] Could not find channel matrix for SID=" + sid );
			}
			return null;
		}
		
		/**
		 * Finds a child by dae-ID or dae-SID.
		 * 
		 * @param	node
		 * @param	daeID
		 * @param	bySID
		 * @return
		 */
		private function findChildByID(node:DisplayObject3D, daeID:String, bySID:Boolean = false):DisplayObject3D
		{	
			if( node is Node3D )
			{
				if( bySID && Node3D(node).daeSID == daeID )
					return node;
				else if( !bySID && Node3D(node).daeID == daeID )
					return node;
			}
			for each(var child:DisplayObject3D in node.children ) 
			{
				var n:DisplayObject3D = findChildByID(child, daeID, bySID);
				if( n )
					return n;
			}
			
			return null;			
		}
		
		/**
		 * Finds a child by name.
		 * 
		 * @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;
		}
		
		/**
		 * Finds the top-most Node3D in the scenegraph.
		 * 
		 * @param	node The node to start searching.
		 * 
		 * @return The found Node3D or null on failure.
		 */
		private function findRootNode(node:DisplayObject3D):Node3D
		{
			if( node is Node3D )
				return Node3D(node);
				
			for each(var child:DisplayObject3D in node.children ) 
			{
				var n:DisplayObject3D = findRootNode(child);
				if( n is Node3D )
					return Node3D(n);
			}
			
			return null;
		}
		
		/**
		 * 
		 * @param	node
		 * @param	sid
		 * @return
		 */
		private function findTransformBySID( node:Node3D, sid:String ):DaeTransform
		{
			for each( var transform:DaeTransform in node.transforms )
			{
				if( transform.sid == sid )
					return transform;
			}
			return null;
		}
		
		/**
		 * Attempts to find a morph-controller for a node.
		 * 
		 * @param	node	The DaeNode. @see org.ascollada.core.DaeNode
		 * 
		 * @return The controller found, or null if not found. @see org.ascollada.core.DaeInstanceController
		 */
		private function findMorphController( node:DaeNode ):DaeInstanceController
		{
			for each( var controller:DaeInstanceController in node.controllers )
			{
				var control:DaeController = document.controllers[controller.url];
				if( control.morph )
					return controller;
			}
			return null;
		}
		
		/**
		 * Attempts to find a skin-controller for a node.
		 * 
		 * @param	node	The DaeNode. @see org.ascollada.core.DaeNode
		 * 
		 * @return The controller found, or null if not found. @see org.ascollada.core.DaeInstanceController
		 */
		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;
		}
			
		/**
		 * Flips all face normals of a geometry.
		 * 
		 * @param	geometry
		 */ 
		private function flipFaceNormals( geometry:GeometryObject3D ):void
		{
			if(!geometry || !geometry.faces)
				return;
				
			for each(var triangle:Triangle3D in geometry.faces)
			{
				triangle.faceNormal.x = -triangle.faceNormal.x;
				triangle.faceNormal.y = -triangle.faceNormal.y;
				triangle.faceNormal.z = -triangle.faceNormal.z;	
				
				// recalculate vertex normals
				triangle.v0.calculateNormal();
				triangle.v1.calculateNormal();
				triangle.v2.calculateNormal();
			}	
		}
		
		/**
		 * Links a skin to its bones.
		 * 
		 * @param	skin	The Skin3D to link.
		 * @param	instance_controller
		 * @return
		 */
		private function linkSkin(skin:Skin3D, instance_controller:DaeInstanceController):void
		{
			var controller:DaeController = document.controllers[ instance_controller.url ];
			
			var daeSkin:DaeSkin = controller.skin;

			var found:Object = new Object();
			
			skin.joints = new Array();
			skin.skeletons = new Array();

			// <instance_controller> node can have 0 <skeleton> nodes...
			// so we simply push the 'top' node ID into the skeletons array.
			if( !instance_controller.skeletons.length )
			{
				var node:Node3D = findRootNode(this);
				
				if( node )
					instance_controller.skeletons.push(node.daeID);
				else
					throw new Error( "instance_controller doesn't have a skeleton node, and no _rootNode could be found!" );
			}
			
			// the skeletons array contains the ID of nodes to start searching for our bones.
			for(var i:int = 0; i < instance_controller.skeletons.length; i++ )
			{				
				var skeletonId:String = instance_controller.skeletons[i];
				var skeletonNode:DisplayObject3D;
				
				// there should be a DO3D in our scenegraph
				skeletonNode = findChildByID(this, skeletonId);
				if( !skeletonNode )
				{
					Papervision3D.log( "[ERROR] could not find skeleton: " + skeletonId );
					throw new Error( "could not find skeleton: " + skeletonId);
				}		
				
				// save a reference of the skeleton to Skin3D
				skin.skeletons.push(skeletonNode);

				// loop over all bones for this skin
				for( var j:int = 0; j < daeSkin.joints.length; j++ )
				{
					var jointId:String = daeSkin.joints[j];
					
					// make sure we don't add this bone twice
					if( found[jointId] )
						continue;
						
					// the bone *should* be a child of the skeleton
					var joint:Node3D = findChildByID(skeletonNode, jointId) as Node3D;
					if( !joint )
						joint = findChildByID(skeletonNode, jointId, true) as Node3D;
					if( !joint )
						joint = findChildByID(this, jointId, true) as Node3D;
					if( !joint )
					{
						Papervision3D.log( "[ERROR] could not find joint: " + jointId + " " + skeletonId);
						throw new Error( "could not find joint: " + jointId + " " + skeletonId);
					}
					
					// the bone *should* have a bindmatrix
					var bindMatrix:Array = daeSkin.findJointBindMatrix2(jointId);
					if( !bindMatrix )
					{
						Papervision3D.log( "[ERROR] could not find bindmatrix for joint: " + jointId);
						throw new Error( "could not find bindmatrix for joint: " + jointId );
					}	
					joint.bindMatrix = new Matrix3D(bindMatrix);
					
					// the bone *should* have vertex weights
					joint.blendVerts = daeSkin.findJointVertexWeightsByIDOrSID(jointId);
					if( !joint.blendVerts )
					{
						Papervision3D.log( "[ERROR] could not find influences for joint: " + jointId );
						throw new Error( "could not find influences for joint: " + jointId );
					}	
					
					skin.joints.push(joint);
					
					found[jointId] = joint;
				}
			}
			
			var ctl:SkinController = new SkinController(skin, _yUp);
			
			skin.addController(ctl);
		}
		
		/**
		 * Links all skins with its bones etc.
		 * 
		 * @param	do3d
		 * @return
		 */
		private function linkSkins( do3d:DisplayObject3D ):void
		{
			if( _skins[ do3d ] is DaeInstanceController && do3d is Skin3D )
				linkSkin(do3d as Skin3D, _skins[do3d]);
				
			for each( var child:DisplayObject3D in do3d.children )
				linkSkins(child);
		}
				
		/**
		 * 
		 * @param	do3d
		 * @param	existingMaterial
		 * @param	newMaterial
		 * @return
		 */
		private function updateMaterials( do3d:DisplayObject3D, existingMaterial:MaterialObject3D, newMaterial:MaterialObject3D ):void
		{
			existingMaterial.unregisterObject(do3d);
			
			if( do3d.material === existingMaterial )
				do3d.material = newMaterial;
					
			if( do3d.geometry && do3d.geometry.faces && do3d.geometry.faces.length )
			{
				for each( var triangle:Triangle3D in do3d.geometry.faces )
				{
					if( triangle.material === existingMaterial )
						triangle.material = newMaterial;
				}
			}
			
			for each( var child:DisplayObject3D in do3d.children )
				updateMaterials( child, existingMaterial, newMaterial );
		}
		
		/**
		 * 
		 * @param	event
		 * @return
		 */
		private function animationCompleteHandler( event:Event ):void
		{
			if(this.animate)
				buildAnimations(this);
			dispatchEvent(event);
		}
		
		/**
		 * Fired when an animation was loaded.
		 * 
		 * @param	event
		 */
		private function animationProgressHandler( event:ProgressEvent ):void
		{
			dispatchEvent(event);
		}
		
		/**
		 * Fired on collada file load progress.
		 * 
		 * @param	event
		 */
		private function loadProgressHandler( event:ProgressEvent ):void
		{
			dispatchEvent(event);
		}
		
		/**
		 * Fired when a material was succesfully loaded.
		 * 
		 * @param	event
		 */
		private function materialCompleteHandler( event:FileLoadEvent ):void
		{
			dispatchEvent(event);
		}
		
		/**
		 * Fired when an IOErrorEvent occured.
		 * 
		 * @param	event
		 */
		private function handleIOError( event:IOErrorEvent ):void
		{
			dispatchEvent(event);
		}
		
		/**
		 * Fired when a material failed to load.
		 * 
		 * @param	event
		 */
		private function materialErrorHandler( event:FileLoadEvent ):void
		{
			Logger.error( "[ERROR] a texture failed to load: " + event.file );
			dispatchEvent( event );
		}
		
		/** Parses the Collada file. @see org.ascollada.io.DaeReader. */
		private var _reader:DaeReader;
		
		/** Morphs. */
		private var _morphs:Dictionary;
		
		/** Skins. */
		private var _skins:Dictionary;
		
		/** */
		private var _materialInstances:Object;
		
		/** */
		private var _materialTextureSets:Object;
		
		/** Boolean indicating the Collada file's UP-axis is Y-up or not. */
		private var _yUp:Boolean;
		
		/** The asset passed to load. @see #load */
		private var _asset:*;
		
		/** */
		private var _rootNode:DisplayObject3D;
		
		/** Boolean indicating the DAE's scale was set before load. */
		private var _loadScaleSet:Boolean = false;
	}
}