//<script>
;
 
 
 
if( typeof(startupScripts) == 'undefined'){
 
	var startupScripts = {
		"0":function(){},
		"1":function(){},
		"2":function(){},
		"3":function(){},
		"4":function(){},
		"5":function(){},
		"6":function(){},
		"7":function(){}
	};
 
}
 
 
 
/**
*
* Class containing all the methods used in the 3d visual assembly
* @class renderGlobal
* @static
*/
 
 
 
 
// Put recieved data about assembly into here. The code handles the rest.
// theXMLFile should be a string, and theSTLFiles as a binary ArrayBuffer
// Any text-based STL files should be in an 8-bit encoding
/**
*
* The function which handles the actual rendering of the solution file animation
* and loading in the models
*
* @method rdr_recieveData
* @for renderGlobal
* @param {String} theXMLFile
* @param {Object} theSTLFiles
* @return {Void}
*
*/
function rdr_receiveData(theXMLFile, theSTLFiles){
 
	theXML=theXMLFile;
 
	parts.length=0;
	var pos=0;
	var lim=theSTLFiles.length;
	var partGeom;
	var partMesh;
 
	while(pos<lim){
		partGeom=null;
		partGeom=theSTLFiles[pos];
		if(partGeom===null){
			partGeom=parseStlBinary(fileReaders[pos].Reader.result);
		}
 
		//console.log(partGeom);
 
		partMesh=new THREE.Mesh(
				partGeom,
				new THREE.MeshNormalMaterial( )
		);
		parts.push({
			Mesh: partMesh,
			Name: fileReaders[pos].Name
		})
		scene.add(partMesh);
 
		pos++;
	}
 
	rdr_renderParts();
 
}
 
 
 
 
 
 
 
 
 
// Dialates time with the scrolling of the mouse
function rdr_zoomIt(e){
 
	//zoom=zoom*Math.pow(1.001,e.wheelDelta);
	var theDelta = e.deltaY == 0 ? 0 : ( e.deltaY > 0 ? 1 : -1 );
	zoom+=theDelta*(-1);
 
}
 
 
/**
*
*  Attempts to lock the mouse for camera manupulation
*
* @method rdr_tryMouseLock
* @for renderGlobal
* @return {Void}
*
*/
function rdr_tryMouseLock(){
 
	var element= document.getElementById("theDisplay");
 
	element.requestPointerLock = element.requestPointerLock ||
		 element.mozRequestPointerLock ||
		 element.webkitRequestPointerLock;
	// Ask the browser to lock the pointer
	element.requestPointerLock();
 
}
 
 
 
/**
*
* Adds or Removes event listeners for input meant for camera manipulation.
* Is triggered by a change in the state of the mouse locking or unlocking.
* The mouse locking results in input listeners being added to the webpage,
* whereas the unlocking of the mouse results in the removal of appropriate
* listeners.
*
* @method rdr_lockChange
* @for renderGlobal
*
*
* @param {Event} e The event that is to be applied to the function by event listeners upon
* a change in the state of mouselock
* @return {Void}
*
*
*/
function rdr_lockChange(e){
 
	var theTarget=document.getElementById("theDisplay");
	if (document.pointerLockElement === theTarget ||
		document.mozPointerLockElement === theTarget ||
		document.webkitPointerLockElement === theTarget) {
		// Pointer was just locked
		// Enable the mousemove listener
		document.addEventListener("mousemove", rdr_mouseMoved, false);
		pointerIsLocked=true;
	}
	else {
		// Pointer was just unlocked
		// Disable the mousemove listener
		document.removeEventListener("mousemove", rdr_mouseMoved, false);
		pointerIsLocked=false;
	}
 
}
 
 
 
