Fast texture tool improvements (#3624)

https://files.facepunch.com/louie/1b1811b1/sbox-dev_wPVinlJTtE.png

-Support Tiling in the fast texture tool.
-Shortcuts.
-Escaping out resets to orignal uv.
-Unwrap Square better.
-World Mapping.
-Apply active material when entering fast texturing.
-Clicking in the rect view with no rect file fills to the full uv.
-Snapping toggle.
-Reset uv and focus buttons.
-New cleaner UI.

Author: bakscratch

game/addons/tools/Code/Editor/RectEditor/EdgeAwareFaceUnwrapper.cs

@@ -14,41 +14,23 @@ public EdgeAwareFaceUnwrapper( MeshFace[] meshFaces )
 		faces = meshFaces;
 	}
 
-	public UnwrapResult UnwrapToSquare()
+	public UnwrapResult Unwrap( MappingMode mode )
 	{
 		if ( faces.Length == 0 )
 			return new UnwrapResult();
 
-		foreach ( var face in faces )
-		{
-			if ( !face.IsValid )
-				continue;
+		bool straighten = mode == MappingMode.UnwrapSquare;
 
-			var vertices = face.Component.Mesh.GetFaceVertices( face.Handle );
-			var indices = new List<int>();
-
-			foreach ( var vertexHandle in vertices )
-			{
-				var key = (face, vertexHandle);
-				if ( !faceVertexToIndex.TryGetValue( key, out var index ) )
-				{
-					index = vertexPositions.Count;
-					faceVertexToIndex[key] = index;
-					vertexPositions.Add( face.Component.Mesh.GetVertexPosition( vertexHandle ) );
-				}
-				indices.Add( index );
-			}
-
-			faceToVertexIndices[face] = indices;
-		}
+		InitializeVertexMap();
 
 		var unwrappedUVs = new List<Vector2>( new Vector2[vertexPositions.Count] );
 		var processedFaces = new HashSet<MeshFace>();
 		var faceQueue = new Queue<MeshFace>();
 
 		if ( faces.Length > 0 && faces[0].IsValid )
 		{
-			UnwrapFirstFace( faces[0], unwrappedUVs );
+			// Seed the unwrap with the first face
+			UnwrapFirstFace( faces[0], unwrappedUVs, straighten );
 			processedFaces.Add( faces[0] );
 
 			for ( int i = 1; i < faces.Length; i++ )
@@ -69,7 +51,7 @@ public UnwrapResult UnwrapToSquare()
 			if ( processedFaces.Contains( currentFace ) )
 				continue;
 
-			if ( TryUnfoldFace( currentFace, processedFaces, unwrappedUVs ) )
+			if ( TryUnfoldFace( currentFace, processedFaces, unwrappedUVs, straighten ) )
 			{
 				processedFaces.Add( currentFace );
 				attempts = 0;
@@ -80,62 +62,185 @@ public UnwrapResult UnwrapToSquare()
 			}
 		}
 
-		var finalFaceIndices = new List<List<int>>();
+		return BuildResult( unwrappedUVs );
+	}
+
+	private void InitializeVertexMap()
+	{
 		foreach ( var face in faces )
 		{
-			if ( face.IsValid && faceToVertexIndices.TryGetValue( face, out var indices ) )
+			if ( !face.IsValid )
+				continue;
+
+			var vertices = face.Component.Mesh.GetFaceVertices( face.Handle );
+			var indices = new List<int>();
+
+			foreach ( var vertexHandle in vertices )
 			{
-				finalFaceIndices.Add( indices );
+				var key = (face, vertexHandle);
+				if ( !faceVertexToIndex.TryGetValue( key, out var index ) )
+				{
+					index = vertexPositions.Count;
+					faceVertexToIndex[key] = index;
+					vertexPositions.Add( face.Component.Mesh.GetVertexPosition( vertexHandle ) );
+				}
+				indices.Add( index );
 			}
-		}
 
-		return new UnwrapResult
-		{
-			VertexPositions = unwrappedUVs,
-			FaceIndices = finalFaceIndices,
-			OriginalPositions = vertexPositions
-		};
+			faceToVertexIndices[face] = indices;
+		}
 	}
 
