From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001 From: Samsuik 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 90a82bd7977ebe520bdcc2ab99e11452d5cf4a21..eeacf65ebb0ea7070de6e773d31651e4c190d592 100644 --- a/src/main/java/net/minecraft/world/level/Explosion.java +++ b/src/main/java/net/minecraft/world/level/Explosion.java @@ -295,7 +295,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 e6b17f32f2b6930739a98c6139442383c1847add..24c1caa060e7c41eac81c19f873ac9273c6b84c2 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 closestPointTo(Vec3 target) { // Paper start - optimise collisions if (this.isEmpty) {