It go fast

bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkit.java

@@ -1,27 +1,39 @@
 package com.volmit.iris.platform.bukkit;
 
+import com.volmit.iris.engine.EngineConfiguration;
 import com.volmit.iris.platform.IrisPlatform;
 import com.volmit.iris.platform.PlatformBiome;
 import com.volmit.iris.platform.PlatformBlock;
+import com.volmit.iris.platform.PlatformNamespaceKey;
 import com.volmit.iris.platform.PlatformWorld;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitKey;
 import lombok.Data;
 import lombok.EqualsAndHashCode;
 import org.bukkit.Bukkit;
 import org.bukkit.Material;
 import org.bukkit.World;
+import org.bukkit.WorldCreator;
 import org.bukkit.block.Biome;
+import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.plugin.java.JavaPlugin;
 
 import java.util.Arrays;
+import java.util.UUID;
 import java.util.stream.Stream;
 
-@Data
-@EqualsAndHashCode(callSuper = false)
 public class IrisBukkit extends JavaPlugin implements IrisPlatform {
     private static IrisBukkit instance;
 
     public void onEnable() {
         instance = this;
+
+        getServer().getScheduler().scheduleSyncDelayedTask(this, () -> {
+            World world = Bukkit.createWorld(new WorldCreator("iristests/" + UUID.randomUUID()).generator(new IrisBukkitChunkGenerator(this, EngineConfiguration.builder()
+                .threads(4)
+                .mutable(true)
+                .timings(true)
+                .build())));
+        }, 10);
     }
 
     public void onDisable() {
@@ -41,7 +53,9 @@ public class IrisBukkit extends JavaPlugin implements IrisPlatform {
     public Stream<PlatformBlock> getBlocks() {
         //This is because it's a method extension
         //noinspection Convert2MethodRef
-        return Arrays.stream(Material.values()).parallel().filter(Material::isBlock).map(Material::createBlockData).map(i -> i.bukkitBlock());
+        return Arrays.stream(Material.values()).parallel().filter((i) -> !i.isLegacy())
+            .filter(Material::isBlock)
+            .map(Material::createBlockData).map(i -> i.bukkitBlock());
     }
 
     @Override
@@ -67,4 +81,23 @@ public class IrisBukkit extends JavaPlugin implements IrisPlatform {
 
         return w.bukkitWorld();
     }
+
+    @Override
+    public PlatformBlock parseBlock(String raw) {
+        return Bukkit.createBlockData(raw).bukkitBlock();
+    }
+
+    @Override
+    public PlatformNamespaceKey key(String namespace, String key) {
+        return BukkitKey.of(namespace, key);
+    }
+
+    @Override
+    public ChunkGenerator getDefaultWorldGenerator(String worldName, String id) {
+        return new IrisBukkitChunkGenerator(this, EngineConfiguration.builder()
+            .threads(4)
+            .mutable(true)
+            .timings(true)
+            .build());
+    }
 }

bukkit/src/main/java/com/volmit/iris/platform/bukkit/IrisBukkitChunkGenerator.java

@@ -0,0 +1,90 @@
+package com.volmit.iris.platform.bukkit;
+
+import art.arcane.amulet.collections.hunk.Hunk;
+import art.arcane.amulet.metric.Average;
+import art.arcane.amulet.metric.PrecisionStopwatch;
+import com.volmit.iris.engine.EngineConfiguration;
+import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
+import com.volmit.iris.engine.feature.IrisFeatureTarget;
+import com.volmit.iris.engine.feature.standard.FeatureTerrain;
+import com.volmit.iris.platform.IrisPlatform;
+import com.volmit.iris.platform.PlatformBlock;
+import org.bukkit.Bukkit;
+import org.bukkit.Material;
+import org.bukkit.World;
+import org.bukkit.generator.ChunkGenerator;
+import com.volmit.iris.platform.bukkit.util.ChunkDataHunkView;
+import org.bukkit.generator.WorldInfo;
+
+import java.util.Random;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicReference;
+import java.util.concurrent.locks.ReentrantLock;
+
+public class IrisBukkitChunkGenerator extends ChunkGenerator {
+    private final IrisPlatform platform;
+    private final EngineConfiguration configuration;
+    private final AtomicReference<IrisEngine> engine;
+    private final ReentrantLock engineLock;
+    private final AtomicInteger perSecond;
+    private final PrecisionStopwatch p = PrecisionStopwatch.start();
+    private final Average a = new Average(128);
+
+    public IrisBukkitChunkGenerator(IrisPlatform platform, EngineConfiguration configuration)
+    {
+        this.perSecond = new AtomicInteger(0);
+        this.platform = platform;
+        this.configuration = configuration;
+        engine = new AtomicReference<>();
+        engineLock = new ReentrantLock();
+    }
+
+    @Override
+    public ChunkData generateChunkData(World world, Random random, int x, int z, BiomeGrid biome) {
+        PrecisionStopwatch pp = PrecisionStopwatch.start();
+        initEngine(world);
+        ChunkData data = Bukkit.createChunkData(world);
+        Hunk<PlatformBlock> chunk = new ChunkDataHunkView(data);
+        IrisFeatureSizedTarget targetSize = IrisFeatureSizedTarget.builder()
+            .width(chunk.getWidth())
+            .height(chunk.getHeight())
+            .depth(chunk.getDepth())
+            .offsetX(x << 4)
+            .offsetZ(z << 4)
+            .offsetY(0)
+            .build();
+        FeatureTerrain.TerrainFeatureState state = engine.get().getTerrainFeature().prepare(engine.get(), targetSize);
+        engine.get().getTerrainFeature().generate(engine.get(), state, new IrisFeatureTarget<>(chunk, targetSize));
+        perSecond.incrementAndGet();
+        a.put(pp.getMilliseconds());
+
+        if(p.getMilliseconds() > 1000)
+        {
+            p.reset();
+            p.begin();
+            System.out.println("PERSECOND: " + perSecond.getAndSet(0) + " AMS: " + ((int)Math.round(a.getAverage())) + "ms");
+        }
+
+        return data;
+    }
+
+    private void initEngine(World world) {
+        if(engine.get() == null)
+        {
+            engineLock.lock();
+
+            if(engine.get() == null)
+            {
+                engine.set(new IrisEngine(platform, world.bukkitWorld(), configuration));
+            }
+
+            engineLock.unlock();
+        }
+    }
+
+    @Override
+    public boolean canSpawn(World world, int x, int z) {
+        return false;
+    }
+}

bukkit/src/main/java/com/volmit/iris/platform/bukkit/util/ChunkDataHunkView.java

@@ -0,0 +1,53 @@
+package com.volmit.iris.platform.bukkit.util;
+
+import art.arcane.amulet.collections.hunk.Hunk;
+import com.volmit.iris.platform.PlatformBlock;
+import com.volmit.iris.platform.bukkit.wrapper.BukkitBlock;
+import org.bukkit.generator.ChunkGenerator;
+
+@SuppressWarnings("ClassCanBeRecord")
+public class ChunkDataHunkView implements Hunk<PlatformBlock> {
+    private final ChunkGenerator.ChunkData chunk;
+
+    public ChunkDataHunkView(ChunkGenerator.ChunkData chunk) {
+        this.chunk = chunk;
+    }
+
+    @Override
+    public int getWidth() {
+        return 16;
+    }
+
+    @Override
+    public int getDepth() {
+        return 16;
+    }
+
+    @Override
+    public int getHeight() {
+        return chunk.getMaxHeight() - chunk.getMinHeight();
+    }
+
+    @Override
+    public void set(int x1, int y1, int z1, int x2, int y2, int z2, PlatformBlock t) {
+        if(t == null) {
+            return;
+        }
+
+        chunk.setRegion(x1, y1 + chunk.getMinHeight(), z1, x2, y2 + chunk.getMinHeight(), z2, ((BukkitBlock)t).getDelegate());
+    }
+
+    @Override
+    public void setRaw(int x, int y, int z, PlatformBlock t) {
+        if(t == null) {
+            return;
+        }
+
+        chunk.setBlock(x, y + chunk.getMinHeight(), z, ((BukkitBlock)t).getDelegate());
+    }
+
+    @Override
+    public PlatformBlock getRaw(int x, int y, int z) {
+        return chunk.getBlockData(x, y + chunk.getMinHeight(), z).bukkitBlock();
+    }
+}