-	private void UnwrapFirstFace( MeshFace face, List<Vector2> unwrappedUVs )
+	private void UnwrapFirstFace( MeshFace face, List<Vector2> unwrappedUVs, bool straighten )
 	{
 		if ( !faceToVertexIndices.TryGetValue( face, out var indices ) || indices.Count < 3 )
 			return;
 
-		var pos0 = vertexPositions[indices[0]];
-		var pos1 = vertexPositions[indices[1]];
-		var pos2 = vertexPositions[indices[2]];
+		if ( straighten && indices.Count == 4 )
+		{
+			var p0 = vertexPositions[indices[0]];
+			var p1 = vertexPositions[indices[1]];
+			var p3 = vertexPositions[indices[3]];
 
-		var u = (pos1 - pos0).Normal;
-		var normal = u.Cross( (pos2 - pos0).Normal ).Normal;
-		var v = normal.Cross( u );
+			float width = p0.Distance( p1 );
+			float height = p0.Distance( p3 );
 
-		foreach ( var vertexIndex in indices )
+			unwrappedUVs[indices[0]] = new Vector2( 0, 0 );
+			unwrappedUVs[indices[1]] = new Vector2( width, 0 );
+			unwrappedUVs[indices[2]] = new Vector2( width, height );
+			unwrappedUVs[indices[3]] = new Vector2( 0, height );
+		}
+		else
 		{
-			var pos = vertexPositions[vertexIndex];
-			var relative = pos - pos0;
-			unwrappedUVs[vertexIndex] = new Vector2( relative.Dot( u ), relative.Dot( v ) );
+			var p0 = vertexPositions[indices[0]];
+			var p1 = vertexPositions[indices[1]];
+			var p2 = vertexPositions[indices[2]];
+
+			var uDir = (p1 - p0).Normal;
+			var normal = uDir.Cross( (p2 - p0).Normal ).Normal;
+			var vDir = normal.Cross( uDir );
+
+			foreach ( var idx in indices )
+			{
+				var relative = vertexPositions[idx] - p0;
+				unwrappedUVs[idx] = new Vector2( relative.Dot( uDir ), relative.Dot( vDir ) );
+			}
 		}
 	}
 
-	private bool TryUnfoldFace( MeshFace currentFace, HashSet<MeshFace> processedFaces, List<Vector2> unwrappedUVs )
+	private bool TryUnfoldFace( MeshFace currentFace, HashSet<MeshFace> processedFaces, List<Vector2> unwrappedUVs, bool straighten )
 	{
 		if ( !faceToVertexIndices.TryGetValue( currentFace, out var currentIndices ) )
 			return false;
 
 		foreach ( var processedFace in processedFaces )
 		{
-			var sharedVertices = FindSharedVertices( currentFace, processedFace, unwrappedUVs );
-			if ( sharedVertices.HasValue )
+			var sharedEdge = FindSharedVertices( currentFace, processedFace, unwrappedUVs );
+			if ( sharedEdge.HasValue )
 			{
-				UnfoldFaceAlongEdge( currentFace, currentIndices, sharedVertices.Value, unwrappedUVs );
+				UnfoldFaceAlongEdge( currentFace, currentIndices, sharedEdge.Value, unwrappedUVs, straighten );
 				return true;
 			}
 		}
 
 		return false;
 	}
 