/**
*
* Changes the orientation of the camera based off of the mouse movement
* contained in the supplied mouse movement event. X-axis movement
* corresponds to change in the yaw of the camera whereas Y-axis movement
* corresponds to a change in the pitch of the camera.
*
* @method rdr_mouseMoved
* @for renderGlobal
*
* @param {Event} e The mouse movement event to be supplied to the function by a mouse
* movement event listener on the web page
* @return {Void}
*
*/
function rdr_mouseMoved(e){
 
	var movementX = e.movementX ||
		  e.mozMovementX        ||
		  e.webkitMovementX     ||
		  0;
	var movementY = e.movementY ||
		  e.mozMovementY        ||
		  e.webkitMovementY     ||
		  0;
 
	camPitch-=movementY/400;
	if(camPitch> Math.PI/2){
		camPitch= Math.PI/2;
	}
	else if(camPitch< Math.PI/(-2)){
		camPitch= Math.PI/(-2)
	}
 
	camYaw-=movementX/400;
	if(camPitch> Math.PI){
		camPitch= Math.PI;
	}
	else if(camPitch< Math.PI*(-1)){
		camPitch= Math.PI*(-1);
	}
 
}
 
 
 
// Changes key press states based off of key presses
/**
*
* Accepts a key press event and, if the key press corresponds to one
* of the keys used for manipulating the view, sets the proper components
* of "inputState" to true.
*
* @method rdr_registerDown
* @for renderGlobal
*
*
* @param {Event} e The key down event to be supplied to the function by a key down event
* listener on the web page
* @return {Void}
*
*/
function rdr_registerDown(e){
 
 
 
	var theKey;
	if (e.which == null) {
		theKey= String.fromCharCode(e.keyCode) // IE
	} else if (e.which!=0 /*&& e.charCode!=0*/) {
		theKey= String.fromCharCode(e.which)   // the rest
	} else {
		return;// special key
	}
	theKey=theKey.toUpperCase();
 
 
 
	if(theKey=='A'){
		inputState.A=true;
	}
	if(theKey=='S'){
		inputState.S=true;
	}
	if(theKey=='D'){
		inputState.D=true;
	}
	if(theKey=='W'){
		inputState.W=true;
	}
	if(theKey==' '){
		inputState.Space=false;
	}
	if(theKey=='Q'){
		inputState.Q=true;
	}
	if(theKey=='E'){
		inputState.E=true;
	}
	if(theKey=='R'){
		inputState.R=true;
	}
	if(theKey=='F'){
		inputState.F=true;
	}
	return;
 
}
 
 
 
 
/**
*
* Accepts a key press release and, if the key release corresponds to one
* of the keys used for manipulating the view, sets the proper components
* of "inputState" to false
*
* @method rdr_registerUp
* @for renderGlobal
*
*
* @param {Event} e The key up event to be supplied to the function by a key up event
* listener on the web page
* @return {Void}
*
*/
function rdr_registerUp(e){
 
 
	var theKey;
	if (e.which == null) {
		theKey= String.fromCharCode(e.keyCode) // IE
	} else if (e.which!=0 /*&& e.charCode!=0*/) {
		theKey= String.fromCharCode(e.which)   // the rest
	} else {
		return;// special key
	}
	theKey=theKey.toUpperCase();
 
 
 
	if(theKey=='A'){
		inputState.A=false;
	}
	if(theKey=='S'){
		inputState.S=false;
	}
	if(theKey=='D'){
		inputState.D=false;
	}
	if(theKey=='W'){
		inputState.W=false;
	}
	if(theKey==' '){
		inputState.Space=false;
	}
	if(theKey=='Q'){
		inputState.Q=false;
	}
	if(theKey=='E'){
		inputState.E=false;
	}
	if(theKey=='R'){
		inputState.R=false;
	}
	if(theKey=='F'){
		inputState.F=false;
	}
	return;
 
}
 
 
// Affects the state of the camera/animation based off of the state of the inputs
/**
*
* Once called, interprets the current state of registered inputs and manipulates
* the visualization accordingly, including the accelleration of the camera, as
* affected by the W,S,A, and D keys, and the rotation of the camera if the F key
* is depressed and there currently is a highlighted object of interest
*
* @method rdr_manageControls
* @for renderGlobal
* @return {Void}
*
*/
function rdr_manageControls(){
 
	// Set up rotation and relative position deltas
	var theRot= new THREE.Quaternion(0,0,0,0);
	theRot.setFromEuler(camera.rotation);
	var theDir= new THREE.Vector3(0,0,0);
 
 
	//
	if(inputState.A==true){
		theDir.x-=1;
	}
	if(inputState.S==true){
		theDir.z+=1;
	}
	if(inputState.D==true){
		theDir.x+=1;
	}
	if(inputState.W==true){
		theDir.z-=1;
	}
	if(inputState.Space==true && inputState.switchPrimed==true){
		inputState.switchPrimed = false;
		treequenceActive = !treequenceActive;
	}
	if(inputState.Space==false){
		inputState.switchPrimed = true;
	}
	if(inputState.Q==true){
		momentum.y-=1;
	}
	if(inputState.E==true){
		momentum.y+=1;
	}
	if(inputState.R==true){
		theTime=0;
	}
 
	if(theDir.length()>0.1){
 
		if(theBoost<boostLim){
 
			theBoost+=boostInc;
 
		}
		else{
 
			theBoost=boostLim;
 
		}
 
	}
	else{
 
		theBoost=1;
 
	}
 
	theDir.applyQuaternion(theRot);
	theDir.multiplyScalar(theSpeed*theBoost);
 
	momentum.x+=theDir.x;
	momentum.y+=theDir.y;
	momentum.z+=theDir.z;
 
	camera.position.x+=momentum.x;
	camera.position.y+=momentum.y;
	camera.position.z+=momentum.z;
 
 
 
 
	if(inputState.F==true){
		if(focusPoint==null && objectOfInterest!=null){
			focusPoint=objectOfInterest;
		}
		if(focusPoint!=null){
 
			camera.lookAt(getPartCenter(focusPoint));
			camPitch=camera.rotation.x;
			camYaw=camera.rotation.y;
		}
	}
	else{
		if(focusPoint!=null){
			focusPoint.Mesh.material= getStdMaterial();
			focusPoint=null;
		}
	}
 
	if(focusPoint==null){
		camera.rotation.x=camPitch;
		camera.rotation.y=camYaw;
	}
 
 
}
 
 
 
 
 
 
 
