Improve reliability of texture orientation computation

- Remove assumption that vertex order is aligned to world in a certain way
- Merge UV rotation computation and UV winding order computation as both now use the same value (texture matrix determinant)

Author: PepperCode1

src/main/java/me/pepperbell/continuity/client/processor/CompactCtmQuadProcessor.java

@@ -35,21 +35,21 @@ public class CompactCtmQuadProcessor extends AbstractQuadProcessor {
 	static {
 		int[][] map = QUADRANT_INDEX_MAPS;
 
-		map[0] = new int[] { 0, 1, 2, 3 }; // 0 - 0 1 2 3
-		map[1] = map[0].clone(); // 1 - 3 0 1 2
+		map[0] = new int[] { 0, 1, 2, 3 }; // 0 1 2 3
+		map[1] = map[0].clone(); // 3 0 1 2
 		ArrayUtils.shift(map[1], 1);
-		map[2] = map[1].clone(); // 2 - 2 3 0 1
+		map[2] = map[1].clone(); // 2 3 0 1
 		ArrayUtils.shift(map[2], 1);
-		map[3] = map[2].clone(); // 3 - 1 2 3 0
+		map[3] = map[2].clone(); // 1 2 3 0
 		ArrayUtils.shift(map[3], 1);
 
-		map[4] = map[3].clone(); // 4 - 0 3 2 1
+		map[4] = map[0].clone(); // 3 2 1 0
 		ArrayUtils.reverse(map[4]);
-		map[5] = map[4].clone(); // 5 - 1 0 3 2
+		map[5] = map[4].clone(); // 0 3 2 1
 		ArrayUtils.shift(map[5], 1);
-		map[6] = map[5].clone(); // 6 - 2 1 0 3
+		map[6] = map[5].clone(); // 1 0 3 2
 		ArrayUtils.shift(map[6], 1);
-		map[7] = map[6].clone(); // 7 - 3 2 1 0
+		map[7] = map[6].clone(); // 2 1 0 3
 		ArrayUtils.shift(map[7], 1);
 	}
 
@@ -351,7 +351,7 @@ public ProcessingResult processQuadInner(MutableQuadView quad, Sprite sprite, Bl
 			int spriteIndexB;
 			if (uSplit) {
 				firstSplit = uSplit01;
-				swapAB = orientation == 2 || orientation == 3 || orientation == 4 || orientation == 7;
+				swapAB = orientation == 2 || orientation == 3 || orientation == 4 || orientation == 5;
 				if ((vSignum0 + vSignum1 + vSignum2 + vSignum3) <= 0) {
 					spriteIndexA = getSpriteIndex(0, connections);
 					spriteIndexB = getSpriteIndex(3, connections);
@@ -361,7 +361,7 @@ public ProcessingResult processQuadInner(MutableQuadView quad, Sprite sprite, Bl
 				}
 			} else {
 				firstSplit = vSplit01;
-				swapAB = orientation == 1 || orientation == 2 || orientation == 4 || orientation == 5;
+				swapAB = orientation == 1 || orientation == 2 || orientation == 5 || orientation == 6;
 				if ((uSignum0 + uSignum1 + uSignum2 + uSignum3) <= 0) {
 					spriteIndexA = getSpriteIndex(1, connections);
 					spriteIndexB = getSpriteIndex(0, connections);
@@ -462,7 +462,7 @@ protected int getSpriteIndex(int quadrantIndex, int connections) {
 		int index2 = (quadrantIndex + 3) % 4;
 		boolean connected1 = ((connections >>> index1 * 2) & 1) == 1;
 		boolean connected2 = ((connections >>> index2 * 2) & 1) == 1;
-		if (connected1 && connected2) {
+		if (connected1 & connected2) {
 			if (((connections >>> (index2 * 2 + 1)) & 1) == 1) {
 				return 1;
 			}

src/main/java/me/pepperbell/continuity/client/processor/DirectionMaps.java

@@ -36,14 +36,14 @@ public final class DirectionMaps {
 			map[3] = map[2].clone(); // u l d r
 			ArrayUtils.shift(map[3], -1);
 
-			map[4] = map[0].clone(); // u r d l ; v - 1 ; h - 3
-			ArrayUtils.reverse(map[4]);
-			map[5] = map[4].clone(); // l u r d ; v - 0 ; h - 2
-			ArrayUtils.shift(map[5], 1);
-			map[6] = map[5].clone(); // d l u r ; v - 3 ; h - 1
-			ArrayUtils.shift(map[6], 1);
-			map[7] = map[6].clone(); // r d l u ; v - 2 ; h - 0
-			ArrayUtils.shift(map[7], 1);
+			map[4] = map[0].clone(); // r d l u
+			ArrayUtils.swap(map[4], 0, 2);
+			map[5] = map[1].clone(); // u r d l
+			ArrayUtils.swap(map[5], 0, 2);
+			map[6] = map[2].clone(); // l u r d
+			ArrayUtils.swap(map[6], 0, 2);
+			map[7] = map[3].clone(); // d l u r
+			ArrayUtils.swap(map[7], 0, 2);
 		}
 	}
 

src/main/java/me/pepperbell/continuity/client/processor/simple/RepeatSpriteProvider.java

@@ -93,21 +93,21 @@ public Sprite getSprite(QuadView quad, Sprite sprite, BlockRenderView blockView,
 				spriteY = -temp - 1;
 			}
 			case 4 -> {
+				spriteX = -spriteX - 1;
+			}
+			case 5 -> {
 				int temp = spriteX;
 				spriteX = spriteY;
 				spriteY = temp;
 			}
-			case 5 -> {
+			case 6 -> {
 				spriteY = -spriteY - 1;
 			}
-			case 6 -> {
+			case 7 -> {
 				int temp = spriteX;
 				spriteX = -spriteY - 1;
 				spriteY = -temp - 1;
 			}
-			case 7 -> {
-				spriteX = -spriteX - 1;
-			}
 		}
 
 		spriteX %= width;

src/main/java/me/pepperbell/continuity/client/util/QuadUtil.java

@@ -24,7 +24,7 @@ public static void interpolate(MutableQuadView quad, Sprite oldSprite, Sprite ne
 		}
 	}
 
-	public static void assignLerpedUVs(MutableQuadView quad, Sprite sprite) {
+	public static void assignLerpedUvs(MutableQuadView quad, Sprite sprite) {
 		float delta = sprite.getAnimationFrameDelta();
 		float centerU = (sprite.getMinU() + sprite.getMaxU()) * 0.5f;
 		float centerV = (sprite.getMinV() + sprite.getMaxV()) * 0.5f;
@@ -41,7 +41,7 @@ public static void assignLerpedUVs(MutableQuadView quad, Sprite sprite) {
 	public static void emitOverlayQuad(QuadEmitter emitter, Direction face, Sprite sprite, int color, RenderMaterial material) {
 		emitter.square(face, 0, 0, 1, 1, 0);
 		emitter.color(color, color, color, color);
-		assignLerpedUVs(emitter, sprite);
+		assignLerpedUvs(emitter, sprite);
 		emitter.material(material);
 		emitter.emit();
 	}
@@ -79,56 +79,96 @@ public static boolean isQuadUnitSquare(QuadView quad) {
 		return true;
 	}
 
+	/**
+	 * Returns an int in range [0, 7] representing the texture orientation of the given quad relative to the world.
+	 *
+	 * <ul>
+	 *     <li>0 - 0 degree counterclockwise rotation, counterclockwise UV winding order</li>
+	 *     <li>1 - 90 degree counterclockwise rotation, counterclockwise UV winding order</li>
+	 *     <li>2 - 180 degree counterclockwise rotation, counterclockwise UV winding order</li>
+	 *     <li>3 - 270 degree counterclockwise rotation, counterclockwise UV winding order</li>
+	 *     <li>4 - 0 degree counterclockwise rotation, clockwise UV winding order</li>
+	 *     <li>5 - 90 degree counterclockwise rotation, clockwise UV winding order</li>
+	 *     <li>6 - 180 degree counterclockwise rotation, clockwise UV winding order</li>
+	 *     <li>7 - 270 degree counterclockwise rotation, clockwise UV winding order</li>
+	 * </ul>
+	 */
 	public static int getTextureOrientation(QuadView quad) {
-		int rotation = getUVRotation(quad);
-		if (getUVWinding(quad) == Winding.CLOCKWISE) {
-			return rotation + 4;
+		// Texture matrix
+		float tm00 = quad.u(3) - quad.u(1);
+		float tm01 = quad.v(3) - quad.v(1);
+		float tm10 = quad.u(2) - quad.u(0);
+		float tm11 = quad.v(2) - quad.v(0);
+		// Determinant of texture matrix; also cross product of its column vectors
+		float determinant = tm00 * tm11 - tm10 * tm01;
+		if (determinant == 0) {
+			return 0;
 		}
-		return rotation;
-	}
+		float s = 1 / determinant;
+		// Second column of inverse texture matrix
+		float itm10 = -tm10 * s;
+		float itm11 = tm00 * s;
 
-	public static int getUVRotation(QuadView quad) {
-		int minVertex = 0;
-		float minDistance = 3.0f;
-		for (int vertexId = 0; vertexId < 4; vertexId++) {
-			float u = quad.u(vertexId);
-			float v = quad.v(vertexId);
-			float distance = u * u + v * v;
-			if (distance < minDistance) {
-				minDistance = distance;
-				minVertex = vertexId;
+		int xAxis;
+		int xAxisSign;
+		int yAxis;
+		int yAxisSign;
+		switch (quad.lightFace()) {
+			case DOWN -> {
+				xAxis = 0; // +X
+				xAxisSign = 1;
+				yAxis = 2; // +Z
+				yAxisSign = 1;
+			}
+			case UP -> {
+				xAxis = 0; // +X
+				xAxisSign = 1;
+				yAxis = 2; // -Z
+				yAxisSign = -1;
+			}
+			case NORTH -> {
+				xAxis = 0; // -X
+				xAxisSign = -1;
+				yAxis = 1; // +Y
+				yAxisSign = 1;
+			}
+			case SOUTH -> {
+				xAxis = 0; // +X
+				xAxisSign = 1;
+				yAxis = 1; // +Y
+				yAxisSign = 1;
+			}
+			case WEST -> {
+				xAxis = 2; // +Z
+				xAxisSign = 1;
+				yAxis = 1; // +Y
+				yAxisSign = 1;
+			}
+			case EAST -> {
+				xAxis = 2; // -Z
+				xAxisSign = -1;
+				yAxis = 1; // +Y
+				yAxisSign = 1;
+			}
+			default -> {
+				return 0;
 			}
 		}
-		return minVertex;
-	}
-
-	public static Winding getUVWinding(QuadView quad) {
-		float u3 = quad.u(3);
-		float v3 = quad.v(3);
-		float u0 = quad.u(0);
-		float v0 = quad.v(0);
-		float u1 = quad.u(1);
-		float v1 = quad.v(1);
-
-		float value = (u3 - u0) * (v1 - v0) - (v3 - v0) * (u1 - u0);
-		if (value > 0) {
-			return Winding.COUNTERCLOCKWISE;
-		} else if (value < 0) {
-			return Winding.CLOCKWISE;
-		}
-		return Winding.UNDEFINED;
-	}
+		// Position matrix
+		float pm00 = quad.posByIndex(3, xAxis) - quad.posByIndex(1, xAxis);
+		float pm01 = quad.posByIndex(3, yAxis) - quad.posByIndex(1, yAxis);
+		float pm10 = quad.posByIndex(2, xAxis) - quad.posByIndex(0, xAxis);
+		float pm11 = quad.posByIndex(2, yAxis) - quad.posByIndex(0, yAxis);
 
-	public enum Winding {
-		COUNTERCLOCKWISE,
-		CLOCKWISE,
-		UNDEFINED;
+		// Texture up vector in projected world space
+		// Computed as (position matrix * inverse texture matrix * [0; -1]); [0; -1] is the texture up vector in texture space
+		// Axis signs should be multiplied into position matrix values, but multiplying here instead saves 2 multiplications
+		float x = -(pm00 * itm10 + pm10 * itm11) * xAxisSign;
+		float y = -(pm01 * itm10 + pm11 * itm11) * yAxisSign;
 
-		public Winding reverse() {
-			if (this == UNDEFINED) {
-				return this;
-			}
-			return this == CLOCKWISE ? COUNTERCLOCKWISE : CLOCKWISE;
-		}
+		// Clamp vector to nearest axis-aligned direction
+		// up/+y -> 0, left/-x -> 1, down/-y -> 2, right/+x -> 3
+		// Add 4 if the UV winding order is clockwise
+		return (Math.abs(y) >= Math.abs(x) ? (y > 0 ? 0 : 2) : (x > 0 ? 3 : 1)) + (determinant < 0 ? 4 : 0);
 	}
 }