From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: ishland <ishlandmc@yeah.net>
Date: Tue, 21 Sep 2021 10:37:34 +0200
Subject: [PATCH] c2me: optimization.math

Copyright (c) 2021-2022 ishland

Original code by RelativityMC, licensed under MIT
You can find the original code on https://github.com/RelativityMC/C2ME-fabric (Yarn mappings)

diff --git a/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java b/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
index 765b56776e457109ddea9f7dbfd0b17beefee51e..0b2c02891c240626f2f274c1fc854648801996f4 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/synth/ImprovedNoise.java
@@ -11,6 +11,27 @@ public final class ImprovedNoise {
     public final double yo;
     public final double zo;
 
+    // Mirai start - c2me: optimization.math
+    private static final double[] FLAT_SIMPLEX_GRAD = new double[]{
+            1, 1, 0, 0,
+            -1, 1, 0, 0,
+            1, -1, 0, 0,
+            -1, -1, 0, 0,
+            1, 0, 1, 0,
+            -1, 0, 1, 0,
+            1, 0, -1, 0,
+            -1, 0, -1, 0,
+            0, 1, 1, 0,
+            0, -1, 1, 0,
+            0, 1, -1, 0,
+            0, -1, -1, 0,
+            1, 1, 0, 0,
+            0, -1, 1, 0,
+            -1, 1, 0, 0,
+            0, -1, -1, 0,
+    };
+    // Mirai end
+
     public ImprovedNoise(RandomSource random) {
         this.xo = random.nextDouble() * 256.0D;
         this.yo = random.nextDouble() * 256.0D;
@@ -34,34 +55,38 @@ public final class ImprovedNoise {
         return this.noise(x, y, z, 0.0D, 0.0D);
     }
 
+    // Mirai start - c2me: optimization.math
+    /**
+     * @author ishland
+     * @reason optimize: remove frequent type conversions
+     */
     /** @deprecated */
     @Deprecated
     public double noise(double x, double y, double z, double yScale, double yMax) {
         double d = x + this.xo;
         double e = y + this.yo;
         double f = z + this.zo;
-        int i = Mth.floor(d);
-        int j = Mth.floor(e);
-        int k = Mth.floor(f);
-        double g = d - (double)i;
-        double h = e - (double)j;
-        double l = f - (double)k;
-        double o;
-        if (yScale != 0.0D) {
+        double i = Mth.floor(d);
+        double j = Mth.floor(e);
+        double k = Mth.floor(f);
+        double g = d - i;
+        double h = e - j;
+        double l = f - k;
+        double o = 0.0D;
+        if (yScale != 0.0) {
             double m;
-            if (yMax >= 0.0D && yMax < h) {
+            if (yMax >= 0.0 && yMax < h) {
                 m = yMax;
             } else {
                 m = h;
             }
 
-            o = (double)Mth.floor(m / yScale + (double)1.0E-7F) * yScale;
-        } else {
-            o = 0.0D;
+            o = Mth.floor(m / yScale + 1.0E-7F) * yScale;
         }
 
-        return this.sampleAndLerp(i, j, k, g, h - o, l, h);
+        return this.sampleAndLerp((int) i, (int) j, (int) k, g, h - o, l, h);
     }
+    // Mirai end
 
     public double noiseWithDerivative(double x, double y, double z, double[] ds) {
         double d = x + this.xo;
@@ -84,26 +109,75 @@ public final class ImprovedNoise {
         return this.p[hash & 255] & 255;
     }
 
+    // Mirai start - c2me: optimization.math
+    /**
+     * @author ishland
+     * @reason inline math & small optimization: remove frequent type conversions and redundant ops
+     */
     private double sampleAndLerp(int sectionX, int sectionY, int sectionZ, double localX, double localY, double localZ, double fadeLocalX) {
-        int i = this.p(sectionX);
-        int j = this.p(sectionX + 1);
-        int k = this.p(i + sectionY);
-        int l = this.p(i + sectionY + 1);
-        int m = this.p(j + sectionY);
-        int n = this.p(j + sectionY + 1);
-        double d = gradDot(this.p(k + sectionZ), localX, localY, localZ);
-        double e = gradDot(this.p(m + sectionZ), localX - 1.0D, localY, localZ);
-        double f = gradDot(this.p(l + sectionZ), localX, localY - 1.0D, localZ);
-        double g = gradDot(this.p(n + sectionZ), localX - 1.0D, localY - 1.0D, localZ);
-        double h = gradDot(this.p(k + sectionZ + 1), localX, localY, localZ - 1.0D);
-        double o = gradDot(this.p(m + sectionZ + 1), localX - 1.0D, localY, localZ - 1.0D);
-        double p = gradDot(this.p(l + sectionZ + 1), localX, localY - 1.0D, localZ - 1.0D);
-        double q = gradDot(this.p(n + sectionZ + 1), localX - 1.0D, localY - 1.0D, localZ - 1.0D);
-        double r = Mth.smoothstep(localX);
-        double s = Mth.smoothstep(fadeLocalX);
-        double t = Mth.smoothstep(localZ);
-        return Mth.lerp3(r, s, t, d, e, f, g, h, o, p, q);
+        // TODO [VanillaCopy] but optimized
+        final int var0 = sectionX & 0xFF;
+        final int var1 = (sectionX + 1) & 0xFF;
+        final int var2 = this.p[var0] & 0xFF;
+        final int var3 = this.p[var1] & 0xFF;
+        final int var4 = (var2 + sectionY) & 0xFF;
+        final int var5 = (var2 + sectionY + 1) & 0xFF;
+        final int var6 = (var3 + sectionY) & 0xFF;
+        final int var7 = (var3 + sectionY + 1) & 0xFF;
+        final int var8 = this.p[var4] & 0xFF;
+        final int var9 = this.p[var5] & 0xFF;
+        final int var10 = this.p[var6] & 0xFF;
+        final int var11 = this.p[var7] & 0xFF;
+
+        final int var12 = (var8 + sectionZ) & 0xFF;
+        final int var13 = (var10 + sectionZ) & 0xFF;
+        final int var14 = (var9 + sectionZ) & 0xFF;
+        final int var15 = (var11 + sectionZ) & 0xFF;
+        final int var16 = (var8 + sectionZ + 1) & 0xFF;
+        final int var17 = (var10 + sectionZ + 1) & 0xFF;
+        final int var18 = (var9 + sectionZ + 1) & 0xFF;
+        final int var19 = (var11 + sectionZ + 1) & 0xFF;
+        final int var20 = (this.p[var12] & 15) << 2;
+        final int var21 = (this.p[var13] & 15) << 2;
+        final int var22 = (this.p[var14] & 15) << 2;
+        final int var23 = (this.p[var15] & 15) << 2;
+        final int var24 = (this.p[var16] & 15) << 2;
+        final int var25 = (this.p[var17] & 15) << 2;
+        final int var26 = (this.p[var18] & 15) << 2;
+        final int var27 = (this.p[var19] & 15) << 2;
+        final double var60 = localX - 1.0;
+        final double var61 = localY - 1.0;
+        final double var62 = localZ - 1.0;
+        final double var87 = FLAT_SIMPLEX_GRAD[(var20) | 0] * localX + FLAT_SIMPLEX_GRAD[(var20) | 1] * localY + FLAT_SIMPLEX_GRAD[(var20) | 2] * localZ;
+        final double var88 = FLAT_SIMPLEX_GRAD[(var21) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var21) | 1] * localY + FLAT_SIMPLEX_GRAD[(var21) | 2] * localZ;
+        final double var89 = FLAT_SIMPLEX_GRAD[(var22) | 0] * localX + FLAT_SIMPLEX_GRAD[(var22) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var22) | 2] * localZ;
+        final double var90 = FLAT_SIMPLEX_GRAD[(var23) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var23) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var23) | 2] * localZ;
+        final double var91 = FLAT_SIMPLEX_GRAD[(var24) | 0] * localX + FLAT_SIMPLEX_GRAD[(var24) | 1] * localY + FLAT_SIMPLEX_GRAD[(var24) | 2] * var62;
+        final double var92 = FLAT_SIMPLEX_GRAD[(var25) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var25) | 1] * localY + FLAT_SIMPLEX_GRAD[(var25) | 2] * var62;
+        final double var93 = FLAT_SIMPLEX_GRAD[(var26) | 0] * localX + FLAT_SIMPLEX_GRAD[(var26) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var26) | 2] * var62;
+        final double var94 = FLAT_SIMPLEX_GRAD[(var27) | 0] * var60 + FLAT_SIMPLEX_GRAD[(var27) | 1] * var61 + FLAT_SIMPLEX_GRAD[(var27) | 2] * var62;
+
+        final double var95 = localX * 6.0 - 15.0;
+        final double var96 = fadeLocalX * 6.0 - 15.0;
+        final double var97 = localZ * 6.0 - 15.0;
+        final double var98 = localX * var95 + 10.0;
+        final double var99 = fadeLocalX * var96 + 10.0;
+        final double var100 = localZ * var97 + 10.0;
+        final double var101 = localX * localX * localX * var98;
+        final double var102 = fadeLocalX * fadeLocalX * fadeLocalX * var99;
+        final double var103 = localZ * localZ * localZ * var100;
+
+        final double var113 = var87 + var101 * (var88 - var87);
+        final double var114 = var93 + var101 * (var94 - var93);
+        final double var115 = var91 + var101 * (var92 - var91);
+        final double var117 = var114 - var115;
+        final double var118 = var102 * (var89 + var101 * (var90 - var89) - var113);
+        final double var119 = var102 * var117;
+        final double var120 = var113 + var118;
+        final double var121 = var115 + var119;
+        return var120 + (var103 * (var121 - var120));
     }