/**
*
* Accepts a string and outputs the string of all characters following the final '.' symbol
* in the string. This is used internally to extract file extensions from file names.
*
* @method rdr_grabExtension
* @for renderGlobal
* @param {String} theName The file name to be processed
* @return {String} the extension in the given file name. If no extension is found, the
* 'undefined' value is returned.
*
*/
function rdr_grabExtension(theName){
	return (/[.]/.exec(theName)) ? /[^.]+$/.exec(theName) : undefined;
}
 
// Returns from the given list of file readers those that have not completed loading
function rdr_whoIsLeft(theReaders){
 
	var pos=0;
	var lim=fileReaders.length;
	var theList=[];
	while(pos<lim){
		if(theReaders[pos].Reader.readyState!=2){
			theList.push(theReaders[pos].Name);
		}
		pos++;
	}
	console.log(theList);
 
}
 
 
 
 
/**
*
* Called internally by "loadParts". Parses the text stored in "theXML" into a tree
* structure composed of nested javascript objects and converts that structure into a
* series of keyframe arrays, each of which are stored alongside their respective
* parts in "partFrames". Additionally, generates the path lines for each subassembly
* and inserts those lines into "scene".
*
* @method rdr_renderParts
* @for renderGlobal
* @return {Void}
*
*/
function rdr_renderParts(){
 
 
	theXML = inText;
	// Cuts of the common first characters from all the part names
	cutoffPartNames(parts);
 
	// Parses in the xml of the treequence
	//console.log(theXML);
	var treeQ = $.parseXML(theXML);
	console.log(treeQ);
	treeQ=grab(treeQ,"AssemblyCandidate");
	//console.log(treeQ);
	treeQ=grab(treeQ,"Sequence");
	//console.log(treeQ);
	treeQ=grab(treeQ,"Subassemblies");
	//console.log(treeQ);
	treeQ=grab(treeQ,"SubAssembly");
 
	// Turns the treequence into a tree storing the movement data of each subassembly
	console.log(treeQ);
	var moveTree=getMovement(treeQ,0,0,0,new THREE.Vector3(0,0,0),0);
	console.log(moveTree);
 
	// Cuts off the common first characters of all the part names in the tree
	cutOffNames(moveTree,similarityCutoff(getNameList(moveTree)));
	//console.log(moveTree);
	//printAllNames(parts,moveTree);
 
	// Makes a series of keyframes for each part for evaluation in the animation
	var theFrameLists=makeKeyFrames(moveTree,[],[]);
	timeAdjustment = addCurveKeyFrames( theFrameLists, new THREE.Vector3 ( 1000,1000,1000 ) );
	//bumpTreeTimes(moveTree,10*timeAdjustment);
	//console.log(theFrameLists);
	//console.log(parts);
 
	// Links each key frame list object to the appropriate part object
	partFrames= bindPartsToKeyFrames(theFrameLists,parts);
	//console.log(partFrames.length.toString());
	//console.log(partFrames.length.toString());
	//console.log(partFrames);
	//showFrames(theFrameLists);
 
	// Zeroes the time, for obvious reasons
	theTime=0;
 
	// Adds the movement trace lines to the scene
	addLines(moveTree,null,scene,false);
 
	// Stores the movement tree for later use
	movementTree=moveTree;
 
	// Mirrors the time measurements at each keyfram to turn the dissassembly into
	// an assembly animation
	flipTreeTime(movementTree,getLongestTime(movementTree));
	//console.log(partFrames.length.toString());
	addDisplacement(movementTree, partFrames, 0);
 
	// Populates the treequence graphic
	document.getElementById("treequenceDiv").classList.add("refBranch");
	insertTreequenceHTML(movementTree,document.getElementById("treequenceDiv"));
	rdr_showHideTreequence();
 
	// Fixes a minor thing in the treequence graphic
	getChildrenByTag(document.getElementById("treequenceDiv"),"BUTTON")[0].innerHTML="+";
	getChildrenByTag(document.getElementById("treequenceDiv"),"DIV")[0].classList.add("rootNode");
	// Begins to display the parts
	initAxisLines();
 
	alignAssemblyCenter();
 
	addGrid(50000,500, -1000, 0x888888);
	addGrid(50000,500, 8000, 0x888888);
 
	var pos = 0;
	while(pos<100){
		addCylender(200, -1000, 8000, (pos%10)/10*50000-25000, pos/10/10*50000-25000, 8, 12, 0x888888);
		pos++;
	}
 
	rdr_render();
 
}
 
 
 
 
// Toggles the display of the treequence graphic
/**
*
* Toggles the display of the HTML div element containing the treequence representation of
* the assembly.
*
* @method rdr_showHideTreequence
* @for renderGlobal
* @return {Void}
*
*/
function rdr_showHideTreequence(){
 
	TDiv=document.getElementById("treequenceDiv");
	if(TDiv.state=="shown"){
		TDiv.state="notShown";
		TDiv.classList.remove("shown");
		TDiv.classList.add("hidden");
	}
	else{
		TDiv.state="shown";
		TDiv.classList.remove("hidden");
		TDiv.classList.add("shown");
	}
 
}
 
 
 
