C# pb_Object.SetSharedIndicesUV方法代码示例

	/**
	 * move the UVs to where the edges passed meet
	 */
	static bool AlignEdges(pb_Object pb, pb_Face f1, pb_Face f2, pb_Edge edge1, pb_Edge edge2)
	{
		Vector2[] uvs = pb.uv;
		pb_IntArray[] sharedIndices = pb.sharedIndices;
		pb_IntArray[] sharedIndicesUV = pb.sharedIndicesUV;

		/**
		 * Match each edge vertex to the other
		 */
		int[] matchX = new int[2] { edge1.x, -1 };
		int[] matchY = new int[2] { edge1.y, -1 };

		int siIndex = sharedIndices.IndexOf(edge1.x);
		if(siIndex < 0) 
			return false;

		if(sharedIndices[siIndex].array.Contains(edge2.x))
		{
			matchX[1] = edge2.x;
			matchY[1] = edge2.y;
		}
		else
		{
			matchX[1] = edge2.y;
			matchY[1] = edge2.x;
		}

		// scale face 2 to match the edge size of f1
		float dist_e1 = Vector2.Distance(uvs[edge1.x], uvs[edge1.y]);
		float dist_e2 = Vector2.Distance(uvs[edge2.x], uvs[edge2.y]);
		
		float scale = dist_e1/dist_e2;
		
		// doesn't matter what point we scale around because we'll move it in the next step anyways
		foreach(int i in f2.distinctIndices)
			uvs[i] = uvs[i].ScaleAroundPoint(Vector2.zero, Vector2.one * scale);

		/**
		 * Figure out where the center of each edge is so that we can move the f2 edge to match f1's origin 
		 */
		Vector2 f1_center = (uvs[edge1.x] + uvs[edge1.y]) / 2f;
		Vector2 f2_center = (uvs[edge2.x] + uvs[edge2.y]) / 2f;

		Vector2 diff = f1_center - f2_center;

		/**
		 * Move f2 face to where it's matching edge center is on top of f1's center
		 */
		foreach(int i in f2.distinctIndices)
			uvs[i] += diff;

		/**
		 * Now that the edge's centers are matching, rotate f2 to match f1's angle
		 */
		Vector2 angle1 = uvs[matchY[0]] - uvs[matchX[0]];
		Vector2 angle2 = uvs[matchY[1]] - uvs[matchX[1]];

		float angle = Vector2.Angle(angle1, angle2);
		if(Vector3.Cross(angle1, angle2).z < 0)
			angle = 360f - angle;
	
		foreach(int i in f2.distinctIndices)
			uvs[i] = pb_Math.RotateAroundPoint(uvs[i], f1_center, angle);

		float error = Mathf.Abs( Vector2.Distance(uvs[matchX[0]], uvs[matchX[1]]) ) + Mathf.Abs( Vector2.Distance(uvs[matchY[0]], uvs[matchY[1]]) );

		// now check that the matched UVs are on top of one another if the error allowance is greater than some small value
		if(error > .02)
		{
			// first try rotating 180 degrees
			foreach(int i in f2.distinctIndices)
				uvs[i] = pb_Math.RotateAroundPoint(uvs[i], f1_center, 180f);

			float e2 = Mathf.Abs( Vector2.Distance(uvs[matchX[0]], uvs[matchX[1]]) ) + Mathf.Abs( Vector2.Distance(uvs[matchY[0]], uvs[matchY[1]]) );
			if(e2 < error)
				error = e2;
			else
			{
				// flip 'em back around
				foreach(int i in f2.distinctIndices)
					uvs[i] = pb_Math.RotateAroundPoint(uvs[i], f1_center, 180f);
			}
		}

		// If successfully aligned, merge the sharedIndicesUV
		pbUVOps.SplitUVs(pb, f2.distinctIndices);

		pb_IntArrayUtility.MergeSharedIndices(ref sharedIndicesUV, matchX);
		pb_IntArrayUtility.MergeSharedIndices(ref sharedIndicesUV, matchY);

		pb_IntArray.RemoveEmptyOrNull(ref sharedIndicesUV);

		pb.SetSharedIndicesUV(sharedIndicesUV);

		// @todo Update Element Groups here?

		pb.SetUV(uvs);
//.........这里部分代码省略.........

		/**
		 * Triangulate an entire pb_Object.
		 */
		public static void Triangulate(pb_Object pb)
		{
			Vector3[] 	v = pb.vertices;
			Color[] 	c = pb.colors;
			Vector2[] 	u = pb.uv;

			int triangleCount = pb.TriangleCount();
			// int triangleCount = pb_Face.AllTriangles(pb.faces).Length; // pb.msh.triangles.Length;

			if(triangleCount == v.Length)
			{
				Debug.LogWarning("We can't pull over any further!\npb_Object: " + pb.name + " is already triangulated.");
			}

			int vertexCount = triangleCount;
			int faceCount = vertexCount / 3;

			Vector3[]	tri_vertices = new Vector3[vertexCount];
			Color[] 	tri_colors = new Color[vertexCount];
			Vector2[]	tri_uvs = new Vector2[vertexCount];
			pb_Face[]	tri_faces = new pb_Face[faceCount];

			int n = 0, f = 0;
			foreach(pb_Face face in pb.faces)
			{
				int[] indices = face.indices;

				for(int i = 0; i < indices.Length; i+=3)
				{
					tri_vertices[n+0] = v[indices[i+0]];
					tri_vertices[n+1] = v[indices[i+1]];
					tri_vertices[n+2] = v[indices[i+2]];

					tri_colors[n+0] = c[indices[i+0]];
					tri_colors[n+1] = c[indices[i+1]];
					tri_colors[n+2] = c[indices[i+2]];

					tri_uvs[n+0] = u[indices[i+0]];
					tri_uvs[n+1] = u[indices[i+1]];
					tri_uvs[n+2] = u[indices[i+2]];
		
					tri_faces[f++] = new pb_Face( new int[] { n+0, n+1, n+2 },
												face.material,
												face.uv,
												face.smoothingGroup,
												face.textureGroup,		// textureGroup -> force to manual uv mode
												face.elementGroup,
												face.manualUV
											);	
					n += 3;
				}

			}

			pb.SetVertices(tri_vertices);
			pb.SetColors(tri_colors);
			pb.SetUV(tri_uvs);
			pb.SetFaces(tri_faces);

			pb.SetSharedIndices( pb_IntArrayUtility.ExtractSharedIndices(tri_vertices) );
			pb.SetSharedIndicesUV( new pb_IntArray[0] );
		}

	/**
	 *	\brief Given an array of "donors", this method returns a merged #pb_Object.
	 */
	 public static bool CombineObjects(pb_Object[] pbs, out pb_Object combined)
	 {
	 	combined = null;

	 	if(pbs.Length < 1) return false;

	 	List<Vector3> v = new List<Vector3>();
	 	List<Vector2> u = new List<Vector2>();
	 	List<Color> c = new List<Color>();
	 	List<pb_Face> f = new List<pb_Face>();
	 	List<pb_IntArray> s = new List<pb_IntArray>();
	 	List<pb_IntArray> suv = new List<pb_IntArray>();

	 	foreach(pb_Object pb in pbs)
	 	{
	 		int vertexCount = v.Count;

	 		// Vertices
	 		v.AddRange(pb.VerticesInWorldSpace());

	 		// UVs
	 		u.AddRange(pb.uv);

	 		// Colors
	 		c.AddRange(pb.colors);

			// Faces
	 		pb_Face[] faces = new pb_Face[pb.faces.Length];
	 		for(int i = 0; i < faces.Length; i++)
	 		{
	 			faces[i] = new pb_Face(pb.faces[i]);
	 			faces[i].manualUV = true;
	 			faces[i].ShiftIndices(vertexCount);
	 			faces[i].RebuildCaches();
	 		}
	 		f.AddRange(faces);

	 		// Shared Indices
	 		pb_IntArray[] si = pb.GetSharedIndices();
	 		for(int i = 0; i < si.Length; i++)
	 		{
	 			for(int n = 0; n < si[i].Length; n++)
	 				si[i][n] += vertexCount;
	 		}
	 		s.AddRange(si);

	 		// Shared Indices UV
	 		{
		 		pb_IntArray[] si_uv = pb.GetSharedIndicesUV();
		 		for(int i = 0; i < si_uv.Length; i++)
		 		{
		 			for(int n = 0; n < si_uv[i].Length; n++)
		 				si_uv[i][n] += vertexCount;
		 		}

		 		suv.AddRange(si_uv);
		 	}
	 	}

		GameObject go = (GameObject)GameObject.Instantiate(pbs[0].gameObject);
	 	go.transform.position = Vector3.zero;
	 	go.transform.localRotation = Quaternion.identity;
	 	go.transform.localScale = Vector3.one;

	 	// Destroy the children
	 	foreach(Transform t in go.transform)
	 		GameObject.DestroyImmediate(t.gameObject);

	 	if(go.GetComponent<pb_Object>()) GameObject.DestroyImmediate(go.GetComponent<pb_Object>());
	 	if(go.GetComponent<pb_Entity>()) GameObject.DestroyImmediate(go.GetComponent<pb_Entity>());

	 	combined = go.AddComponent<pb_Object>();

		combined.SetVertices(v.ToArray());
		combined.SetUV(u.ToArray());
		combined.SetColors(c.ToArray());
		combined.SetFaces(f.ToArray());

		combined.SetSharedIndices( s.ToArray() ?? pb_IntArrayUtility.ExtractSharedIndices(v.ToArray()) );
		combined.SetSharedIndicesUV( suv.ToArray() ?? new pb_IntArray[0] {});

		combined.ToMesh();

		combined.GetComponent<pb_Entity>().SetEntity( pbs[0].GetComponent<pb_Entity>().entityType );
	 	
	 	combined.CenterPivot( pbs[0].transform.position );

		combined.Refresh();

		// refresh donors since deleting the children of the instantiated object could cause them to lose references
		foreach(pb_Object pb in pbs)
			pb.Verify();

	 	return true;
	 }