Actually decent

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

@@ -1,5 +1,6 @@
 package com.volmit.iris.platform.bukkit;
 
+import art.arcane.amulet.io.IO;
 import com.volmit.iris.engine.EngineConfiguration;
 import com.volmit.iris.platform.IrisPlatform;
 import com.volmit.iris.platform.PlatformBiome;
@@ -14,9 +15,13 @@ import org.bukkit.Material;
 import org.bukkit.World;
 import org.bukkit.WorldCreator;
 import org.bukkit.block.Biome;
+import org.bukkit.entity.Player;
 import org.bukkit.generator.ChunkGenerator;
 import org.bukkit.plugin.java.JavaPlugin;
 
+import java.io.Closeable;
+import java.io.File;
+import java.io.IOException;
 import java.util.Arrays;
 import java.util.UUID;
 import java.util.stream.Stream;
@@ -30,11 +35,45 @@ public class IrisBukkit extends JavaPlugin implements IrisPlatform {
         getServer().getScheduler().scheduleSyncDelayedTask(this, () -> {
             World world = Bukkit.createWorld(new WorldCreator("iristests/" + UUID.randomUUID()).generator(new IrisBukkitChunkGenerator(this, EngineConfiguration.builder()
                 .build())));
+            for(Player i : Bukkit.getOnlinePlayers())
+            {
+                i.teleport(world.getSpawnLocation());
+            }
         }, 10);
     }
 
     public void onDisable() {
+        World w = null;
+        for(World i : Bukkit.getWorlds()) {
+            if(!i.getName().startsWith("iristest")) {
+                w = i;
+                break;
+            }
+        }
 
+        for(World i : Bukkit.getWorlds()) {
+            if(i.getName().startsWith("iristest"))
+            {
+                for(Player j : i.getPlayers())
+                {
+                    j.teleport(w.getSpawnLocation());
+                }
+
+                if(i.getGenerator() instanceof Closeable c)
+                {
+                    try {
+                        c.close();
+                    } catch(IOException e) {
+                        throw new RuntimeException(e);
+                    }
+                }
+
+                i.bukkitWorld().unloadChunks(false, true);
+                File folder = i.getWorldFolder();
+                Bukkit.unloadWorld(i, false);
+                IO.delete(folder);
+            }
+        }
     }
 
     public static IrisBukkit getInstance() {

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

@@ -4,10 +4,9 @@ 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.Engine;
 import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
 import com.volmit.iris.engine.feature.IrisFeatureTarget;
-import com.volmit.iris.engine.feature.features.FeatureTerrain;
 import com.volmit.iris.engine.pipeline.PipedHunkStack;
 import com.volmit.iris.platform.IrisPlatform;
 import com.volmit.iris.platform.PlatformBlock;
@@ -16,16 +15,17 @@ import org.bukkit.World;
 import org.bukkit.generator.ChunkGenerator;
 import com.volmit.iris.platform.bukkit.util.ChunkDataHunkView;
 
-import java.nio.channels.Pipe;
+import java.io.Closeable;
+import java.io.IOException;
 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 {
+public class IrisBukkitChunkGenerator extends ChunkGenerator implements Closeable {
     private final IrisPlatform platform;
     private final EngineConfiguration configuration;
-    private final AtomicReference<IrisEngine> engine;
+    private final AtomicReference<Engine> engine;
     private final ReentrantLock engineLock;
     private final AtomicInteger perSecond;
     private final PrecisionStopwatch p = PrecisionStopwatch.start();
@@ -46,8 +46,6 @@ public class IrisBukkitChunkGenerator extends ChunkGenerator {
         initEngine(world);
         ChunkData data = Bukkit.createChunkData(world);
         Hunk<PlatformBlock> chunk = new ChunkDataHunkView(data);
-        PipedHunkStack stack = new PipedHunkStack();
-        stack.register(PlatformBlock.class, chunk);
         IrisFeatureSizedTarget targetSize = IrisFeatureSizedTarget.builder()
             .width(chunk.getWidth())
             .height(chunk.getHeight())
@@ -56,6 +54,9 @@ public class IrisBukkitChunkGenerator extends ChunkGenerator {
             .offsetZ(z << 4)
             .offsetY(0)
             .build();
+        IrisFeatureTarget<PlatformBlock> blockTarget = new IrisFeatureTarget<>(chunk, targetSize);
+        PipedHunkStack stack = new PipedHunkStack();
+        stack.register(PlatformBlock.class, blockTarget);
         engine.get().getPlumbing().generate(engine.get(), targetSize, stack);
         perSecond.incrementAndGet();
         a.put(pp.getMilliseconds());
@@ -77,7 +78,7 @@ public class IrisBukkitChunkGenerator extends ChunkGenerator {
 
             if(engine.get() == null)
             {
-                engine.set(new IrisEngine(platform, world.bukkitWorld(), configuration));
+                engine.set(new Engine(platform, world.bukkitWorld(), configuration));
             }
 
             engineLock.unlock();
@@ -88,4 +89,9 @@ public class IrisBukkitChunkGenerator extends ChunkGenerator {
     public boolean canSpawn(World world, int x, int z) {
         return false;
     }
+
+    @Override
+    public void close() throws IOException {
+        engine.get().close();
+    }
 }

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

@@ -29,7 +29,7 @@ public class ChunkDataHunkView implements Hunk<PlatformBlock> {
     }
 
     @Override
-    public void set(int x1, int y1, int z1, int x2, int y2, int z2, PlatformBlock t) {
+    public synchronized void set(int x1, int y1, int z1, int x2, int y2, int z2, PlatformBlock t) {
         if(t == null) {
             return;
         }
@@ -38,7 +38,7 @@ public class ChunkDataHunkView implements Hunk<PlatformBlock> {
     }
 
     @Override
-    public void setRaw(int x, int y, int z, PlatformBlock t) {
+    public synchronized void setRaw(int x, int y, int z, PlatformBlock t) {
         if(t == null) {
             return;
         }

engine/src/main/java/com/volmit/iris/engine/Engine.java

@@ -20,8 +20,8 @@ import java.util.Map;
 import java.util.Optional;
 
 @Data
-public class IrisEngine implements Closeable {
+public class Engine implements Closeable {
-    private static final Map<Thread, WeakReference<IrisEngine>> engineContext = new ConcurrentWeakHashMap<>();
+    private static final Map<Thread, WeakReference<Engine>> engineContext = new ConcurrentWeakHashMap<>();
     private final IrisPlatform platform;
     private final EngineRegistry registry;
     private final EngineConfiguration configuration;
@@ -30,7 +30,7 @@ public class IrisEngine implements Closeable {
     private final EngineExecutor executor;
     private final EnginePlumbing plumbing;
 
-    public IrisEngine(IrisPlatform platform, PlatformWorld world, EngineConfiguration configuration) {
+    public Engine(IrisPlatform platform, PlatformWorld world, EngineConfiguration configuration) {
         this.configuration = configuration;
         this.platform = platform;
         this.world = world;
@@ -43,7 +43,7 @@ public class IrisEngine implements Closeable {
         this.plumbing = EnginePlumbing.builder().engine(this)
             .pipeline(EnginePipeline.builder()
                 .phase(PipelinePhase.builder()
-                    .task(PipelineTask.<PlatformBlock>builder().target(PlatformBlock.class).feature(new FeatureTerrain(this)).build())
+                    .task(new PipelineTask<>(new FeatureTerrain(this), PlatformBlock.class))
                     .build())
                 .build())
             .build();
@@ -59,9 +59,9 @@ public class IrisEngine implements Closeable {
         return getPlatform().key(nsk);
     }
 
-    public static Optional<IrisEngine> context()
+    public static Optional<Engine> context()
     {
-        WeakReference<IrisEngine> reference = engineContext.get(Thread.currentThread());
+        WeakReference<Engine> reference = engineContext.get(Thread.currentThread());
 
         if(reference != null)
         {

engine/src/main/java/com/volmit/iris/engine/EngineBlockCache.java

@@ -7,10 +7,10 @@ import java.util.concurrent.ConcurrentHashMap;
 
 public class EngineBlockCache
 {
-    private final IrisEngine engine;
+    private final Engine engine;
     private final Map<String, PlatformBlock> cache;
 
-    public EngineBlockCache(IrisEngine engine)
+    public EngineBlockCache(Engine engine)
     {
         this.engine = engine;
         this.cache = new ConcurrentHashMap<>();

engine/src/main/java/com/volmit/iris/engine/EngineExecutor.java

@@ -9,13 +9,13 @@ import java.util.concurrent.ForkJoinWorkerThread;
 
 @Data
 public class EngineExecutor implements ForkJoinPool.ForkJoinWorkerThreadFactory, Thread.UncaughtExceptionHandler, Closeable {
-    private final IrisEngine engine;
+    private final Engine engine;
     private final ForkJoinPool forks;
 
-    public EngineExecutor(IrisEngine engine)
+    public EngineExecutor(Engine engine)
     {
         this.engine = engine;
-        forks = new ForkJoinPool(engine.getConfiguration().getThreads(), this, this, false);
+        forks = new ForkJoinPool(engine.getConfiguration().getThreads(), this, this, true);
     }
 
     @Override

engine/src/main/java/com/volmit/iris/engine/feature/IrisFeature.java

@@ -1,33 +1,33 @@
 package com.volmit.iris.engine.feature;
 
-import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.Engine;
 import com.volmit.iris.platform.PlatformNamespaced;
 import lombok.Data;
 
 @Data
 public abstract class IrisFeature<T extends PlatformNamespaced, S extends IrisFeatureState> {
     private final String name;
-    private final IrisEngine engine;
+    private final Engine engine;
     private boolean heightAgnostic;
 
-    public IrisFeature(String name, IrisEngine engine)
+    public IrisFeature(String name, Engine engine)
     {
         this.engine = engine;
         this.name = name;
         this.heightAgnostic = true;
     }
 
-    public IrisFeatureTask<T, S> task(IrisFeatureSizedTarget target, int verticalExecutionSize, int horizontalExecutionSize)
+    public IrisFeatureTask<T, S> task(IrisFeatureSizedTarget target, IrisFeatureTarget<T> origin, int verticalExecutionSize, int horizontalExecutionSize, IrisFeatureTaskTiming timings)
     {
-        return new IrisFeatureTask<>(engine, this, target, verticalExecutionSize, horizontalExecutionSize, heightAgnostic);
+        return new IrisFeatureTask<>(engine, this, target, origin, verticalExecutionSize, horizontalExecutionSize, heightAgnostic, timings);
     }
 
-    public IrisFeatureTask<T, S> task(IrisFeatureSizedTarget target, int horizontalExecutionSize)
+    public IrisFeatureTask<T, S> task(IrisFeatureSizedTarget target, IrisFeatureTarget<T> origin, int horizontalExecutionSize, IrisFeatureTaskTiming timings)
     {
-        return new IrisFeatureTask<>(engine, this, target, Integer.MAX_VALUE, horizontalExecutionSize, heightAgnostic);
+        return new IrisFeatureTask<>(engine, this, target, origin, Integer.MAX_VALUE, horizontalExecutionSize, heightAgnostic, timings);
     }
 
-    public abstract S prepare(IrisEngine engine, IrisFeatureSizedTarget target);
+    public abstract S prepare(Engine engine, IrisFeatureSizedTarget target);
 
-    public abstract void generate(IrisEngine engine, S state, IrisFeatureTarget<T> target);
+    public abstract void generate(Engine engine, S state, IrisFeatureTarget<T> target);
 }

engine/src/main/java/com/volmit/iris/engine/feature/IrisFeatureSizedTarget.java

@@ -2,6 +2,7 @@ package com.volmit.iris.engine.feature;
 
 import art.arcane.amulet.collections.hunk.Hunk;
 import art.arcane.amulet.collections.hunk.storage.ArrayHunk;
+import art.arcane.amulet.collections.hunk.view.HunkView;
 import art.arcane.amulet.geometry.Vec;
 import art.arcane.amulet.range.IntegerRange;
 import com.volmit.iris.platform.PlatformNamespaced;
@@ -37,6 +38,11 @@ public class IrisFeatureSizedTarget {
         return new IrisFeatureTarget<>(new ArrayHunk<>(width, height, depth), this);
     }
 
+    public <T extends PlatformNamespaced> IrisFeatureTarget<T> hunked(IrisFeatureTarget<T> origin)
+    {
+        return new IrisFeatureTarget<>(new HunkView<>(origin.getHunk(), width, height, depth, offsetX - origin.getOffsetX(), offsetY - origin.getOffsetY(), offsetZ - origin.getOffsetZ()), this);
+    }
+
     Stream<IrisFeatureSizedTarget> splitX() {
         if(width <= 1) {
             return Stream.of(this);
@@ -121,15 +127,15 @@ public class IrisFeatureSizedTarget {
         return new IntegerRange(0, getDepth() - 1);
     }
 
-    public static IrisFeatureSizedTarget mergedSize(Stream<IrisFeatureSizedTarget> targets) {
+    public static IrisFeatureSizedTarget mergedSize(Stream<IrisFeatureSizedTarget> targets, boolean x, boolean y, boolean z) {
         List<IrisFeatureSizedTarget> t = targets.toList();
         return IrisFeatureSizedTarget.builder()
-            .width(t.stream().mapToInt(IrisFeatureSizedTarget::getWidth).sum())
+            .width(x ? t.stream().mapToInt(IrisFeatureSizedTarget::getWidth).sum() : t[0].getWidth())
-            .height(t.stream().mapToInt(IrisFeatureSizedTarget::getHeight).sum())
+            .height(y ? t.stream().mapToInt(IrisFeatureSizedTarget::getHeight).sum() : t[0].getHeight())
-            .depth(t.stream().mapToInt(IrisFeatureSizedTarget::getDepth).sum())
+            .depth(z ? t.stream().mapToInt(IrisFeatureSizedTarget::getDepth).sum() : t[0].getDepth())
-            .offsetX(t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetX).min().orElse(0))
+            .offsetX(x ? t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetX).min().orElse(0) : t[0].getOffsetX())
-            .offsetY(t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetY).min().orElse(0))
+            .offsetY(y ? t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetY).min().orElse(0) : t[0].getOffsetY())
-            .offsetZ(t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetZ).min().orElse(0))
+            .offsetZ(z ? t.stream().mapToInt(IrisFeatureSizedTarget::getOffsetZ).min().orElse(0) : t[0].getOffsetZ())
             .build();
     }
 }

engine/src/main/java/com/volmit/iris/engine/feature/IrisFeatureTarget.java

@@ -1,6 +1,7 @@
 package com.volmit.iris.engine.feature;
 
 import art.arcane.amulet.collections.hunk.Hunk;
+import art.arcane.amulet.collections.hunk.view.HunkView;
 import com.volmit.iris.platform.PlatformNamespaced;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -28,15 +29,14 @@ public class IrisFeatureTarget<T extends PlatformNamespaced> extends IrisFeature
         this(hunk, target.getOffsetX(), target.getOffsetY(), target.getOffsetZ());
     }
 
-    public static <V extends PlatformNamespaced> IrisFeatureTarget<V> mergedTarget(Stream<IrisFeatureTarget<V>> targets)
+    public static <V extends PlatformNamespaced> IrisFeatureTarget<V> mergedTarget(Stream<IrisFeatureTarget<V>> targets, IrisFeatureTarget<V> origin, boolean x, boolean y, boolean z)
     {
         List<IrisFeatureTarget<V>> t = targets.toList();
-        IrisFeatureSizedTarget mergedSize = IrisFeatureSizedTarget.mergedSize(t.stream().map(i -> i));
+        IrisFeatureSizedTarget mergedSize = IrisFeatureSizedTarget.mergedSize(t.stream().map(i -> i), x, y, z);
-        Hunk<V> hunk = Hunk.newArrayHunk(mergedSize.getWidth(), mergedSize.getHeight(), mergedSize.getDepth());
+        Hunk<V> hunk = new HunkView<>(origin.getHunk(), mergedSize.getWidth(), mergedSize.getHeight(), mergedSize.getDepth(),
-        t.forEach(i -> hunk.insert(
+            mergedSize.getOffsetX() - origin.getOffsetX(),
-            i.getOffsetX() - mergedSize.getOffsetX(),
+            mergedSize.getOffsetY() - origin.getOffsetY(),
-            i.getOffsetY() - mergedSize.getOffsetY(),
+            mergedSize.getOffsetZ() - origin.getOffsetZ());
-            i.getOffsetZ() - mergedSize.getOffsetZ(), i.getHunk()));
         return new IrisFeatureTarget<>(hunk, mergedSize);
     }
 }

engine/src/main/java/com/volmit/iris/engine/feature/IrisFeatureTask.java

@@ -1,14 +1,14 @@
 package com.volmit.iris.engine.feature;
 
-import art.arcane.amulet.collections.hunk.Hunk;
+import art.arcane.amulet.metric.PrecisionStopwatch;
-import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.Engine;
 import com.volmit.iris.platform.PlatformNamespaced;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 
 import java.util.concurrent.Callable;
+import java.util.concurrent.ForkJoinTask;
 import java.util.concurrent.RecursiveTask;
-import java.util.stream.Collectors;
 
 /**
  * Continuously splits up a hunk of work in all 3 dimensions until the job size is within the
@@ -19,34 +19,58 @@ import java.util.stream.Collectors;
 @Builder
 @AllArgsConstructor
 public class IrisFeatureTask<T extends PlatformNamespaced, S extends IrisFeatureState> extends RecursiveTask<IrisFeatureTarget<T>> implements Callable<IrisFeatureTarget<T>> {
-    private final IrisEngine engine;
+    private final Engine engine;
     private final IrisFeature<T, S> feature;
     private final IrisFeatureSizedTarget size;
+    private final IrisFeatureTarget<T> origin;
     private final int verticalPrepareSize;
     private final int horizontalPrepareSize;
     private final boolean heightAgnostic;
+    private final IrisFeatureTaskTiming timings;
 
     @Override
     protected IrisFeatureTarget<T> compute() {
+        IrisFeatureTarget<T> result;
+        PrecisionStopwatch p = null;
+
+        if(timings != null)
+        {
+            p = PrecisionStopwatch.start();
+        }
+
         if(!heightAgnostic && size.getHeight() > verticalPrepareSize * 2) {
-            return IrisFeatureTarget.mergedTarget(size.splitY().map(i -> engine.getExecutor().getForks().invoke(with(i))));
+
+            result = IrisFeatureTarget.mergedTarget(size.splitY()
+                .map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<IrisFeatureTarget<T>>) with(i)))
+                .map(ForkJoinTask::join), origin, false, true, false);
         }
 
         else if(size.getWidth() > horizontalPrepareSize * 2) {
-            return IrisFeatureTarget.mergedTarget(size.splitX().map(i -> engine.getExecutor().getForks().invoke(with(i))));
+            result = IrisFeatureTarget.mergedTarget(size.splitX().map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<IrisFeatureTarget<T>>) with(i)))
+                .map(ForkJoinTask::join), origin, true, false, false);
         }
 
         else if(size.getDepth() > horizontalPrepareSize * 2) {
-            return IrisFeatureTarget.mergedTarget(size.splitZ().map(i -> engine.getExecutor().getForks().invoke(with(i))));
+            result = IrisFeatureTarget.mergedTarget(size.splitZ().map(i -> engine.getExecutor().getForks().submit((ForkJoinTask<IrisFeatureTarget<T>>) with(i)))
+                .map(ForkJoinTask::join), origin, false, false, true);
         }
 
-        IrisPreparedFeature<T, S> preparedFeature = new IrisPreparedFeature<>(engine, feature, size, feature.prepare(engine, size));
+        else {
-        return preparedFeature.generate();
+            IrisPreparedFeature<T, S> preparedFeature = new IrisPreparedFeature<>(engine, feature, size, feature.prepare(engine, size));
+            result = preparedFeature.generate(origin);
+        }
+
+        if(timings != null)
+        {
+            timings.onCompleted(p.getMilliseconds());
+        }
+
+        return result;
     }
 
     private IrisFeatureTask<T, S> with(IrisFeatureSizedTarget size)
     {
-        return new IrisFeatureTask<>(engine, feature, size, verticalPrepareSize, horizontalPrepareSize, heightAgnostic);
+        return new IrisFeatureTask<>(engine, feature, size, origin, verticalPrepareSize, horizontalPrepareSize, heightAgnostic, null);
     }
 
     @Override

engine/src/main/java/com/volmit/iris/engine/feature/IrisFeatureTaskTiming.java

@@ -0,0 +1,6 @@
+package com.volmit.iris.engine.feature;
+
+@FunctionalInterface
+public interface IrisFeatureTaskTiming {
+    void onCompleted(double ms);
+}

engine/src/main/java/com/volmit/iris/engine/feature/IrisPreparedFeature.java

@@ -1,6 +1,6 @@
 package com.volmit.iris.engine.feature;
 
-import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.Engine;
 import com.volmit.iris.platform.PlatformNamespaced;
 import lombok.Builder;
 import lombok.Data;
@@ -8,19 +8,15 @@ import lombok.Data;
 @Builder
 @Data
 public class IrisPreparedFeature<T extends PlatformNamespaced, S extends IrisFeatureState> {
-    private final IrisEngine engine;
+    private final Engine engine;
     private final IrisFeature<T, S> feature;
     private final IrisFeatureSizedTarget size;
     private final S state;
 
-    public IrisFeatureTarget<T> generate()
+    public IrisFeatureTarget<T> generate(IrisFeatureTarget<T> origin)
     {
-        IrisFeatureTarget<T> target = size.hunked();
+        IrisFeatureTarget<T> target = size.hunked(origin);
-
+        feature.generate(engine, state, target);
-        if(Math.r(0.25))
-        {
-            feature.generate(engine, state, target);
-        }
 
         return target;
     }

engine/src/main/java/com/volmit/iris/engine/feature/features/FeatureTerrain.java

@@ -1,9 +1,13 @@
 package com.volmit.iris.engine.feature.features;
 
 import art.arcane.amulet.range.IntegerRange;
+import art.arcane.source.api.NoisePlane;
+import art.arcane.source.api.fractal.FractalFBMProvider;
+import art.arcane.source.api.interpolator.StarcastInterpolator;
 import art.arcane.source.api.noise.Generator;
+import art.arcane.source.api.noise.provider.CellularProvider;
 import art.arcane.source.api.noise.provider.SimplexProvider;
-import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.Engine;
 import com.volmit.iris.engine.feature.IrisFeature;
 import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
 import com.volmit.iris.engine.feature.IrisFeatureState;
@@ -16,20 +20,22 @@ import lombok.Data;
 public class FeatureTerrain extends IrisFeature<PlatformBlock, FeatureTerrain.TerrainFeatureState>
 {
     private final PlatformBlock stone;
-    private final Generator generator;
+    private final NoisePlane generator;
 
-    public FeatureTerrain(IrisEngine engine)
+    public FeatureTerrain(Engine engine)
     {
         super("terrain", engine);
         stone = engine.block("stone");
-        this.generator = new Generator(new SimplexProvider(engine.getWorld().getSeed()))
+        Generator g = new Generator(new FractalFBMProvider((s) -> new CellularProvider(s), 1234));
+        g.scale(0.01);
+        this.generator = new StarcastInterpolator(new Generator(new SimplexProvider(engine.getWorld().getSeed()))
             .maxOutput(64)
             .minOutput(0)
-            .scale(0.01);
+            .scale(0.01).warp(g), 8, 96);
     }
 
     @Override
-    public TerrainFeatureState prepare(IrisEngine engine, IrisFeatureSizedTarget target) {
+    public TerrainFeatureState prepare(Engine engine, IrisFeatureSizedTarget target) {
         final ShortNoiseCache noise = new ShortNoiseCache(target.getWidth(), target.getDepth());
         int cx,cz;
 
@@ -48,7 +54,7 @@ public class FeatureTerrain extends IrisFeature<PlatformBlock, FeatureTerrain.Te
     }
 
     @Override
-    public void generate(IrisEngine engine, TerrainFeatureState state, IrisFeatureTarget<PlatformBlock> target) {
+    public void generate(Engine engine, TerrainFeatureState state, IrisFeatureTarget<PlatformBlock> target) {
         for(int x : target.localX()) {
             for(int z : target.localZ()) {
                 int h = state.getNoise().get(x, z);

engine/src/main/java/com/volmit/iris/engine/optimizer/HunkSlizeConfiguration.java

@@ -0,0 +1,58 @@
+package com.volmit.iris.engine.optimizer;
+
+import art.arcane.amulet.range.IntegerRange;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@Data
+@AllArgsConstructor
+public class HunkSlizeConfiguration {
+    private final int verticalSlice;
+    private final int horizontalSlize;
+
+    public static List<HunkSlizeConfiguration> generateConfigurations(IntegerRange vertical, IntegerRange horizontal)
+    {
+        List<HunkSlizeConfiguration> configurations = new ArrayList<>();
+
+        for(int i : slice(vertical))
+        {
+            for(int j : slice(horizontal))
+            {
+                configurations.add(new HunkSlizeConfiguration(i, j));
+            }
+        }
+
+        return configurations;
+    }
+
+    public static List<HunkSlizeConfiguration> generateConfigurations(int vertical, IntegerRange horizontal)
+    {
+        List<HunkSlizeConfiguration> configurations = new ArrayList<>();
+
+        for(int j : slice(horizontal))
+        {
+            configurations.add(new HunkSlizeConfiguration(vertical, j));
+        }
+
+        return configurations;
+    }
+
+    private static List<Integer> slice(IntegerRange range)
+    {
+        List<Integer> v = new ArrayList<>();
+        v.add(range.getRightEndpoint());
+        v.add(range.getLeftEndpoint());
+        int i = (int) (range.getRightEndpoint() / 1.25);
+
+        while(i > range.getLeftEndpoint() && i >= 1)
+        {
+            v.add(i);
+            i /= 1.25;
+        }
+
+        return v.withoutDuplicates();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizationAttempt.java

@@ -0,0 +1,37 @@
+package com.volmit.iris.engine.optimizer;
+
+import art.arcane.amulet.metric.Average;
+import lombok.Data;
+
+import java.util.concurrent.atomic.AtomicInteger;
+
+@Data
+public class IrisOptimizationAttempt<T> {
+    private final Average average;
+    private final AtomicInteger runs;
+    private final int testRuns;
+    private final T parameters;
+
+    public IrisOptimizationAttempt(T parameters, int testRuns)
+    {
+        this.parameters = parameters;
+        this.testRuns = testRuns;
+        this.average = new Average(testRuns);
+        this.runs = new AtomicInteger(0);
+    }
+
+    public double getAverageTime()
+    {
+        return average.getAverage();
+    }
+
+    public boolean isComplete()
+    {
+        return runs.get() >= testRuns;
+    }
+
+    public void report(double ms) {
+        average.put(ms);
+        runs.incrementAndGet();
+    }
+}

engine/src/main/java/com/volmit/iris/engine/optimizer/IrisOptimizer.java

@@ -0,0 +1,72 @@
+package com.volmit.iris.engine.optimizer;
+
+import lombok.Builder;
+import lombok.Data;
+import lombok.Singular;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Map;
+import java.util.concurrent.ConcurrentHashMap;
+
+@Data
+public class IrisOptimizer<T> {
+    private final int testRuns;
+    private final List<T> options;
+    private final Map<T, IrisOptimizationAttempt<T>> attempts = new ConcurrentHashMap<>();
+    private T defaultOption;
+    private final double chanceToTest;
+    private double bestTime;
+
+    public IrisOptimizer(int testRuns, List<T> options, T defaultOption, double chanceToTest)
+    {
+        this.bestTime = Double.MAX_VALUE;
+        this.testRuns = testRuns;
+        this.options = options;
+        this.defaultOption = defaultOption;
+        this.chanceToTest = chanceToTest;
+
+        for(T i : options)
+        {
+            attempts.put(i, new IrisOptimizationAttempt<>(i, testRuns));
+        }
+    }
+
+    public String toString()
+    {
+        return "optimizer";
+    }
+
+    public synchronized void report(T parameters, double ms)
+    {
+        IrisOptimizationAttempt<T> attempt = attempts.get(parameters);
+
+        if(attempt != null)
+        {
+            attempt.report(ms);
+
+            if(attempt.isComplete())
+            {
+                attempts.remove(parameters);
+                double result = attempt.getAverageTime();
+
+                if(result < bestTime)
+                {
+                    bestTime = result;
+                    defaultOption = attempt.getParameters();
+                }
+            }
+        }
+    }
+
+    public T nextParameters()
+    {
+        if(!attempts.isEmpty() && Math.r(chanceToTest))
+        {
+            return attempts.k().popRandom();
+        }
+
+        return defaultOption;
+    }
+}

engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePipeline.java

@@ -1,14 +1,12 @@
 package com.volmit.iris.engine.pipeline;
 
-import com.volmit.iris.engine.EngineExecutor;
+import com.volmit.iris.engine.Engine;
-import com.volmit.iris.engine.IrisEngine;
 import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.Singular;
 
-import java.util.ArrayList;
 import java.util.List;
 
 @Data
@@ -19,7 +17,7 @@ public class EnginePipeline
     @Singular
     private final List<PipelinePhase> phases;
 
-    public void generate(IrisEngine engine,IrisFeatureSizedTarget target,  PipedHunkStack stack)
+    public void generate(Engine engine, IrisFeatureSizedTarget target, PipedHunkStack stack)
     {
         for(PipelinePhase i : phases)
         {

engine/src/main/java/com/volmit/iris/engine/pipeline/EnginePlumbing.java

@@ -1,25 +1,23 @@
 package com.volmit.iris.engine.pipeline;
 
-import com.volmit.iris.engine.IrisEngine;
+import com.volmit.iris.engine.Engine;
 import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
-import com.volmit.iris.engine.pipeline.EnginePipeline;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.Singular;
 
-import java.util.ArrayList;
 import java.util.List;
 
 @Data
 @Builder
 @AllArgsConstructor
 public class EnginePlumbing {
-    private final IrisEngine engine;
+    private final Engine engine;
     @Singular
     private final List<EnginePipeline> pipelines;
 
-    public void generate(IrisEngine engine, IrisFeatureSizedTarget target, PipedHunkStack stack)
+    public void generate(Engine engine, IrisFeatureSizedTarget target, PipedHunkStack stack)
     {
         for(EnginePipeline i : pipelines)
         {

engine/src/main/java/com/volmit/iris/engine/pipeline/PipedHunkStack.java

@@ -1,27 +1,27 @@
 package com.volmit.iris.engine.pipeline;
 
-import art.arcane.amulet.collections.hunk.Hunk;
+import com.volmit.iris.engine.feature.IrisFeatureTarget;
 import com.volmit.iris.platform.PlatformNamespaced;
 
 import java.util.HashMap;
 import java.util.Map;
 
 public class PipedHunkStack {
-    private final Map<Class<? extends PlatformNamespaced>, Hunk<? extends PlatformNamespaced>> hunks;
+    private final Map<Class<? extends PlatformNamespaced>, IrisFeatureTarget<? extends PlatformNamespaced>> hunks;
 
     public PipedHunkStack()
     {
         this.hunks = new HashMap<>();
     }
 
-    public void register(Class<? extends PlatformNamespaced> clazz, Hunk<? extends PlatformNamespaced> hunk)
+    public void register(Class<? extends PlatformNamespaced> clazz, IrisFeatureTarget<? extends PlatformNamespaced> hunk)
     {
         hunks.put(clazz, hunk);
     }
 
     @SuppressWarnings("unchecked")
-    public <T extends PlatformNamespaced> Hunk<T> hunk(Class<?> hunk)
+    public <T extends PlatformNamespaced> IrisFeatureTarget<T> hunk(Class<?> hunk)
     {
-        return (Hunk<T>) hunks.get(hunk);
+        return (IrisFeatureTarget<T>) hunks.get(hunk);
     }
 }

engine/src/main/java/com/volmit/iris/engine/pipeline/PipelinePhase.java

@@ -1,23 +1,16 @@
 package com.volmit.iris.engine.pipeline;
 
-import art.arcane.amulet.collections.ObjectBiset;
+import com.volmit.iris.engine.Engine;
-import art.arcane.amulet.collections.hunk.Hunk;
-import com.volmit.iris.engine.IrisEngine;
-import com.volmit.iris.engine.feature.IrisFeature;
 import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
 import com.volmit.iris.engine.feature.IrisFeatureTarget;
-import com.volmit.iris.engine.feature.IrisFeatureTask;
-import com.volmit.iris.platform.PlatformNamespaced;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
 import lombok.Singular;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.concurrent.ExecutionException;
 import java.util.stream.Collectors;
-import static art.arcane.amulet.MagicalSugar.*;
 
 @Data
 @Builder
@@ -27,20 +20,14 @@ public class PipelinePhase
     @Singular
     private final List<PipelineTask<?>> tasks;
 
-    @SuppressWarnings({"unchecked"})
+    public List<IrisFeatureTarget<?>> generate(Engine engine, IrisFeatureSizedTarget target, PipedHunkStack stack) {
-    public void generate(IrisEngine engine, IrisFeatureSizedTarget target, PipedHunkStack stack) {
+        return engine.getExecutor().getForks().invokeAll(tasks.stream().map(i -> i.task(target, stack.hunk(i.getTarget())))
-        List<IrisFeatureTarget<?>> targets = engine.getExecutor().getForks().invokeAll(tasks.stream().map(i -> i.task(target)).collect(Collectors.toList())).stream().map(i -> {
+            .collect(Collectors.toList())).stream().map(i -> {
             try {
                 return i.get();
             } catch(InterruptedException | ExecutionException e) {
                 throw new RuntimeException(e);
             }
         }).collect(Collectors.toList());
-
-        for(int i : index targets)
-        {
-            IrisFeatureTarget<?> targetResult = targets[i];
-            stack.hunk(tasks[i].getTarget()).insert((Hunk<PlatformNamespaced>) targetResult.getHunk());
-        }
     }
 }

engine/src/main/java/com/volmit/iris/engine/pipeline/PipelineTask.java

@@ -1,22 +1,48 @@
 package com.volmit.iris.engine.pipeline;
 
+import art.arcane.amulet.range.IntegerRange;
+import com.volmit.iris.engine.optimizer.HunkSlizeConfiguration;
 import com.volmit.iris.engine.feature.IrisFeature;
 import com.volmit.iris.engine.feature.IrisFeatureSizedTarget;
+import com.volmit.iris.engine.feature.IrisFeatureTarget;
 import com.volmit.iris.engine.feature.IrisFeatureTask;
+import com.volmit.iris.engine.optimizer.IrisOptimizer;
 import com.volmit.iris.platform.PlatformNamespaced;
 import lombok.AllArgsConstructor;
-import lombok.Builder;
 import lombok.Data;
 
+import java.util.List;
+
+import static art.arcane.amulet.MagicalSugar.*;
+
 @AllArgsConstructor
-@Builder
 @Data
 public class PipelineTask<T extends PlatformNamespaced>
 {
     private final IrisFeature<T, ?> feature;
     private final Class<T> target;
+    private final IntegerRange verticalEnvelope;
+    private final IntegerRange horizontalEnvelope;
+    private final IrisOptimizer<HunkSlizeConfiguration> optimizer;
 
-    public IrisFeatureTask<T, ?> task(IrisFeatureSizedTarget target){
+    public PipelineTask(IrisFeature<T, ?> feature, Class<T> target, IntegerRange verticalEnvelope, IntegerRange horizontalEnvelope)
-        return feature.task(target, 1000, 4);
+    {
+        this.feature = feature;
+        this.target = target;
+        this.verticalEnvelope = verticalEnvelope;
+        this.horizontalEnvelope = horizontalEnvelope;
+        List<HunkSlizeConfiguration> configurations = feature.isHeightAgnostic() ? HunkSlizeConfiguration.generateConfigurations(Integer.MAX_VALUE, horizontalEnvelope)
+            : HunkSlizeConfiguration.generateConfigurations(verticalEnvelope, horizontalEnvelope);
+        this.optimizer = new IrisOptimizer<>(256, configurations, configurations[0], 0.75);
+    }
+
+    public PipelineTask(IrisFeature<T, ?> feature, Class<T> target)
+    {
+        this(feature, target, 1 to 16, 1 to 16);
+    }
+
+    public IrisFeatureTask<T, ?> task(IrisFeatureSizedTarget target, IrisFeatureTarget<T> origin){
+        HunkSlizeConfiguration configuration = optimizer.nextParameters();
+        return feature.task(target, origin,configuration.getVerticalSlice(), configuration.getHorizontalSlize(), (ms) -> optimizer.report(configuration, ms));
     }
 }