Re-add original pipeline implementation

2026-06-18 14:50:56 +00:00 · 2022-11-16 14:13:16 +11:00
parent 6cdef5d4ad
commit c1c85174ed
39 changed files with 1640 additions and 0 deletions
@@ -0,0 +1,94 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeExpander;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.api.util.vector.Vector2;
+
+
+public class BiomeHolderImpl implements BiomeHolder {
+    private final Vector2.Mutable origin;
+    private final int width;
+    private final int offset;
+    private BiomeDelegate[][] biomes;
+    
+    public BiomeHolderImpl(int width, Vector2.Mutable origin) {
+        width += 4;
+        this.width = width;
+        biomes = new BiomeDelegate[width][width];
+        this.origin = origin;
+        this.offset = 2;
+    }
+    
+    private BiomeHolderImpl(BiomeDelegate[][] biomes, Vector2.Mutable origin, int width, int offset) {
+        this.biomes = biomes;
+        this.origin = origin;
+        this.width = width;
+        this.offset = 2 * offset;
+    }
+    
+    @Override
+    public BiomeHolder expand(BiomeExpander expander, long seed) {
+        BiomeDelegate[][] old = biomes;
+        int newWidth = width * 2 - 1;
+        
+        biomes = new BiomeDelegate[newWidth][newWidth];
+        
+        for(int x = 0; x < width; x++) {
+            for(int z = 0; z < width; z++) {
+                biomes[x * 2][z * 2] = old[x][z];
+                if(z != width - 1)
+                    biomes[x * 2][z * 2 + 1] = expander.getBetween(x + origin.getX(), z + 1 + origin.getZ(), seed, old[x][z],
+                                                                   old[x][z + 1]);
+                if(x != width - 1)
+                    biomes[x * 2 + 1][z * 2] = expander.getBetween(x + 1 + origin.getX(), z + origin.getZ(), seed, old[x][z],
+                                                                   old[x + 1][z]);
+                if(x != width - 1 && z != width - 1)
+                    biomes[x * 2 + 1][z * 2 + 1] = expander.getBetween(x + 1 + origin.getX(), z + 1 + origin.getZ(), seed, old[x][z],
+                                                                       old[x + 1][z + 1], old[x][z + 1], old[x + 1][z]);
+            }
+        }
+        return new BiomeHolderImpl(biomes, origin.setX(origin.getX() * 2 - 1).setZ(origin.getZ() * 2 - 1), newWidth, offset);
+    }
+    
+    @Override
+    public void mutate(BiomeMutator mutator, long seed) {
+        for(int x = 0; x < width; x++) {
+            for(int z = 0; z < width; z++) {
+                BiomeMutator.ViewPoint viewPoint = new BiomeMutator.ViewPoint(this, x, z);
+                biomes[x][z] = mutator.mutate(viewPoint, x + origin.getX(), z + origin.getZ(), seed);
+            }
+        }
+    }
+    
+    @Override
+    public void fill(BiomeSource source, long seed) {
+        for(int x = 0; x < width; x++) {
+            for(int z = 0; z < width; z++) {
+                biomes[x][z] = source.getBiome(origin.getX() + x, origin.getZ() + z, seed);
+            }
+        }
+    }
+    
+    @Override
+    public BiomeDelegate getBiome(int x, int z) {
+        x += offset;
+        z += offset;
+        return getBiomeRaw(x, z);
+    }
+    
+    @Override
+    public BiomeDelegate getBiomeRaw(int x, int z) {
+        if(x >= width || z >= width || x < 0 || z < 0) return null;
+        return biomes[x][z];
+    }
+}
@@ -0,0 +1,83 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.api.util.vector.Vector2;
+
+
+public class BiomePipeline {
+    private final BiomeSource source;
+    private final List<Stage> stages;
+    private final int size;
+    private final int init;
+    
+    private BiomePipeline(BiomeSource source, List<Stage> stages, int size, int init) {
+        this.source = source;
+        this.stages = stages;
+        this.size = size;
+        this.init = init;
+    }
+    
+    /**
+     * Get biomes in a chunk
+     *
+     * @param x Chunk X coord
+     * @param z Chunk Z coord
+     *
+     * @return BiomeHolder containing biomes.
+     */
+    public BiomeHolder getBiomes(int x, int z, long seed) {
+        BiomeHolder holder = new BiomeHolderImpl(init, Vector2.of(x * (init - 1), z * (init - 1)).mutable());
+        holder.fill(source, seed);
+        for(Stage stage : stages) holder = stage.apply(holder, seed);
+        return holder;
+    }
+    
+    public BiomeSource getSource() {
+        return source;
+    }
+    
+    public List<Stage> getStages() {
+        return Collections.unmodifiableList(stages);
+    }
+    
+    public int getSize() {
+        return size;
+    }
+    
+    public static final class BiomePipelineBuilder {
+        private final int init;
+        private final List<Stage> stages = new ArrayList<>();
+        private int expand;
+        
+        public BiomePipelineBuilder(int init) {
+            this.init = init;
+            expand = init;
+        }
+        
+        public BiomePipeline build(BiomeSource source) {
+            for(Stage stage : stages) {
+                if(stage.isExpansion()) expand = expand * 2 - 1;
+            }
+            
+            return new BiomePipeline(source, stages, expand, init);
+        }
+        
+        public BiomePipelineBuilder addStage(Stage stage) {
+            stages.add(stage);
+            return this;
+        }
+    }
+}
@@ -0,0 +1,89 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline;
+
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import java.util.function.Supplier;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.BiomeDelegateLoader;
+import com.dfsek.terra.addons.biome.pipeline.config.BiomePipelineTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.SamplerSourceTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.expander.ExpanderStageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.BorderListMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.BorderMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.ReplaceListMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.ReplaceMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.mutator.SmoothMutatorTemplate;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.addons.manifest.api.AddonInitializer;
+import com.dfsek.terra.api.Platform;
+import com.dfsek.terra.api.addon.BaseAddon;
+import com.dfsek.terra.api.event.events.config.pack.ConfigPackPostLoadEvent;
+import com.dfsek.terra.api.event.events.config.pack.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.inject.annotations.Inject;
+import com.dfsek.terra.api.registry.CheckedRegistry;
+import com.dfsek.terra.api.registry.Registry;
+import com.dfsek.terra.api.util.reflection.TypeKey;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+public class BiomePipelineAddon implements AddonInitializer {
+    
+    public static final TypeKey<Supplier<ObjectTemplate<BiomeSource>>> SOURCE_REGISTRY_KEY = new TypeKey<>() {
+    };
+    
+    public static final TypeKey<Supplier<ObjectTemplate<Stage>>> STAGE_REGISTRY_KEY = new TypeKey<>() {
+    };
+    public static final TypeKey<Supplier<ObjectTemplate<BiomeProvider>>> PROVIDER_REGISTRY_KEY = new TypeKey<>() {
+    };
+    @Inject
+    private Platform platform;
+    
+    @Inject
+    private BaseAddon addon;
+    
+    @Override
+    public void initialize() {
+        platform.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(addon, ConfigPackPreLoadEvent.class)
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<BiomeProvider>>> providerRegistry = event.getPack().getOrCreateRegistry(
+                            PROVIDER_REGISTRY_KEY);
+                    providerRegistry.register(addon.key("PIPELINE"), BiomePipelineTemplate::new);
+                })
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<BiomeSource>>> sourceRegistry = event.getPack().getOrCreateRegistry(
+                            SOURCE_REGISTRY_KEY);
+                    sourceRegistry.register(addon.key("SAMPLER"), SamplerSourceTemplate::new);
+                })
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<Stage>>> stageRegistry = event.getPack().getOrCreateRegistry(
+                            STAGE_REGISTRY_KEY);
+                    stageRegistry.register(addon.key("FRACTAL_EXPAND"), ExpanderStageTemplate::new);
+                    stageRegistry.register(addon.key("SMOOTH"), SmoothMutatorTemplate::new);
+                    stageRegistry.register(addon.key("REPLACE"), ReplaceMutatorTemplate::new);
+                    stageRegistry.register(addon.key("REPLACE_LIST"), ReplaceListMutatorTemplate::new);
+                    stageRegistry.register(addon.key("BORDER"), BorderMutatorTemplate::new);
+                    stageRegistry.register(addon.key("BORDER_LIST"), BorderListMutatorTemplate::new);
+                })
+                .failThrough();
+        platform.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(addon, ConfigPackPostLoadEvent.class)
+                .then(event -> {
+                    Registry<Biome> biomeRegistry = event.getPack().getRegistry(Biome.class);
+                    event.getPack().applyLoader(BiomeDelegate.class, new BiomeDelegateLoader(biomeRegistry));
+                });
+    }
+}
@@ -0,0 +1,71 @@
+package com.dfsek.terra.addons.biome.pipeline;
+
+import java.util.function.Consumer;
+
+import com.dfsek.terra.api.util.Column;
+import com.dfsek.terra.api.util.function.IntIntObjConsumer;
+import com.dfsek.terra.api.util.function.IntObjConsumer;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+class BiomePipelineColumn implements Column<Biome> {
+    private final int min;
+    private final int max;
+    
+    private final int x;
+    private final int z;
+    private final Biome biome;
+    
+    protected BiomePipelineColumn(BiomeProvider biomeProvider, int min, int max, int x, int z, long seed) {
+        this.min = min;
+        this.max = max;
+        this.x = x;
+        this.z = z;
+        this.biome = biomeProvider.getBiome(x, 0, z, seed);
+    }
+    
+    @Override
+    public int getMinY() {
+        return min;
+    }
+    
+    @Override
+    public int getMaxY() {
+        return max;
+    }
+    
+    @Override
+    public int getX() {
+        return x;
+    }
+    
+    @Override
+    public int getZ() {
+        return z;
+    }
+    
+    @Override
+    public Biome get(int y) {
+        return biome;
+    }
+    
+    @Override
+    public void forRanges(int resolution, IntIntObjConsumer<Biome> consumer) {
+        consumer.accept(min, max, biome);
+    }
+    
+    @Override
+    public void forEach(Consumer<Biome> consumer) {
+        for(int y = min; y < max; y++) {
+            consumer.accept(biome);
+        }
+    }
+    
+    @Override
+    public void forEach(IntObjConsumer<Biome> consumer) {
+        for(int y = min; y < max; y++) {
+            consumer.accept(y, biome);
+        }
+    }
+}
@@ -0,0 +1,131 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline;
+
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
+import net.jafama.FastMath;
+
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.StreamSupport;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.registry.key.StringIdentifiable;
+import com.dfsek.terra.api.util.Column;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+public class BiomePipelineProvider implements BiomeProvider {
+    private final LoadingCache<SeededVector, BiomeHolder> holderCache;
+    private final BiomePipeline pipeline;
+    private final int resolution;
+    private final NoiseSampler mutator;
+    private final double noiseAmp;
+    
+    private final Set<Biome> biomes;
+    
+    public BiomePipelineProvider(BiomePipeline pipeline, int resolution, NoiseSampler mutator, double noiseAmp) {
+        this.resolution = resolution;
+        this.mutator = mutator;
+        this.noiseAmp = noiseAmp;
+        holderCache = Caffeine.newBuilder()
+                              .maximumSize(1024)
+                              .build(key -> pipeline.getBiomes(key.x, key.z, key.seed));
+        this.pipeline = pipeline;
+        
+        Set<BiomeDelegate> biomeSet = new HashSet<>();
+        pipeline.getSource().getBiomes().forEach(biomeSet::add);
+        Iterable<BiomeDelegate> result = biomeSet;
+        for(Stage stage : pipeline.getStages()) {
+            result = stage.getBiomes(result); // pass through all stages
+        }
+        this.biomes = new HashSet<>();
+        Iterable<BiomeDelegate> finalResult = result;
+        result.forEach(biomeDelegate -> {
+            if(biomeDelegate.isEphemeral()) {
+                
+                StringBuilder biomeList = new StringBuilder("\n");
+                StreamSupport.stream(finalResult.spliterator(), false)
+                             .sorted(Comparator.comparing(StringIdentifiable::getID))
+                             .forEach(delegate -> biomeList
+                                     .append("    - ")
+                                     .append(delegate.getID())
+                                     .append(':')
+                                     .append(delegate.getClass().getCanonicalName())
+                                     .append('\n'));
+                throw new IllegalArgumentException("Biome Pipeline leaks ephemeral biome \"" + biomeDelegate.getID() +
+                                                   "\". Ensure there is a stage to guarantee replacement of the ephemeral biome. Biomes: " +
+                                                   biomeList);
+            }
+            this.biomes.add(biomeDelegate.getBiome());
+        });
+    }
+    
+    @Override
+    public Biome getBiome(int x, int y, int z, long seed) {
+        return getBiome(x, z, seed);
+    }
+    
+    public Biome getBiome(int x, int z, long seed) {
+        x += mutator.noise(seed + 1, x, z) * noiseAmp;
+        z += mutator.noise(seed + 2, x, z) * noiseAmp;
+
+
+        x /= resolution;
+        z /= resolution;
+
+        int fdX = FastMath.floorDiv(x, pipeline.getSize());
+        int fdZ = FastMath.floorDiv(z, pipeline.getSize());
+        return holderCache.get(new SeededVector(fdX, fdZ, seed)).getBiome(x - fdX * pipeline.getSize(),
+                                                                          z - fdZ * pipeline.getSize()).getBiome();
+    }
+    
+    @Override
+    public Optional<Biome> getBaseBiome(int x, int z, long seed) {
+        return Optional.of(getBiome(x, z, seed));
+    }
+    
+    @Override
+    public Iterable<Biome> getBiomes() {
+        return biomes;
+    }
+    
+    @Override
+    public Column<Biome> getColumn(int x, int z, long seed, int min, int max) {
+        return new BiomePipelineColumn(this, min, max, x, z, seed);
+    }
+    
+    @Override
+    public int resolution() {
+        return resolution;
+    }
+    
+    private record SeededVector(int x, int z, long seed) {
+        @Override
+        public boolean equals(Object obj) {
+            if(obj instanceof SeededVector that) {
+                return this.z == that.z && this.x == that.x && this.seed == that.seed;
+            }
+            return false;
+        }
+
+        @Override
+        public int hashCode() {
+            int code = x;
+            code = 31 * code + z;
+            return 31 * code + ((int) (seed ^ (seed >>> 32)));
+        }
+    }
+}
@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.api;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeExpander;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+
+
+public interface BiomeHolder {
+    BiomeHolder expand(BiomeExpander expander, long seed);
+    
+    void mutate(BiomeMutator mutator, long seed);
+    
+    void fill(BiomeSource source, long seed);
+    
+    BiomeDelegate getBiome(int x, int z);
+    
+    BiomeDelegate getBiomeRaw(int x, int z);
+}
@@ -0,0 +1,35 @@
+package com.dfsek.terra.addons.biome.pipeline.api.delegate;
+
+import java.util.Set;
+
+import com.dfsek.terra.api.registry.key.StringIdentifiable;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public interface BiomeDelegate extends StringIdentifiable {
+    static BiomeDelegate ephemeral(String id) {
+        return new EphemeralBiomeDelegate(id);
+    }
+    
+    static BiomeDelegate from(Biome biome) {
+        return new DelegatedBiome(biome);
+    }
+    
+    static BiomeDelegate self() {
+        return SelfDelegate.INSTANCE;
+    }
+    
+    Biome getBiome();
+    
+    Set<String> getTags();
+    
+    default boolean isEphemeral() {
+        return false;
+    }
+    
+    default boolean isSelf() {
+        return false;
+    }
+    
+    
+}
@@ -0,0 +1,40 @@
+package com.dfsek.terra.addons.biome.pipeline.api.delegate;
+
+import java.util.Set;
+
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+final class DelegatedBiome implements BiomeDelegate {
+    private final Biome biome;
+    
+    public DelegatedBiome(Biome biome) {
+        this.biome = biome;
+    }
+    
+    @Override
+    public Biome getBiome() {
+        return biome;
+    }
+    
+    @Override
+    public int hashCode() {
+        return biome.hashCode();
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if(!(obj instanceof DelegatedBiome that)) return false;
+        return that.biome.equals(this.biome);
+    }
+    
+    @Override
+    public Set<String> getTags() {
+        return biome.getTags();
+    }
+    
+    @Override
+    public String getID() {
+        return biome.getID();
+    }
+}
@@ -0,0 +1,51 @@
+package com.dfsek.terra.addons.biome.pipeline.api.delegate;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+final class EphemeralBiomeDelegate implements BiomeDelegate {
+    private final Set<String> tags;
+    private final String id;
+    
+    public EphemeralBiomeDelegate(String id) {
+        this.id = id;
+        tags = new HashSet<>();
+        tags.add(id);
+        tags.add("ALL");
+    }
+    
+    @Override
+    public Biome getBiome() {
+        throw new UnsupportedOperationException("Cannot get biome from ephemeral delegate");
+    }
+    
+    @Override
+    public Set<String> getTags() {
+        return tags;
+    }
+    
+    @Override
+    public String getID() {
+        return id;
+    }
+    
+    @Override
+    public boolean isEphemeral() {
+        return true;
+    }
+    
+    @Override
+    public int hashCode() {
+        return id.hashCode();
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if(!(obj instanceof EphemeralBiomeDelegate that)) return false;
+        
+        return this.id.equals(that.id);
+    }
+}
@@ -0,0 +1,40 @@
+package com.dfsek.terra.addons.biome.pipeline.api.delegate;
+
+import java.util.Collections;
+import java.util.Set;
+
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+final class SelfDelegate implements BiomeDelegate {
+    public static final SelfDelegate INSTANCE = new SelfDelegate();
+    
+    private SelfDelegate() {
+
+    }
+    
+    @Override
+    public Biome getBiome() {
+        throw new UnsupportedOperationException("Cannot get biome from self delegate");
+    }
+    
+    @Override
+    public boolean isSelf() {
+        return true;
+    }
+    
+    @Override
+    public boolean isEphemeral() {
+        return true;
+    }
+    
+    @Override
+    public Set<String> getTags() {
+        return Collections.emptySet();
+    }
+    
+    @Override
+    public String getID() {
+        return "SELF";
+    }
+}
@@ -0,0 +1,20 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.api.stage;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+
+
+public interface Stage {
+    BiomeHolder apply(BiomeHolder in, long seed);
+    
+    boolean isExpansion();
+    
+    Iterable<BiomeDelegate> getBiomes(Iterable<BiomeDelegate> biomes);
+}
@@ -0,0 +1,15 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.api.stage.type;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+
+
+public interface BiomeExpander {
+    BiomeDelegate getBetween(double x, double z, long seed, BiomeDelegate... others);
+}
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.api.stage.type;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+
+
+public interface BiomeMutator {
+    BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed);
+    
+    default Iterable<BiomeDelegate> getBiomes(Iterable<BiomeDelegate> biomes) {
+        return biomes;
+    }
+    
+    class ViewPoint {
+        private final BiomeHolder biomes;
+        private final int offX;
+        private final int offZ;
+        
+        public ViewPoint(BiomeHolder biomes, int offX, int offZ) {
+            this.biomes = biomes;
+            this.offX = offX;
+            this.offZ = offZ;
+        }
+        
+        
+        public BiomeDelegate getBiome(int x, int z) {
+            return biomes.getBiomeRaw(x + offX, z + offZ);
+        }
+    }
+}
@@ -0,0 +1,32 @@
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.api.depth.DepthTracker;
+import com.dfsek.tectonic.api.exception.LoadException;
+import com.dfsek.tectonic.api.loader.ConfigLoader;
+import com.dfsek.tectonic.api.loader.type.TypeLoader;
+import org.jetbrains.annotations.NotNull;
+
+import java.lang.reflect.AnnotatedType;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.api.registry.Registry;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class BiomeDelegateLoader implements TypeLoader<BiomeDelegate> {
+    private final Registry<Biome> biomeRegistry;
+    
+    public BiomeDelegateLoader(Registry<Biome> biomeRegistry) {
+        this.biomeRegistry = biomeRegistry;
+    }
+    
+    @Override
+    public BiomeDelegate load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker)
+    throws LoadException {
+        if(c.equals("SELF")) return BiomeDelegate.self();
+        return biomeRegistry
+                .getByID((String) c)
+                .map(BiomeDelegate::from)
+                .orElseGet(() -> BiomeDelegate.ephemeral((String) c));
+    }
+}
@@ -0,0 +1,54 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Description;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import java.util.List;
+
+import com.dfsek.terra.addons.biome.pipeline.BiomePipeline;
+import com.dfsek.terra.addons.biome.pipeline.BiomePipelineProvider;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+@SuppressWarnings({ "FieldMayBeFinal", "unused" })
+public class BiomePipelineTemplate extends BiomeProviderTemplate {
+    @Value("pipeline.initial-size")
+    @Default
+    @Description("""
+                 The initial size of biome chunks. This value must be at least 2.
+                 <b>This is not the final size of biome chunks. Final chunks will be much larger</b>.
+                                  
+                 It is recommended to keep biome chunks' final size in the range of [50, 300]
+                 to prevent performance issues. To calculate the size of biome chunks, simply
+                 take initial-size and for each expand stage, multiply the running value by 2
+                 and subtract 1. (The size is also printed to the server console if you
+                 have debug mode enabled)""")
+    private @Meta int initialSize = 2;
+    
+    @Value("pipeline.source")
+    @Description("The Biome Source to use for initial population of biomes.")
+    private @Meta BiomeSource source;
+    
+    @Value("pipeline.stages")
+    @Description("A list of pipeline stages to apply to the result of #source")
+    private @Meta List<@Meta Stage> stages;
+    
+    @Override
+    public BiomeProvider get() {
+        BiomePipeline.BiomePipelineBuilder biomePipelineBuilder = new BiomePipeline.BiomePipelineBuilder(initialSize);
+        stages.forEach(biomePipelineBuilder::addStage);
+        BiomePipeline pipeline = biomePipelineBuilder.build(source);
+        return new BiomePipelineProvider(pipeline, resolution, blend, blendAmp);
+    }
+}
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Description;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+public abstract class BiomeProviderTemplate implements ObjectTemplate<BiomeProvider> {
+    @Value("resolution")
+    @Default
+    @Description("""
+                 The resolution at which to sample biomes.
+                                  
+                 Larger values are quadratically faster, but produce lower quality results.
+                 For example, a value of 3 would sample every 3 blocks.""")
+    protected @Meta int resolution = 1;
+    @Value("blend.sampler")
+    @Default
+    @Description("A sampler to use for blending the edges of biomes via domain warping.")
+    protected @Meta NoiseSampler blend = NoiseSampler.zero();
+    @Value("blend.amplitude")
+    @Default
+    @Description("The amplitude at which to perform blending.")
+    protected @Meta double blendAmp = 0d;
+}
@@ -0,0 +1,34 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Description;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+import com.dfsek.terra.addons.biome.pipeline.source.SamplerSource;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class SamplerSourceTemplate extends SourceTemplate {
+    @Value("sampler")
+    @Description("The sampler used to distribute biomes.")
+    private @Meta NoiseSampler noise;
+    
+    @Value("biomes")
+    @Description("The biomes to be distributed.")
+    private @Meta ProbabilityCollection<@Meta BiomeDelegate> biomes;
+    
+    @Override
+    public BiomeSource get() {
+        return new SamplerSource(biomes, noise);
+    }
+}
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config;
+
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.biome.pipeline.source.BiomeSource;
+
+
+public abstract class SourceTemplate implements ObjectTemplate<BiomeSource> {
+
+}
@@ -0,0 +1,23 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config.stage;
+
+import com.dfsek.tectonic.api.config.template.annotations.Description;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
+public abstract class StageTemplate implements ObjectTemplate<Stage> {
+    @Value("sampler")
+    @Description("Sampler to use for stage distribution.")
+    protected @Meta NoiseSampler noise;
+}
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config.stage.expander;
+
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.expand.FractalExpander;
+import com.dfsek.terra.addons.biome.pipeline.stages.ExpanderStage;
+
+
+public class ExpanderStageTemplate extends StageTemplate {
+    @Override
+    public Stage get() {
+        return new ExpanderStage(new FractalExpander(noise));
+    }
+}
@@ -0,0 +1,42 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import java.util.Map;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.BorderListMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+@SuppressWarnings("unused")
+public class BorderListMutatorTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+    
+    @Value("default-replace")
+    private @Meta String defaultReplace;
+    
+    @Value("default-to")
+    private @Meta ProbabilityCollection<@Meta BiomeDelegate> defaultTo;
+    
+    @Value("replace")
+    private @Meta Map<@Meta BiomeDelegate, @Meta ProbabilityCollection<@Meta BiomeDelegate>> replace;
+    
+    
+    @Override
+    public Stage get() {
+        return new MutatorStage(new BorderListMutator(replace, from, defaultReplace, noise, defaultTo));
+    }
+}
@@ -0,0 +1,36 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.BorderMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+@SuppressWarnings("unused")
+public class BorderMutatorTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+    
+    @Value("replace")
+    private @Meta String replace;
+    
+    @Value("to")
+    private @Meta ProbabilityCollection<@Meta BiomeDelegate> to;
+    
+    @Override
+    public Stage get() {
+        return new MutatorStage(new BorderMutator(from, replace, noise, to));
+    }
+}
@@ -0,0 +1,38 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import java.util.Map;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.ReplaceListMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+@SuppressWarnings("unused")
+public class ReplaceListMutatorTemplate extends StageTemplate {
+    @Value("default-from")
+    private @Meta String defaultFrom;
+    
+    @Value("default-to")
+    private @Meta ProbabilityCollection<@Meta BiomeDelegate> defaultTo;
+    
+    @Value("to")
+    private @Meta Map<@Meta BiomeDelegate, @Meta ProbabilityCollection<@Meta BiomeDelegate>> replace;
+    
+    @Override
+    public Stage get() {
+        return new MutatorStage(new ReplaceListMutator(replace, defaultFrom, defaultTo, noise));
+    }
+}
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.ReplaceMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+@SuppressWarnings("unused")
+public class ReplaceMutatorTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+    
+    @Value("to")
+    private @Meta ProbabilityCollection<@Meta BiomeDelegate> to;
+    
+    @Override
+    public Stage get() {
+        return new MutatorStage(new ReplaceMutator(from, to, noise));
+    }
+}
@@ -0,0 +1,21 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.config.stage.mutator;
+
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.mutator.SmoothMutator;
+import com.dfsek.terra.addons.biome.pipeline.stages.MutatorStage;
+
+
+public class SmoothMutatorTemplate extends StageTemplate {
+    @Override
+    public Stage get() {
+        return new MutatorStage(new SmoothMutator(noise));
+    }
+}
@@ -0,0 +1,27 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.expand;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeExpander;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.MathUtil;
+
+
+public class FractalExpander implements BiomeExpander {
+    private final NoiseSampler sampler;
+    
+    public FractalExpander(NoiseSampler sampler) {
+        this.sampler = sampler;
+    }
+    
+    @Override
+    public BiomeDelegate getBetween(double x, double z, long seed, BiomeDelegate... others) {
+        return others[MathUtil.normalizeIndex(sampler.noise(seed, x, z), others.length)];
+    }
+}
@@ -0,0 +1,67 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.mutator;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class BorderListMutator implements BiomeMutator {
+    private final String border;
+    private final NoiseSampler noiseSampler;
+    private final ProbabilityCollection<BiomeDelegate> replaceDefault;
+    private final String defaultReplace;
+    private final Map<BiomeDelegate, ProbabilityCollection<BiomeDelegate>> replace;
+    
+    public BorderListMutator(Map<BiomeDelegate, ProbabilityCollection<BiomeDelegate>> replace, String border, String defaultReplace,
+                             NoiseSampler noiseSampler, ProbabilityCollection<BiomeDelegate> replaceDefault) {
+        this.border = border;
+        this.noiseSampler = noiseSampler;
+        this.replaceDefault = replaceDefault;
+        this.defaultReplace = defaultReplace;
+        this.replace = replace;
+    }
+    
+    @Override
+    public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) {
+        BiomeDelegate origin = viewPoint.getBiome(0, 0);
+        if(origin.getTags().contains(defaultReplace)) {
+            for(int xi = -1; xi <= 1; xi++) {
+                for(int zi = -1; zi <= 1; zi++) {
+                    if(xi == 0 && zi == 0) continue;
+                    BiomeDelegate current = viewPoint.getBiome(xi, zi);
+                    if(current != null && current.getTags().contains(border)) {
+                        if(replace.containsKey(origin)) {
+                            BiomeDelegate biome = replace.get(origin).get(noiseSampler, x, z, seed);
+                            return biome.isSelf() ? origin : biome;
+                        }
+                        BiomeDelegate biome = replaceDefault.get(noiseSampler, x, z, seed);
+                        return biome.isSelf() ? origin : biome;
+                    }
+                }
+            }
+        }
+        return origin;
+    }
+    
+    @Override
+    public Iterable<BiomeDelegate> getBiomes(Iterable<BiomeDelegate> biomes) {
+        Set<BiomeDelegate> biomeSet = new HashSet<>();
+        biomes.forEach(biomeSet::add);
+        biomeSet.addAll(replaceDefault.getContents().stream().filter(Predicate.not(BiomeDelegate::isSelf)).toList());
+        replace.forEach((biome, collection) -> biomeSet.addAll(collection.getContents()));
+        return biomeSet;
+    }
+}
@@ -0,0 +1,66 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.mutator;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class BorderMutator implements BiomeMutator {
+    private final String border;
+    private final NoiseSampler noiseSampler;
+    private final ProbabilityCollection<BiomeDelegate> replace;
+    private final String replaceTag;
+    
+    public BorderMutator(String border, String replaceTag, NoiseSampler noiseSampler, ProbabilityCollection<BiomeDelegate> replace) {
+        this.border = border;
+        this.noiseSampler = noiseSampler;
+        this.replace = replace;
+        this.replaceTag = replaceTag;
+    }
+    
+    @Override
+    public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) {
+        BiomeDelegate origin = viewPoint.getBiome(0, 0);
+        if(origin.getTags().contains(replaceTag)) {
+            for(int xi = -1; xi <= 1; xi++) {
+                for(int zi = -1; zi <= 1; zi++) {
+                    if(xi == 0 && zi == 0) continue;
+                    BiomeDelegate current = viewPoint.getBiome(xi, zi);
+                    if(current != null && current.getTags().contains(border)) {
+                        BiomeDelegate biome = replace.get(noiseSampler, x, z, seed);
+                        return biome.isSelf() ? origin : biome;
+                    }
+                }
+            }
+        }
+        return origin;
+    }
+    
+    @Override
+    public Iterable<BiomeDelegate> getBiomes(Iterable<BiomeDelegate> biomes) {
+        Set<BiomeDelegate> biomeSet = new HashSet<>();
+        biomes.forEach(biomeSet::add);
+        biomeSet.addAll(
+                replace
+                        .getContents()
+                        .stream()
+                        .filter(
+                                Predicate.not(BiomeDelegate::isSelf)
+                               )
+                        .toList()
+                       );
+        return biomeSet;
+    }
+}
@@ -0,0 +1,72 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.mutator;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class ReplaceListMutator implements BiomeMutator {
+    private final Map<BiomeDelegate, ProbabilityCollection<BiomeDelegate>> replace;
+    private final NoiseSampler sampler;
+    private final ProbabilityCollection<BiomeDelegate> replaceDefault;
+    private final String defaultTag;
+    
+    public ReplaceListMutator(Map<BiomeDelegate, ProbabilityCollection<BiomeDelegate>> replace, String defaultTag,
+                              ProbabilityCollection<BiomeDelegate> replaceDefault, NoiseSampler sampler) {
+        this.replace = replace;
+        this.sampler = sampler;
+        this.defaultTag = defaultTag;
+        this.replaceDefault = replaceDefault;
+    }
+    
+    @Override
+    public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) {
+        BiomeDelegate center = viewPoint.getBiome(0, 0);
+        if(replace.containsKey(center)) {
+            BiomeDelegate biome = replace.get(center).get(sampler, x, z, seed);
+            return biome.isSelf() ? viewPoint.getBiome(0, 0) : biome;
+        }
+        if(viewPoint.getBiome(0, 0).getTags().contains(defaultTag)) {
+            BiomeDelegate biome = replaceDefault.get(sampler, x, z, seed);
+            return biome.isSelf() ? viewPoint.getBiome(0, 0) : biome;
+        }
+        return center;
+    }
+    
+    @Override
+    public Iterable<BiomeDelegate> getBiomes(Iterable<BiomeDelegate> biomes) {
+        Set<BiomeDelegate> biomeSet = new HashSet<>();
+        
+        Set<BiomeDelegate> reject = new HashSet<>();
+        
+        biomes.forEach(biome -> {
+            if(!biome.getTags().contains(defaultTag) && !replace.containsKey(biome)) {
+                biomeSet.add(biome);
+            } else {
+                reject.add(biome);
+            }
+        });
+        biomeSet.addAll(replaceDefault.getContents().stream().flatMap(terraBiome -> {
+            if(terraBiome.isSelf()) return reject.stream();
+            return Stream.of(terraBiome);
+        }).toList());
+        replace.forEach((biome, collection) -> biomeSet.addAll(collection.getContents().stream().map(terraBiome -> {
+            if(terraBiome.isSelf()) return biome;
+            return terraBiome;
+        }).toList()));
+        return biomeSet;
+    }
+}
@@ -0,0 +1,57 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.mutator;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class ReplaceMutator implements BiomeMutator {
+    private final String replaceableTag;
+    private final ProbabilityCollection<BiomeDelegate> replace;
+    private final NoiseSampler sampler;
+    
+    public ReplaceMutator(String replaceable, ProbabilityCollection<BiomeDelegate> replace, NoiseSampler sampler) {
+        this.replaceableTag = replaceable;
+        this.replace = replace;
+        this.sampler = sampler;
+    }
+    
+    @Override
+    public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) {
+        if(viewPoint.getBiome(0, 0).getTags().contains(replaceableTag)) {
+            BiomeDelegate biome = replace.get(sampler, x, z, seed);
+            return biome.isSelf() ? viewPoint.getBiome(0, 0) : biome;
+        }
+        return viewPoint.getBiome(0, 0);
+    }
+    
+    @Override
+    public Iterable<BiomeDelegate> getBiomes(Iterable<BiomeDelegate> biomes) {
+        Set<BiomeDelegate> biomeSet = new HashSet<>();
+        Set<BiomeDelegate> reject = new HashSet<>();
+        biomes.forEach(biome -> {
+            if(!biome.getTags().contains(replaceableTag)) {
+                biomeSet.add(biome);
+            } else {
+                reject.add(biome);
+            }
+        });
+        biomeSet.addAll(replace.getContents().stream().flatMap(terraBiome -> {
+            if(terraBiome.isSelf()) return reject.stream();
+            return Stream.of(terraBiome);
+        }).toList());
+        return biomeSet;
+    }
+}
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.mutator;
+
+import java.util.Objects;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.MathUtil;
+
+
+public class SmoothMutator implements BiomeMutator {
+    
+    private final NoiseSampler sampler;
+    
+    public SmoothMutator(NoiseSampler sampler) {
+        this.sampler = sampler;
+    }
+    
+    @Override
+    public BiomeDelegate mutate(ViewPoint viewPoint, double x, double z, long seed) {
+        BiomeDelegate top = viewPoint.getBiome(1, 0);
+        BiomeDelegate bottom = viewPoint.getBiome(-1, 0);
+        BiomeDelegate left = viewPoint.getBiome(0, 1);
+        BiomeDelegate right = viewPoint.getBiome(0, -1);
+        
+        
+        boolean vert = Objects.equals(top, bottom) && top != null;
+        boolean horiz = Objects.equals(left, right) && left != null;
+        
+        if(vert && horiz) {
+            return MathUtil.normalizeIndex(sampler.noise(seed, x, z), 2) == 0 ? left : top;
+        }
+        
+        if(vert) return top;
+        if(horiz) return left;
+        
+        return viewPoint.getBiome(0, 0);
+    }
+}
@@ -0,0 +1,17 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.source;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+
+
+public interface BiomeSource {
+    BiomeDelegate getBiome(double x, double z, long seed);
+    
+    Iterable<BiomeDelegate> getBiomes();
+}
@@ -0,0 +1,33 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.source;
+
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class SamplerSource implements BiomeSource {
+    private final ProbabilityCollection<BiomeDelegate> biomes;
+    private final NoiseSampler sampler;
+    
+    public SamplerSource(ProbabilityCollection<BiomeDelegate> biomes, NoiseSampler sampler) {
+        this.biomes = biomes;
+        this.sampler = sampler;
+    }
+    
+    @Override
+    public BiomeDelegate getBiome(double x, double z, long seed) {
+        return biomes.get(sampler, x, z, seed);
+    }
+    
+    @Override
+    public Iterable<BiomeDelegate> getBiomes() {
+        return biomes.getContents();
+    }
+}
@@ -0,0 +1,37 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.stages;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeExpander;
+
+
+public class ExpanderStage implements Stage {
+    private final BiomeExpander expander;
+    
+    public ExpanderStage(BiomeExpander expander) {
+        this.expander = expander;
+    }
+    
+    @Override
+    public BiomeHolder apply(BiomeHolder in, long seed) {
+        return in.expand(expander, seed);
+    }
+    
+    @Override
+    public boolean isExpansion() {
+        return true;
+    }
+    
+    @Override
+    public Iterable<BiomeDelegate> getBiomes(Iterable<BiomeDelegate> biomes) {
+        return biomes;
+    }
+}
@@ -0,0 +1,46 @@
+/*
+ * Copyright (c) 2020-2021 Polyhedral Development
+ *
+ * The Terra Core Addons are licensed under the terms of the MIT License. For more details,
+ * reference the LICENSE file in this module's root directory.
+ */
+
+package com.dfsek.terra.addons.biome.pipeline.stages;
+
+import com.dfsek.terra.addons.biome.pipeline.api.BiomeHolder;
+import com.dfsek.terra.addons.biome.pipeline.api.delegate.BiomeDelegate;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.Stage;
+import com.dfsek.terra.addons.biome.pipeline.api.stage.type.BiomeMutator;
+
+
+public class MutatorStage implements Stage {
+    private final BiomeMutator mutator;
+    
+    public MutatorStage(BiomeMutator mutator) {
+        this.mutator = mutator;
+    }
+    
+    @Override
+    public BiomeHolder apply(BiomeHolder in, long seed) {
+        in.mutate(mutator, seed);
+        return in;
+    }
+    
+    @Override
+    public boolean isExpansion() {
+        return false;
+    }
+    
+    @Override
+    public Iterable<BiomeDelegate> getBiomes(Iterable<BiomeDelegate> biomes) {
+        return mutator.getBiomes(biomes);
+    }
+    
+    public enum Type {
+        REPLACE,
+        REPLACE_LIST,
+        BORDER,
+        BORDER_LIST,
+        SMOOTH
+    }
+}
@@ -0,0 +1,12 @@
+schema-version: 1
+contributors:
+  - Terra contributors
+id: biome-provider-pipeline
+version: @VERSION@
+entrypoints:
+  - "com.dfsek.terra.addons.biome.pipeline.BiomePipelineAddon"
+website:
+  issues: https://github.com/PolyhedralDev/Terra/issues
+  source: https://github.com/PolyhedralDev/Terra
+  docs: https://terra.polydev.org
+license: MIT License