Add proper uv-lock counter-rotation calculation, and fix default uvs for a proper cube-mapping

Author: TBlueF

core/src/main/java/de/bluecolored/bluemap/core/map/hires/block/ResourceModelRenderer.java

@@ -51,6 +51,7 @@
 import de.bluecolored.bluemap.core.world.block.ExtendedBlock;
 import lombok.Getter;
 
+import java.util.EnumMap;
 import java.util.function.Function;
 
 /**
@@ -71,6 +72,7 @@ public class ResourceModelRenderer implements BlockRenderer {
     private final VectorM2f[] uvs = new VectorM2f[4];
     private final Color tintColor = new Color();
     private final Color mapColor = new Color();
+    private final EnumMap<Direction, Float> uvLockRotationCache = new EnumMap<>(Direction.class);
 
     private BlockNeighborhood block;
     private Variant variant;
@@ -195,11 +197,7 @@ private void createElementFace(Element element, Direction faceDir, VectorM3f c0,
         ) return;
 
         // calculate faceRotationVector
-        faceRotationVector.set(
-                faceDirVector.getX(),
-                faceDirVector.getY(),
-                faceDirVector.getZ()
-        );
+        faceRotationVector.set(faceDirVector);
         faceRotationVector.rotateAndScale(element.getRotation().getMatrix());
         makeRotationRelative(faceRotationVector);
 
@@ -258,19 +256,10 @@ private void createElementFace(Element element, Direction faceDir, VectorM3f c0,
             uvs[i] = rawUvs[(rotationSteps + i) % 4];
 
         // UV-Lock counter-rotation
-        float uvRotation = 0f;
         if (variant.isUvlock() && variant.isTransformed()) {
-            float xRotSin = TrigMath.sin(variant.getX() * TrigMath.DEG_TO_RAD);
-            float xRotCos = TrigMath.cos(variant.getX() * TrigMath.DEG_TO_RAD);
-
-            uvRotation =
-                    variant.getY() * (faceDirVector.getY() * xRotCos + faceDirVector.getZ() * xRotSin) +
-                    variant.getX() * (1 - faceDirVector.getY());
-        }
+            float uvRotation = uvLockRotation(faceDir);
 
-        // rotate uv's
-        if (uvRotation != 0){
-            uvRotation = (float)(uvRotation * TrigMath.DEG_TO_RAD);
+            // rotate uv's
             float cx = TrigMath.cos(uvRotation), cy = TrigMath.sin(uvRotation);
             for (VectorM2f uv : uvs) {
                 uv.translate(-0.5f, -0.5f);
@@ -351,6 +340,42 @@ private void createElementFace(Element element, Direction faceDir, VectorM3f c0,
         }
     }
 
+    private final VectorM3f rotatedNormal = new VectorM3f(0, 0, 0);
+    private final VectorM3f rotatedUp = new VectorM3f(0, 0, 0);
+    private final VectorM3f projectedWorldUp = new VectorM3f(0, 0, 0);
+    private float uvLockRotation(Direction direction) {
+        if (!variant.isTransformed()) return 0f;
+
+        makeRotationRelative(rotatedNormal.set(direction.toVector()));
+        makeRotationRelative(rotatedUp.set(direction.getLocalUp().toVector()));
+
+        // project world-up (0, 1, 0) onto rotated face
+        projectedWorldUp.set(0f, 1f, 0f);
+        float dot = projectedWorldUp.dot(rotatedNormal);
+        projectedWorldUp.set(rotatedNormal);
+        projectedWorldUp.mul(dot);
+        projectedWorldUp.set(
+                0f - projectedWorldUp.x,
+                1f - projectedWorldUp.y,
+                0f - projectedWorldUp.z
+        );
+
+        // special case, if we are close to up or down, the rotation should be locked to NORTH/SOUTH (localUp)
+        if (projectedWorldUp.lengthSquared() < 0.01) {
+            Direction upDown = rotatedNormal.y > 0f ? Direction.UP : Direction.DOWN;
+            projectedWorldUp.set(upDown.getLocalUp().toVector());
+        } else {
+            projectedWorldUp.normalize();
+        }
+
+        // compute angle between rotatedUp and projectedWorldUp around rotatedNormal
+        dot = rotatedUp.dot(projectedWorldUp);
+        return (float) TrigMath.atan2(
+                rotatedUp.cross(projectedWorldUp).dot(rotatedNormal),
+                dot
+        );
+    }
+
     private ExtendedBlock getRotationRelativeBlock(Direction direction){
         return getRotationRelativeBlock(direction.toVector());
     }

core/src/main/java/de/bluecolored/bluemap/core/resources/pack/resourcepack/model/Element.java

@@ -100,15 +100,27 @@ private void init() {
 
     private Vector4f calculateDefaultUV(Direction face) {
         return switch (face) {
-            case DOWN, UP -> new Vector4f(
+            case UP -> new Vector4f(
                     from.getX(), from.getZ(),
                     to.getX(), to.getZ()
             );
-            case NORTH, SOUTH -> new Vector4f(
+            case DOWN -> new Vector4f(
+                    from.getX(), 16 - to.getZ(),
+                    to.getX(), 16 - from.getZ()
+            );
+            case NORTH -> new Vector4f(
+                    16 - to.getX(), 16 - to.getY(),
+                    16 - from.getX(), 16 - from.getY()
+            );
+            case SOUTH -> new Vector4f(
                     from.getX(), 16 - to.getY(),
                     to.getX(), 16 - from.getY()
             );
-            case WEST, EAST -> new Vector4f(
+            case EAST -> new Vector4f(
+                    16 - to.getZ(), 16 - to.getY(),
+                    16 - from.getZ(), 16 - from.getY()
+            );
+            case WEST -> new Vector4f(
                     from.getZ(), 16 - to.getY(),
                     to.getZ(), 16 - from.getY()
             );

core/src/main/java/de/bluecolored/bluemap/core/util/Direction.java

@@ -26,10 +26,10 @@
 
 import com.flowpowered.math.vector.Vector3i;
 import de.bluecolored.bluemap.core.util.math.Axis;
+import lombok.Getter;
 
 import java.util.Objects;
 
-
 public enum Direction {
 
     UP    ( 0, 1, 0, Axis.Y),
@@ -60,11 +60,18 @@ public enum Direction {
         SOUTH.right = WEST;
         WEST.right = NORTH;
         EAST.right = SOUTH;
+
+        UP.localUp = NORTH;
+        DOWN.localUp = SOUTH;
+        NORTH.localUp = UP;
+        SOUTH.localUp = UP;
+        WEST.localUp = UP;
+        EAST.localUp = UP;
     }
 
     private final Vector3i dir;
-    private final Axis axis;
-    private Direction opposite, left, right;
+    @Getter private final Axis axis;
+    @Getter private Direction opposite, left, right, localUp;
 
     Direction(int x, int y, int z, Axis axis) {
         this.dir = new Vector3i(x, y, z);
@@ -76,25 +83,10 @@ public Vector3i toVector(){
         return dir;
     }
 
-    public Direction opposite() {
-        return opposite;
-    }
-
-    public Direction left() {
-        return left;
-    }
-
-    public Direction right() {
-        return right;
-    }
-
-    public Axis getAxis() {
-        return axis;
-    }
-
     public static Direction fromString(String name){
         Objects.requireNonNull(name);
 
         return valueOf(name.toUpperCase());
     }
+
 }

core/src/main/java/de/bluecolored/bluemap/core/util/math/VectorM3f.java

@@ -24,6 +24,8 @@
  */
 package de.bluecolored.bluemap.core.util.math;
 
