polyExpand_revisit.vfl

float clampAngle(float inputAngle){
  float x = inputAngle/3.14159265;
  x=x%2;
  if(x>1){
      x=-1+(x%1);
  }
  if(x<-1){
      x=1+(x%1);
  }
  x = x*3.14159265;
  return x;
}

float sideCheckXZ(vector s; vector e; vector p){ //+=left
  float result = (e[0]-s[0])*(p[2]-s[2])  -  (e[2]-s[2])*(p[0]-s[0]);
  return result;
}

//To fix the uv's we must first find a distance attribute between original points

//for each prim group "class"
int currentClass = 0;
int pass;
int foundPrimitives[];
while (len(foundPrimitives)>0||currentClass==0){ //loop through all classes, escape when reaching highest class
	foundPrimitives={}; 	///☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼///
	//go through all primitives
	int nprim = nprimitives(0);
	for(int npim=0; npim<nprim;npim++){  //push all primitives of class x to foundPrimitives
		//get prim class
		int c = prim(0,"class",npim);
		if(c==currentClass){
			push(foundPrimitives,npim);
		}
	}
	if(len(foundPrimitives)>0){
		int originals[];			///☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼///
		int boundaries[];			///☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼☼///
		foreach(int fprim; foundPrimitives){ //push all original points to an original array
			int pointArray[] = primpoints(0,fprim);
			foreach(int thisPoint; pointArray){
				int original = inpointgroup(0, "original",thisPoint);//int  inpointgroup(<geometry>geometry, string groupname, int pointnum)
				if(original==1){
					if(find(originals, thisPoint)<0){
						push(originals,thisPoint);					
					}
				}else{
					if(find(boundaries, thisPoint)<0){
						push(boundaries,thisPoint);					
					}
				}
			}
		}

		//find a way to remove junctions from evaluation. 
		int firstOriginal = 0;
		int lastOriginal = -1;
		int originalsReversed[] = reverse(originals);
		foreach(int originalCheck; originals){ //oci="originalcheckindex"
			if( inpointgroup(0,"j",originalCheck) ==1){
				//go to next
			}else{//not a junction
				firstOriginal=originalCheck;
				break;
			}
		}
		foreach (int originalCheck;originalsReversed){
			if( inpointgroup(0,"j",originalCheck) ==1){
				//go to next
			}else{//not a junction
				lastOriginal=originalCheck;
				break;
			}		    
		}

		vector dir = prim(0,"dir",foundPrimitives[0]);
		vector p1 = point(0,"P",firstOriginal);
		vector p2 = point(0,"P",lastOriginal);
		vector dir2 = normalize(p2-p1);
		float dot = dot(dir,dir2);
		if(dot<0){
			originals = reverse(originals);
		}
		//if(currentClass==138){
		//	printf("originals: %f\\n",originals);
		//	printf("dir1: %f, dir2: %f, o1: %f, o2: %f, dot: %f\\n", dir,dir2,originals[0],originals[-1],dot);
		//}



		//find the distance to root(first point in "originals[]") for each orignal, and store
		float total = 0.0;
		float ucoords[];
		float originalAngles[];
		vector originalPositions[];
		for(int o=0;o<len(originals);o++){
			int lastOriginal = originals[o-1];
			int thisOriginal = originals[o];
			int nextOriginal = originals[o+1];
			vector o1 = point(0,"P",lastOriginal);
			vector o2 = point(0,"P",thisOriginal);
			vector o3 = point(0,"P",nextOriginal);
			vector delta = o3-o2;
			float a = atan2(delta[2],delta[0]);
			///////////////////////////////////
			///////////////////////////////////
			///////////////////////////////////
			///////////////////////////////////
			//store location
			push(originalPositions, o2);
			//store angle
			if(o<len(originals)-1){
				push(originalAngles,a);
			}else{//repeat last angle for last point
				push(originalAngles,originalAngles[-1]);
			}
			//store offset
			if(o!=0){
				total = total + distance(o1,o2);
			}

			//set uv coordinate
			push(ucoords, total);
			vector ouv = set(total,0.5);
			pass = setpointattrib(0,"uv",thisOriginal, ouv,"set");
			//pass = setpointattrib(0,"Cd",thisOriginal, hsvtorgb({0.1,1.0,1.0}),"set");
			//vector ouv2 = set(total,0);
			//pass = setpointattrib(0,"uv",thisOriginal, ouv2,"set");
		}

		//now we deal with boundaries.
		foreach(int fprim; foundPrimitives){
			int thisprimPoints[] = primpoints(0,fprim);
			//find at least one original
			int theseOriginals[]; //indices to actual original
			int theseBounds[];	//actual bound #
			foreach(int tpp; thisprimPoints){
				int index = find(originals,tpp);
				if(index>-1){
					push(theseOriginals, index);
				}
				index = find(boundaries,tpp);
				if(index>-1){
					push(theseBounds,tpp);
				}
			}
			//float offset = ucoords[thisOriginal];
			//float angle = originalAngles[thisOriginal];
			foreach(int seg; int bound; theseBounds){
				//find closest original
				vector thisP = point(0,"P",bound);
				float minDist=9999999;
				int closestOriginalIndex =-1;
				foreach(int origAddress;theseOriginals){
					float distance = distance(originalPositions[origAddress],thisP);
					if(distance<minDist){
						closestOriginalIndex = origAddress;
						minDist = distance;
					}
				}
				//find angle and distanceto that closest original
				//vector delta = thisP - originalPositions[closestOriginalIndex];
				vector delta = thisP-originalPositions[closestOriginalIndex];
				float dist = length(delta);
				float ang = atan2(delta[2],delta[0]);
				float refang = originalAngles[closestOriginalIndex];
				float angCorrected = ang-refang;

				vector newuv = set(
					cos(angCorrected)*minDist+ucoords[closestOriginalIndex],
					sin(angCorrected)*minDist+0.5
				);
				int pass2 = setpointattrib(0,"uv", bound, newuv,"set");
				//pass = setpointattrib(0,"Cd",bound, hsvtorgb(set(bound/71.0,1.0,1.0)),"set");
			}

		}
	}





	currentClass++;
}