ui_NEW_COREY_CHANGES_4_17_15.mel

{
	global int $isBuildingPluginLoaded = true;

	global string $baseCurve;
	global string $profileCurves[];
	global int $numProfiles;
	global float $baseCentroid[];
	global float $minPointHeightDiff;
	global int $doProfileCurvesStartFromTop[]; //0 indicates bottom, 1 indicates top
	global int $numPointsPerCurve[];
	global int $maxNumPtsInAProfile;
	global vector $curveDistancesFromBase[];
	global vector $intersectionStartPoints[];
	global vector $intersectionEndPoints[];
	global string $curveCommand;
	global float $averageProfPointHeights[]; //for each level!
	global string $loftedSurfaces[];
	global string $theExtrudedBuilding;

	
	global proc createCurveUI () {
		menu -parent MayaWindow -label "CURVE" -tearOff true "CurveMenu";

		menuItem -label "Make Base Curve" -command "makeBaseCurve" -parent CurveMenu "baseCurveItem";
		menuItem -label "Save Base Curve" -command "saveBaseCurve" -parent CurveMenu "baseSaveItem";
		menuItem -label "Make Profile Curve" -command "makeProfileCurve" -parent CurveMenu "profileCurveItem";
		menuItem -label "Save Profile Curve" -command "saveProfileCurves" -parent CurveMenu "profileSaveItem";
		menuItem -label "Clear Profile Curves" -command "clearProfileCurves" -parent CurveMenu "profileClearItem";
		menuItem -label "Extrude From Selected" -command "extrudeFromCurve" -parent CurveMenu "extrudeSelectedItem";


		menuItem -label "Load Building" -command "openLoadBuildingDialogue" -parent CurveMenu "loadItem";
		menuItem -label "Save Building" -command "openSaveBuildingDialogue" -parent CurveMenu "saveItem";

		menuItem -label "Extrude Building" -command "extrudeBuilding" -parent CurveMenu "extrudeItem";

	}


	//LOADING/SAVING
	global proc string getCurveCommand(string $curve, float $offsetX, float $offsetY, float $offsetZ){

		string $command = "curve -d 1";

		string $pString = "";
		string $kString = "";
		string $profCurveSpans = $curve + ".spans";
		string $degCurveSpans = $curve + ".degree";

		int $spans = `getAttr $profCurveSpans`;
		int $degree = `getAttr $degCurveSpans`;

		int $numPoints = $spans + $degree;
		int $i = 0;
		for($i = 0; $i < $numPoints; ++$i){
			float $currentPoint[] = `getAttr ($curve + ".cv[" + $i +"]")`;
			$pString += " -p " + ($currentPoint[0]+$offsetX) + " " + ($currentPoint[1]+$offsetY) + " " + ($currentPoint[2]+$offsetZ);
			$kString += " -k " + $i;
		}

		$command += $pString + $kString;

		return $command;
	}

	global proc int saveBuilding(string $filenameArr[]){
		if ( $isBuildingPluginLoaded == true){
			print("\n save filename: ");
			print($filenameArr);
			int $i = 0;
			string $filename;
			for($i = 0; $i < size($filenameArr); ++$i){
				$filename = $filename + $filenameArr[$i];
			}
			print ($filename);


			// Create A String Array With Test Data  
			string $myStrArray[] = {"This is line one of my data from Maya.", "This is line two.", "And then line three!"} ;  
			    
			  
			// Open Your File  
			$fileId = `fopen $filename "w"` ;  
			
			// Print base curve To File 
			if($baseCurve != ""){ 
				string $commandToPrint = getCurveCommand($baseCurve, 0, 0, 0);
				print("\n to print: ");
				print($commandToPrint);
				fprint $fileId ($commandToPrint+"\n") ;
			}




			// Print profile curves To File  
			//for($curve in $profileCurves)  
			//fprint $fileId ($line+"\n") ;  
			fprint $fileId (size($profileCurves) +"\n") ;
			for($i = 0; $i < size($profileCurves); ++$i){
				string $currentProfCurve = $profileCurves[$i];
				string $commandToPrint = getCurveCommand($currentProfCurve, 0, 0, 0);
				print("\n to print: ");
				print($commandToPrint);

				fprint $fileId ($commandToPrint+"\n") ;
			}


			//TODO: print anchors to file!
			  
			// Close File  
			fclose $fileId ; 
		}
		else{
			print("building plugin not loaded!");
			return false;
		}

		return true;
	}

	global proc int loadBuilding(string $filename){
		if ( $isBuildingPluginLoaded == true){
			clearProfileCurves();
			reset();


			print("\n load filename: ");
			print($filename);

			// Open File  
			$fileId = `fopen $filename "r"` ;  
			  
			// Define String Array  
			//string $dataArray[] ;  
			  
			// Get The First Line  
			string $nextLine = `fgetline $fileId` ; 
			eval($nextLine); //THIS IS THE BASE CURVE 
			saveBaseCurve();
			  
			//get the number of profile curves
			$nextLine = `fgetline $fileId` ;
			int $numberOfProfs = $nextLine;

			//Evaluate profile curves! 
			int $i = 0; 
			for($i = 0; $i < $numberOfProfs; ++$i) {  
			  
				// Strip Whitespace From The Beginning And End Of The Line  
				//string $cleanLine = strip($nextLine) ;  
				  
				// Add To Array  
				//$dataArray[size($dataArray)] = $cleanLine ;  
				  
				// Get Next Line And Continue  
				//PROFILE CURVES
				$nextLine = `fgetline $fileId` ;  
				eval($nextLine);
				saveProfileCurves();
			}  
		}
		else{
			print("building plugin not loaded!");
			return false;
		}
		extrudeBuilding();
		return true;
	}



	global proc openLoadBuildingDialogue(){
		//fileBrowser( "onOpen", "Hello", "", 0 ); //loadBuilding comes from the load/save mel
		//fileBrowserDialog -fc "onOpen" -m 0 -ft "" -an "Open" -in (`workspace -q -rd`+`workspace -q -active`);
		//$filename = fileDialog;
		string $result = `fileDialog`;
		print ($result);
		loadBuilding($result);
	}

	global proc openSaveBuildingDialogue(){
		//fileBrowser( "onSave", "HEyo", "", 0 ); //saveBuilding comes from the load/save mel
		//fileBrowserDialog -fc "onSave" -m 0 -ft "" -an "Save" -om "SaveAs" -in (`workspace -q -rd`+`workspace -q -active`);
		string $basicFilter = "*.txt";
		string $result[] = `fileDialog2 -fileFilter $basicFilter -dialogStyle 2`;
		print ($result);
		saveBuilding($result);
	}








	//BUILDING STUFF
	global proc makeBaseCurve () {
		selectCurveTool();

	}

	global proc saveBaseCurve () {
		string $selected[] = `ls -sl`;
		string $selectedCurve = $selected[0];
		
		$baseCurve = $selectedCurve;

		print "saved base curve!";

	}

	global proc makeProfileCurve () {
		selectCurveTool();
	}

	global proc saveProfileCurves () {
		$numProfiles = size($profileCurves);

		string $selected[] = `ls -sl`;

		$profileCurves[$numProfiles] = $selected[0];

		$numProfiles = $numProfiles + 1;

		print($profileCurves[0]);

		print "saved profile curve!";
	}

	global proc selectCurveTool () {

		CVCurveTool;
		curveCVToolScript 4;
		// Result: curveContextCV //
		curveCVValues curveContextCV;
		toolPropertyShow;
		changeToolIcon;
		autoUpdateAttrEd;
		updateAnimLayerEditor("AnimLayerTab");
		statusLineUpdateInputField;

		curveCVValues curveContextCV;
		curveCVCtx -e -d 1 -bez 0 `currentCtx`;



		//curveCVValues curveContextCV;
		//toolPropertyShow;
		//changeToolIcon;
		//autoUpdateAttrEd;
		//updateAnimLayerEditor("AnimLayerTab");
		//statusLineUpdateInputField;
		//curveCVCtx -e -d 1 -bez 0 `currentCtx`;
	
		//curveCVValues curveContextCV;
		//toolPropertyShow;
	}

	global proc float getDistance(float $p1[], float $p2[]){

		float $diffVec[] = {$p1[0] - $p2[0], $p1[1] - $p2[1], $p1[2] - $p2[2]};
		float $distance = sqrt (($diffVec[0] * $diffVec[0]) + ($diffVec[1] * $diffVec[1]) + ($diffVec[2] * $diffVec[2]));
		return $distance;
	}
 
	global proc clearProfileCurves(){
		clear($profileCurves);

		print(size($profileCurves));
	}

 	global proc reset(){
		clear($baseCentroid);
		//global float $minPointHeightDiff;
		clear($doProfileCurvesStartFromTop); //0 indicates bottom, 1 indicates top
		clear($numPointsPerCurve);
		//global int $maxNumPtsInAProfile;
		clear($intersectionStartPoints);
		clear($intersectionEndPoints);
		//global string $curveCommand;
		clear($averageProfPointHeights); //for each level!
		clear($loftedSurfaces);
		clear($curveDistancesFromBase);

		if($theExtrudedBuilding != "" && objExists($theExtrudedBuilding)){
			select -r $theExtrudedBuilding;
			doDelete;
		}
		$theExtrudedBuilding = "";
 	}

	global proc extrudeBuilding (){
		reset();


		//REMOVE ANY PROFILE CURVES THAT DON'T EXIST ANYMORE
		int $index = 0;
		string $deletedProfs[];
		int $numDeletedProfs = 0;
		for($index = 0; $index < size($profileCurves); ++$index){
			if(!objExists($profileCurves[$index])){
				$deletedProfs[$numDeletedProfs] = $profileCurves[$index];
				$numDeletedProfs++;
				print("\n removed a prof curve!");
			}
		}

		$profileCurves = stringArrayRemove($deletedProfs, $profileCurves);




		if ((size($profileCurves) > 0) && ($baseCurve != "")){

			string $baseCurveSpans = $baseCurve + ".spans";
			string $baseCurveDeg = $baseCurve + ".degree";
			int $spans = `getAttr $baseCurveSpans`;
			int $degree = `getAttr $baseCurveDeg`;

			int $numBasePoints = $spans + $degree;


			//count the TOTAL number of profile points, across all profile curves
			$maxNumPtsInAProfile = 0;
			int $numTotalProfilePoints = 0;
			for ($i = 0; $i < size($profileCurves); ++$i){
				string $currentCurve = $profileCurves[$i];

				//int $spans = `getAttr $currentCurve.spans`;
				//int $degree = `getAttr $currentCurve.degree`;

				//$numTotalProfilePoints += $spans + $degree;



				string $profCurveSpans = $currentCurve + ".spans";
				string $degCurveSpans = $currentCurve + ".degree";

				int $spans = `getAttr $profCurveSpans`;
				int $degree = `getAttr $degCurveSpans`;

				$numTotalProfilePoints = $spans + $degree;


				//print("\nTOTAL NUM PROFILE POINTS: ");
				//print($numTotalProfilePoints);

				//get the max number of points in a profile, for use in extrusion
				if($spans + $degree > $maxNumPtsInAProfile){
					$maxNumPtsInAProfile = $spans + $degree;
				}

				$numPointsPerCurve[$i] = $spans + $degree;

			}


			if($numBasePoints > 2){

				alignProfileCurves($numBasePoints);

				calculateAverageProfPointHeights();

				int $numProfileCurves = size($profileCurves);



				string $buildingCurves[];

				int $currPointIndex = 0;
				//for each point in the biggest profile curve... there should be a new 'base curve'
				for($currPointIndex = 0; $currPointIndex < $maxNumPtsInAProfile; ++$currPointIndex){


					int $buildingCurvePointNum = 0;

					//reset curveCommand string
					$curveCommand = "curve -d 1";
					string $pFlag = "-p";
					string $kFlag = "-k";
					string $nameFlag = "-name";
					string $space = " ";

					string $nextCurveName = "buildingCurve" + $currPointIndex;

					/*print("\ncurve command reset : ");
					print($curveCommand);

					print("\nnum base points: ");
					print($numBasePoints);*/

					int $basePointIteration = 0;

					for($basePointIteration = 0; $basePointIteration < $numBasePoints; ++$basePointIteration){
						float $currentBasePoint[] = `getAttr ($baseCurve + ".cv[" + $basePointIteration +"]")`;

						//print("\nbase point iteration: ");
						//print($basePointIteration);

						//FOR SOME REASON THE CURVE ISN'T MOVING DOWN BEFORE HERE...
						//float $height = $currentProfPoint[1] - $minPointHeightDiff; //TODO: DEAL WITH THIS FOR ALL CURVES
						float $height = $averageProfPointHeights[$currPointIndex];//TODO: DEAL WITH THIS FOR ALL CURVES



						$curveCommand = $curveCommand + $space + $pFlag + $space + $currentBasePoint[0] + $space + $height + $space + $currentBasePoint[2];

						$buildingCurvePointNum++;

						if($basePointIteration < $numBasePoints - 1){

							int $basePointIterationNext = $basePointIteration+1;
							float $nextBasePoint[] = `getAttr ($baseCurve + ".cv[" + $basePointIterationNext +"]")`;




							//go through current level of each profile curve
							for($i = 0; $i < $numProfileCurves; ++$i){

								//print("\nnum profile curves: ");
								//print($numProfileCurves);

								string $currentProfCurve = $profileCurves[$i];
								vector $currentDifferenceFromBase = $curveDistancesFromBase[$i];

								/*if($currPointIndex == 0){
									print( "\ni");
									print("\n");
									print($i);
									print("\n current diff from base! P1\n");
									print($currentDifferenceFromBase.x);
									print("\n");
									print($currentDifferenceFromBase.y);
									print("\n");
									print($currentDifferenceFromBase.z);
									print("\n");

								}*/

								if($doProfileCurvesStartFromTop[$i] == 0){ //curve starts at bottom
									print("\n curve starts at bottom!");

									if($numPointsPerCurve[$i] > $currPointIndex){ //if this curve has more points than the index we're at
										//check if current point intersects the base curve currently
										
										float $currentProfPoint[] = `getAttr ($currentProfCurve + ".cv[" + $currPointIndex +"]")`;

										vector $currIntersectionP1 = $intersectionStartPoints[$i];
										vector $currIntersectionP2 = $intersectionEndPoints[$i];

										if( insertCurveIntoBase($currentBasePoint, $nextBasePoint, $currIntersectionP1, $currIntersectionP2, $currentProfPoint, $currentDifferenceFromBase) == 1){
											$buildingCurvePointNum++;
										}

									}
									else{

										//use the highest curve point of the curve as the current curve, even if it's a duplicate
										int $lastCurvePointIndex = $numPointsPerCurve[$i] - 1;
										float $currentProfPoint[] = `getAttr ($currentProfCurve + ".cv[" + $lastCurvePointIndex +"]")`;


										vector $currIntersectionP1 = $intersectionStartPoints[$i];
										vector $currIntersectionP2 = $intersectionEndPoints[$i];

										if( insertCurveIntoBase($currentBasePoint, $nextBasePoint, $currIntersectionP1, $currIntersectionP2, $currentProfPoint, $currentDifferenceFromBase) == 1 ){
											$buildingCurvePointNum++;
										}
									}

								}
								else if($doProfileCurvesStartFromTop[$i] == 1){ //curve starts at top
									print("\n curve starts at top!");
									if($numPointsPerCurve[$i] > $currPointIndex){ //if this curve has more points than the index we're at
										int $lastCurvePointIndex = $numPointsPerCurve[$i] - 1 - $currPointIndex;
										float $currentProfPoint[] = `getAttr ($currentProfCurve + ".cv[" + $lastCurvePointIndex +"]")`;

										vector $currIntersectionP1 = $intersectionStartPoints[$i];
										vector $currIntersectionP2 = $intersectionEndPoints[$i];

										//vector $currIntersectionP3 = $intersectionStartPoints[$i+1];
										//vector $currIntersectionP4 = $intersectionEndPoints[$i+1];

										//print("\ncurrent index: ");
										//print($i);

										if($i == 2){
											/*print("\n num intersection start points!");
											print(size($intersectionStartPoints));

											print("\n currIntersection P1\n");
											print($currIntersectionP1.x);
											print("\n");
											print($currIntersectionP1.y);
											print("\n");
											print($currIntersectionP1.z);
											print("\n");

											print("\n currIntersection P2\n");
											print($currIntersectionP2.x);
											print("\n");
											print($currIntersectionP2.y);
											print("\n");
											print($currIntersectionP2.z);
											print("\n");*/

											/*print("\n currIntersection P3\n");
											print($currIntersectionP3.x);
											print("\n");
											print($currIntersectionP3.y);
											print("\n");
											print($currIntersectionP3.z);
											print("\n");

											print("\n currIntersection P4\n");
											print($currIntersectionP4.x);
											print("\n");
											print($currIntersectionP4.y);
											print("\n");
											print($currIntersectionP4.z);
											print("\n");*/
										}

										if( insertCurveIntoBase($currentBasePoint, $nextBasePoint, $currIntersectionP1, $currIntersectionP2, $currentProfPoint, $currentDifferenceFromBase) == 1 ){
											$buildingCurvePointNum++;
										}
									}
									else{
										int $lastCurvePointIndex = 0;
										float $currentProfPoint[] = `getAttr ($currentProfCurve + ".cv[" + $lastCurvePointIndex +"]")`;

										vector $currIntersectionP1 = $intersectionStartPoints[$i];
										vector $currIntersectionP2 = $intersectionEndPoints[$i];

										if( insertCurveIntoBase($currentBasePoint, $nextBasePoint, $currIntersectionP1, $currIntersectionP2, $currentProfPoint, $currentDifferenceFromBase) == 1 ){
											$buildingCurvePointNum++;
										}
									}


								}

							}

						}


					}

					for($j = 0; $j < $buildingCurvePointNum; ++$j){
						$curveCommand = $curveCommand + $space + $kFlag + $space + $j;
					}

					$curveCommand = $curveCommand + $space + $nameFlag + $space + $nextCurveName;

					//create the curve and add it to the buildingCurves array
					//print("\ncurve command eval: ");
					//print($curveCommand);
					eval ($curveCommand);
					$buildingCurves[$currPointIndex] = $nextCurveName;


				}

				//6. loft!
				if($maxNumPtsInAProfile > 0){
					string $firstCurve = $buildingCurves[0];
					//print("\nfirst building curve!");
					//print($firstCurve);
					closeCurve -ch 1 -ps 1 -rpo 1 -bb 0.5 -bki 0 -p 0.1 $firstCurve; //close the initial curve
				}
				for($i = 0; $i < $maxNumPtsInAProfile - 1; ++$i){
					string $curve1 = $buildingCurves[$i];
					string $curve2 = $buildingCurves[$i+1];
					closeCurve -ch 1 -ps 1 -rpo 1 -bb 0.5 -bki 0 -p 0.1 $curve2; //close the second curve

					//loft -ch 1 -u 1 -c 0 -ar 1 -d 3 -ss 1 -rn 0 -po 0 -rsn true $curve1 $curve2; //nurbs
					loft -ch 1 -u 1 -c 0 -ar 1 -d 3 -ss 1 -rn 0 -po 1 -rsn true $curve1 $curve2; //polygons

					string $selected[] = `ls -sl`;
					string $loftedSurface = $selected[0];
					$loftedSurfaces[$i] = $loftedSurface;
				}
				
				/* //DEBUG
				int $a = 0;
				for($a = 0; $a < size($intersectionStartPoints); ++$a){

					print("\nintersection starts");
					print($intersectionStartPoints[$a]);
					print("\nintersection ends");
					print($intersectionEndPoints[$a]);


				}*/

				//combine the lofted meshes:
				string $combineLoftedSurfacesCommand = "polyUnite -ch 1 -mergeUVSets 1";
				for($i = 0; $i < size($buildingCurves) - 1; ++$i){
					$combineLoftedSurfacesCommand = $combineLoftedSurfacesCommand + " " + $loftedSurfaces[$i];
				}
				eval ($combineLoftedSurfacesCommand);

				//delete the building curves -- don't need them anymore
				for($i = 0; $i < size($buildingCurves); ++$i){
					select -r $buildingCurves[$i];
					doDelete;
				}
				clear($buildingCurves);

				//fill in the holes!
				string $selected[] = `ls -sl`;
				$theExtrudedBuilding = $selected[0];
				polyCloseBorder -ch 1 polySurface1;
				

			}
			else{
				//not enough base points
				print "\nnot enough base points to extrude!";
			}
		}
		else{
			print "\neither no base curve or no profile curves!";
		}
	}


	global proc calculateAverageProfPointHeights(){

		print("\naveraging profile point heights!");

		int $numProfileCurves = size($profileCurves);

		int $currPointIndex = 0;
		//for each point in the biggest profile curve... there should be a new 'base curve'
		for($currPointIndex = 0; $currPointIndex < $maxNumPtsInAProfile; ++$currPointIndex){

			print("\n num profile curves: ");
			print($maxNumPtsInAProfile);

			float $sum = 0.0;
			float $numPoints = 0.0;

			//go through current level of each profile curve
			for($i = 0; $i < $numProfileCurves; ++$i){	

				print("\n num profile curves: ");
				print($numProfileCurves);

				string $currentProfCurve = $profileCurves[$i];
				vector $currentDifferenceFromBase = $curveDistancesFromBase[$i];

				if($doProfileCurvesStartFromTop[$i] == 0){ //curve starts at bottom
					print("\n averaging curve starts at bottom!");

					if($numPointsPerCurve[$i] > $currPointIndex){ //if this curve has more points than the index we're at
						//check if current point intersects the base curve currently
						
						float $currentProfPoint[] = `getAttr ($currentProfCurve + ".cv[" + $currPointIndex +"]")`;

						$sum += $currentProfPoint[1] - $currentDifferenceFromBase.y;
						$numPoints++;

					}
					else{
						print("\n averaging curve starts at bottom!");

						//use the highest curve point of the curve as the current curve, even if it's a duplicate
						int $lastCurvePointIndex = $numPointsPerCurve[$i] - 1;
						float $currentProfPoint[] = `getAttr ($currentProfCurve + ".cv[" + $lastCurvePointIndex +"]")`;

						$sum += $currentProfPoint[1] - $currentDifferenceFromBase.y;
						$numPoints++;
					}

				}
				else if($doProfileCurvesStartFromTop[$i] == 1){ //curve starts at top
					//print("\n curve starts at top!");
					if($numPointsPerCurve[$i] > $currPointIndex){ //if this curve has more points than the index we're at
						int $lastCurvePointIndex = $numPointsPerCurve[$i] - 1 - $currPointIndex;
						float $currentProfPoint[] = `getAttr ($currentProfCurve + ".cv[" + $lastCurvePointIndex +"]")`;

						$sum += $currentProfPoint[1] - $currentDifferenceFromBase.y;
						$numPoints++;
					}
					else{
						int $lastCurvePointIndex = 0;
						float $currentProfPoint[] = `getAttr ($currentProfCurve + ".cv[" + $lastCurvePointIndex +"]")`;

						$sum += $currentProfPoint[1] - $currentDifferenceFromBase.y;
						$numPoints++;
					}
				}
			}

			$averageProfPointHeights[$currPointIndex] = $sum / $numPoints;

		}

	}


	global proc int insertCurveIntoBase(float $baseP1[], float $baseP2[], vector $intersectEdgeP1 , vector $intersectEdgeP2, float $currentProfPoint[], vector $currentDifferenceFromBase){

				string $pFlag = "-p";
				string $kFlag = "-k";
				string $nameFlag = "-name";
				string $space = " ";

				float $xPos = $currentProfPoint[0] - $currentDifferenceFromBase.x;
				float $height = $currentProfPoint[1] - $currentDifferenceFromBase.y; //TODO: DEAL WITH THIS FOR ALL CURVES -- should store this somewhere...
				print("\ninserting curve. current prof point height: \n");
				print($height);
				float $zPos = $currentProfPoint[2] - $currentDifferenceFromBase.z;

				if(($baseP1[0] == $intersectEdgeP1.x) && ($baseP1[1] == $intersectEdgeP1.y) && ($baseP1[2] == $intersectEdgeP1.z)){
					//print("\nMAYBE ADDING EXTRA PROFILE CURVE POINT!");
					if(($baseP2[0] == $intersectEdgeP2.x) && ($baseP2[1] == $intersectEdgeP2.y) && ($baseP2[2] == $intersectEdgeP2.z)){
						//print("\nADDING EXTRA PROFILE CURVE POINT!");

						$curveCommand = $curveCommand + $space + $pFlag + $space + $xPos + $space + $height + $space + $zPos;
						//$buildingCurvePointNum++;
						return 1;
					}
				}
				else if(($baseP1[0] == $intersectEdgeP2.x) && ($baseP1[1] == $intersectEdgeP2.y) && ($baseP1[2] == $intersectEdgeP2.z)){
					//print("\nMAYBE ADDING EXTRA PROFILE CURVE POINT!");
					if(($baseP2[0] == $intersectEdgeP1.x) && ($baseP2[1] == $intersectEdgeP1.y) && ($baseP2[2] == $intersectEdgeP1.z)){
						//NOTE: DUPLICATE CODE FROM IF STATEMENT UP ABOVE. SHOULD REFACTOR.
						//print("\nADDING EXTRA PROFILE CURVE POINT!");

						$curveCommand = $curveCommand + $space + $pFlag + $space + $xPos + $space + $height + $space + $zPos;
						//$buildingCurvePointNum++;
						return 1;
					}
				}

				return 0;
			//}


		//}

	}



	global proc alignProfileCurves(float $numBasePoints){
		calculateBaseCentroid();

		int $numProfileCurves = size($profileCurves);
		for ($i = 0; $i < $numProfileCurves; ++$i){

			//for now, extrude based on a single profile curve
			//print("\nPROFILE CURVES ALIGN YEAHHH");
			//print("\nnum profile curves: ");
			//print($numProfileCurves);
			$profileCurve = $profileCurves[$i];
			
			print("\naligning curve: ");
			print($profileCurve);
			//TODO: CHANGE TO CHECKING if the first or last point is lower???
			
			//1. find if the first point or the last point of the profile curve is lower
			
			
			string $profCurveSpans = $profileCurve + ".spans";
			string $degCurveSpans = $profileCurve + ".degree";

			int $numSpans = `getAttr $profCurveSpans`;
			int $degree = `getAttr $degCurveSpans`;

			int $numProfilePoints = $numSpans + $degree;

			//print("num profile points!");
			//print($numProfilePoints);

			float $firstPos[] = `getAttr ($profileCurve + ".cv[0]")`;//`xform -worldSpace -query -translation $firstPoint`;
			float $lastPos[] = `getAttr ($profileCurve + ".cv[" + ($numProfilePoints - 1) +"]")`;//;`xform -worldSpace -query -translation $lastPoint`;


			float $minYPointPos[] = $firstPos;
			print("\nfirst pos x: ");
			print($firstPos[0]);
			print("\nlastPos x: ");
			print($lastPos[0]);
			

			int $isFirstPosHigh = 0; //bool for if first point or last
			print("\ncalculating if curve starts from top or bottom\n");
			print($lastPos[1]);
			if($lastPos[1] < $firstPos[1]){
				print("\nfirst pos is HIGH");
				$isFirstPosHigh = 1;
				$minYPointPos = $lastPos;
			}
			$doProfileCurvesStartFromTop[$i] = $isFirstPosHigh;


			//translate curve to y = 0 if necessary...
			if( ($i == 0) || ($minYPointPos[1] < $minPointHeightDiff) ){
				$minPointHeightDiff = $minYPointPos[1];
			}

			//3. find edge of curve that intersects with line (bottom curve point and polygon centroid)

			//get minYPoint's new position
			
			$minYPointPos[1] = 0; //when moved, should have been set to zero --> can set this directly.



			//4. move the profile curve to intersect with the base curve

			float $intersectionPoint[];


			float $intersectEdgeStart[] = {0.0, 0.0, 0.0};
			float $intersectEdgeEnd[] = {0.0, 0.0, 0.0};
			int $isIntersection = 0;

			int $j = 0;
			for ($j = 0; $j < $numBasePoints - 1; ++$j){

				float $p1Pos[] = `getAttr ($baseCurve + ".cv[" + $j +"]")`;//`xform -worldSpace -query -translation $p1`;


				float $jPlus = $j + 1;
				float $p2Pos[] = `getAttr ($baseCurve + ".cv[" + $jPlus +"]")`;//`xform -worldSpace -query -translation $p2`;

				//takes in bottom profile curve point, and edge defining positions
				if ( checkProfileEdgeIntersection($minYPointPos, $p1Pos, $p2Pos) == 1) {	

					print "calculating intersection point!";
					
					//calculate the intersection point
					$tempIntersectionPoint = calculateIntersectionPointXZ($minYPointPos, $baseCentroid, $p1Pos, $p2Pos);



					if($isIntersection == 1){ //there has already been an intersection
						//if the distance from the minPoint to the edge is less -- use that as the intersection!
						print("\nCHECK COMPETING INTERSECTION");
						if(getDistance($minYPointPos, $tempIntersectionPoint) < getDistance($minYPointPos, $intersectionPoint)){

							$intersectEdgeStart = $p1Pos;
							$intersectEdgeEnd = $p2Pos;

							$intersectionPoint = $tempIntersectionPoint;

							print("\nINTERSECTION DEFEATED");
						}
						//else, don't change the current intersection point

					}
					else{
						print("\nSET INIT INTERSECTION");
						$intersectEdgeStart = $p1Pos;
						$intersectEdgeEnd = $p2Pos;

						$intersectionPoint = $tempIntersectionPoint;

						$isIntersection = 1;
					}

				}
			}
			if($isIntersection == 1){ // there should always be an intersection, as we're moving the profile toward the base
				//DEBUG SPHERE
				polySphere -ch on -o on -r 0.189486 ;
				move -r $intersectionPoint[0] $intersectionPoint[1] $intersectionPoint[2];



				/*print("\nminYpoint");
				print("\n");
				print($minYPointPos[0]);
				print("\n");
				print($minYPointPos[1]);
				print("\n");
				print($minYPointPos[2]);

				print("\nintersection point");
				print("\n");
				print($intersectionPoint[0]);
				print("\n");
				print($intersectionPoint[1]);
				print("\n");
				print($intersectionPoint[2]);*/




				//RECALCULATING THIS. MAY BE UNNECESSARY. BLARG.
				float $firstPos[] = `getAttr ($profileCurve + ".cv[0]")`;
				float $lastPos[] = `getAttr ($profileCurve + ".cv[" + ($numProfilePoints - 1) +"]")`;


				//$isFirstPosHigh = 1; //bool for if first point or last
				//$doProfileCurvesStartFromTop[$i] = $isFirstPosHigh;

				float $minYPointPos[] = $firstPos;
				
				if($lastPos[1] < $firstPos[1]){
					//print("\nfirst pos is HIGH");
					$isFirstPosHigh = 1;
					$minYPointPos = $lastPos;
				}




				//minYPoint - intersection point -- need to move the profile curve to meet the intersection point...
				float $diffVec[] = {$minYPointPos[0] - $intersectionPoint[0], $minYPointPos[1] - $intersectionPoint[1], $minYPointPos[2] - $intersectionPoint[2]};

				float $diffX = $diffVec[0];
				float $diffY = $diffVec[1];
				float $diffZ = $diffVec[2];

				vector $differenceFromBase = <<$diffX, $diffY, $diffZ>>;
				$curveDistancesFromBase[$i] = $differenceFromBase;

				/*print("\nmoving to this intersection point:");
				print($intersectionPoint[0]);
				print("\n");
				print($intersectionPoint[1]);
				print("\n");
				print($intersectionPoint[2]);*/


				//create new curve command -- make a new one at the right position!
				//move the profile curve to align with edge!
				select -r $profileCurve ;
				move -r (-$diffX) (-$diffY) (-$diffZ) ; //already moved down earlier



				/*string $newProfCurveCommand = getCurveCommand($profileCurve, -$diffX, -$diffY, -$diffZ);
				string $newName = $profileCurve;
				select -r $profileCurve;
				doDelete;

				string $deletedProfs[] = {$profileCurve};
				$profileCurves = stringArrayRemove($deletedProfs, $profileCurves);

				$newProfCurveCommand += "-name " + "profCurve" + (size($profileCurves) + 1) ; //SWAP OUT CURVES
				eval($newProfCurveCommand); //create the replacement profile curve
				saveProfileCurves(); //will save the newly created profile curve*/


				//$minYPointPos[0] = $minYPointPos[0] + (-$diffVec[0]/2.0);
				//$minYPointPos[2] = $minYPointPos[2] + (-$diffVec[2]/2.0);

				print("OH HEY ADDING AN INTERSECTION POINT NOW");

				//HERE WE KEEP TRACK OF THE INTERSECTION POINTS
				vector $intersectionStartVector = <<$intersectEdgeStart[0],$intersectEdgeStart[1],$intersectEdgeStart[2]>>;
				vector $intersectionEndVector = <<$intersectEdgeEnd[0],$intersectEdgeEnd[1],$intersectEdgeEnd[2]>>;

				$intersectionStartPoints[ size($intersectionStartPoints) ] = $intersectionStartVector;
				$intersectionEndPoints[ size($intersectionEndPoints) ] = $intersectionEndVector;

				/*print("\nINTERSECTION START\n");
					print($intersectionStartVector.x);
					print("\n");
					print($intersectionStartVector.y);
					print("\n");
					print($intersectionStartVector.z);


				print("\nINTERSECTION END\n");
					print($intersectionEndVector.x);
					print("\n");
					print($intersectionEndVector.y);
					print("\n");
					print($intersectionEndVector.z);*/

			}
			


		}


	}

	global proc calculateBaseCentroid(){
		// formula: http://en.wikipedia.org/wiki/Centroid#Centroid_of_polygon

		//print("\n calculating centroid!");

		float $baseCentroidX;
		float $baseCentroidZ;

		string $baseCurveSpans = $baseCurve + ".spans";
		string $degCurveSpans = $baseCurve + ".degree";
		int $spans = `getAttr $baseCurveSpans`;
		int $degree = `getAttr $degCurveSpans`;

		int $numBasePoints = $spans + $degree;
		
		float $area;
		if($numBasePoints >= 3){
			for($i = 0; $i < $numBasePoints - 1; ++$i){

				float $p1Pos[] = `getAttr ($baseCurve + ".cv[" + $i +"]")`;
				float $iPlus = $i + 1;
				float $p2Pos[] = `getAttr ($baseCurve + ".cv[" + $iPlus + "]")`;

				// A = p1.x * p2.z - p2.x * p1.z
				$area += ( $p1Pos[0] * $p2Pos[2] ) - ( $p2Pos[0] * $p1Pos[2] );

				/*print ("\n p1: ");
				print $p1Pos[0];
				print (" ");
				print $p1Pos[2];

				print ("\n p2: ");
				print $p2Pos[0];
				print (" ");
				print $p2Pos[2];*/

				//Cx = ( p1.x + p2.x ) * (p1.x * p2.z - p2.x * p1.z)
				$baseCentroidX += ( $p1Pos[0] + $p2Pos[0] ) * ( ( $p1Pos[0] * $p2Pos[2] ) - ( $p2Pos[0] * $p1Pos[2] ) ) ;

				//Cz = ( p1.z + p2.z ) * (p1.x * p2.z - p2.x * p1.z)
				$baseCentroidZ += ( $p1Pos[2] + $p2Pos[2] ) * ( ( $p1Pos[0] * $p2Pos[2] ) - ( $p2Pos[0] * $p1Pos[2] ) );



				if($i == $numBasePoints - 2){
					//DO ONE LAST ROUND WITH THE FIRST POINT AND THE LAST POINT
					float $p1Pos[] = `getAttr ($baseCurve + ".cv[" + $iPlus + "]")`;
					float $p2Pos[] = `getAttr ($baseCurve + ".cv[0]")`;

					$area += ( $p1Pos[0] * $p2Pos[2] ) - ( $p2Pos[0] * $p1Pos[2] );

					$baseCentroidX += ( $p1Pos[0] + $p2Pos[0] ) * ( ( $p1Pos[0] * $p2Pos[2] ) - ( $p2Pos[0] * $p1Pos[2] ) ) ;

					
					$baseCentroidZ += ( $p1Pos[2] + $p2Pos[2] ) * ( ( $p1Pos[0] * $p2Pos[2] ) - ( $p2Pos[0] * $p1Pos[2] ) );
				}
			}
		}

		//do (outside of sum) scalar mults
		$area = $area*0.5;
		//print("\nbase area: ");
		//print $area;
		float $areaMult = 1.0/(6.0*$area);
		$baseCentroidX = $baseCentroidX * $areaMult;
		$baseCentroidZ = $baseCentroidZ * $areaMult;

		/*print("\ncentroid X: ");
		print $baseCentroidX;

		print("\ncentroid Z: ");
		print $baseCentroidZ;*/

		$baseCentroid[0] = $baseCentroidX;
		$baseCentroid[1] = 0;
		$baseCentroid[2] = $baseCentroidZ;

		//DEBUG SPHERE
		polySphere -ch on -o on -r 0.05;
		move -r $baseCentroidX 0.0 $baseCentroidZ;
	}

	global proc int checkProfileEdgeIntersection(float $minYPointPos[], float $p1Pos[], float $p2Pos[]){
		// algorithm: http://bryceboe.com/2006/10/23/line-segment-intersection-algorithm/

		calculateBaseCentroid();

		/*print("\nminYPointPos: ");
		print($minYPointPos);
		print("p1Pos:");
		print($p1Pos);
		print("p2Pos");
		print($p2Pos);*/


		if( checkCCW ( $minYPointPos, $p1Pos, $p2Pos ) != checkCCW ( $baseCentroid , $p1Pos, $p2Pos ) ){
			if( checkCCW ( $minYPointPos, $baseCentroid, $p1Pos) != checkCCW ( $minYPointPos, $baseCentroid, $p2Pos ) ){
				print ("\nan intersection!");
				return 1;
			}
		}
		else{
			print("\nno intersection!");
			return 0;
		}

		return 0;
	}

	//check CCW -- in XZ plane
	global proc int checkCCW(float $a[], float $b[], float $c[]){
		if( ($c[2] - $a[2]) * ($b[0] - $a[0]) > ($b[2] - $a[2]) * ($c[0] - $a[0]) ) {
			//print("\nis ccw!");
			return 1;
		
		}
		//print("\nnot ccw!");
		return 0;
	}

	global proc float[] calculateIntersectionPointXZ(float $start1[], float $end1[], float $start2[], float $end2[]){ //in the XZ plane
		calculateBaseCentroid();

		/*print("\nGAHHH\n");

		print("\nstart point 1: ");
		print($start1);
		print("\nend point 1: ");
		print($end1);
		print("\nstart point 2: ");
		print($start2);
		print("\nend point 2: ");
		print($end2);*/

		//make sure the points with the lowest x coord are the start points
		if($start1[0] > $end1[0]){
			//print("\n SWAP!");
			float $temp[] = $start1;
			$start1 = $end1;
			$end1 = $temp;
		}

		if($start2[0] > $end2[0]){
			//print("\n SWAP!");
			float $temp[] = $start2;
			$start2 = $end2;
			$end2 = $temp;
		}


		/*print("\nstart point 1: ");
		print($start1);
		print("\nend point 1: ");
		print($end1);
		print("\nstart point 2: ");
		print($start2);
		print("\nend point 2: ");
		print($end2);*/

		//solve for slope m
		float $rise1 = ($end1[2] - $start1[2]);
		float $run1 = ($end1[0] - $start1[0]);

		float $rise2 = ($end2[2] - $start2[2]);
		float $run2 = ($end2[0] - $start2[0]);


		if($run1 == 0){
			if($run2 == 0){
				//parallel! both are vertical lines
				print ("\nERROR: NO INTERSECTION -- VERTICAL PARALLEL LINES");
			
				float $intersection[] = {0.0, 0.0, 0.0};
				return $intersection;
			}
			float $m2 = $rise2 / $run2;

			float $b2 = $start2[2] - ($m2 * $start2[0]);

			float $x = $start1[0]; //line is vertical, constant x
			float $z = ($m2 * $x) + $b2;

			float $intersection[] = {$x, 0.0, $z};
			//print("\nintersection: ");
			print($intersection);
			return $intersection; 
		}
		else if($run2 == 0){
			float $m1 = $rise1 / $run1;

			float $b1 = $start1[2] - ($m1 * $start1[0]);

			float $x = $start2[0]; //line is vertical, constant x
			float $z = ($m1 * $x) + $b1;

			float $intersection[] = {$x, 0.0, $z};
			//print("\nintersection A: ");
			//print($intersection);
			return $intersection;
		}
		else{

			//...now continue with usual case...

			//solve for slope m
			float $m1 = $rise1 / $run1;
			float $m2 = $rise2 / $run2;


			//check for parallel lines -- same slope
			if($m1 == $m2){
				print ("\nERROR: NO INTERSECTION -- PARALLEL LINES");
			
				float $intersection[] = {0.0, 0.0, 0.0};
				return $intersection;
			}
			else{ //otherwise not parallel
				//solve for z-intercept b
				float $b1 = $start1[2] - ($m1 * $start1[0]);
				float $b2 = $start2[2] - ($m2 * $start2[0]);

				float $x = ($b1 - $b2) / ($m2 - $m1);

				//solve for z:
				float $z = ($m1 * $x) + $b1;

				float $intersection[] = {$x, 0.0, $z};
				/*print("\nintersection: B");
				print($intersection);
				print("\nslope m1");
				print($m1);
				print("\nslope m2");
				print($m2);
				print("\nintercept b1");
				print($b1);
				print("\nintercept b2");
				print($b2);*/
				return $intersection;
			}
		}

	}


	global proc extrudeFromCurve (){ //TODO: change to using base curve
		string $selected[] = `ls -sl`;
		string $selectedCurve = $selected[0];

		//int $numCurvePoints = `getAttr $selected.spans` + `getAttr $selected.degree`;



		select -r $selectedCurve ;
		duplicate -rr;
		move -r 0 6 0 ;

		select -tgl $selectedCurve ;

		string $selected[] = `ls -sl`;
		$selectedCurve = $selected[0];
		string $selectedCurve2 = $selected[1];
		loft -ch 1 -u 1 -c 0 -ar 1 -d 3 -ss 1 -rn 0 -po 0 -rsn true $selectedCurve $selectedCurve2;
	}

	global proc deleteCurveUI () {
		deleteUI CurveMenu;
	}
}