+import com.flowpowered.math.vector.Vector3i;
+
 public class VectorM3f {
 
     public float x, y, z;
@@ -41,6 +43,35 @@ public VectorM3f set(float x, float y, float z) {
         return this;
     }
 
+    public VectorM3f set(Vector3i v) {
+        this.x = v.getX();
+        this.y = v.getY();
+        this.z = v.getZ();
+        return this;
+    }
+
+    public VectorM3f set(VectorM3f v) {
+        this.x = v.x;
+        this.y = v.y;
+        this.z = v.z;
+        return this;
+    }
+
+    public VectorM3f mul(float a) {
+        this.x *= a;
+        this.y *= a;
+        this.z *= a;
+        return this;
+    }
+
+    public VectorM3f cross(VectorM3f v) {
+        return set(
+                y * v.z - z * v.y,
+                z * v.x - x * v.z,
+                x * v.y - y * v.x
+        );
+    }
+
     public VectorM3f transform(MatrixM3f t) {
         return set(
                 t.m00 * x + t.m01 * y + t.m02 * z,
@@ -81,4 +112,7 @@ public double lengthSquared() {
         return x * x + y * y + z * z;
     }
 
+    public float dot(VectorM3f v) {
+        return x * v.x + y * v.y + z * v.z;
+    }
 }