startupScripts["7"] = function(){
	//
	//    Pretty Important: Keep this as true unless/until you've incorperated some other
	//                      method of getting file input/output
	//
	manualFileInput=false;
 
 
	if(manualFileInput==true){
 
		document.getElementById("HUD").innerHTML="<input type='file' id='fileinput' multiple />"+document.getElementById("HUD").innerHTML;
 
	}
	// Holder for animation frames for parts
	partFrames=null;
 
	// Sets the time to 0, for the sake of starting the animation at the right time
	theTime=0;
 
 
	// Holder for parsed-in javascript objects from the XML document
	theTreequence=null;
 
	treequenceActive = false;
 
 
	timeAdjustment = 0;
 
	standard = false;
 
 
	// Holds the state of button press inputs to smooth out control response
 
 
 
	/**
	*
	* Contains a representation of the last keyboard events reported by the
	* web page for each given key that acts as input for manipulating the
	* visulization: 'W','A','S','D','R','F', and the 'Space' key
	*
	* @element inputState
	* @for renderGlobal
	* @return {Void}
	*
	*/
	inputState={
 
		W: false,
		A: false,
		S: false,
		D: false,
		R: false,
		F: false,
		Q: false,
		E: false,
		Space: false,
		switchPrimed: false
 
	}
 
 
	// The color of the background of the scene
	skyColor= 0xFFFFFF;
 
	if(standard){
		skyColor = 0x000000;
	}
 
	// The tree structure holding animation data
	movementTree=null;
	theCenter= new THREE.Vector3(0,0,0);
 
	// The part directly in front of the camera, if any such part exists
	objectOfInterest=null;
 
	// The part being locked onto by using the 'F' key
	focusPoint=null;
 
	// Name of the part being looked at, if there is any such part
	mouseOverText="";
 
	// Time dialation coefficeint
	zoom=0.2;
 
	// Base Accelleration
	theSpeed=0.2;
 
	// Accelleration bonus variables
	theBoost=1; // Initial accelleration bonus
	boostLim=25; // Limit to accelleration bonus
	boostInc=0.1; // Rate of accelleration bonus increase
 
	// Coefficient of drag camera experiences
	theDrag=0.96;
 
	// Angles of camera
	camYaw=0;
	camPitch=Math.PI/2;
 
	// The momentum of the camera
	momentum= new THREE.Vector3(0,0,0);
 
 
 
	/**update
	*
	* The main portion of the visualization's rendering cycle, managing frame rate,
	* input, camera decelleration, keyframe manipulation, model animation, object highlighting,
	* and informational display.
	*
	* @method render
	* @for renderGlobal
	* @return {Void}
	*
	*/
	rdr_render = function () {
 
		// The function that will manage frame requests
		requestAnimationFrame( rdr_render );
 
 
 
		// Recieve input and set the appropriate state
		rdr_manageControls();
 
		// Apply air friction to camera
		momentum.multiplyScalar(theDrag);
 
 
		// Moves the parts along the appropriate motions of the animation
		if(zoom>=0){
			theTime=animate(partFrames,theTime,Math.pow(zoom,1.008),treequenceActive);
		}
		else{
			theTime=animate(partFrames,theTime,0-Math.pow(0-zoom,1.008),treequenceActive);
		}
 
 
		// Reset the appearence of the last object of interest
		if(objectOfInterest!=null){
			objectOfInterest.Mesh.material=getStdMaterial();
		}
 
		// Get the first part being directly looked at and sets it as object of interest
		objectOfInterest=getFirstIntersect(scene,camera,partFrames);
 
 
		// Change appearance of the object of interest and display the appropriate information
		if(objectOfInterest!==null && standard !== true){
 
			mouseOverText=" "+objectOfInterest.Name.substring(0,objectOfInterest.Name.length-4);
			objectOfInterest.Mesh.material=new THREE.MeshStandardMaterial({
				color:0xbbbbbb,
				roughness: 1.0,
				metalness: 1.0,
				shading: THREE.SmoothShading
			} );
 
		}
		else{
 
			mouseOverText="";
 
		}
 
 
		// Change appearance of the focus point mesh
		if(focusPoint!=null && standard !== true){
 
			focusPoint.Mesh.material=new THREE.MeshStandardMaterial({
				color:0xff6666,
				roughness: 1.0,
				metalness: 1.0,
				shading: THREE.SmoothShading
			} );
 
		}
 
 
		// Display information about the object of interest
		document.getElementById("mouseoverName").innerHTML="PART: "+mouseOverText;
		document.getElementById("theTime").innerHTML=("TIME: "+ theTime.toFixed(10)).toString();
 
		// Update the installation trace lines
		updateLines(movementTree,null,theTime-timeAdjustment,false,treequenceActive);
 
		updateAxisLines();
 
 
		// Call for the render
		renderer.render(scene, camera);
 
	};
 
	camera.position.x=0;
	camera.position.z=0;
	camera.position.y=0;
 
	// The variable holding the state of whether or not the pointer is locked
	pointerIsLocked=false;
 
	clearScene("theDisplay");
 
	// Setting camera to Yaw-Pitch-Roll configuration
	camera.rotation.reorder('YXZ');
 
 
	theXAxis=null;
	theYAxis=null;
	theZAxis=null;
	xRet=null;
	yRet=null;
 
 
 
 
	// Adding a whole bunch of event listeners for input
	document.getElementById("theDisplay").addEventListener("wheel", rdr_zoomIt);
	document.addEventListener('pointerlockchange', rdr_lockChange, false);
	document.addEventListener('mozpointerlockchange', rdr_lockChange, false);
	document.addEventListener('webkitpointerlockchange', rdr_lockChange, false);
	document.addEventListener('keydown', rdr_registerDown , false);
	document.addEventListener('keyup', rdr_registerUp , false);
 
	rdr_renderParts();
 
}
 
//</script>