Revert "Graphs & streams "

This reverts commit 66a717b927b996268b7bed2798c88040698b917f.

src/main/java/com/volmit/iris/core/loader/ResourceLoader.java

@@ -42,7 +42,6 @@ import java.util.Locale;
 import java.util.concurrent.atomic.AtomicInteger;
 import java.util.concurrent.atomic.AtomicReference;
 import java.util.concurrent.atomic.AtomicReferenceArray;
-import java.util.function.Consumer;
 import java.util.function.Predicate;
 import java.util.stream.Stream;
 
@@ -222,21 +221,6 @@ public class ResourceLoader<T extends IrisRegistrant> implements MeteredCache {
         return m;
     }
 
-    public KList<T> loadAll(KList<String> s, Consumer<T> postLoad) {
-        KList<T> m = new KList<>();
-
-        for (String i : s) {
-            T t = load(i);
-
-            if (t != null) {
-                m.add(t);
-                postLoad.accept(t);
-            }
-        }
-
-        return m;
-    }
-
     public KList<T> loadAll(String[] s) {
         KList<T> m = new KList<>();
 

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

@@ -123,34 +123,48 @@ public class IrisComplex implements DataProvider {
                 ProceduralStream.of((x, z) -> focusRegion,
                         Interpolated.of(a -> 0D, a -> focusRegion))
                 : regionStyleStream
-                .selectRarity(data.getRegionLoader().loadAll(engine.getDimension().getRegions()))
+                .selectRarity(engine.getDimension().getRegions(), (i) -> data.getRegionLoader().load(i))
-                .cache2D("regionStream", engine, cacheSize);
+                .convertCached((s) -> data.getRegionLoader().load(s)).cache2D("regionStream", engine, cacheSize);
         regionIDStream = regionIdentityStream.convertCached((i) -> new UUID(Double.doubleToLongBits(i), String.valueOf(i * 38445).hashCode() * 3245556666L));
         caveBiomeStream = regionStream.convert((r)
                 -> engine.getDimension().getCaveBiomeStyle().create(rng.nextParallelRNG(InferredType.CAVE.ordinal()), getData()).stream()
                 .zoom(r.getCaveBiomeZoom())
-                .selectRarity(data.getBiomeLoader().loadAll(r.getCaveBiomes()))
+                .selectRarity(r.getCaveBiomes(), (i) -> data.getBiomeLoader().load(i))
-                .onNull(emptyBiome)
+                .onNull("")
+                .convertCached((s) -> {
+                    if (s.isEmpty()) {
+                        return emptyBiome;
+                    }
+
+                    return data.getBiomeLoader().load(s)
+                            .setInferredType(InferredType.CAVE);
+                })
         ).convertAware2D(ProceduralStream::get).cache2D("caveBiomeStream", engine, cacheSize);
         inferredStreams.put(InferredType.CAVE, caveBiomeStream);
         landBiomeStream = regionStream.convert((r)
                         -> engine.getDimension().getLandBiomeStyle().create(rng.nextParallelRNG(InferredType.LAND.ordinal()), getData()).stream()
                         .zoom(r.getLandBiomeZoom())
-                        .selectRarity(data.getBiomeLoader().loadAll(r.getLandBiomes(), (t) -> t.setInferredType(InferredType.LAND)))
+                        .selectRarity(r.getLandBiomes(), (i) -> data.getBiomeLoader().load(i))
+                        .convertCached((s) -> data.getBiomeLoader().load(s)
+                                .setInferredType(InferredType.LAND))
                 ).convertAware2D(ProceduralStream::get)
                 .cache2D("landBiomeStream", engine, cacheSize);
         inferredStreams.put(InferredType.LAND, landBiomeStream);
         seaBiomeStream = regionStream.convert((r)
                         -> engine.getDimension().getSeaBiomeStyle().create(rng.nextParallelRNG(InferredType.SEA.ordinal()), getData()).stream()
                         .zoom(r.getSeaBiomeZoom())
-                        .selectRarity(data.getBiomeLoader().loadAll(r.getSeaBiomes(), (t) -> t.setInferredType(InferredType.SEA)))
+                        .selectRarity(r.getSeaBiomes(), (i) -> data.getBiomeLoader().load(i))
+                        .convertCached((s) -> data.getBiomeLoader().load(s)
+                                .setInferredType(InferredType.SEA))
                 ).convertAware2D(ProceduralStream::get)
                 .cache2D("seaBiomeStream", engine, cacheSize);
         inferredStreams.put(InferredType.SEA, seaBiomeStream);
         shoreBiomeStream = regionStream.convert((r)
                 -> engine.getDimension().getShoreBiomeStyle().create(rng.nextParallelRNG(InferredType.SHORE.ordinal()), getData()).stream()
                 .zoom(r.getShoreBiomeZoom())
-                .selectRarity(data.getBiomeLoader().loadAll(r.getShoreBiomes(), (t) -> t.setInferredType(InferredType.SHORE)))
+                .selectRarity(r.getShoreBiomes(), (i) -> data.getBiomeLoader().load(i))
+                .convertCached((s) -> data.getBiomeLoader().load(s)
+                        .setInferredType(InferredType.SHORE))
         ).convertAware2D(ProceduralStream::get).cache2D("shoreBiomeStream", engine, cacheSize);
         inferredStreams.put(InferredType.SHORE, shoreBiomeStream);
         bridgeStream = focus != null ? ProceduralStream.of((x, z) -> focus.getInferredType(),

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

@@ -25,7 +25,6 @@ import com.volmit.iris.core.events.IrisEngineHotloadEvent;
 import com.volmit.iris.core.gui.PregeneratorJob;
 import com.volmit.iris.core.project.IrisProject;
 import com.volmit.iris.core.service.PreservationSVC;
-import com.volmit.iris.engine.biome.AreaSystem;
 import com.volmit.iris.engine.data.cache.AtomicCache;
 import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.framework.EngineEffects;
@@ -105,12 +104,10 @@ public class IrisEngine implements Engine {
     private double maxBiomeLayerDensity;
     private double maxBiomeDecoratorDensity;
     private IrisComplex complex;
-    private AreaSystem biomeSystem;
 
     public IrisEngine(EngineTarget target, boolean studio) {
         this.studio = studio;
         this.target = target;
-        biomeSystem = getDimension().createBiomeSystem();
         getEngineData();
         verifySeed();
         this.seedManager = new SeedManager(target.getWorld().getRawWorldSeed());

src/main/java/com/volmit/iris/engine/object/IRare.java

@@ -18,71 +18,7 @@
 
 package com.volmit.iris.engine.object;
 
-import com.volmit.iris.util.collection.KList;
-import com.volmit.iris.util.reflect.V;
-import com.volmit.iris.util.stream.ProceduralStream;
-import com.volmit.iris.util.stream.arithmetic.FittedStream;
-import com.volmit.iris.util.stream.interpolation.Interpolated;
-
-import java.util.HashSet;
-import java.util.List;
-import java.util.Set;
-
 public interface IRare {
-    static <T extends IRare>ProceduralStream<T> stream(ProceduralStream<Double> noise, List<T> possibilities)
-    {
-        return ProceduralStream.of((x, z) -> pick(possibilities, noise.get(x, z)),
-            (x, y, z) -> pick(possibilities, noise.get(x, y, z)),
-            new Interpolated<T>() {
-                @Override
-                public double toDouble(T t) {
-                    return 0;
-                }
-
-                @Override
-                public T fromDouble(double d) {
-                    return null;
-                }
-            });
-    }
-
-    static <T extends IRare> T pick(List<T> possibilities, double noiseValue)
-    {
-        if(possibilities.isEmpty())
-        {
-            return null;
-        }
-
-        if(possibilities.size() == 1)
-        {
-            return possibilities.get(0);
-        }
-
-        double completeWeight = 0.0;
-        double highestWeight = 0.0;
-
-        for (T item : possibilities)
-        {
-            double weight = Math.max(item.getRarity(), 1);
-            highestWeight = Math.max(highestWeight, weight);
-            completeWeight += weight;
-        }
-
-        double r = noiseValue * completeWeight;
-        double countWeight = 0.0;
-
-        for (T item : possibilities) {
-            double weight = Math.max(highestWeight - Math.max(item.getRarity(), 1), 1);
-            countWeight += weight;
-            if (countWeight >= r)
-            {
-                return item;
-            }
-        }
-
-        return null;
-    }
-
     static int get(Object v) {
         return v instanceof IRare ? Math.max(1, ((IRare) v).getRarity()) : 1;
     }

src/main/java/com/volmit/iris/engine/object/IrisDimension.java

@@ -21,10 +21,7 @@ package com.volmit.iris.engine.object;
 import com.volmit.iris.Iris;
 import com.volmit.iris.core.loader.IrisData;
 import com.volmit.iris.core.loader.IrisRegistrant;
-import com.volmit.iris.engine.biome.AreaSystem;
-import com.volmit.iris.engine.biome.ProceduralBiomeSystem;
 import com.volmit.iris.engine.data.cache.AtomicCache;
-import com.volmit.iris.engine.framework.Engine;
 import com.volmit.iris.engine.object.annotations.ArrayType;
 import com.volmit.iris.engine.object.annotations.Desc;
 import com.volmit.iris.engine.object.annotations.MaxNumber;
@@ -396,8 +393,4 @@ public class IrisDimension extends IrisRegistrant {
     public void scanForErrors(JSONObject p, VolmitSender sender) {
 
     }
-
-    public AreaSystem createBiomeSystem(Engine engine) {
-        return new ProceduralBiomeSystem(engine);
-    }
 }

src/main/java/com/volmit/iris/engine/object/IrisGeneratorStyle.java

@@ -28,14 +28,11 @@ import com.volmit.iris.engine.object.annotations.Snippet;
 import com.volmit.iris.util.math.RNG;
 import com.volmit.iris.util.noise.CNG;
 import com.volmit.iris.util.noise.ExpressionNoise;
-import com.volmit.iris.util.stream.ProceduralStream;
 import lombok.AllArgsConstructor;
 import lombok.Data;
 import lombok.NoArgsConstructor;
 import lombok.experimental.Accessors;
 
-import java.util.List;
-
 @Snippet("style")
 @Accessors(chain = true)
 @NoArgsConstructor

src/main/java/com/volmit/iris/util/stream/ProceduralStream.java

@@ -29,7 +29,6 @@ import com.volmit.iris.util.function.Function3;
 import com.volmit.iris.util.function.Function4;
 import com.volmit.iris.util.hunk.Hunk;
 import com.volmit.iris.util.math.RNG;
-import com.volmit.iris.util.reflect.V;
 import com.volmit.iris.util.stream.arithmetic.AddingStream;
 import com.volmit.iris.util.stream.arithmetic.ClampedStream;
 import com.volmit.iris.util.stream.arithmetic.CoordinateBitShiftLeftStream;
@@ -64,10 +63,8 @@ import com.volmit.iris.util.stream.utility.ProfiledStream;
 import com.volmit.iris.util.stream.utility.SemaphoreStream;
 import com.volmit.iris.util.stream.utility.SynchronizedStream;
 
-import java.util.ArrayList;
 import java.util.List;
 import java.util.function.Function;
-import java.util.stream.Collectors;
 
 @SuppressWarnings("ALL")
 public interface ProceduralStream<T> extends ProceduralLayer, Interpolated<T> {
@@ -366,16 +363,32 @@ public interface ProceduralStream<T> extends ProceduralLayer, Interpolated<T> {
         return new SelectionStream<V>(this, rarityTypes);
     }
 
-    default <V extends IRare> ProceduralStream<V> selectRarity(List<V> types) {
+    default <V> ProceduralStream<V> selectRarity(List<V> types) {
-        return IRare.stream(this.forceDouble(), types);
+        KList<V> rarityTypes = new KList<>();
+        int totalRarity = 0;
+        for (V i : types) {
+            totalRarity += IRare.get(i);
         }
 
-    default <V> ProceduralStream<IRare> selectRarity(List<V> types, Function<V, IRare> loader) {
+        for (V i : types) {
-        List<IRare> r = new ArrayList<>();
+            rarityTypes.addMultiple(i, totalRarity / IRare.get(i));
-        for(V f : types) {
-            r.add(loader.apply(f));
         }
-        return selectRarity(r);
+
+        return new SelectionStream<V>(this, rarityTypes);
+    }
+
+    default <V> ProceduralStream<V> selectRarity(List<V> types, Function<V, IRare> loader) {
+        KList<V> rarityTypes = new KList<>();
+        int totalRarity = 0;
+        for (V i : types) {
+            totalRarity += IRare.get(loader.apply(i));
+        }
+
+        for (V i : types) {
+            rarityTypes.addMultiple(i, totalRarity / IRare.get(loader.apply(i)));
+        }
+
+        return new SelectionStream<V>(this, rarityTypes);
     }
 
     default <V> int countPossibilities(List<V> types, Function<V, IRare> loader) {