SakuraMC/patches/server/0009-Optimise-rayTracing.patch

From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Samsuik <kfian294ma4@gmail.com>
Date: Tue, 1 Mar 2022 18:40:09 +0000
Subject: [PATCH] Optimise rayTracing


diff --git a/src/main/java/net/minecraft/world/level/Explosion.java b/src/main/java/net/minecraft/world/level/Explosion.java
index 7aa9ddb1d61ffb7da3f867e5a5bd04e3432b5621..3d5131e51fb924778c392267699fe2c11bf2f40f 100644
--- a/src/main/java/net/minecraft/world/level/Explosion.java
+++ b/src/main/java/net/minecraft/world/level/Explosion.java
@@ -297,7 +297,7 @@ public class Explosion {
                     }
                 }
 
-                if (!collision.isEmpty() && collision.clip(from, to, currPos) != null) {
+                if (!collision.isEmpty() && collision.clipDirect(from, to, currPos)) { // Sakura - optimise block clipping
                     return true;
                 }
             }
diff --git a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
index 001e2e6ed4b8b63a23dc0013882674834812a961..138fd28437fb4923773b8e6ba9bb53c3ce540e0d 100644
--- a/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
+++ b/src/main/java/net/minecraft/world/phys/shapes/VoxelShape.java
@@ -720,6 +720,110 @@ public abstract class VoxelShape {
         // Paper end - optimise collisions
     }
 
+    // Sakura start
+    // As of 1.20.2 paper has their own version of the pufferfish patch that this patch expanded on.
+    // A bit this patch is now obsolete such as simple AABB clipping.
+    // We will still use our method when a detailed hit result isn't required.
+    public boolean clipDirect(Vec3 start, Vec3 end, BlockPos pos) {
+        if (this.isEmpty) {
+            return false;
+        }
+
+        double vec3_x = end.x - start.x;
+        double vec3_y = end.y - start.y;
+        double vec3_z = end.z - start.z;
+        double vec3_lengthSqr = (vec3_x * vec3_x) + (vec3_y * vec3_y) + (vec3_z * vec3_z);
+
+        if (vec3_lengthSqr < 1.0E-7D) {
+            return false;
+        }
+
+        AABB singleAABB = this.singleAABBRepresentation;
+        //noinspection ConstantValue
+        if (singleAABB != null) {
+            return clipWithBBDirect(singleAABB, vec3_x, vec3_y, vec3_z, start, pos);
+        }
+
+        return clipWithBBsDirect(vec3_x, vec3_y, vec3_z, start, pos);
+    }
+
+    protected boolean clipWithBBDirect(AABB single, double deltaX, double deltaY, double deltaZ, Vec3 from, BlockPos pos) {
+        double posX = pos.getX();
+        double posY = pos.getY();
+        double posZ = pos.getZ();
+
+        return clipPointBB(single, from, posX, posY, posZ, deltaX, deltaY, deltaZ)
+            || clipInsideDirectBB(single, deltaX, deltaY, deltaZ, from, pos);
+    }
+
+    protected boolean clipWithBBsDirect(double deltaX, double deltaY, double deltaZ, Vec3 from, BlockPos pos) {
+        double posX = pos.getX();
+        double posY = pos.getY();
+        double posZ = pos.getZ();
+
+        for (AABB bb : toAabbs()) { // err
+            if (clipPointBB(bb, from, posX, posY, posZ, deltaX, deltaY, deltaZ)) {
+                return true;
+            }
+        }
+
+        return clipInsideDirectBBs(deltaX, deltaY, deltaZ, from, pos);
+    }
+
+    @SuppressWarnings("SuspiciousNameCombination")
+    protected static boolean clipPointBB(AABB box, Vec3 p, double posX, double posY, double posZ, double deltaX, double deltaY, double deltaZ) {
+        double minX = box.minX + posX;
+        double minY = box.minY + posY;
+        double minZ = box.minZ + posZ;
+        double maxX = box.maxX + posX;
+        double maxY = box.maxY + posY;
+        double maxZ = box.maxZ + posZ;
+
+        // todo: this could be simplified by using the centre of the bb
+        // if the bb dimensions are not the same then either scale or subtract from the result.
+        double closestX = deltaX > 1.0E-7D ? minX : maxX;
+        double closestY = deltaY > 1.0E-7D ? minY : maxY;
+        double closestZ = deltaZ > 1.0E-7D ? minZ : maxZ;
+
+        return clipPoint(deltaX, deltaY, deltaZ, closestX, minY, maxY, minZ, maxZ, p.x, p.y, p.z)
+            || clipPoint(deltaY, deltaZ, deltaX, closestY, minZ, maxZ, minX, maxX, p.y, p.z, p.x)
+            || clipPoint(deltaZ, deltaX, deltaY, closestZ, minX, maxX, minY, maxY, p.z, p.x, p.y);
+    }
+
+    private static boolean clipPoint(double deltaX, double deltaY, double deltaZ, double begin, double minX, double maxX, double minZ, double maxZ, double startX, double startY, double startZ) {
+        double d = (begin - startX) / deltaX;
+        double e = startY + d * deltaY;
+        double f = startZ + d * deltaZ;
+        return (d > 0.0D && d < 1.0) && (minX - 1.0E-7D < e && maxX + 1.0E-7D > e) && (minZ - 1.0E-7D < f && maxZ + 1.0E-7D > f);
+    }
+
+    // Absolutely horrendous code that takes a toll on all clip misses.
+    // This cannot be removed to maintain edge cases caused by this code existing in vanilla.
+    protected boolean clipInsideDirectBB(AABB single, double vec3_x, double vec3_y, double vec3_z, Vec3 start, BlockPos pos) {
+        double fromBehindX = start.x + (vec3_x * 0.001D);
+        double fromBehindY = start.y + (vec3_y * 0.001D);
+        double fromBehindZ = start.z + (vec3_z * 0.001D);
+
+        double fromBehindOffsetX = fromBehindX - (double) pos.getX();
+        double fromBehindOffsetY = fromBehindY - (double) pos.getY();
+        double fromBehindOffsetZ = fromBehindZ - (double) pos.getZ();
+
+        return single.contains(fromBehindOffsetX, fromBehindOffsetY, fromBehindOffsetZ);
+    }
+
+    protected boolean clipInsideDirectBBs(double vec3_x, double vec3_y, double vec3_z, Vec3 start, BlockPos pos) {
+        double fromBehindX = start.x + (vec3_x * 0.001D);
+        double fromBehindY = start.y + (vec3_y * 0.001D);
+        double fromBehindZ = start.z + (vec3_z * 0.001D);
+
+        int indexX = this.findIndex(Direction.Axis.X, fromBehindX - (double)pos.getX());
+        int indexY = this.findIndex(Direction.Axis.Y, fromBehindY - (double)pos.getY());
+        int indexZ = this.findIndex(Direction.Axis.Z, fromBehindZ - (double)pos.getZ());
+
+        return this.shape.isFullWide(indexX, indexY, indexZ);
+    }
+    // Sakura end
+
     public Optional<Vec3> closestPointTo(Vec3 target) {
         // Paper start - optimise collisions
         if (this.isEmpty) {