Synthetics

engine/src/main/java/com/volmit/iris/engine/dimension/IrisBiome.java

@@ -2,6 +2,7 @@ package com.volmit.iris.engine.dimension;
 
 import com.volmit.iris.engine.resolver.EngineResolvable;
 import com.volmit.iris.engine.resolver.Resolvable;
+import com.volmit.iris.platform.PlatformBiome;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
 import lombok.Data;
@@ -24,4 +25,9 @@ public class IrisBiome extends EngineResolvable {
 
     @Builder.Default
     private IrisRange height = IrisRange.flat(1);
+
+    public PlatformBiome toPlatformBiome()
+    {
+        return null;
+    }
 }

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

@@ -3,6 +3,7 @@ package com.volmit.iris.engine.feature;
 import art.arcane.amulet.range.IntegerRange;
 import art.arcane.spatial.hunk.storage.ArrayHunk;
 import art.arcane.spatial.hunk.view.HunkView;
+import art.arcane.spatial.util.Consume;
 import com.volmit.iris.platform.PlatformNamespaced;
 import lombok.AllArgsConstructor;
 import lombok.Builder;
@@ -94,6 +95,24 @@ public class FeatureSizedTarget {
         return getOffsetZ() + getDepth() - 1;
     }
 
+    public IntegerRange yCap(int max) {
+        return new IntegerRange(y().getLeftEndpoint(), Math.min(y().getRightEndpoint(), max));
+    }
+
+    public void forYCap(Consume.One<Integer> consumer, int max) {
+        for(int y : yCap(max)) {
+            consumer.accept(y);
+        }
+    }
+
+    public void forXZ(Consume.Two<Integer, Integer> consumer) {
+        for(int x : x()) {
+            for(int z : z()) {
+                consumer.accept(x, z);
+            }
+        }
+    }
+
     public IntegerRange x()
     {
         return new IntegerRange(getOffsetX(), getAbsoluteMaxX());

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

@@ -7,16 +7,16 @@ import lombok.Data;
 
 @Data
 public class FeatureStorage {
-    private ShortNoiseCache heightmap;
+    private ShortNoiseCache height;
-    private NoiseCache<IrisBiome> biomemap;
+    private NoiseCache<IrisBiome> biome;
-    private final int width;
+    private final int w;
-    private final int height;
+    private final int h;
 
-    public FeatureStorage(int width, int height)
+    public FeatureStorage(int w, int h)
     {
-        this.width = width;
+        this.w = w;
-        this.height = height;
+        this.h = h;
-        this.heightmap = new ShortNoiseCache(width, height);
+        this.height = new ShortNoiseCache(w, h);
-        this.biomemap = new NoiseCache<>(width, height);
+        this.biome = new NoiseCache<>(w, h);
     }
 }

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

@@ -0,0 +1,12 @@
+package com.volmit.iris.engine.feature;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.feature.FeatureStorage;
+import com.volmit.iris.engine.feature.FeatureTarget;
+import com.volmit.iris.engine.feature.features.FeatureTerrain;
+import com.volmit.iris.engine.resolver.EngineResolvable;
+import com.volmit.iris.platform.PlatformNamespaced;
+
+public interface SyntheticFeature<T extends PlatformNamespaced, V extends EngineResolvable, S extends FeatureState> {
+    void generate(Engine engine, V component, FeatureTarget<T> target, S state);
+}

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

@@ -0,0 +1,44 @@
+package com.volmit.iris.engine.feature.features;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.dimension.IrisBiome;
+import com.volmit.iris.engine.feature.*;
+import com.volmit.iris.platform.PlatformBiome;
+import com.volmit.iris.util.NoiseCache;
+import lombok.AllArgsConstructor;
+import lombok.Data;
+
+public class FeatureOriginBiome extends Feature<PlatformBiome, FeatureOriginBiome.State> {
+    public FeatureOriginBiome(Engine engine) {
+        super("biome-origin", engine);
+    }
+
+    @Override
+    public State prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage) {
+        final NoiseCache<IrisBiome> noise = storage.getBiome();
+
+        for(int x : target.x()) {
+            for(int z : target.z()) {
+                noise.set(x & storage.getW() - 1, z & storage.getH() - 1, null);
+            }
+        }
+
+        return new State(noise);
+    }
+
+    @Override
+    public void generate(Engine engine, State state, FeatureTarget<PlatformBiome> target, FeatureStorage storage) {
+        for(int x : target.x()) {
+            for(int z : target.z()) {
+                IrisBiome b = state.getBiomes().get(x, z);
+                target.getHunk().set(x, 0, z, b.toPlatformBiome());
+            }
+        }
+    }
+
+    @Data
+    @AllArgsConstructor
+    public static class State implements FeatureState {
+        private final NoiseCache<IrisBiome> biomes;
+    }
+}

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