+	private void UnfoldFaceAlongEdge( MeshFace face, List<int> faceIndices, (int idx1, int idx2, Vector2 uv1, Vector2 uv2) edge, List<Vector2> unwrappedUVs, bool straighten )
+	{
+		unwrappedUVs[edge.idx1] = edge.uv1;
+		unwrappedUVs[edge.idx2] = edge.uv2;
+
+		// SQUARE MODE.
+		if ( straighten && faceIndices.Count == 4 )
+		{
+			UnfoldQuadStraight( faceIndices, edge, unwrappedUVs );
+		}
+		// CONFORMING MODE.
+		else
+		{
+			UnfoldGeometric( faceIndices, edge, unwrappedUVs );
+		}
+	}
+
+	/// <summary>
+	/// Unfolds a quad by extruding the shared edge perpendicularly by the average length of the connecting sides.
+	/// This forces the UV strip to remain straight (grid-like) even if the 3D mesh curves.
+	/// </summary>
+	private void UnfoldQuadStraight( List<int> faceIndices, (int idx1, int idx2, Vector2 uv1, Vector2 uv2) edge, List<Vector2> unwrappedUVs )
+	{
+		var uvVec = edge.uv2 - edge.uv1;
+		var uvLen = uvVec.Length;
+		var uvNormal = uvLen > 0.000001f ? uvVec / uvLen : new Vector2( 1, 0 );
+		var uvPerp = new Vector2( -uvNormal.y, uvNormal.x ); // 90 degrees Left
+
+		int ptr1 = faceIndices.IndexOf( edge.idx1 );
+		int ptr2 = faceIndices.IndexOf( edge.idx2 );
+
+		int connectedTo1;
+		int connectedTo2;
+
+		if ( (ptr1 + 1) % 4 == ptr2 )
+		{
+			connectedTo2 = faceIndices[(ptr2 + 1) % 4];
+			connectedTo1 = faceIndices[(ptr1 + 3) % 4];
+		}
+		else
+		{
+			connectedTo1 = faceIndices[(ptr1 + 1) % 4];
+			connectedTo2 = faceIndices[(ptr2 + 3) % 4];
+		}
+
+		float len1 = vertexPositions[edge.idx1].Distance( vertexPositions[connectedTo1] );
+		float len2 = vertexPositions[edge.idx2].Distance( vertexPositions[connectedTo2] );
+		float avgLen = (len1 + len2) * 0.5f;
+
+		unwrappedUVs[connectedTo1] = edge.uv1 + uvPerp * avgLen;
+		unwrappedUVs[connectedTo2] = edge.uv2 + uvPerp * avgLen;
+	}
+
+	/// <summary>
+	/// Unfolds a face by projecting its vertices onto a 2D plane defined by the shared edge.
+	/// This preserves the original geometric angles and shapes.
+	/// </summary>
+	private void UnfoldGeometric( List<int> faceIndices, (int idx1, int idx2, Vector2 uv1, Vector2 uv2) edge, List<Vector2> unwrappedUVs )
+	{
+		var pA = vertexPositions[edge.idx1];
+		var pB = vertexPositions[edge.idx2];
+		var edge3D = pB - pA;
+		var edge2D = edge.uv2 - edge.uv1;
+
+		Vector3 pThird = Vector3.Zero;
+		foreach ( var idx in faceIndices )
+		{
+			if ( idx != edge.idx1 && idx != edge.idx2 )
+			{
+				pThird = vertexPositions[idx];
+				break;
+			}
+		}
+
+		var faceNormal = edge3D.Cross( pThird - pA ).Normal;
+		var localU = edge3D.Normal;
+		var localV = faceNormal.Cross( localU );
+
+		var edge2DDir = edge2D.Normal;
+		var edge2DPerp = new Vector2( -edge2DDir.y, edge2DDir.x );
+		var scale = edge3D.Length > 0 ? edge2D.Length / edge3D.Length : 1.0f;
+
+		foreach ( var idx in faceIndices )
+		{
+			if ( idx == edge.idx1 || idx == edge.idx2 )
+				continue;
+
+			var relative3D = vertexPositions[idx] - pA;
+			float u = relative3D.Dot( localU );
+			float v = relative3D.Dot( localV );
+
+			unwrappedUVs[idx] = edge.uv1 + edge2DDir * u * scale + edge2DPerp * v * scale;
+		}
+	}
+
 	private (int idx1, int idx2, Vector2 uv1, Vector2 uv2)? FindSharedVertices( MeshFace face1, MeshFace face2, List<Vector2> unwrappedUVs )
 	{
 		if ( !faceToVertexIndices.TryGetValue( face1, out var indices1 ) ||
@@ -147,74 +252,52 @@ private bool TryUnfoldFace( MeshFace currentFace, HashSet<MeshFace> processedFac
 			var idx1a = indices1[i];
 			var idx1b = indices1[(i + 1) % indices1.Count];
 
+			var pos1a = vertexPositions[idx1a];
+			var pos1b = vertexPositions[idx1b];
+
 			for ( int j = 0; j < indices2.Count; j++ )
 			{
 				var idx2a = indices2[j];
 				var idx2b = indices2[(j + 1) % indices2.Count];
 
-				var pos1a = vertexPositions[idx1a];
-				var pos1b = vertexPositions[idx1b];
 				var pos2a = vertexPositions[idx2a];
 				var pos2b = vertexPositions[idx2b];
 
 				const float tolerance = 0.001f;
 				bool matchForward = pos1a.Distance( pos2a ) < tolerance && pos1b.Distance( pos2b ) < tolerance;
 				bool matchReverse = pos1a.Distance( pos2b ) < tolerance && pos1b.Distance( pos2a ) < tolerance;
 
-				if ( matchForward || matchReverse )
+				if ( matchForward )
+				{
+					return (idx1a, idx1b, unwrappedUVs[idx2a], unwrappedUVs[idx2b]);
+				}
+				if ( matchReverse )
 				{
-					return matchForward
-						? (idx1a, idx1b, unwrappedUVs[idx2a], unwrappedUVs[idx2b])
-						: (idx1a, idx1b, unwrappedUVs[idx2b], unwrappedUVs[idx2a]);
+					return (idx1a, idx1b, unwrappedUVs[idx2b], unwrappedUVs[idx2a]);
 				}
 			}
 		}
 
 		return null;
 	}
 
-	private void UnfoldFaceAlongEdge( MeshFace face, List<int> faceIndices, (int idx1, int idx2, Vector2 uv1, Vector2 uv2) sharedEdge, List<Vector2> unwrappedUVs )
+	private UnwrapResult BuildResult( List<Vector2> unwrappedUVs )
 	{
-		unwrappedUVs[sharedEdge.idx1] = sharedEdge.uv1;
-		unwrappedUVs[sharedEdge.idx2] = sharedEdge.uv2;
-
-		var edge3DA = vertexPositions[sharedEdge.idx1];
-		var edge3DB = vertexPositions[sharedEdge.idx2];
-		var edge3D = edge3DB - edge3DA;
-		var edge2D = sharedEdge.uv2 - sharedEdge.uv1;
-
-		Vector3 thirdVertex = Vector3.Zero;
-		foreach ( var idx in faceIndices )
+		var finalFaceIndices = new List<List<int>>();
+		foreach ( var face in faces )
 		{
-			if ( idx != sharedEdge.idx1 && idx != sharedEdge.idx2 )
+			if ( face.IsValid && faceToVertexIndices.TryGetValue( face, out var indices ) )
 			{
-				thirdVertex = vertexPositions[idx];
-				break;
+				finalFaceIndices.Add( indices );
 			}
 		}
 
-		var faceNormal = edge3D.Cross( thirdVertex - edge3DA ).Normal;
-		var localU = edge3D.Normal;
-		var localV = faceNormal.Cross( localU );
-
-		foreach ( var idx in faceIndices )
+		return new UnwrapResult
 		{
-			if ( idx == sharedEdge.idx1 || idx == sharedEdge.idx2 )
-				continue;
-
-			var pos3D = vertexPositions[idx];
-			var relative3D = pos3D - edge3DA;
-			var localPos = new Vector2( relative3D.Dot( localU ), relative3D.Dot( localV ) );
-
-			var edgeLength2D = edge2D.Length;
-			var edgeLength3D = edge3D.Length;
-			var scale = edgeLength3D > 0 ? edgeLength2D / edgeLength3D : 1.0f;
-
-			var edge2DDir = edge2D.Normal;
-			var edge2DPerp = new Vector2( -edge2DDir.y, edge2DDir.x );
-
-			unwrappedUVs[idx] = sharedEdge.uv1 + edge2DDir * localPos.x * scale + edge2DPerp * localPos.y * scale;
-		}
+			VertexPositions = unwrappedUVs,
+			FaceIndices = finalFaceIndices,
+			OriginalPositions = vertexPositions
+		};
 	}
 
 	public class UnwrapResult