From 0000000000000000000000000000000000000000 Mon Sep 17 00:00:00 2001
From: Aikar <aikar@aikar.co>
Date: Thu, 4 Jun 2020 22:43:29 -0400
Subject: [PATCH] Optimize Light Engine

Massive update to light to improve performance and chunk loading/generation.

1) Massive bit packing/unpacking optimizations and inlining.
  A lot of performance has to do with constant packing and unpacking of bits.
  We now inline a most bit operations, and re-use base x/y/z bits in many places.
  This helps with cpu level processing to just do all the math at once instead
  of having to jump in and out of function calls.

  This much logic also is likely over the JVM Inline limit for JIT too.
2) Applied a few of JellySquid's Phosphor mod optimizations such as
  - ensuring we don't notify neighbor chunks when neighbor chunk doesn't need to be notified
  - reduce hasLight checks in initializing light, and prob some more, they are tagged JellySquid where phosphor influence was used.
3) Optimize hot path accesses to getting updating chunk to have less branching
4) Optimize getBlock accesses to have less branching, and less unpacking
5) Have a separate urgent bucket for chunk light tasks. These tasks will always cut in line over non blocking light tasks.
6) Retain chunk priority while light tasks are enqueued. So if a task comes in at high priority but the queue is full
   of tasks already at a lower priority, before the task was simply added to the end. Now it can cut in line to the front.
   this applies for both urgent and non urgent tasks.
7) Buffer non urgent tasks even if queueUpdate is called multiple times to improve efficiency.
8) Fix NPE risk that crashes server in getting nibble data

