Optimized sinus by lithium

Update Upstream (Purpur)

build.gradle.kts

@@ -4,7 +4,7 @@ import io.papermc.paperweight.util.constants.*
 plugins {
     java
     id("com.github.johnrengelman.shadow") version "7.1.2"
-    id("io.papermc.paperweight.patcher") version "1.4.1"
+    id("io.papermc.paperweight.patcher") version "1.5.0"
 }
 
 repositories {

gradle.properties

@@ -2,7 +2,7 @@ group = dev.kaiijumc.kaiiju
 version = 1.19.3-R0.1-SNAPSHOT
 mcVersion = 1.19.3
 
-purpurRef = 08aa4dccaad7e5d31ca51b53489d2d413e49748d
+purpurRef = fccccfa1948408e30d51358e1906d6b8a4014cfc
 
 org.gradle.caching=true
 org.gradle.parallel=true

patches/server/0001-Kaiiju-Rebranding.patch

@@ -5,7 +5,7 @@ Subject: [PATCH] Kaiiju Rebranding
 
 
 diff --git a/build.gradle.kts b/build.gradle.kts
-index 020927dfe9624453311d1d171a10f44344ec8710..c6a4c48b14a8c927284720b79b93ee1aa9df7da6 100644
+index f25c0557cf984b97e0ab361f579eccbf46f82170..7f1f4988a25a5ebac36c25c045c51eefecab6862 100644
 --- a/build.gradle.kts
 +++ b/build.gradle.kts
 @@ -7,7 +7,7 @@ plugins {
@@ -17,7 +17,7 @@ index 020927dfe9624453311d1d171a10f44344ec8710..c6a4c48b14a8c927284720b79b93ee1a
      // Pufferfish start
      implementation("io.papermc.paper:paper-mojangapi:1.19.3-R0.1-SNAPSHOT") {
          exclude("io.papermc.paper", "paper-api")
-@@ -83,7 +83,7 @@ tasks.jar {
+@@ -84,7 +84,7 @@ tasks.jar {
          attributes(
              "Main-Class" to "org.bukkit.craftbukkit.Main",
              "Implementation-Title" to "CraftBukkit",
@@ -141,10 +141,10 @@ index cea4447aad2d64db56a76e4ba180dc7326d2e13b..40b4bd2f1a61c2d9a59c9c09b7271340
                  this.getRunningThread().stop();
                  try {
 diff --git a/src/main/java/org/bukkit/craftbukkit/CraftServer.java b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-index 4a8aafd341fdad4b5ae326c4759b3381f5061fb5..caf1237491649205f7b3c7ea4fe1d31d567bbafe 100644
+index c32e32005968b46d1f7d5162ab15c61e36f398f5..23f4edebbfa045716f956128703b58baced58f49 100644
 --- a/src/main/java/org/bukkit/craftbukkit/CraftServer.java
 +++ b/src/main/java/org/bukkit/craftbukkit/CraftServer.java
-@@ -262,7 +262,7 @@ import javax.annotation.Nullable; // Paper
+@@ -261,7 +261,7 @@ import javax.annotation.Nullable; // Paper
  import javax.annotation.Nonnull; // Paper
  
  public final class CraftServer implements Server {

patches/server/0008-Kaiiju-Network-Configuration.patch

@@ -0,0 +1,19 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: "Sofiane H. Djerbi" <46628754+kugge@users.noreply.github.com>
+Date: Thu, 16 Feb 2023 01:38:59 +0200
+Subject: [PATCH] Kaiiju Network Configuration
+
+
+diff --git a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+index f5c9a42b98dceda2355a28591c59c383e7906421..3756ab4acf4487972fd065fe85ef7812605fda41 100644
+--- a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
++++ b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+@@ -210,4 +210,7 @@ public class KaiijuConfig {
+             regionFormatLinearCompressionLevel = 1;
+         }
+     }
++
++    private static void networkSettings() {
++    }
+ }
+\ No newline at end of file

patches/server/0009-Purpur-Network-Send-Null-Entity-Packets.patch

@@ -0,0 +1,57 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: "Sofiane H. Djerbi" <46628754+kugge@users.noreply.github.com>
+Date: Thu, 16 Feb 2023 01:49:54 +0200
+Subject: [PATCH] Purpur Network Send Null Entity Packets
+
+
+diff --git a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+index 3756ab4acf4487972fd065fe85ef7812605fda41..c213726efa4dd95e6e731e9c7e75fb23c3c4763f 100644
+--- a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
++++ b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+@@ -211,6 +211,8 @@ public class KaiijuConfig {
+         }
+     }
+ 
++    public static boolean sendNullEntityPackets = true;
+     private static void networkSettings() {
++        sendNullEntityPackets = getBoolean("network.send-null-entity-packets", sendNullEntityPackets);
+     }
+ }
+\ No newline at end of file
+diff --git a/src/main/java/net/minecraft/server/level/ServerEntity.java b/src/main/java/net/minecraft/server/level/ServerEntity.java
+index 0f9a3a6c05fee59c29764f0c0d7a6cb8a2a861b1..9d0a52bf600583ecbf80c2233a01ff43e609266f 100644
+--- a/src/main/java/net/minecraft/server/level/ServerEntity.java
++++ b/src/main/java/net/minecraft/server/level/ServerEntity.java
+@@ -186,6 +186,11 @@ public class ServerEntity {
+                         this.teleportDelay = 0;
+                         packet1 = new ClientboundTeleportEntityPacket(this.entity);
+                     }
++                    // Kaiiju start - Don't send null move entity packets
++                    if (!dev.kaiijumc.kaiiju.KaiijuConfig.sendNullEntityPackets && isNullMovePacket(packet1)) {
++                        packet1 = null;
++                    }
++                    // Kaiiju end
+                 }
+ 
+                 if ((this.trackDelta || this.entity.hasImpulse || this.entity instanceof LivingEntity && ((LivingEntity) this.entity).isFallFlying()) && this.tickCount > 0) {
+@@ -252,6 +257,20 @@ public class ServerEntity {
+ 
+     }
+ 
++    // Kaiiju start - Don't send null move entity packets
++    private boolean isNullMovePacket(Packet<?> packet) {
++        if (packet instanceof ClientboundMoveEntityPacket move) {
++            if (packet instanceof ClientboundMoveEntityPacket.Pos)
++                return move.getXa() == 0 && move.getYa() == 0 && move.getZa() == 0;
++            if (packet instanceof ClientboundMoveEntityPacket.PosRot)
++                return move.getXa() == 0 && move.getYa() == 0 && move.getZa() == 0 && move.getyRot() == 0 && move.getxRot() == 0;
++            if (packet instanceof ClientboundMoveEntityPacket.Rot)
++                return move.getyRot() == 0 && move.getxRot() == 0;
++        }
++        return false;
++    }
++    // Kaiiju end
++    
+     public void removePairing(ServerPlayer player) {
+         this.entity.stopSeenByPlayer(player);
+         player.connection.send(new ClientboundRemoveEntitiesPacket(new int[]{this.entity.getId()}));

patches/server/0010-Kaiiju-Lithium-Configuration.patch

@@ -0,0 +1,21 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: "Sofiane H. Djerbi" <46628754+kugge@users.noreply.github.com>
+Date: Thu, 16 Feb 2023 21:28:49 +0200
+Subject: [PATCH] Kaiiju Lithium Configuration
+
+
+diff --git a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+index c213726efa4dd95e6e731e9c7e75fb23c3c4763f..e1fc127ac3fb47f3a4ad84d4b3f3ec25f40389f8 100644
+--- a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
++++ b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+@@ -215,4 +215,9 @@ public class KaiijuConfig {
+     private static void networkSettings() {
+         sendNullEntityPackets = getBoolean("network.send-null-entity-packets", sendNullEntityPackets);
+     }
++
++    public static boolean lithiumEnable = true;
++    private static void lithiumSettings() {
++        lithiumEnable = getBoolean("lithium.enable", lithiumEnable);
++    }
+ }
+\ No newline at end of file

patches/server/0011-Lithium-Math-FastUtil.patch

@@ -0,0 +1,126 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: "Sofiane H. Djerbi" <46628754+kugge@users.noreply.github.com>
+Date: Thu, 16 Feb 2023 21:34:37 +0200
+Subject: [PATCH] Lithium Math FastUtil
+
+Author: JellySquid
+Licence: LGPL-3.0
+
+diff --git a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+index e1fc127ac3fb47f3a4ad84d4b3f3ec25f40389f8..ff45fefd7058673f0c79875854accd041bc0c3a1 100644
+--- a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
++++ b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+@@ -217,7 +217,9 @@ public class KaiijuConfig {
+     }
+ 
+     public static boolean lithiumEnable = true;
++    public static boolean lithiumMathFastUtil = true;
+     private static void lithiumSettings() {
+         lithiumEnable = getBoolean("lithium.enable", lithiumEnable);
++        lithiumMathFastUtil = getBoolean("lithium.math.fast-util", lithiumMathFastUtil) && lithiumEnable;
+     }
+ }
+\ No newline at end of file
+diff --git a/src/main/java/net/minecraft/core/AxisCycle.java b/src/main/java/net/minecraft/core/AxisCycle.java
+index b5d8a60dc78a76c0a55bfc30cc49d26857bd914a..dd8d98acf21bb676e86f9befb45fd09e1b14a01d 100644
+--- a/src/main/java/net/minecraft/core/AxisCycle.java
++++ b/src/main/java/net/minecraft/core/AxisCycle.java
+@@ -35,6 +35,18 @@ public enum AxisCycle {
+ 
+         @Override
+         public Direction.Axis cycle(Direction.Axis axis) {
++            // Kaiiju start - Lithium
++            if (dev.kaiijumc.kaiiju.KaiijuConfig.lithiumMathFastUtil){
++                switch (axis.ordinal()) {
++                    case 0: //X
++                       return Direction.Axis.Y;
++                    case 1: //Y
++                        return Direction.Axis.Z;
++                    case 2: //Z
++                        return Direction.Axis.X;
++                }
++            }
++            // Kaiiju end
+             return AXIS_VALUES[Math.floorMod(axis.ordinal() + 1, 3)];
+         }
+ 
+@@ -56,6 +68,18 @@ public enum AxisCycle {
+ 
+         @Override
+         public Direction.Axis cycle(Direction.Axis axis) {
++            // Kaiiju start - Lithium
++            if (dev.kaiijumc.kaiiju.KaiijuConfig.lithiumMathFastUtil){
++                switch (axis.ordinal()) {
++                    case 0: //X
++                       return Direction.Axis.Z;
++                    case 1: //Y
++                        return Direction.Axis.X;
++                    case 2: //Z
++                        return Direction.Axis.Y;
++                }
++            }
++            // Kaiiju end
+             return AXIS_VALUES[Math.floorMod(axis.ordinal() - 1, 3)];
+         }
+ 
+diff --git a/src/main/java/net/minecraft/core/Direction.java b/src/main/java/net/minecraft/core/Direction.java
+index a4dc96b1a3bf309584657e3a1e7dfaea967f9425..09c1989dc3b12d9488b8869e71f2a4890656cc36 100644
+--- a/src/main/java/net/minecraft/core/Direction.java
++++ b/src/main/java/net/minecraft/core/Direction.java
+@@ -191,6 +191,7 @@ public enum Direction implements StringRepresentable {
+     }
+ 
+     public Direction getOpposite() {
++        if (dev.kaiijumc.kaiiju.KaiijuConfig.lithiumMathFastUtil) return VALUES[this.oppositeIndex]; // Kaiiju
+         return from3DDataValue(this.oppositeIndex);
+     }
+ 
+@@ -453,6 +454,7 @@ public enum Direction implements StringRepresentable {
+     }
+ 
+     public static Direction getRandom(RandomSource random) {
++        if (dev.kaiijumc.kaiiju.KaiijuConfig.lithiumMathFastUtil) return VALUES[random.nextInt(VALUES.length)]; // Kaiiju
+         return Util.getRandom(VALUES, random);
+     }
+ 
+diff --git a/src/main/java/net/minecraft/world/phys/AABB.java b/src/main/java/net/minecraft/world/phys/AABB.java
+index cfb2e46b34b2982d6724f18214557fc80cf4adfa..4fae201f57dc23ed0e25f17739f97133a7f7534c 100644
+--- a/src/main/java/net/minecraft/world/phys/AABB.java
++++ b/src/main/java/net/minecraft/world/phys/AABB.java
+@@ -81,10 +81,36 @@ public class AABB {
+     }
+ 
+     public double min(Direction.Axis axis) {
++        // Kaiiju start - Lithium
++        if (dev.kaiijumc.kaiiju.KaiijuConfig.lithiumMathFastUtil){
++            switch (axis.ordinal()) {
++                case 0: //X
++                   return this.minX;
++                case 1: //Y
++                    return this.minY;
++                case 2: //Z
++                    return this.minZ;
++            }
++            throw new IllegalArgumentException();
++        }
++        // Kaiiju end
+         return axis.choose(this.minX, this.minY, this.minZ);
+     }
+ 
+     public double max(Direction.Axis axis) {
++        // Kaiiju start - Lithium
++        if (dev.kaiijumc.kaiiju.KaiijuConfig.lithiumMathFastUtil){
++            switch (axis.ordinal()) {
++                case 0: //X
++                   return this.maxX;
++                case 1: //Y
++                    return this.maxY;
++                case 2: //Z
++                    return this.maxZ;
++            }
++            throw new IllegalArgumentException();
++        }
++        // Kaiiju end
+         return axis.choose(this.maxX, this.maxY, this.maxZ);
+     }
+ 

patches/server/0012-Lithium-Math-SineLut.patch

@@ -0,0 +1,145 @@
+From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
+From: "Sofiane H. Djerbi" <46628754+kugge@users.noreply.github.com>
+Date: Fri, 17 Feb 2023 00:34:31 +0200
+Subject: [PATCH] Lithium Math SineLut
+
+Author: JellySquid
+Licence: LGPL-3.0
+
+diff --git a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+index ff45fefd7058673f0c79875854accd041bc0c3a1..8105e2747ee784ba9dde2ddeb7bf7a29639337ee 100644
+--- a/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
++++ b/src/main/java/dev/kaiijumc/kaiiju/KaiijuConfig.java
+@@ -218,8 +218,10 @@ public class KaiijuConfig {
+ 
+     public static boolean lithiumEnable = true;
+     public static boolean lithiumMathFastUtil = true;
++    public static boolean lithiumMathSineLut = true;
+     private static void lithiumSettings() {
+         lithiumEnable = getBoolean("lithium.enable", lithiumEnable);
+         lithiumMathFastUtil = getBoolean("lithium.math.fast-util", lithiumMathFastUtil) && lithiumEnable;
++        lithiumMathSineLut = getBoolean("lithium.math.sine-lut", lithiumMathSineLut) && lithiumEnable;
+     }
+ }
+\ No newline at end of file
+diff --git a/src/main/java/me/jellysquid/mods/lithium/common/util/math/CompactSineLUT.java b/src/main/java/me/jellysquid/mods/lithium/common/util/math/CompactSineLUT.java
+new file mode 100644
+index 0000000000000000000000000000000000000000..ccb45e94ea6d1a627df786fb88baec7edd1f2427
+--- /dev/null
++++ b/src/main/java/me/jellysquid/mods/lithium/common/util/math/CompactSineLUT.java
+@@ -0,0 +1,90 @@
++package me.jellysquid.mods.lithium.common.util.math;
++
++import net.minecraft.util.Mth;
++
++/**
++ * A replacement for the sine angle lookup table used in {@link MathHelper}, both reducing the size of LUT and improving
++ * the access patterns for common paired sin/cos operations.
++ *
++ *  sin(-x) = -sin(x)
++ *    ... to eliminate negative angles from the LUT.
++ *
++ *  sin(x) = sin(pi/2 - x)
++ *    ... to eliminate supplementary angles from the LUT.
++ *
++ * Using these identities allows us to reduce the LUT from 64K entries (256 KB) to just 16K entries (64 KB), enabling
++ * it to better fit into the CPU's caches at the expense of some cycles on the fast path. The implementation has been
++ * tightly optimized to avoid branching where possible and to use very quick integer operations.
++ *
++ * Generally speaking, reducing the size of a lookup table is always a good optimization, but since we need to spend
++ * extra CPU cycles trying to maintain parity with vanilla, there is the potential risk that this implementation ends
++ * up being slower than vanilla when the lookup table is able to be kept in cache memory.
++ *
++ * Unlike other "fast math" implementations, the values returned by this class are *bit-for-bit identical* with those
++ * from {@link MathHelper}. Validation is performed during runtime to ensure that the table is correct.
++ *
++ * @author coderbot16   Author of the original (and very clever) implementation in Rust:
++ *  https://gitlab.com/coderbot16/i73/-/tree/master/i73-trig/src
++ * @author jellysquid3  Additional optimizations, port to Java
++ */
++public class CompactSineLUT {
++    private static final int[] SINE_TABLE_INT = new int[16384 + 1];
++    private static final float SINE_TABLE_MIDPOINT;
++
++    static {
++        final float[] SINE_TABLE = Mth.getSinTable();
++        // Copy the sine table, covering to raw int bits
++        for (int i = 0; i < SINE_TABLE_INT.length; i++) {
++            SINE_TABLE_INT[i] = Float.floatToRawIntBits(SINE_TABLE[i]);
++        }
++
++        SINE_TABLE_MIDPOINT = SINE_TABLE[SINE_TABLE.length / 2];
++
++        // Test that the lookup table is correct during runtime
++        for (int i = 0; i < SINE_TABLE.length; i++) {
++            float expected = SINE_TABLE[i];
++            float value = lookup(i);
++
++            if (expected != value) {
++                throw new IllegalArgumentException(String.format("LUT error at index %d (expected: %s, found: %s)", i, expected, value));
++            }
++        }
++    }
++
++    // [VanillaCopy] MathHelper#sin(float)
++    public static float sin(float f) {
++        return lookup((int) (f * 10430.378f) & 0xFFFF);
++    }
++
++    // [VanillaCopy] MathHelper#cos(float)
++    public static float cos(float f) {
++        return lookup((int) (f * 10430.378f + 16384.0f) & 0xFFFF);
++    }
++
++    private static float lookup(int index) {
++        // A special case... Is there some way to eliminate this?
++        if (index == 32768) {
++            return SINE_TABLE_MIDPOINT;
++        }
++
++        // Trigonometric identity: sin(-x) = -sin(x)
++        // Given a domain of 0 <= x <= 2*pi, just negate the value if x > pi.
++        // This allows the sin table size to be halved.
++        int neg = (index & 0x8000) << 16;
++
++        // All bits set if (pi/2 <= x), none set otherwise
++        // Extracts the 15th bit from 'half'
++        int mask = (index << 17) >> 31;
++
++        // Trigonometric identity: sin(x) = sin(pi/2 - x)
++        int pos = (0x8001 & mask) + (index ^ mask);
++
++        // Wrap the position in the table. Moving this down to immediately before the array access
++        // seems to help the Hotspot compiler optimize the bit math better.
++        pos &= 0x7fff;
++
++        // Fetch the corresponding value from the LUT and invert the sign bit as needed
++        // This directly manipulate the sign bit on the float bits to simplify logic
++        return Float.intBitsToFloat(SINE_TABLE_INT[pos] ^ neg);
++    }
++}
+\ No newline at end of file
+diff --git a/src/main/java/net/minecraft/util/Mth.java b/src/main/java/net/minecraft/util/Mth.java
+index 618f19d70a61062ed5989ec6cf0c036f2e047466..dd320f3a3f2b51a723a2fcc65d477a22c0901455 100644
+--- a/src/main/java/net/minecraft/util/Mth.java
++++ b/src/main/java/net/minecraft/util/Mth.java
+@@ -45,11 +45,19 @@ public class Mth {
+         return (float)((int)(value * f)) / f;
+     }
+ 
++    // Kaiiju start
++    public static float[] getSinTable() {
++        return SIN;
++    }
++    // Kaiiju end
++
+     public static float sin(float value) {
++        if (dev.kaiijumc.kaiiju.KaiijuConfig.lithiumMathSineLut) return me.jellysquid.mods.lithium.common.util.math.CompactSineLUT.sin(value); // Kaiiju
+         return SIN[(int)(value * 10430.378F) & '\uffff'];
+     }
+ 
+     public static float cos(float value) {
++        if (dev.kaiijumc.kaiiju.KaiijuConfig.lithiumMathSineLut) return me.jellysquid.mods.lithium.common.util.math.CompactSineLUT.cos(value); // Kaiiju
+         return SIN[(int)(value * 10430.378F + 16384.0F) & '\uffff'];
+     }
+