+    // Mirai end
 
     private double sampleWithDerivative(int sectionX, int sectionY, int sectionZ, double localX, double localY, double localZ, double[] ds) {
         int i = this.p(sectionX);
diff --git a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java
index b6b56a3db74e07ca015deb7a8ebddc97f6228025..b7fab2ae8abb3092e7bde138f7ca6253cecfaa75 100644
--- a/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java
+++ b/src/main/java/net/minecraft/world/level/levelgen/synth/PerlinNoise.java
@@ -25,6 +25,11 @@ public class PerlinNoise {
     private final double lowestFreqValueFactor;
     private final double lowestFreqInputFactor;
 
+    // Mirai start - c2me: optimization.math
+    private int noiseLevelsCount = 0;
+    private double[] amplitudesArray = null;
+    // Mirai end
+
     /** @deprecated */
     @Deprecated
     public static PerlinNoise createLegacyForBlendedNoise(RandomSource random, IntStream intStream) {
@@ -84,6 +89,10 @@ public class PerlinNoise {
         int i = this.amplitudes.size();
         int j = -this.firstOctave;
         this.noiseLevels = new ImprovedNoise[i];
+        // Mirai start - c2me: optimization.math
+        this.noiseLevelsCount = this.noiseLevels.length;
+        this.amplitudesArray = this.amplitudes.toDoubleArray();
+        // Mirai end
         if (xoroshiro) {
             PositionalRandomFactory positionalRandomFactory = random.forkPositional();
 
@@ -134,9 +143,33 @@ public class PerlinNoise {
         random.consumeCount(262);
     }
 
+    // Mirai start - c2me: optimization.math
+    /**
+     * @author ishland
+     * @reason optimize for common cases
+     */
     public double getValue(double x, double y, double z) {
-        return this.getValue(x, y, z, 0.0D, 0.0D, false);
+        double d = 0.0;
+        double e = this.lowestFreqInputFactor;
+        double f = this.lowestFreqValueFactor;
+
+        for(int i = 0; i < this.noiseLevelsCount; ++i) {
+            ImprovedNoise improvedNoise = this.noiseLevels[i];
+            if (improvedNoise != null) {
+                @SuppressWarnings("deprecation")
+                double g = improvedNoise.noise(
+                        wrap(x * e), wrap(y * e), wrap(z * e), 0.0, 0.0
+                );
+                d += this.amplitudesArray[i] * g * f;
+            }
+
+            e *= 2.0;
+            f /= 2.0;
+        }
+
+        return d;
     }
+    // Mirai end
 
     /** @deprecated */
     @Deprecated
@@ -164,9 +197,15 @@ public class PerlinNoise {
         return this.noiseLevels[this.noiseLevels.length - 1 - octave];
     }
 
+    // Mirai start - c2me: optimization.math
+    /**
+     * @author ishland
+     * @reason remove frequent type conversion
+     */
     public static double wrap(double value) {
-        return value - (double)Mth.lfloor(value / 3.3554432E7D + 0.5D) * 3.3554432E7D;
+        return value - Mth.lfloor(value / 3.3554432E7 + 0.5) * 3.3554432E7;
     }
+    // Mirai end
 
     protected int firstOctave() {
         return this.firstOctave;