Pregen improvements

src/main/java/com/volmit/iris/core/gui/PregeneratorJob.java

@@ -205,8 +205,7 @@ public class PregeneratorJob implements PregenListener {
                 renderer.l = new ReentrantLock();
                 renderer.frame = frame;
                 renderer.job = this;
-                renderer.func = (c, b) ->
+                renderer.func = (c, b) -> {
-                {
                     renderer.l.lock();
                     renderer.order.add(() -> renderer.draw(c, b, renderer.bg));
                     renderer.l.unlock();
@@ -238,10 +237,6 @@ public class PregeneratorJob implements PregenListener {
 
     @Override
     public void onChunkGenerating(int x, int z) {
-        if(engine != null) {
-            return;
-        }
-
         draw(x, z, COLOR_GENERATING);
     }
 

src/main/java/com/volmit/iris/core/pregenerator/IrisPregenerator.java

@@ -56,12 +56,11 @@ public class IrisPregenerator {
     private final KSet<Position2> retry;
     private final KSet<Position2> net;
     private final ChronoLatch cl;
-    private final Semaphore limiter;
+    private final ChronoLatch saveLatch = new ChronoLatch(30000);
 
     public IrisPregenerator(PregenTask task, PregeneratorMethod generator, PregenListener listener) {
         this.listener = listenify(listener);
         cl = new ChronoLatch(5000);
-        limiter = new Semaphore(1024);
         generatedRegions = new KSet<>();
         this.shutdown = new AtomicBoolean(false);
         this.paused = new AtomicBoolean(false);
@@ -166,32 +165,27 @@ public class IrisPregenerator {
         boolean hit = false;
         if(generator.supportsRegions(x, z, listener) && regions) {
             hit = true;
-            try {
+            listener.onRegionGenerating(x, z);
-                limiter.acquire();
+            generator.generateRegion(x, z, listener);
-                listener.onRegionGenerating(x, z);
-                generator.generateRegion(x, z, listener);
-                limiter.release();
-            } catch (InterruptedException e) {
-                throw new RuntimeException(e);
-            }
         } else if(!regions) {
             hit = true;
             listener.onRegionGenerating(x, z);
             PregenTask.iterateRegion(x, z, (xx, zz) -> {
-                try {
+                while(paused.get() && !shutdown.get()) {
-                    limiter.acquire();
+                    J.sleep(50);
-                    generator.generateChunk(xx, zz, listener);
-                    limiter.release();
-                } catch (InterruptedException e) {
-                    throw new RuntimeException(e);
                 }
-            });
+
+                generator.generateChunk(xx, zz, listener);});
         }
 
         if(hit) {
             listener.onRegionGenerated(x, z);
-            listener.onSaving();
+
-            generator.save();
+            if(saveLatch.flip()) {
+                listener.onSaving();
+                generator.save();
+            }
+
             generatedRegions.add(pos);
             checkRegions();
         }

src/main/java/com/volmit/iris/core/pregenerator/PregenTask.java

@@ -49,7 +49,7 @@ public class PregenTask {
     }
 
     public static void iterateRegion(int xr, int zr, Spiraled s) {
-        iterateRegion(xr, zr, s, new Position2(0, 0));
+        iterateRegion(xr, zr, s, new Position2(-(xr << 5), -(zr << 5)));
     }
 
     private static KList<Position2> computeOrder(Position2 pull) {

src/main/java/com/volmit/iris/core/pregenerator/methods/AsyncPregenMethod.java

@@ -31,6 +31,8 @@ import io.papermc.lib.PaperLib;
 import org.bukkit.Chunk;
 import org.bukkit.World;
 
+import java.util.Objects;
+import java.util.concurrent.ExecutionException;
 import java.util.concurrent.Future;
 
 public class AsyncPregenMethod implements PregeneratorMethod {
@@ -68,18 +70,44 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     private void completeChunk(int x, int z, PregenListener listener) {
         try {
-            PaperLib.getChunkAtAsync(world, x, z, true).get();
+            future.add(PaperLib.getChunkAtAsync(world, x, z, true).thenApply((i) -> {
-            listener.onChunkGenerated(x, z);
+                if(i == null) {
-            listener.onChunkCleaned(x, z);
+
+                }
+
+                listener.onChunkGenerated(x, z);
+                listener.onChunkCleaned(x, z);
+                return 0;
+            }));
         } catch(Throwable e) {
             e.printStackTrace();
-            J.sleep(5);
+        }
-            future.add(burst.complete(() -> completeChunk(x, z, listener)));
+    }
+
+    private void waitForChunksPartial(int maxWaiting) {
+        future.removeWhere(Objects::isNull);
+
+        while(future.size() > maxWaiting) {
+            try {
+                Future<?> i = future.remove(0);
+
+                if(i == null) {
+                    continue;
+                }
+
+                i.get();
+            } catch(Throwable e) {
+                e.printStackTrace();
+            }
         }
     }
 
     private void waitForChunks() {
         for(Future<?> i : future.copy()) {
+            if(i == null) {
+                continue;
+            }
+
             try {
                 i.get();
                 future.remove(i);
@@ -87,6 +115,8 @@ public class AsyncPregenMethod implements PregeneratorMethod {
                 e.printStackTrace();
             }
         }
+
+        future.removeWhere(Objects::isNull);
     }
 
     @Override
@@ -107,7 +137,7 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     @Override
     public void save() {
-        waitForChunks();
+        waitForChunksPartial(256);
         unloadAndSaveAllChunks();
     }
 
@@ -123,11 +153,10 @@ public class AsyncPregenMethod implements PregeneratorMethod {
 
     @Override
     public void generateChunk(int x, int z, PregenListener listener) {
-        if(future.size() > IrisSettings.getThreadCount(IrisSettings.get().getConcurrency().getParallelism())) { // TODO: FIX
-            waitForChunks();
-        }
-
         listener.onChunkGenerating(x, z);
+        if(future.size() > 256) {
+            waitForChunksPartial(256);
+        }
         future.add(burst.complete(() -> completeChunk(x, z, listener)));
     }
 

src/main/java/com/volmit/iris/engine/platform/BukkitChunkGenerator.java

@@ -205,7 +205,7 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
             Hunk<BlockData> blocks = Hunk.view(tc);
             Hunk<Biome> biomes = Hunk.view(tc, tc.getMinHeight(), tc.getMaxHeight());
             this.world.bind(world);
-            getEngine().generate(x << 4, z << 4, blocks, biomes, false);
+            getEngine().generate(x << 4, z << 4, blocks, biomes, true);
             Iris.debug("Regenerated " + x + " " + z);
             int t = 0;
             for(int i = getEngine().getHeight() >> 4; i >= 0; i--) {
@@ -356,7 +356,7 @@ public class BukkitChunkGenerator extends ChunkGenerator implements PlatformChun
             } else {
                 ChunkDataHunkHolder blocks = new ChunkDataHunkHolder(tc);
                 BiomeGridHunkHolder biomes = new BiomeGridHunkHolder(tc, tc.getMinHeight(), tc.getMaxHeight());
-                getEngine().generate(x << 4, z << 4, blocks, biomes, true);
+                getEngine().generate(x << 4, z << 4, blocks, biomes, false);
                 blocks.apply();
                 biomes.apply();
             }