diff --git a/src/main/java/net/minecraft/server/ChunkProviderServer.java b/src/main/java/net/minecraft/server/ChunkProviderServer.java
index 604e7004b659daed2844ba1a76bf09288ec549e5..ef980f9859d1d7d0d5e13d0d70e998055f92135e 100644
--- a/src/main/java/net/minecraft/server/ChunkProviderServer.java
+++ b/src/main/java/net/minecraft/server/ChunkProviderServer.java
@@ -1044,7 +1044,7 @@ public class ChunkProviderServer extends IChunkProvider {
             if (ChunkProviderServer.this.tickDistanceManager()) {
                 return true;
             } else {
-                ChunkProviderServer.this.lightEngine.queueUpdate();
+                //ChunkProviderServer.this.lightEngine.queueUpdate(); // Paper - not needed
                 return super.executeNext() || execChunkTask; // Paper
             }
         } finally {
diff --git a/src/main/java/net/minecraft/server/LightEngineBlock.java b/src/main/java/net/minecraft/server/LightEngineBlock.java
index 07fadc21ee12138b52cc77c50da536fec5b032f5..a61d0a27e9525505eedaec8cde44216e807eb9a8 100644
--- a/src/main/java/net/minecraft/server/LightEngineBlock.java
+++ b/src/main/java/net/minecraft/server/LightEngineBlock.java
@@ -13,9 +13,11 @@ public final class LightEngineBlock extends LightEngineLayer<LightEngineStorageB
     }
 
     private int d(long i) {
-        int j = BlockPosition.b(i);
-        int k = BlockPosition.c(i);
-        int l = BlockPosition.d(i);
+        // Paper start - inline math
+        int j = (int) (i >> 38);
+        int k = (int) ((i << 52) >> 52);
+        int l = (int) ((i << 26) >> 38);
+        // Paper end
         IBlockAccess iblockaccess = this.a.c(j >> 4, l >> 4);
 
         return iblockaccess != null ? iblockaccess.h(this.f.d(j, k, l)) : 0;
@@ -30,25 +32,33 @@ public final class LightEngineBlock extends LightEngineLayer<LightEngineStorageB
         } else if (k >= 15) {
             return k;
         } else {
-            int l = Integer.signum(BlockPosition.b(j) - BlockPosition.b(i));
-            int i1 = Integer.signum(BlockPosition.c(j) - BlockPosition.c(i));
-            int j1 = Integer.signum(BlockPosition.d(j) - BlockPosition.d(i));
+            // Paper start - reuse math - credit to JellySquid for idea
+            int jx = (int) (j >> 38);
+            int jy = (int) ((j << 52) >> 52);
+            int jz = (int) ((j << 26) >> 38);
+            int ix = (int) (i >> 38);
+            int iy = (int) ((i << 52) >> 52);
+            int iz = (int) ((i << 26) >> 38);
+            int l = Integer.signum(jx - ix);
+            int i1 = Integer.signum(jy - iy);
+            int j1 = Integer.signum(jz - iz);
+            // Paper end
             EnumDirection enumdirection = EnumDirection.a(l, i1, j1);
 
             if (enumdirection == null) {
                 return 15;
             } else {
                 //MutableInt mutableint = new MutableInt(); // Paper - share mutableint, single threaded
-                IBlockData iblockdata = this.a(j, mutableint);
-
-                if (mutableint.getValue() >= 15) {
+                IBlockData iblockdata = this.getBlockOptimized(jx, jy, jz, mutableint); // Paper
+                int blockedLight = mutableint.getValue(); // Paper
+                if (blockedLight >= 15) { // Paper
                     return 15;
                 } else {
-                    IBlockData iblockdata1 = this.a(i, (MutableInt) null);
+                    IBlockData iblockdata1 = this.getBlockOptimized(ix, iy, iz); // Paper
                     VoxelShape voxelshape = this.a(iblockdata1, i, enumdirection);
                     VoxelShape voxelshape1 = this.a(iblockdata, j, enumdirection.opposite());
 
-                    return VoxelShapes.b(voxelshape, voxelshape1) ? 15 : k + Math.max(1, mutableint.getValue());
+                    return VoxelShapes.b(voxelshape, voxelshape1) ? 15 : k + Math.max(1, blockedLight); // Paper
                 }
             }
         }
@@ -56,14 +66,19 @@ public final class LightEngineBlock extends LightEngineLayer<LightEngineStorageB
 
     @Override
     protected void a(long i, int j, boolean flag) {
-        long k = SectionPosition.e(i);
+        // Paper start - reuse unpacking, credit to JellySquid (Didn't do full optimization though)
+        int x = (int) (i >> 38);
+        int y = (int) ((i << 52) >> 52);
+        int z = (int) ((i << 26) >> 38);
+        long k = SectionPosition.blockPosAsSectionLong(x, y, z);
+        // Paper end
         EnumDirection[] aenumdirection = LightEngineBlock.e;
         int l = aenumdirection.length;
 
         for (int i1 = 0; i1 < l; ++i1) {
             EnumDirection enumdirection = aenumdirection[i1];
-            long j1 = BlockPosition.a(i, enumdirection);
-            long k1 = SectionPosition.e(j1);
+            long j1 = BlockPosition.getAdjacent(x, y, z, enumdirection); // Paper
+            long k1 = SectionPosition.getAdjacentFromBlockPos(x, y, z, enumdirection); // Paper
 
             if (k == k1 || ((LightEngineStorageBlock) this.c).g(k1)) {
                 this.b(i, j1, j, flag);
@@ -88,27 +103,37 @@ public final class LightEngineBlock extends LightEngineLayer<LightEngineStorageB
             }
         }
 
-        long j1 = SectionPosition.e(i);
-        NibbleArray nibblearray = ((LightEngineStorageBlock) this.c).a(j1, true);
+        // Paper start
+        int baseX = (int) (i >> 38);
+        int baseY = (int) ((i << 52) >> 52);
+        int baseZ = (int) ((i << 26) >> 38);
+        long j1 = SectionPosition.blockPosAsSectionLong(baseX, baseY, baseZ);
+        NibbleArray nibblearray = this.c.updating.getUpdatingOptimized(j1);
+        // Paper end
         EnumDirection[] aenumdirection = LightEngineBlock.e;
         int k1 = aenumdirection.length;
 
         for (int l1 = 0; l1 < k1; ++l1) {
             EnumDirection enumdirection = aenumdirection[l1];
-            long i2 = BlockPosition.a(i, enumdirection);
+            // Paper start
+            int newX = baseX + enumdirection.getAdjacentX();
+            int newY = baseY + enumdirection.getAdjacentY();
+            int newZ = baseZ + enumdirection.getAdjacentZ();
+            long i2 = BlockPosition.asLong(newX, newY, newZ);
 
             if (i2 != j) {
-                long j2 = SectionPosition.e(i2);
+                long j2 = SectionPosition.blockPosAsSectionLong(newX, newY, newZ);
+                // Paper end
                 NibbleArray nibblearray1;
 
                 if (j1 == j2) {
                     nibblearray1 = nibblearray;
                 } else {
-                    nibblearray1 = ((LightEngineStorageBlock) this.c).a(j2, true);
+                    nibblearray1 = ((LightEngineStorageBlock) this.c).updating.getUpdatingOptimized(j2); // Paper
                 }
 
                 if (nibblearray1 != null) {
-                    int k2 = this.b(i2, i, this.a(nibblearray1, i2));
+                    int k2 = this.b(i2, i, this.getNibbleLightInverse(nibblearray1, newX, newY, newZ)); // Paper
 
                     if (l > k2) {
                         l = k2;
diff --git a/src/main/java/net/minecraft/server/LightEngineGraphSection.java b/src/main/java/net/minecraft/server/LightEngineGraphSection.java
index 2eb37fb5796d423a70fa7321899a19b6625bbecc..13d067f48647dea63ef1bf3a2a3e0868074ba75f 100644
--- a/src/main/java/net/minecraft/server/LightEngineGraphSection.java
+++ b/src/main/java/net/minecraft/server/LightEngineGraphSection.java
@@ -13,14 +13,20 @@ public abstract class LightEngineGraphSection extends LightEngineGraph {
 
     @Override
     protected void a(long i, int j, boolean flag) {
+        // Paper start
+        int x = (int) (i >> 42);
+        int y = (int) (i << 44 >> 44);
+        int z = (int) (i << 22 >> 42);
+        // Paper end
         for (int k = -1; k <= 1; ++k) {
             for (int l = -1; l <= 1; ++l) {
                 for (int i1 = -1; i1 <= 1; ++i1) {
-                    long j1 = SectionPosition.a(i, k, l, i1);
+                    if (k == 0 && l == 0 && i1 == 0) continue; // Paper
+                    long j1 = (((long) (x + k) & 4194303L) << 42) | (((long) (y + l) & 1048575L)) | (((long) (z + i1) & 4194303L) << 20); // Paper
 
-                    if (j1 != i) {
+                    //if (j1 != i) { // Paper - checked above
                         this.b(i, j1, j, flag);
-                    }
+                    //} // Paper
                 }
             }
         }
@@ -31,10 +37,15 @@ public abstract class LightEngineGraphSection extends LightEngineGraph {
     protected int a(long i, long j, int k) {
         int l = k;
 
+        // Paper start
+        int x = (int) (i >> 42);
+        int y = (int) (i << 44 >> 44);
+        int z = (int) (i << 22 >> 42);
+        // Paper end
         for (int i1 = -1; i1 <= 1; ++i1) {
             for (int j1 = -1; j1 <= 1; ++j1) {
                 for (int k1 = -1; k1 <= 1; ++k1) {
-                    long l1 = SectionPosition.a(i, i1, j1, k1);
+                    long l1 = (((long) (x + i1) & 4194303L) << 42) | (((long) (y + j1) & 1048575L)) | (((long) (z + k1) & 4194303L) << 20); // Paper
 
                     if (l1 == i) {
                         l1 = Long.MAX_VALUE;
diff --git a/src/main/java/net/minecraft/server/LightEngineLayer.java b/src/main/java/net/minecraft/server/LightEngineLayer.java
index 3e9731bcdd4c6370c11ffc93f9fafcaf60fe932b..b5d5dd1075fd6aabbfbbd60f219b76593fc54a76 100644
--- a/src/main/java/net/minecraft/server/LightEngineLayer.java
+++ b/src/main/java/net/minecraft/server/LightEngineLayer.java
@@ -11,10 +11,37 @@ public abstract class LightEngineLayer<M extends LightEngineStorageArray<M>, S e
     protected final EnumSkyBlock b;
     protected final S c;
     private boolean f;
-    protected final BlockPosition.MutableBlockPosition d = new BlockPosition.MutableBlockPosition();
+    protected final BlockPosition.MutableBlockPosition d = new BlockPosition.MutableBlockPosition(); protected final BlockPosition.MutableBlockPosition pos = d; // Paper
     private final long[] g = new long[2];
-    private final IBlockAccess[] h = new IBlockAccess[2];
+    private final IChunkAccess[] h = new IChunkAccess[2]; // Paper
 
+    // Paper start - see fully commented out method below (look for Bedrock)
+    // optimized method with less branching for when scenarios arent needed.
+    // avoid using mutable version if can
+    protected final IBlockData getBlockOptimized(int x, int y, int z, MutableInt mutableint) {
+        IChunkAccess iblockaccess = this.a(x >> 4, z >> 4);
+
+        if (iblockaccess == null) {
+            mutableint.setValue(16);
+            return Blocks.BEDROCK.getBlockData();
+        } else {
+            this.pos.setValues(x, y, z);
+            IBlockData iblockdata = iblockaccess.getType(x, y, z);
+            mutableint.setValue(iblockdata.b(this.a.getWorld(), this.pos));
+            return iblockdata.l() && iblockdata.e() ? iblockdata : Blocks.AIR.getBlockData();
+        }
+    }
+    protected final IBlockData getBlockOptimized(int x, int y, int z) {
+        IChunkAccess iblockaccess = this.a(x >> 4, z >> 4);
+
+        if (iblockaccess == null) {
+            return Blocks.BEDROCK.getBlockData();
+        } else {
+            IBlockData iblockdata = iblockaccess.getType(x, y, z);
+            return iblockdata.l() && iblockdata.e() ? iblockdata : Blocks.AIR.getBlockData();
+        }
+    }
+    // Paper end
     public LightEngineLayer(ILightAccess ilightaccess, EnumSkyBlock enumskyblock, S s0) {
         super(16, 256, 8192);
         this.a = ilightaccess;
@@ -33,7 +60,7 @@ public abstract class LightEngineLayer<M extends LightEngineStorageArray<M>, S e
     }
 
     @Nullable
-    private IBlockAccess a(int i, int j) {
+    private IChunkAccess a(int i, int j) { // Paper
         long k = ChunkCoordIntPair.pair(i, j);
 
         for (int l = 0; l < 2; ++l) {
@@ -42,7 +69,7 @@ public abstract class LightEngineLayer<M extends LightEngineStorageArray<M>, S e
             }
         }
 
-        IBlockAccess iblockaccess = this.a.c(i, j);
+        IChunkAccess iblockaccess = (IChunkAccess) this.a.c(i, j); // Paper
 
         for (int i1 = 1; i1 > 0; --i1) {
             this.g[i1] = this.g[i1 - 1];
@@ -59,37 +86,39 @@ public abstract class LightEngineLayer<M extends LightEngineStorageArray<M>, S e
         Arrays.fill(this.h, (Object) null);
     }
 
-    protected IBlockData a(long i, @Nullable MutableInt mutableint) {
-        if (i == Long.MAX_VALUE) {
-            if (mutableint != null) {
-                mutableint.setValue(0);
-            }
-
-            return Blocks.AIR.getBlockData();
-        } else {
-            int j = SectionPosition.a(BlockPosition.b(i));
-            int k = SectionPosition.a(BlockPosition.d(i));
-            IBlockAccess iblockaccess = this.a(j, k);
-
-            if (iblockaccess == null) {
-                if (mutableint != null) {
-                    mutableint.setValue(16);
-                }
-
-                return Blocks.BEDROCK.getBlockData();
-            } else {
-                this.d.g(i);
-                IBlockData iblockdata = iblockaccess.getType(this.d);
-                boolean flag = iblockdata.l() && iblockdata.e();
-
-                if (mutableint != null) {
-                    mutableint.setValue(iblockdata.b(this.a.getWorld(), (BlockPosition) this.d));
-                }
-
-                return flag ? iblockdata : Blocks.AIR.getBlockData();
-            }
-        }
-    }
+    // Paper start - comment out, see getBlockOptimized
+//    protected IBlockData a(long i, @Nullable MutableInt mutableint) {
+//        if (i == Long.MAX_VALUE) {
+//            if (mutableint != null) {
+//                mutableint.setValue(0);
+//            }
+//
+//            return Blocks.AIR.getBlockData();
+//        } else {
+//            int j = SectionPosition.a(BlockPosition.b(i));
+//            int k = SectionPosition.a(BlockPosition.d(i));
+//            IBlockAccess iblockaccess = this.a(j, k);
+//
+//            if (iblockaccess == null) {
+//                if (mutableint != null) {
+//                    mutableint.setValue(16);
+//                }
+//
+//                return Blocks.BEDROCK.getBlockData();
+//            } else {
+//                this.d.g(i);
+//                IBlockData iblockdata = iblockaccess.getType(this.d);
+//                boolean flag = iblockdata.l() && iblockdata.e();
+//
+//                if (mutableint != null) {
+//                    mutableint.setValue(iblockdata.b(this.a.getWorld(), (BlockPosition) this.d));
+//                }
+//
+//                return flag ? iblockdata : Blocks.AIR.getBlockData();
+//            }
+//        }
+//    }
+    // Paper end
 
     protected VoxelShape a(IBlockData iblockdata, long i, EnumDirection enumdirection) {
         return iblockdata.l() ? iblockdata.a(this.a.getWorld(), this.d.g(i), enumdirection) : VoxelShapes.a();
@@ -124,8 +153,9 @@ public abstract class LightEngineLayer<M extends LightEngineStorageArray<M>, S e
         return i == Long.MAX_VALUE ? 0 : 15 - this.c.i(i);
     }
 
+    protected int getNibbleLightInverse(NibbleArray nibblearray, int x, int y, int z) { return 15 - nibblearray.a(x & 15, y & 15, z & 15); } // Paper - x/y/z version of below
     protected int a(NibbleArray nibblearray, long i) {
-        return 15 - nibblearray.a(SectionPosition.b(BlockPosition.b(i)), SectionPosition.b(BlockPosition.c(i)), SectionPosition.b(BlockPosition.d(i)));
+        return 15 - nibblearray.a((int) (i >> 38) & 15, (int) ((i << 52) >> 52) & 15, (int) ((i << 26) >> 38) & 15); // Paper
     }
 
     @Override
diff --git a/src/main/java/net/minecraft/server/LightEngineSky.java b/src/main/java/net/minecraft/server/LightEngineSky.java
index f0b57784006752e031800a12a1a3c1a5945c636b..32b52ca2462fa206b1184025cb3837d6c326db2d 100644
--- a/src/main/java/net/minecraft/server/LightEngineSky.java
+++ b/src/main/java/net/minecraft/server/LightEngineSky.java
@@ -29,21 +29,25 @@ public final class LightEngineSky extends LightEngineLayer<LightEngineStorageSky
                 return k;
             } else {
                 //MutableInt mutableint = new MutableInt(); // Paper - share mutableint, single threaded
-                IBlockData iblockdata = this.a(j, mutableint);
-
-                if (mutableint.getValue() >= 15) {
+                // Paper start - use x/y/z and optimized block lookup
+                int jx = (int) (j >> 38);
+                int jy = (int) ((j << 52) >> 52);
+                int jz = (int) ((j << 26) >> 38);
+                IBlockData iblockdata = this.getBlockOptimized(jx, jy, jz, mutableint);
+                int blockedLight = mutableint.getValue();
+                if (blockedLight >= 15) {
+                    // Paper end
                     return 15;
                 } else {
-                    int l = BlockPosition.b(i);
-                    int i1 = BlockPosition.c(i);
-                    int j1 = BlockPosition.d(i);
-                    int k1 = BlockPosition.b(j);
-                    int l1 = BlockPosition.c(j);
-                    int i2 = BlockPosition.d(j);
-                    boolean flag = l == k1 && j1 == i2;
-                    int j2 = Integer.signum(k1 - l);
-                    int k2 = Integer.signum(l1 - i1);
-                    int l2 = Integer.signum(i2 - j1);
+                    // Paper start - inline math
+                    int ix = (int) (i >> 38);
+                    int iy = (int) ((i << 52) >> 52);
+                    int iz = (int) ((i << 26) >> 38);
+                    boolean flag = ix == jx && iz == jz;
+                    int j2 = Integer.signum(jx - ix);
+                    int k2 = Integer.signum(jy - iy);
+                    int l2 = Integer.signum(jz - iz);
+                    // Paper end
                     EnumDirection enumdirection;
 
                     if (i == Long.MAX_VALUE) {
@@ -52,7 +56,7 @@ public final class LightEngineSky extends LightEngineLayer<LightEngineStorageSky
                         enumdirection = EnumDirection.a(j2, k2, l2);
                     }
 
-                    IBlockData iblockdata1 = this.a(i, (MutableInt) null);
+                    IBlockData iblockdata1 = i == Long.MAX_VALUE ? Blocks.AIR.getBlockData() : this.getBlockOptimized(ix, iy, iz); // Paper
                     VoxelShape voxelshape;
 
                     if (enumdirection != null) {
@@ -82,9 +86,9 @@ public final class LightEngineSky extends LightEngineLayer<LightEngineStorageSky
                         }
                     }
 
-                    boolean flag1 = i == Long.MAX_VALUE || flag && i1 > l1;
+                    boolean flag1 = i == Long.MAX_VALUE || flag && iy > jy; // Paper rename vars to iy > jy
 
-                    return flag1 && k == 0 && mutableint.getValue() == 0 ? 0 : k + Math.max(1, mutableint.getValue());
+                    return flag1 && k == 0 && blockedLight == 0 ? 0 : k + Math.max(1, blockedLight); // Paper
                 }
             }
         }
@@ -92,10 +96,14 @@ public final class LightEngineSky extends LightEngineLayer<LightEngineStorageSky
 
     @Override
     protected void a(long i, int j, boolean flag) {
-        long k = SectionPosition.e(i);
-        int l = BlockPosition.c(i);
-        int i1 = SectionPosition.b(l);
-        int j1 = SectionPosition.a(l);
+        // Paper start
+        int baseX = (int) (i >> 38);
+        int baseY = (int) ((i << 52) >> 52);
+        int baseZ = (int) ((i << 26) >> 38);
+        long k = SectionPosition.blockPosAsSectionLong(baseX, baseY, baseZ);
+        int i1 = baseY & 15;
+        int j1 = baseY >> 4;
+        // Paper end
         int k1;
 
         if (i1 != 0) {
@@ -110,15 +118,16 @@ public final class LightEngineSky extends LightEngineLayer<LightEngineStorageSky
             k1 = l1;
         }
 
-        long i2 = BlockPosition.a(i, 0, -1 - k1 * 16, 0);
-        long j2 = SectionPosition.e(i2);
+        int newBaseY = baseY + (-1 - k1 * 16); // Paper
+        long i2 = BlockPosition.asLong(baseX, newBaseY, baseZ); // Paper
+        long j2 = SectionPosition.blockPosAsSectionLong(baseX, newBaseY, baseZ); // Paper
 
         if (k == j2 || ((LightEngineStorageSky) this.c).g(j2)) {
             this.b(i, i2, j, flag);
         }
 
-        long k2 = BlockPosition.a(i, EnumDirection.UP);
-        long l2 = SectionPosition.e(k2);
+        long k2 = BlockPosition.asLong(baseX, baseY + 1, baseZ); // Paper
+        long l2 = SectionPosition.blockPosAsSectionLong(baseX, baseY + 1, baseZ); // Paper
 
         if (k == l2 || ((LightEngineStorageSky) this.c).g(l2)) {
             this.b(i, k2, j, flag);
@@ -133,8 +142,8 @@ public final class LightEngineSky extends LightEngineLayer<LightEngineStorageSky
             int k3 = 0;
 
             while (true) {
-                long l3 = BlockPosition.a(i, enumdirection.getAdjacentX(), -k3, enumdirection.getAdjacentZ());
-                long i4 = SectionPosition.e(l3);
+                long l3 = BlockPosition.asLong(baseX + enumdirection.getAdjacentX(), baseY - k3, baseZ + enumdirection.getAdjacentZ()); // Paper
+                long i4 = SectionPosition.blockPosAsSectionLong(baseX + enumdirection.getAdjacentX(), baseY - k3, baseZ + enumdirection.getAdjacentZ()); // Paper
 
                 if (k == i4) {
                     this.b(i, l3, j, flag);
@@ -172,26 +181,36 @@ public final class LightEngineSky extends LightEngineLayer<LightEngineStorageSky
             }
         }
 
-        long j1 = SectionPosition.e(i);
-        NibbleArray nibblearray = ((LightEngineStorageSky) this.c).a(j1, true);
+        // Paper start
+        int baseX = (int) (i >> 38);
+        int baseY = (int) ((i << 52) >> 52);
+        int baseZ = (int) ((i << 26) >> 38);
+        long j1 = SectionPosition.blockPosAsSectionLong(baseX, baseY, baseZ);
+        NibbleArray nibblearray = this.c.updating.getUpdatingOptimized(j1);
+        // Paper end
         EnumDirection[] aenumdirection = LightEngineSky.e;
         int k1 = aenumdirection.length;
 
         for (int l1 = 0; l1 < k1; ++l1) {
             EnumDirection enumdirection = aenumdirection[l1];
-            long i2 = BlockPosition.a(i, enumdirection);
-            long j2 = SectionPosition.e(i2);
+            // Paper start
+            int newX = baseX + enumdirection.getAdjacentX();
+            int newY = baseY + enumdirection.getAdjacentY();
+            int newZ = baseZ + enumdirection.getAdjacentZ();
+            long i2 = BlockPosition.asLong(newX, newY, newZ);
+            long j2 = SectionPosition.blockPosAsSectionLong(newX, newY, newZ);
+            // Paper end
             NibbleArray nibblearray1;
 
             if (j1 == j2) {
                 nibblearray1 = nibblearray;
             } else {
-                nibblearray1 = ((LightEngineStorageSky) this.c).a(j2, true);
+                nibblearray1 = ((LightEngineStorageSky) this.c).updating.getUpdatingOptimized(j2); // Paper
             }
 
             if (nibblearray1 != null) {
                 if (i2 != j) {
-                    int k2 = this.b(i2, i, this.a(nibblearray1, i2));
+                    int k2 = this.b(i2, i, this.getNibbleLightInverse(nibblearray1, newX, newY, newZ)); // Paper
 
                     if (l > k2) {
                         l = k2;
@@ -206,7 +225,7 @@ public final class LightEngineSky extends LightEngineLayer<LightEngineStorageSky
                     j2 = SectionPosition.a(j2, EnumDirection.UP);
                 }
 
-                NibbleArray nibblearray2 = ((LightEngineStorageSky) this.c).a(j2, true);
+                NibbleArray nibblearray2 = this.c.updating.getUpdatingOptimized(j2); // Paper
 
                 if (i2 != j) {
                     int l2;
diff --git a/src/main/java/net/minecraft/server/LightEngineStorage.java b/src/main/java/net/minecraft/server/LightEngineStorage.java
index b8b06c790adfa0246b1a6fb5eab1f63bf5ef8b0b..b98e60772bad7e06845b50fdc11e98c0ea775d3d 100644
--- a/src/main/java/net/minecraft/server/LightEngineStorage.java
+++ b/src/main/java/net/minecraft/server/LightEngineStorage.java
@@ -20,9 +20,9 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
     protected final LongSet c = new LongOpenHashSet();
     protected final LongSet d = new LongOpenHashSet();
     protected volatile M e_visible; protected final Object visibleUpdateLock = new Object(); // Paper - diff on change, should be "visible" - force compile fail on usage change
-    protected final M f; // Paper - diff on change, should be "updating"
+    protected final M f; protected final M updating; // Paper - diff on change, should be "updating"
     protected final LongSet g = new LongOpenHashSet();
-    protected final LongSet h = new LongOpenHashSet();
+    protected final LongSet h = new LongOpenHashSet(); LongSet dirty = h; // Paper - OBFHELPER
     protected final Long2ObjectMap<NibbleArray> i = Long2ObjectMaps.synchronize(new Long2ObjectOpenHashMap());
     private final LongSet n = new LongOpenHashSet();
     private final LongSet o = new LongOpenHashSet();
@@ -30,33 +30,33 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
     protected volatile boolean j;
 
     protected LightEngineStorage(EnumSkyBlock enumskyblock, ILightAccess ilightaccess, M m0) {
-        super(3, 16, 256);
+        super(3, 256, 256); // Paper - bump expected size of level sets to improve collisions and reduce rehashing (seen a lot of it)
         this.l = enumskyblock;
         this.m = ilightaccess;
-        this.f = m0;
+        this.f = m0; updating = m0; // Paper
         this.e_visible = m0.b(); // Paper - avoid copying light data
         this.e_visible.d(); // Paper - avoid copying light data
     }
 
-    protected boolean g(long i) {
-        return this.a(i, true) != null;
+    protected final boolean g(long i) { // Paper - final to help inlining
+        return this.updating.getUpdatingOptimized(i) != null; // Paper - inline to avoid branching
     }
 
     @Nullable
     protected NibbleArray a(long i, boolean flag) {
         // Paper start - avoid copying light data
         if (flag) {
-            return this.a(this.f, i);
+            return this.updating.getUpdatingOptimized(i);
         } else {
             synchronized (this.visibleUpdateLock) {
-                return this.a(this.e_visible, i);
+                return this.e_visible.lookup.apply(i);
             }
         }
         // Paper end - avoid copying light data
     }
 
     @Nullable
-    protected NibbleArray a(M m0, long i) {
+    protected final NibbleArray a(M m0, long i) { // Paper
         return m0.c(i);
     }
 
@@ -70,27 +70,57 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
     protected abstract int d(long i);
 
     protected int i(long i) {
-        long j = SectionPosition.e(i);
-        NibbleArray nibblearray = this.a(j, true);
+        // Paper start - reuse and inline math, use Optimized Updating path
+        final int x = (int) (i >> 38);
+        final int y = (int) ((i << 52) >> 52);
+        final int z = (int) ((i << 26) >> 38);
+        long j = SectionPosition.blockPosAsSectionLong(x, y, z);
+        NibbleArray nibblearray = this.updating.getUpdatingOptimized(j);
+        //  BUG: Sometimes returns null and crashes, try to recover, but to prevent crash just return no light.
+        if (nibblearray == null) {
+            nibblearray = this.e_visible.lookup.apply(j);
+        }
+        if (nibblearray == null) {
+            System.err.println("Null nibble, preventing crash " + BlockPosition.fromLong(i));
+            return 0;
+        }
 
-        return nibblearray.a(SectionPosition.b(BlockPosition.b(i)), SectionPosition.b(BlockPosition.c(i)), SectionPosition.b(BlockPosition.d(i)));
+        return nibblearray.a(x & 15, y & 15, z & 15); // Paper - inline operations
+        // Paper end
     }
 
     protected void b(long i, int j) {
-        long k = SectionPosition.e(i);
+        // Paper start - cache part of the math done in loop below
+        int x = (int) (i >> 38);
+        int y = (int) ((i << 52) >> 52);
+        int z = (int) ((i << 26) >> 38);
+        long k = SectionPosition.blockPosAsSectionLong(x, y, z);
+        // Paper end
 
         if (this.g.add(k)) {
             this.f.a(k);
         }
 
         NibbleArray nibblearray = this.a(k, true);
-
-        nibblearray.a(SectionPosition.b(BlockPosition.b(i)), SectionPosition.b(BlockPosition.c(i)), SectionPosition.b(BlockPosition.d(i)), j);
-
-        for (int l = -1; l <= 1; ++l) {
-            for (int i1 = -1; i1 <= 1; ++i1) {
-                for (int j1 = -1; j1 <= 1; ++j1) {
-                    this.h.add(SectionPosition.e(BlockPosition.a(i, i1, j1, l)));
+        nibblearray.a(x & 15, y & 15, z & 15, j); // Paper - use already calculated x/y/z
+
+        // Paper start - credit to JellySquid for a major optimization here:
+        /*
+         * An extremely important optimization is made here in regards to adding items to the pending notification set. The
+         * original implementation attempts to add the coordinate of every chunk which contains a neighboring block position
+         * even though a huge number of loop iterations will simply map to block positions within the same updating chunk.
+         *
+         * Our implementation here avoids this by pre-calculating the min/max chunk coordinates so we can iterate over only
+         * the relevant chunk positions once. This reduces what would always be 27 iterations to just 1-8 iterations.
+         *
+         * @reason Use faster implementation
+         * @author JellySquid
+         */
+        for (int z2 = (z - 1) >> 4; z2 <= (z + 1) >> 4; ++z2) {
+            for (int x2 = (x - 1) >> 4; x2 <= (x + 1) >> 4; ++x2) {
+                for (int y2 = (y - 1) >> 4; y2 <= (y + 1) >> 4; ++y2) {
+                    this.dirty.add(SectionPosition.asLong(x2, y2, z2));
+                    // Paper end
                 }
             }
         }
@@ -122,17 +152,23 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
         }
 
         if (k >= 2 && j != 2) {
-            if (this.p.contains(i)) {
-                this.p.remove(i);
-            } else {
+            if (!this.p.remove(i)) { // Paper - remove useless contains - credit to JellySquid
+                //this.p.remove(i); // Paper
+            //} else { // Paper
                 this.f.a(i, this.j(i));
                 this.g.add(i);
                 this.k(i);
 
-                for (int l = -1; l <= 1; ++l) {
-                    for (int i1 = -1; i1 <= 1; ++i1) {
-                        for (int j1 = -1; j1 <= 1; ++j1) {
-                            this.h.add(SectionPosition.e(BlockPosition.a(i, i1, j1, l)));
+                // Paper start - reuse x/y/z and only notify valid chunks - Credit to JellySquid (See above method for notes)
+                int x = (int) (i >> 38);
+                int y = (int) ((i << 52) >> 52);
+                int z = (int) ((i << 26) >> 38);
+
+                for (int z2 = (z - 1) >> 4; z2 <= (z + 1) >> 4; ++z2) {
+                    for (int x2 = (x - 1) >> 4; x2 <= (x + 1) >> 4; ++x2) {
+                        for (int y2 = (y - 1) >> 4; y2 <= (y + 1) >> 4; ++y2) {
+                            this.dirty.add(SectionPosition.asLong(x2, y2, z2));
+                            // Paper end
                         }
                     }
                 }
@@ -158,9 +194,9 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
                 return SectionPosition.e(j) == i;
             });
         } else {
-            int j = SectionPosition.c(SectionPosition.b(i));
-            int k = SectionPosition.c(SectionPosition.c(i));
-            int l = SectionPosition.c(SectionPosition.d(i));
+            int j = (int) (i >> 42) << 4; // Paper - inline
+            int k = (int) (i << 44 >> 44) << 4; // Paper - inline
+            int l = (int) (i << 22 >> 42) << 4; // Paper - inline
 
             for (int i1 = 0; i1 < 16; ++i1) {
                 for (int j1 = 0; j1 < 16; ++j1) {
@@ -187,7 +223,7 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
             NibbleArray nibblearray;
 
             while (longiterator.hasNext()) {
-                i = (Long) longiterator.next();
+                i = longiterator.nextLong(); // Paper
                 this.a(lightenginelayer, i);
                 NibbleArray nibblearray1 = (NibbleArray) this.i.remove(i);
 
@@ -205,7 +241,7 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
             longiterator = this.p.iterator();
 
             while (longiterator.hasNext()) {
-                i = (Long) longiterator.next();
+                i = longiterator.nextLong(); // Paper
                 this.l(i);
             }
 
@@ -216,12 +252,13 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
             Entry entry;
             long j;
 
+            NibbleArray test = null; // Paper
             while (objectiterator.hasNext()) {
                 entry = (Entry) objectiterator.next();
                 j = entry.getLongKey();
-                if (this.g(j)) {
+                if ((test = this.updating.getUpdatingOptimized(j)) != null) { // Paper - dont look up nibble twice
                     nibblearray = (NibbleArray) entry.getValue();
-                    if (this.f.c(j) != nibblearray) {
+                    if (test != nibblearray) { // Paper
                         this.a(lightenginelayer, j);
                         this.f.a(j, nibblearray);
                         this.g.add(j);
@@ -234,14 +271,14 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
                 longiterator = this.i.keySet().iterator();
 
                 while (longiterator.hasNext()) {
-                    i = (Long) longiterator.next();
+                    i = longiterator.nextLong(); // Paper
                     this.b(lightenginelayer, i);
                 }
             } else {
                 longiterator = this.n.iterator();
 
                 while (longiterator.hasNext()) {
-                    i = (Long) longiterator.next();
+                    i = longiterator.nextLong(); // Paper
                     this.b(lightenginelayer, i);
                 }
             }
@@ -262,15 +299,20 @@ public abstract class LightEngineStorage<M extends LightEngineStorageArray<M>> e
 
     private void b(LightEngineLayer<M, ?> lightenginelayer, long i) {
         if (this.g(i)) {
-            int j = SectionPosition.c(SectionPosition.b(i));
-            int k = SectionPosition.c(SectionPosition.c(i));
-            int l = SectionPosition.c(SectionPosition.d(i));
+            // Paper start
+            int secX = (int) (i >> 42);
+            int secY = (int) (i << 44 >> 44);
+            int secZ = (int) (i << 22 >> 42);
+            int j = secX << 4; // baseX
+            int k = secY << 4; // baseY
+            int l = secZ << 4; // baseZ
+            // Paper end
             EnumDirection[] aenumdirection = LightEngineStorage.k;
             int i1 = aenumdirection.length;
 
             for (int j1 = 0; j1 < i1; ++j1) {
                 EnumDirection enumdirection = aenumdirection[j1];
-                long k1 = SectionPosition.a(i, enumdirection);
+                long k1 = SectionPosition.getAdjacentFromSectionPos(secX, secY, secZ, enumdirection); // Paper - avoid extra unpacking
 
                 if (!this.i.containsKey(k1) && this.g(k1)) {
                     for (int l1 = 0; l1 < 16; ++l1) {
diff --git a/src/main/java/net/minecraft/server/LightEngineStorageArray.java b/src/main/java/net/minecraft/server/LightEngineStorageArray.java
index 37c44a89f28c44915fcae5a7e2c4797b1c123723..549c2551c2b59730bf53a80f8706d388d96ad932 100644
--- a/src/main/java/net/minecraft/server/LightEngineStorageArray.java
+++ b/src/main/java/net/minecraft/server/LightEngineStorageArray.java
@@ -5,13 +5,18 @@ import javax.annotation.Nullable;
 
 public abstract class LightEngineStorageArray<M extends LightEngineStorageArray<M>> {
 
-    private final long[] b = new long[2];
-    private final NibbleArray[] c = new NibbleArray[2];
+    // private final long[] b = new long[2]; // Paper - unused
+    private final NibbleArray[] c = new NibbleArray[]{NibbleArray.EMPTY_NIBBLE_ARRAY, NibbleArray.EMPTY_NIBBLE_ARRAY}; private final NibbleArray[] cache = c; // Paper - OBFHELPER
     private boolean d;
     protected final com.destroystokyo.paper.util.map.QueuedChangesMapLong2Object<NibbleArray> data; // Paper - avoid copying light data
     protected final boolean isVisible; // Paper - avoid copying light data
-    java.util.function.Function<Long, NibbleArray> lookup; // Paper - faster branchless lookup
 
+    // Paper start - faster lookups with less branching, use interface to avoid boxing instead of Function
+    public final NibbleArrayAccess lookup;
+    public interface NibbleArrayAccess {
+        NibbleArray apply(long id);
+    }
+    // Paper end
     // Paper start - avoid copying light data
     protected LightEngineStorageArray(com.destroystokyo.paper.util.map.QueuedChangesMapLong2Object<NibbleArray> data, boolean isVisible) {
         if (isVisible) {
@@ -19,12 +24,14 @@ public abstract class LightEngineStorageArray<M extends LightEngineStorageArray<
         }
         this.data = data;
         this.isVisible = isVisible;
+        // Paper end - avoid copying light data
+        // Paper start - faster lookups with less branching
         if (isVisible) {
             lookup = data::getVisibleAsync;
         } else {
-            lookup = data::getUpdating;
+            lookup = data.getUpdatingMap()::get; // jump straight the sub map
         }
-        // Paper end - avoid copying light data
+        // Paper end
         this.c();
         this.d = true;
     }
@@ -34,7 +41,9 @@ public abstract class LightEngineStorageArray<M extends LightEngineStorageArray<
     public void a(long i) {
         if (this.isVisible) { throw new IllegalStateException("writing to visible data"); } // Paper - avoid copying light data
         NibbleArray updating = this.data.getUpdating(i); // Paper - pool nibbles
-        this.data.queueUpdate(i, new NibbleArray().markPoolSafe(updating.getCloneIfSet())); // Paper - avoid copying light data - pool safe clone
+        NibbleArray nibblearray = new NibbleArray().markPoolSafe(updating.getCloneIfSet()); // Paper
+        nibblearray.lightCacheKey = i; // Paper
+        this.data.queueUpdate(i, nibblearray); // Paper - avoid copying light data - pool safe clone
         if (updating.cleaner != null) MCUtil.scheduleTask(2, updating.cleaner, "Light Engine Release"); // Paper - delay clean incase anything holding ref was still using it
         this.c();
     }
@@ -43,34 +52,34 @@ public abstract class LightEngineStorageArray<M extends LightEngineStorageArray<
         return lookup.apply(i) != null; // Paper - avoid copying light data
     }
 
-    @Nullable
-    public final NibbleArray c(long i) { // Paper - final
-        if (this.d) {
-            for (int j = 0; j < 2; ++j) {
-                if (i == this.b[j]) {
-                    return this.c[j];
-                }
-            }
-        }
-
-        NibbleArray nibblearray = lookup.apply(i); // Paper - avoid copying light data
+    // Paper start - less branching as we know we are using cache and updating
+    public final NibbleArray getUpdatingOptimized(final long i) { // Paper - final
+        final NibbleArray[] cache = this.cache;
+        if (cache[0].lightCacheKey == i) return cache[0];
+        if (cache[1].lightCacheKey == i) return cache[1];
 
+        final NibbleArray nibblearray = this.lookup.apply(i); // Paper - avoid copying light data
         if (nibblearray == null) {
             return null;
         } else {
-            if (this.d) {
-                for (int k = 1; k > 0; --k) {
-                    this.b[k] = this.b[k - 1];
-                    this.c[k] = this.c[k - 1];
-                }
-
-                this.b[0] = i;
-                this.c[0] = nibblearray;
-            }
-
+            cache[1] = cache[0];
+            cache[0] = nibblearray;
             return nibblearray;
         }
     }
+    // Paper end
+
+    @Nullable
+    public final NibbleArray c(final long i) { // Paper - final
+        // Paper start - optimize visible case or missed updating cases
+        if (this.d) {
+            // short circuit to optimized
+            return getUpdatingOptimized(i);
+        }
+
+        return this.lookup.apply(i);
+        // Paper end
+    }
 
     @Nullable
     public NibbleArray d(long i) {
@@ -80,13 +89,14 @@ public abstract class LightEngineStorageArray<M extends LightEngineStorageArray<
 
     public void a(long i, NibbleArray nibblearray) {
         if (this.isVisible) { throw new IllegalStateException("writing to visible data"); } // Paper - avoid copying light data
+        nibblearray.lightCacheKey = i; // Paper
         this.data.queueUpdate(i, nibblearray); // Paper - avoid copying light data
     }
 
     public void c() {
         for (int i = 0; i < 2; ++i) {
-            this.b[i] = Long.MAX_VALUE;
-            this.c[i] = null;
+            // this.b[i] = Long.MAX_VALUE; // Paper - Unused
+            this.c[i] = NibbleArray.EMPTY_NIBBLE_ARRAY; // Paper
         }
     }
 
diff --git a/src/main/java/net/minecraft/server/LightEngineStorageBlock.java b/src/main/java/net/minecraft/server/LightEngineStorageBlock.java
index 292d8c742d3be41ba8ad7fb7f1251dc7f790b62b..5b7b7506f5d1a7578fb54a578891324dfcec3f03 100644
--- a/src/main/java/net/minecraft/server/LightEngineStorageBlock.java
+++ b/src/main/java/net/minecraft/server/LightEngineStorageBlock.java
@@ -10,10 +10,14 @@ public class LightEngineStorageBlock extends LightEngineStorage<LightEngineStora
 
     @Override
     protected int d(long i) {
-        long j = SectionPosition.e(i);
-        NibbleArray nibblearray = this.a(j, false);
-
-        return nibblearray == null ? 0 : nibblearray.a(SectionPosition.b(BlockPosition.b(i)), SectionPosition.b(BlockPosition.c(i)), SectionPosition.b(BlockPosition.d(i)));
+        // Paper start
+        int baseX = (int) (i >> 38);
+        int baseY = (int) ((i << 52) >> 52);
+        int baseZ = (int) ((i << 26) >> 38);
+        long j = (((long) (baseX >> 4) & 4194303L) << 42) | (((long) (baseY >> 4) & 1048575L)) | (((long) (baseZ >> 4) & 4194303L) << 20);
+        NibbleArray nibblearray = this.e_visible.lookup.apply(j);
+        return nibblearray == null ? 0 : nibblearray.a(baseX & 15, baseY & 15, baseZ & 15);
+        // Paper end
     }
 
     public static final class a extends LightEngineStorageArray<LightEngineStorageBlock.a> {
diff --git a/src/main/java/net/minecraft/server/LightEngineStorageSky.java b/src/main/java/net/minecraft/server/LightEngineStorageSky.java
index 097f58e9ac3f4096d3b9dad75b6ebe76021fa92c..f744f62c93370d096c113f92ee81a8232c35501d 100644
--- a/src/main/java/net/minecraft/server/LightEngineStorageSky.java
+++ b/src/main/java/net/minecraft/server/LightEngineStorageSky.java
@@ -22,7 +22,12 @@ public class LightEngineStorageSky extends LightEngineStorage<LightEngineStorage
 
     @Override
     protected int d(long i) {
-        long j = SectionPosition.e(i);
+        // Paper start
+        int baseX = (int) (i >> 38);
+        int baseY = (int) ((i << 52) >> 52);
+        int baseZ = (int) ((i << 26) >> 38);
+        long j = SectionPosition.blockPosAsSectionLong(baseX, baseY, baseZ);
+        // Paper end
         int k = SectionPosition.c(j);
         synchronized (this.visibleUpdateLock) { // Paper - avoid copying light data
         LightEngineStorageSky.a lightenginestoragesky_a = (LightEngineStorageSky.a) this.e_visible; // Paper - avoid copying light data - must be after lock acquire
@@ -43,7 +48,7 @@ public class LightEngineStorageSky extends LightEngineStorage<LightEngineStorage
                 }
             }
 
-            return nibblearray.a(SectionPosition.b(BlockPosition.b(i)), SectionPosition.b(BlockPosition.c(i)), SectionPosition.b(BlockPosition.d(i)));
+            return nibblearray.a(baseX & 15, (int) ((i << 52) >> 52) & 15, (int) baseZ & 15); // Paper - y changed above
         } else {
             return 15;
         }
@@ -162,7 +167,7 @@ public class LightEngineStorageSky extends LightEngineStorage<LightEngineStorage
             if (k != ((LightEngineStorageSky.a) this.f).b && SectionPosition.c(j) < k) {
                 NibbleArray nibblearray1;
 
-                while ((nibblearray1 = this.a(j, true)) == null) {
+                while ((nibblearray1 = this.updating.getUpdatingOptimized(j)) == null) { // Paper
                     j = SectionPosition.a(j, EnumDirection.UP);
                 }
 
@@ -186,7 +191,10 @@ public class LightEngineStorageSky extends LightEngineStorage<LightEngineStorage
                 longiterator = this.m.iterator();
 
                 while (longiterator.hasNext()) {
-                    i = (Long) longiterator.next();
+                    i = longiterator.nextLong(); // Paper
+                    int baseX = (int) (i >> 42) << 4; // Paper
+                    int baseY = (int) (i << 44 >> 44) << 4; // Paper
+                    int baseZ = (int) (i << 22 >> 42) << 4; // Paper
                     j = this.c(i);
                     if (j != 2 && !this.n.contains(i) && this.l.add(i)) {
                         int l;
@@ -197,10 +205,10 @@ public class LightEngineStorageSky extends LightEngineStorage<LightEngineStorage
                                 ((LightEngineStorageSky.a) this.f).a(i);
                             }
 
-                            Arrays.fill(this.a(i, true).asBytesPoolSafe(), (byte) -1); // Paper
-                            k = SectionPosition.c(SectionPosition.b(i));
-                            l = SectionPosition.c(SectionPosition.c(i));
-                            int i1 = SectionPosition.c(SectionPosition.d(i));
+                            Arrays.fill(this.updating.getUpdatingOptimized(i).asBytesPoolSafe(), (byte) -1); // Paper - use optimized
+                            k = baseX; // Paper
+                            l = baseY; // Paper
+                            int i1 = baseZ; // Paper
                             EnumDirection[] aenumdirection = LightEngineStorageSky.k;
                             int j1 = aenumdirection.length;
 
@@ -209,7 +217,7 @@ public class LightEngineStorageSky extends LightEngineStorage<LightEngineStorage
                             for (int l1 = 0; l1 < j1; ++l1) {
                                 EnumDirection enumdirection = aenumdirection[l1];
 
-                                k1 = SectionPosition.a(i, enumdirection);
+                                k1 = SectionPosition.getAdjacentFromBlockPos(baseX, baseY, baseZ, enumdirection); // Paper
                                 if ((this.n.contains(k1) || !this.l.contains(k1) && !this.m.contains(k1)) && this.g(k1)) {
                                     for (int i2 = 0; i2 < 16; ++i2) {
                                         for (int j2 = 0; j2 < 16; ++j2) {
@@ -242,16 +250,16 @@ public class LightEngineStorageSky extends LightEngineStorage<LightEngineStorage
 
                             for (int i3 = 0; i3 < 16; ++i3) {
                                 for (j1 = 0; j1 < 16; ++j1) {
-                                    long j3 = BlockPosition.a(SectionPosition.c(SectionPosition.b(i)) + i3, SectionPosition.c(SectionPosition.c(i)), SectionPosition.c(SectionPosition.d(i)) + j1);
+                                    long j3 = BlockPosition.a(baseX + i3, baseY, baseZ + j1); // Paper
 
-                                    k1 = BlockPosition.a(SectionPosition.c(SectionPosition.b(i)) + i3, SectionPosition.c(SectionPosition.c(i)) - 1, SectionPosition.c(SectionPosition.d(i)) + j1);
+                                    k1 = BlockPosition.a(baseX + i3, baseY - 1, baseZ + j1); // Paper
                                     lightenginelayer.a(j3, k1, lightenginelayer.b(j3, k1, 0), true);
                                 }
                             }
                         } else {
                             for (k = 0; k < 16; ++k) {
                                 for (l = 0; l < 16; ++l) {
-                                    long k3 = BlockPosition.a(SectionPosition.c(SectionPosition.b(i)) + k, SectionPosition.c(SectionPosition.c(i)) + 16 - 1, SectionPosition.c(SectionPosition.d(i)) + l);
+                                    long k3 = BlockPosition.a(baseX + k, baseY + 16 - 1, baseZ + l); // Paper
 
                                     lightenginelayer.a(Long.MAX_VALUE, k3, 0, true);
                                 }
@@ -266,11 +274,14 @@ public class LightEngineStorageSky extends LightEngineStorage<LightEngineStorage
                 longiterator = this.n.iterator();
 
                 while (longiterator.hasNext()) {
-                    i = (Long) longiterator.next();
+                    i = longiterator.nextLong(); // Paper
+                    int baseX = (int) (i >> 42) << 4; // Paper
+                    int baseY = (int) (i << 44 >> 44) << 4; // Paper
+                    int baseZ = (int) (i << 22 >> 42) << 4; // Paper
                     if (this.l.remove(i) && this.g(i)) {
                         for (j = 0; j < 16; ++j) {
                             for (k = 0; k < 16; ++k) {
-                                long l3 = BlockPosition.a(SectionPosition.c(SectionPosition.b(i)) + j, SectionPosition.c(SectionPosition.c(i)) + 16 - 1, SectionPosition.c(SectionPosition.d(i)) + k);
+                                long l3 = BlockPosition.a(baseX + j, baseY + 16 - 1, baseZ + k); // Paper
 
                                 lightenginelayer.a(Long.MAX_VALUE, l3, 15, false);
                             }
diff --git a/src/main/java/net/minecraft/server/LightEngineThreaded.java b/src/main/java/net/minecraft/server/LightEngineThreaded.java
index a9dc8466278f9ec2becbcb643e6e1c973df72b82..968a1f71a44122ef0c4236d4251497f0b813d3b9 100644
--- a/src/main/java/net/minecraft/server/LightEngineThreaded.java
+++ b/src/main/java/net/minecraft/server/LightEngineThreaded.java
@@ -14,8 +14,98 @@ import org.apache.logging.log4j.Logger;
 public class LightEngineThreaded extends LightEngine implements AutoCloseable {
 
     private static final Logger LOGGER = LogManager.getLogger();
-    private final ThreadedMailbox<Runnable> b;
-    private final ObjectList<Pair<LightEngineThreaded.Update, Runnable>> c = new ObjectArrayList();
+    private final ThreadedMailbox<Runnable> b; ThreadedMailbox<Runnable> mailbox; // Paper
+    // Paper start
+    private static final int MAX_PRIORITIES = PlayerChunkMap.GOLDEN_TICKET + 2;
+
+    public void changePriority(long pair, int currentPriority, int priority) {
+        this.mailbox.queue(() -> {
+            ChunkLightQueue remove = this.queue.buckets[currentPriority].remove(pair);
+            if (remove != null) {
+                ChunkLightQueue existing = this.queue.buckets[priority].put(pair, remove);
+                if (existing != null) {
+                    remove.pre.addAll(existing.pre);
+                    remove.post.addAll(existing.post);
+                }
+            }
+        });
+    }
+
+    static class ChunkLightQueue {
+        public boolean shouldFastUpdate;
+        java.util.ArrayDeque<Runnable> pre = new java.util.ArrayDeque<Runnable>();
+        java.util.ArrayDeque<Runnable> post = new java.util.ArrayDeque<Runnable>();
+
+        ChunkLightQueue(long chunk) {}
+    }
+
+
+    // Retain the chunks priority level for queued light tasks
+    private static class LightQueue {
+        private int size = 0;
+        private int lowestPriority = MAX_PRIORITIES;
+        private final it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkLightQueue>[] buckets = new it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap[MAX_PRIORITIES];
+
+        private LightQueue() {
+            for (int i = 0; i < buckets.length; i++) {
+                buckets[i] = new it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<>();
+            }
+        }
+
+        public final void add(long chunkId, int priority, LightEngineThreaded.Update type, Runnable run) {
+            add(chunkId, priority, type, run, false);
+        }
+        public final void add(long chunkId, int priority, LightEngineThreaded.Update type, Runnable run, boolean shouldFastUpdate) {
+            ChunkLightQueue lightQueue = this.buckets[priority].computeIfAbsent(chunkId, ChunkLightQueue::new);
+            this.size++;
+            if (type == Update.PRE_UPDATE) {
+                lightQueue.pre.add(run);
+            } else {
+                lightQueue.post.add(run);
+            }
+            if (shouldFastUpdate) {
+                lightQueue.shouldFastUpdate = true;
+            }
+
+            if (this.lowestPriority > priority) {
+                this.lowestPriority = priority;
+            }
+        }
+
+        public final boolean isEmpty() {
+            return this.size == 0;
+        }
+
+        public final int size() {
+            return this.size;
+        }
+
+        public boolean poll(java.util.List<Runnable> pre, java.util.List<Runnable> post) {
+            boolean hasWork = false;
+            it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkLightQueue>[] buckets = this.buckets;
+            while (lowestPriority < MAX_PRIORITIES && !isEmpty()) {
+                it.unimi.dsi.fastutil.longs.Long2ObjectLinkedOpenHashMap<ChunkLightQueue> bucket = buckets[lowestPriority];
+                if (bucket.isEmpty()) {
+                    lowestPriority++;
+                    continue;
+                }
+                ChunkLightQueue queue = bucket.removeFirst();
+                this.size -= queue.pre.size() + queue.post.size();
+                pre.addAll(queue.pre);
+                post.addAll(queue.post);
+                queue.pre.clear();
+                queue.post.clear();
+                hasWork = true;
+                if (queue.shouldFastUpdate) {
+                    return true;
+                }
+            }
+            return hasWork;
+        }
+    }
+
+    private final LightQueue queue = new LightQueue();
+    // Paper end
     private final PlayerChunkMap d;
     private final Mailbox<ChunkTaskQueueSorter.a<Runnable>> e;
     private volatile int f = 5;
@@ -25,7 +115,7 @@ public class LightEngineThreaded extends LightEngine implements AutoCloseable {
         super(ilightaccess, true, flag);
         this.d = playerchunkmap;
         this.e = mailbox;
-        this.b = threadedmailbox;
+        this.mailbox = this.b = threadedmailbox; // Paper
     }
 
     public void close() {}
@@ -111,8 +201,11 @@ public class LightEngineThreaded extends LightEngine implements AutoCloseable {
 
     private void a(int i, int j, IntSupplier intsupplier, LightEngineThreaded.Update lightenginethreaded_update, Runnable runnable) {
         this.e.a(ChunkTaskQueueSorter.a(() -> {
-            this.c.add(Pair.of(lightenginethreaded_update, runnable));
-            if (this.c.size() >= this.f) {
+            // Paper start
+            int priority = intsupplier.getAsInt();
+            this.queue.add(ChunkCoordIntPair.pair(i, j), priority, lightenginethreaded_update, runnable); // Paper
+            if (priority <= 25) { // don't auto kick off unless priority
+                // Paper end
                 this.b();
             }
 
@@ -134,7 +227,14 @@ public class LightEngineThreaded extends LightEngine implements AutoCloseable {
         ChunkCoordIntPair chunkcoordintpair = ichunkaccess.getPos();
 
         ichunkaccess.b(false);
-        this.a(chunkcoordintpair.x, chunkcoordintpair.z, LightEngineThreaded.Update.PRE_UPDATE, SystemUtils.a(() -> {
+        // Paper start
+        long pair = chunkcoordintpair.pair();
+        CompletableFuture<IChunkAccess> future = new CompletableFuture<>();
+        IntSupplier prioritySupplier1 = d.getPrioritySupplier(pair);
+        IntSupplier prioritySupplier = flag ? () -> Math.max(1, prioritySupplier1.getAsInt() - 10) : prioritySupplier1;
+        this.e.a(ChunkTaskQueueSorter.a(() -> {
+            this.queue.add(pair, prioritySupplier.getAsInt(), LightEngineThreaded.Update.PRE_UPDATE, SystemUtils.a(() -> {
+                // Paper end
             ChunkSection[] achunksection = ichunkaccess.getSections();
 
             for (int i = 0; i < 16; ++i) {
@@ -155,52 +255,51 @@ public class LightEngineThreaded extends LightEngine implements AutoCloseable {
             this.d.c(chunkcoordintpair);
         }, () -> {
             return "lightChunk " + chunkcoordintpair + " " + flag;
+            // Paper start  - merge the 2 together
         }));
-        return CompletableFuture.supplyAsync(() -> {
+
+        this.queue.add(pair, prioritySupplier.getAsInt(), LightEngineThreaded.Update.POST_UPDATE, () -> {
             ichunkaccess.b(true);
             super.b(chunkcoordintpair, false);
-            return ichunkaccess;
-        }, (runnable) -> {
-            this.a(chunkcoordintpair.x, chunkcoordintpair.z, LightEngineThreaded.Update.POST_UPDATE, runnable);
+            // Paper start
+            future.complete(ichunkaccess);
         });
+            queueUpdate(); // run queue now
+        }, pair, prioritySupplier));
+        return future;
+        // Paper end
     }
 
     public void queueUpdate() {
-        if ((!this.c.isEmpty() || super.a()) && this.g.compareAndSet(false, true)) {
+        if ((!this.queue.isEmpty() || super.a()) && this.g.compareAndSet(false, true)) { // Paper
             this.b.a((() -> { // Paper - decompile error
                 this.b();
                 this.g.set(false);
+                queueUpdate(); // Paper - if we still have work to do, do it!
             }));
         }
 
     }
 
+    // Paper start - replace impl
+    private final java.util.List<Runnable> pre = new java.util.ArrayList<>();
+    private final java.util.List<Runnable> post = new java.util.ArrayList<>();
     private void b() {
-        int i = Math.min(this.c.size(), this.f);
-        ObjectListIterator<Pair<LightEngineThreaded.Update, Runnable>> objectlistiterator = this.c.iterator();
-
-        Pair pair;
-        int j;
-
-        for (j = 0; objectlistiterator.hasNext() && j < i; ++j) {
-            pair = (Pair) objectlistiterator.next();
-            if (pair.getFirst() == LightEngineThreaded.Update.PRE_UPDATE) {
-                ((Runnable) pair.getSecond()).run();
-            }
+        int i = Math.min(queue.size(), 4);
+        boolean ran = false;
+        while (i-- > 0 && queue.poll(pre, post)) {
+            pre.forEach(Runnable::run);
+            pre.clear();
+            super.a(Integer.MAX_VALUE, true, true);
+            post.forEach(Runnable::run);
+            post.clear();
+            ran = true;
         }
-
-        objectlistiterator.back(j);
-        super.a(Integer.MAX_VALUE, true, true);
-
-        for (j = 0; objectlistiterator.hasNext() && j < i; ++j) {
-            pair = (Pair) objectlistiterator.next();
-            if (pair.getFirst() == LightEngineThreaded.Update.POST_UPDATE) {
-                ((Runnable) pair.getSecond()).run();
-            }
-
-            objectlistiterator.remove();
+        if (!ran) {
+            // might have level updates to go still
+            super.a(Integer.MAX_VALUE, true, true);
         }
-
+        // Paper end
     }
 
     public void a(int i) {
diff --git a/src/main/java/net/minecraft/server/NibbleArray.java b/src/main/java/net/minecraft/server/NibbleArray.java
index 8cedfdd820cc02a76607b53e0b054fc74654f907..a9795394c9b17f9f0ce4c4f9c8f51a48e950418e 100644
--- a/src/main/java/net/minecraft/server/NibbleArray.java
+++ b/src/main/java/net/minecraft/server/NibbleArray.java
@@ -8,6 +8,13 @@ import javax.annotation.Nullable;
 public class NibbleArray {
 
     // Paper start
+    static final NibbleArray EMPTY_NIBBLE_ARRAY = new NibbleArray() {
+        @Override
+        public byte[] asBytes() {
+            throw new IllegalStateException();
+        }
+    };
+    long lightCacheKey = Long.MIN_VALUE;
     public static byte[] EMPTY_NIBBLE = new byte[2048];
     private static final int nibbleBucketSizeMultiplier = Integer.getInteger("Paper.nibbleBucketSize", 3072);
     private static final int maxPoolSize = Integer.getInteger("Paper.maxNibblePoolSize", (int) Math.min(6, Math.max(1, Runtime.getRuntime().maxMemory() / 1024 / 1024 / 1024)) * (nibbleBucketSizeMultiplier * 8));
diff --git a/src/main/java/net/minecraft/server/PlayerChunk.java b/src/main/java/net/minecraft/server/PlayerChunk.java
index 446c401b3139f8c6c0e70d883340f0140d94b752..a3bce8f13bf278af2d6870891daa9bf692b4e267 100644
--- a/src/main/java/net/minecraft/server/PlayerChunk.java
+++ b/src/main/java/net/minecraft/server/PlayerChunk.java
@@ -716,6 +716,7 @@ public class PlayerChunk {
                 ioPriority = com.destroystokyo.paper.io.PrioritizedTaskQueue.HIGH_PRIORITY;
             }
             chunkMap.world.asyncChunkTaskManager.raisePriority(location.x, location.z, ioPriority);
+            chunkMap.world.getChunkProvider().getLightEngine().changePriority(location.pair(), getCurrentPriority(), priority);
         }
         if (getCurrentPriority() != priority) {
             this.v.a(this.location, this::getCurrentPriority, priority, this::setPriority); // use preferred priority
diff --git a/src/main/java/net/minecraft/server/PlayerChunkMap.java b/src/main/java/net/minecraft/server/PlayerChunkMap.java
index 0e684a040b1a6cee056e8716c2a69620fc440af3..8c5639fa55404474df8656d3f6ad2db1bc71e3da 100644
--- a/src/main/java/net/minecraft/server/PlayerChunkMap.java
+++ b/src/main/java/net/minecraft/server/PlayerChunkMap.java
@@ -653,6 +653,7 @@ public class PlayerChunkMap extends IChunkLoader implements PlayerChunk.d {
         // Paper end
     }
 
+    protected final IntSupplier getPrioritySupplier(long i) { return c(i); } // Paper - OBFHELPER
     protected IntSupplier c(long i) {
         return () -> {
             PlayerChunk playerchunk = this.getVisibleChunk(i);
diff --git a/src/main/java/net/minecraft/server/ThreadedMailbox.java b/src/main/java/net/minecraft/server/ThreadedMailbox.java
index 35f4d2d9591e625ab0bbeab7b606761e74965eec..698d82dd736529a8cbfad5c6bed70ab97f0064bb 100644
--- a/src/main/java/net/minecraft/server/ThreadedMailbox.java
+++ b/src/main/java/net/minecraft/server/ThreadedMailbox.java
@@ -109,7 +109,8 @@ public class ThreadedMailbox<T> implements Mailbox<T>, AutoCloseable, Runnable {
 
     }
 
-    @Override
+
+    public void queue(T t0) { a(t0); } @Override // Paper - OBFHELPER
     public void a(T t0) {
         this.a.a(t0);
         this.f();
diff --git a/src/main/java/net/minecraft/server/WorldServer.java b/src/main/java/net/minecraft/server/WorldServer.java
index 472a0c624f09b7c6c07bbe8feadadf3ac7dd05a3..3a740f5669876271a3f13c64e28eb6f2cb033b4c 100644
--- a/src/main/java/net/minecraft/server/WorldServer.java
+++ b/src/main/java/net/minecraft/server/WorldServer.java
@@ -708,6 +708,7 @@ public class WorldServer extends World implements GeneratorAccessSeed {
             }
             gameprofilerfiller.exit();
             timings.chunkTicksBlocks.stopTiming(); // Paper
+            getChunkProvider().getLightEngine().queueUpdate(); // Paper
             // Paper end
         }
     }