Simplify angle adjustment logic

Reuse existing logic from the motion translation

Author: jpenilla

src/main/java/com/direwolf20/justdirethings/common/entities/PortalEntity.java

@@ -18,12 +18,12 @@
 import net.minecraft.world.level.ChunkPos;
 import net.minecraft.world.level.Level;
 import net.minecraft.world.phys.AABB;
+import net.minecraft.world.phys.Vec2;
 import net.minecraft.world.phys.Vec3;
 import net.minecraft.world.phys.shapes.Shapes;
 import net.neoforged.neoforge.common.Tags;
 import net.neoforged.neoforge.entity.PartEntity;
 import org.joml.Quaternionf;
-import org.joml.Vector2f;
 import org.joml.Vector3f;
 
 import javax.annotation.Nullable;
@@ -426,13 +426,13 @@ public void teleport(Entity entity) {
         if (getLinkedPortal() != null) {
             Vec3 teleportTo = getTeleportTo(entity, linkedPortal);
             // Adjust the entity's rotation to match the exit portal's direction
-            Vector2f newLookAngle = transformLookAngle(entity, linkedPortal);
+            Vec2 newLookAngle = transformLookAngle(entity, linkedPortal);
             entity.resetFallDistance();
 
             Vec3 newMotion = calculateVelocity(entity);
 
             // Teleport the entity to the new location and set its rotation
-            boolean success = entity.teleportTo((ServerLevel) linkedPortal.level(), teleportTo.x(), teleportTo.y(), teleportTo.z(), new HashSet<>(), newLookAngle.y(), newLookAngle.x());
+            boolean success = entity.teleportTo((ServerLevel) linkedPortal.level(), teleportTo.x(), teleportTo.y(), teleportTo.z(), new HashSet<>(), newLookAngle.y, newLookAngle.x);
 
             if (success) {
                 entity.resetFallDistance();
@@ -491,86 +491,22 @@ public static Vec3 transformMotion(Vec3 motion, Direction from, Direction to) {
     /**
      * Adjust the entity's look angle (pitch and yaw) for seamless transitions between portals.
      *
-     * <p>Transitioning between two 'vertical' portals will keep the vertical look, but transform the horizontal
-     * look. For example, if you enter a portal looking at the portal and 10 degrees to the right, you will
-     * leave the exit portal looking away from the portal and 10 degrees to the right. And if you walk in
-     * backwards, you will walk out looking at the exit portal.</p>
-     *
-     * <p>Transitioning between two 'horizontal' (ceiling/floor) portals, the horizontal look is kept,
-     * but the vertical look is flipped such that if you enter a floor portal looking down at it, you will exit a
-     * ceiling portal looking down out of it, or another floor portal looking up out of it.</p>
-     *
-     * <p>Transitions between vertical and horizontal portals currently leave the look angle untouched.
-     * Similar ideas could be applied to enhance this (albeit with a more complex implementation), but these use cases
-     * are less common, and the lack of seamless angle adjustment is less jarring than with axis aligned pairs.</p>
-     *
-     * @param entity entity
+     * @param entity      entity
      * @param destination destination portal
-     * @return adjusted (pitch, yaw)
-     */
-    private Vector2f transformLookAngle(Entity entity, PortalEntity destination) {
-        final Direction myDirection = this.getDirection();
-        final boolean verticalEntry = myDirection.getAxis() != Direction.Axis.Y;
-        final Direction destDirection = destination.getDirection();
-        final boolean verticalExit = destDirection.getAxis() != Direction.Axis.Y;
-        final float entityYaw = entity.getYRot();
-        final float entityPitch = entity.getXRot();
-
-        float newYaw = entityYaw;
-        float newPitch = entityPitch;
-
-        if (verticalEntry && verticalExit) { // Handle vertical-to-vertical portal transitions (N/E/S/W)
-            final float entryFacingYaw = getDirectFacingYaw(myDirection);
-            final float exitAwayYaw = getDirectFacingAwayYaw(destDirection);
-
-            // Calculate deviation from facing the entry portal
-            final float yawDeviation = Mth.wrapDegrees(entityYaw - entryFacingYaw);
-
-            // Apply deviation to the direction facing AWAY from the exit portal
-            newYaw = Mth.wrapDegrees(exitAwayYaw + yawDeviation);
-        } else if (!verticalEntry && !verticalExit) { // Both portals are horizontal (U/D to U/D)
-            // Keep horizontal look
-            newYaw = entityYaw;
-            // If we enter looking at the portal, we should exit looking away (and vice versa)
-            newPitch = myDirection == destDirection ? -entityPitch : entityPitch;
-        }
-
-        // Normalize angles to valid ranges
-        newYaw = Mth.wrapDegrees(newYaw);
-        newPitch = Math.max(-90, Math.min(90, newPitch));
-
-        return new Vector2f(newPitch, newYaw);
-    }
-
-    /**
-     * Returns the yaw for looking directly away from the front of the portal.
-     *
-     * @param direction direction
-     * @return yaw
-     */
-    private static float getDirectFacingAwayYaw(Direction direction) {
-        return switch (direction) {
-            case NORTH -> 180;
-            case SOUTH -> 0;
-            case EAST -> -90;
-            case WEST -> 90;
-            default -> 0;
-        };
-    }
-
-    /**
-     * Returns the yaw for looking directly at the front of the portal.
-     *
-     * @param direction direction
-     * @return yaw
+     * @return adjusted (xrot, yrot)
      */
-    private static float getDirectFacingYaw(Direction direction) {
-        return switch (direction) {
-            case NORTH -> 0;
-            case SOUTH -> 180;
-            case EAST -> 90;
-            case WEST -> -90;
-            default -> 0;
-        };
+    private Vec2 transformLookAngle(Entity entity, PortalEntity destination) {
+        final Vec3 newLook = transformMotion(entity.getLookAngle(), getDirection(), destination.getDirection().getOpposite());
+        return toDegrees(newLook);
+    }
+
+    private static Vec2 toDegrees(Vec3 vector) {
+        double x = vector.x;
+        double y = vector.y;
+        double z = vector.z;
+        double hyp = Math.sqrt(x * x + z * z);
+        float xrot = Mth.wrapDegrees((float)(-(Mth.atan2(y, hyp) * 180.0F / (float)Math.PI)));
+        float yrot = Mth.wrapDegrees((float)(Mth.atan2(z, x) * 180.0F / (float)Math.PI) - 90.0F);
+        return new Vec2(xrot, yrot);
     }
 }