@@ -10,45 +10,32 @@ import com.volmit.iris.util.ShortNoiseCache;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 
-public class FeatureTerrain extends Feature<PlatformBlock, FeatureTerrain.TerrainFeatureState> {
+public class FeatureTerrain extends Feature<PlatformBlock, FeatureTerrain.State> {
     private final PlatformBlock stone;
     private final NoisePlane generator;
 
-    public FeatureTerrain(Engine engine)
+    public FeatureTerrain(Engine engine) {
-    {
         super("terrain", engine);
         stone = engine.block("stone");
         this.generator = NoisePreset.NATURAL.create(1234).fit(0, 64).scale(0.2);
     }
 
     @Override
-    public TerrainFeatureState prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage) {
+    public State prepare(Engine engine, FeatureSizedTarget target, FeatureStorage storage) {
-        final ShortNoiseCache noise = storage.getHeightmap();
+        target.forXZ((x, z) -> storage.getHeight().set(x & storage.getW() - 1, z & storage.getH() - 1, (short) generator.noise(x, z)));
-
+        return new State(storage.getHeight());
-        for(int x : target.x()) {
-            for(int z : target.z()) {
-                noise.set(x & storage.getWidth() - 1, z & storage.getHeight() - 1, (short) generator.noise(x, z));
-            }
-        }
-
-        return new TerrainFeatureState(noise);
     }
 
     @Override
-    public void generate(Engine engine, TerrainFeatureState state, FeatureTarget<PlatformBlock> target, FeatureStorage storage) {
+    public void generate(Engine engine, State state, FeatureTarget<PlatformBlock> target, FeatureStorage storage) {
-        for(int x : target.x()) {
+        target.forXZ((x, z) -> target.forYCap((y -> {
-            for(int z : target.z()) {
-                int h = state.getNoise().get(x, z);
-                for(int y : new IntegerRange(target.y().getLeftEndpoint(), Math.min(target.y().getRightEndpoint(), h))) {
             target.getHunk().set(x, y, z, stone);
-                }
+        }), state.getNoise().get(x, z)));
-            }
-        }
     }
 
     @Data
     @AllArgsConstructor
-    public static class TerrainFeatureState implements FeatureState {
+    public static class State implements FeatureState {
         private final ShortNoiseCache noise;
     }
 }

engine/src/main/java/com/volmit/iris/engine/feature/features/synthetic/SyntheticBiomeTerrain.java

@@ -0,0 +1,17 @@
+package com.volmit.iris.engine.feature.features.synthetic;
+
+import com.volmit.iris.engine.Engine;
+import com.volmit.iris.engine.dimension.IrisBiome;
+import com.volmit.iris.engine.feature.FeatureStorage;
+import com.volmit.iris.engine.feature.FeatureTarget;
+import com.volmit.iris.engine.feature.SyntheticFeature;
+import com.volmit.iris.engine.feature.features.FeatureTerrain;
+import com.volmit.iris.platform.PlatformBlock;
+
+public class SyntheticBiomeTerrain implements SyntheticFeature<PlatformBlock, IrisBiome, FeatureTerrain.State>
+{
+    @Override
+    public void generate(Engine engine, IrisBiome component, FeatureTarget<PlatformBlock> target, FeatureTerrain.State state) {
+
+    }
+}