Update README.md

Allows you to create a block with physics enabled

.github/ISSUE_TEMPLATE/BUG_REPORT.md

@@ -43,7 +43,7 @@ assignees: ""
   is Terra that is causing the issue.
 - [ ] I have checked that this is an issue with Terra and not an issue with the
   pack I am using.
-  <!-- If this is an issue with the default Terra pack, please open an issue on the pack repo: https://github.com/PolyhedralDev/TerraDefaultConfig/issues/new -->
+  <!-- If this is an issue with the default Terra pack, please open an issue on the pack repo: https://github.com/PolyhedralDev/TerraOverworldConfig/issues/new -->
 - [ ] I have attached a copy of the `latest.log` file
 - [ ] I have filled out and provided all the appropriate information.
 

CODE_OF_CONDUCT.md

@@ -315,19 +315,15 @@ Terra has a global moderation team which is currently comprised of the following
 members:
 
 - solonovamax
-  -
-  discord: [@solonovamax#6983](https://discord.com/channels/@me/566146322273402881)*
+    - discord: [@solonovamax#6983](https://discord.com/channels/@me/566146322273402881)*
     - github: [@solonovamax](https://github.com/solonovamax)
-    -
-  email: [solonovamax@12oclockpoint.com](mailto:solonovamax@12oclockpoint.com)
+    - email: [solonovamax@12oclockpoint.com](mailto:solonovamax@12oclockpoint.com)
 - dfsek
-  -
-  discord: [@dfsek#4208](https://discord.com/channels/@me/378350362236682240)*
+    - discord: [@dfsek#4208](https://discord.com/channels/@me/378350362236682240)*
     - github: [@dfsek](https://github.com/dfsek)
     - email: [dfsek@protonmail.com](mailto:dfsek@protonmail.com)
 - duplex (duplexsystem)
-  -
-  discord: [@Duplex#0797](https://discord.com/channels/@me/356822848641171456)*
+    - discord: [@Duplex#0797](https://discord.com/channels/@me/356822848641171456)*
     - github: [@duplexsystem](https://github.com/duplexsystem)
     - email: [duplexsys@protonmail.com](mailto:duplexsys@protonmail.com)
 
@@ -401,32 +397,17 @@ issue on this github repo, or contact a member of the global moderation team.
 ## License and Attribution
 
 This set of guidelines is distributed under a
-[Creative Commons Attribution-ShareAlike license](https://creativecommons.org/licenses/by-sa/3.0/)
-.
+[Creative Commons Attribution-ShareAlike license](https://creativecommons.org/licenses/by-sa/3.0/).
 
-These guidelines have been adapted from
-[Mozilla's Community Participation Guidelines](https://www.mozilla.org/en-US/about/governance/policies/participation/)
-, which were adapted from:
+These guidelines have been adapted with modifications from the following sources:
 
-- Mozilla's original Community Participation Guidelines
+- [Mozilla's Community Participation Guidelines](https://www.mozilla.org/en-US/about/governance/policies/participation/)
 - The [Ubuntu Code of Conduct](https://ubuntu.com/community/code-of-conduct)
--
-
-Mozilla's [View Source Conference Code of Conduct](https://viewsourceconf.org/berlin-2016/code-of-conduct/)
-
-- And
-  the [Rust Language Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct)
-
-which in turn were based
-on [Stumptown Syndicate's Citizen Code of Conduct](http://citizencodeofconduct.org/)
-, along with some adapted text from
-the [LGBTQ in Technology Code of Conduct](https://lgbtq.technology/coc.html) and
-the [WisCon code of conduct](http://wiscon.net/policies/anti-harassment/code-of-conduct/)
-.
-
-It was then modified by solonovamax with various inclusions from
-the [LGBTQ in Technology Code of Conduct](https://lgbtq.technology/coc.html) and
-a few other sources.
+- Mozilla's [View Source Conference Code of Conduct](https://viewsourceconf.org/berlin-2016/code-of-conduct/)
+- The [Rust Language Code of Conduct](https://www.rust-lang.org/policies/code-of-conduct)
+- The [Stumptown Syndicate's Citizen Code of Conduct](http://citizencodeofconduct.org/)
+- The [LGBTQ in Technology Code of Conduct](https://lgbtq.technology/coc.html)
+- The [WisCon code of conduct](http://wiscon.net/policies/anti-harassment/code-of-conduct/)
 
 ## Notes
 
@@ -443,7 +424,6 @@ people are not comfortable
 using [neopronouns](https://www.mypronouns.org/neopronouns). But if someone
 refuses to use your more common pronouns, you should report them to us.
 Additionally, you may not ask people to use unreasonable pronouns, such as '
-acab/acabself', 'that/bitch', 'ur/mom', or
-'dream/dreamself' (pronouns related to real people, eg. the minecraft youtuber '
-dreamwastaken'). Doing so will be considered mockery of individuals who use
+acab/acabself', 'that/bitch', 'ur/mom', or anything else that may be considered
+disrectful. Doing so will be considered mockery of individuals who use
 non-standard pronouns and is very disrespectful.

build.gradle.kts

@@ -1,8 +1,8 @@
 preRelease(true)
 
-versionProjects(":common:api", version("6.2.0"))
-versionProjects(":common:implementation", version("6.2.0"))
-versionProjects(":platforms", version("6.2.0"))
+versionProjects(":common:api", version("6.4.0"))
+versionProjects(":common:implementation", version("6.4.0"))
+versionProjects(":platforms", version("6.4.0"))
 
 
 allprojects {
@@ -42,6 +42,7 @@ afterEvaluate {
     forImmediateSubProjects(":platforms") {
         configureDistribution()
     }
+    project(":platforms:bukkit:common").configureDistribution()
     forSubProjects(":common:addons") {
         apply(plugin = "com.github.johnrengelman.shadow")
         

buildSrc/src/main/kotlin/DistributionConfig.kt

@@ -1,6 +1,7 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 import java.io.File
 import java.io.FileWriter
+import java.net.URI
 import java.net.URL
 import java.nio.file.FileSystems
 import java.nio.file.Files
@@ -44,7 +45,7 @@ fun Project.configureDistribution() {
         
         doLast {
             // https://github.com/johnrengelman/shadow/issues/111
-            val dest = tasks.named<ShadowJar>("shadowJar").get().archiveFile.get().asFile.toPath()
+            val dest = URI.create("jar:" + tasks.named<ShadowJar>("shadowJar").get().archiveFile.get().asFile.toURI())
             
             FileSystems.newFileSystem(dest, mapOf("create" to "false"), null).use { fs ->
                 forSubProjects(":common:addons") {

buildSrc/src/main/kotlin/Versions.kt

@@ -4,7 +4,7 @@ object Versions {
         const val paralithic = "0.7.0"
         const val strata = "1.1.1"
         
-        const val cloud = "1.7.0"
+        const val cloud = "1.8.0"
         
         const val slf4j = "1.7.36"
         const val log4j_slf4j_impl = "2.14.1"
@@ -19,39 +19,38 @@ object Versions {
     
     object Fabric {
         const val fabricLoader = "0.14.8"
-        const val fabricAPI = "0.57.0+1.19"
+        const val fabricAPI = "0.83.1+1.20.1"
     }
     
     object Quilt {
         const val quiltLoader = "0.17.0"
-        const val fabricApi = "2.0.0-beta.4+0.57.0-1.19"
+        const val fabricApi = "6.0.0-beta.3+0.76.0-1.19.4"
     }
     
     object Mod {
         const val mixin = "0.11.2+mixin.0.8.5"
         
-        const val minecraft = "1.19"
-        const val yarn = "$minecraft+build.1"
-        const val fabricLoader = "0.14.2"
+        const val minecraft = "1.20.1"
+        const val yarn = "$minecraft+build.2"
+        const val fabricLoader = "0.14.21"
         
         const val architecuryLoom = "0.12.0.290"
         const val architecturyPlugin = "3.4-SNAPSHOT"
         
         const val loomQuiltflower = "1.7.1"
-        
-        const val lazyDfu = "0.1.2"
     }
     
     object Forge {
-        const val forge = "${Mod.minecraft}-41.0.63"
+        const val forge = "${Mod.minecraft}-47.0.3"
         const val burningwave = "12.53.0"
     }
     
     object Bukkit {
         const val paper = "1.18.2-R0.1-SNAPSHOT"
         const val paperLib = "1.0.5"
-        const val minecraft = "1.19"
+        const val minecraft = "1.20.1"
         const val reflectionRemapper = "0.1.0-SNAPSHOT"
+        const val paperDevBundle = "1.20.1-R0.1-SNAPSHOT"
     }
     
     object Sponge {

common/addons/biome-provider-image-v2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2021 Polyhedral Development
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

common/addons/biome-provider-image-v2/README.md

@@ -0,0 +1,5 @@
+# biome-provider-image-v2
+
+Implements and registers the `IMAGE` biome provider, which
+utilizes various config types provided by the `library-image` addon to
+distribute biomes based on images.

common/addons/biome-provider-image-v2/build.gradle.kts

@@ -0,0 +1,12 @@
+version = version("1.0.0")
+
+dependencies {
+    compileOnlyApi(project(":common:addons:manifest-addon-loader"))
+    compileOnlyApi(project(":common:addons:library-image"))
+    implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+    testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+}
+
+tasks.named<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar>("shadowJar") {
+    relocate("net.jafama", "com.dfsek.terra.addons.biome.image.lib.jafama")
+}

common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProvider.java

@@ -0,0 +1,51 @@
+/*
+ * 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.image.v2;
+
+import java.util.Optional;
+
+import com.dfsek.terra.addons.image.converter.ColorConverter;
+import com.dfsek.terra.addons.image.colorsampler.ColorSampler;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+public class ImageBiomeProvider implements BiomeProvider {
+    private final int resolution;
+    
+    private final ColorConverter<Biome> colorConverter;
+    
+    private final ColorSampler colorSampler;
+    
+    public ImageBiomeProvider(ColorConverter<Biome> colorConverter, ColorSampler colorSampler, int resolution) {
+        this.resolution = resolution;
+        this.colorConverter = colorConverter;
+        this.colorSampler = colorSampler;
+    }
+    
+    @Override
+    public Biome getBiome(int x, int y, int z, long seed) {
+        return getBiome(x, z);
+    }
+    
+    public Biome getBiome(int x, int z) {
+        x /= resolution;
+        z /= resolution;
+        return colorConverter.apply(colorSampler.apply(x, z));
+    }
+    
+    @Override
+    public Optional<Biome> getBaseBiome(int x, int z, long seed) {
+        return Optional.of(getBiome(x, z));
+    }
+    
+    @Override
+    public Iterable<Biome> getBiomes() {
+        return colorConverter.getEntries();
+    }
+}

common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/ImageBiomeProviderAddon.java

@@ -0,0 +1,74 @@
+/*
+ * 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.image.v2;
+
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import java.util.function.Supplier;
+
+import com.dfsek.terra.addons.biome.image.v2.config.ImageProviderTemplate;
+import com.dfsek.terra.addons.biome.image.v2.config.converter.ClosestBiomeColorConverterTemplate;
+import com.dfsek.terra.addons.biome.image.v2.config.converter.ExactBiomeColorConverterTemplate;
+import com.dfsek.terra.addons.biome.image.v2.config.converter.mapping.DefinedBiomeColorMappingTemplate;
+import com.dfsek.terra.addons.image.converter.ColorConverter;
+import com.dfsek.terra.addons.image.converter.mapping.BiomeDefinedColorMapping;
+import com.dfsek.terra.addons.image.converter.mapping.ColorMapping;
+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.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.util.reflection.TypeKey;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+public class ImageBiomeProviderAddon implements AddonInitializer {
+    public static final TypeKey<Supplier<ObjectTemplate<BiomeProvider>>> PROVIDER_REGISTRY_KEY = new TypeKey<>() {
+    };
+    
+    public static final TypeKey<Supplier<ObjectTemplate<ColorConverter<Biome>>>> BIOME_COLOR_CONVERTER_REGISTRY_KEY = new TypeKey<>() {
+    };
+    
+    public static final TypeKey<Supplier<ObjectTemplate<ColorMapping<Biome>>>> BIOME_COLOR_MAPPING_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)
+                .priority(501)
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<BiomeProvider>>> providerRegistry = event.getPack().getOrCreateRegistry(
+                            PROVIDER_REGISTRY_KEY);
+                    providerRegistry.register(addon.key("IMAGE"), ImageProviderTemplate::new);
+                })
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<ColorConverter<Biome>>>> biomeColorConverterRegistry = event.getPack().getOrCreateRegistry(
+                            BIOME_COLOR_CONVERTER_REGISTRY_KEY);
+                    biomeColorConverterRegistry.register(addon.key("EXACT"), ExactBiomeColorConverterTemplate::new);
+                    biomeColorConverterRegistry.register(addon.key("CLOSEST"), ClosestBiomeColorConverterTemplate::new);
+                })
+                .then(event -> {
+                    CheckedRegistry<Supplier<ObjectTemplate<ColorMapping<Biome>>>> biomeColorMappingRegistry = event.getPack().getOrCreateRegistry(
+                            BIOME_COLOR_MAPPING_REGISTRY_KEY);
+                    biomeColorMappingRegistry.register(addon.key("USE_BIOME_COLORS"), () -> () -> new BiomeDefinedColorMapping<>(event.getPack().getRegistry(Biome.class), b -> b));
+                    biomeColorMappingRegistry.register(addon.key("MAP"), DefinedBiomeColorMappingTemplate::new);
+                })
+                .failThrough();
+    }
+}

common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/ImageProviderTemplate.java

@@ -0,0 +1,40 @@
+/*
+ * 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.image.v2.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.addons.biome.image.v2.ImageBiomeProvider;
+import com.dfsek.terra.addons.image.converter.ColorConverter;
+import com.dfsek.terra.addons.image.colorsampler.ColorSampler;
+import com.dfsek.terra.api.world.biome.Biome;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+@SuppressWarnings("FieldMayBeFinal")
+public class ImageProviderTemplate implements ObjectTemplate<BiomeProvider> {
+    
+    @Value("resolution")
+    @Default
+    @Description("Sets the resolution at which to sample the image.")
+    private int resolution = 1;
+    
+    @Value("color-sampler")
+    private ColorSampler colorSampler;
+    
+    @Value("color-conversion")
+    private ColorConverter<Biome> colorConverter;
+    
+    @Override
+    public BiomeProvider get() {
+        return new ImageBiomeProvider(colorConverter, colorSampler, resolution);
+    }
+}

common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ClosestBiomeColorConverterTemplate.java

@@ -0,0 +1,19 @@
+package com.dfsek.terra.addons.biome.image.v2.config.converter;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.image.config.converter.ClosestColorConverterTemplate;
+import com.dfsek.terra.addons.image.converter.mapping.ColorMapping;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class ClosestBiomeColorConverterTemplate extends ClosestColorConverterTemplate<Biome> {
+
+    @Value("match")
+    private ColorMapping<Biome> match;
+    
+    @Override
+    protected ColorMapping<Biome> getMapping() {
+        return match;
+    }
+}

common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/ExactBiomeColorConverterTemplate.java

@@ -0,0 +1,37 @@
+package com.dfsek.terra.addons.biome.image.v2.config.converter;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.image.config.converter.ExactColorConverterTemplate;
+import com.dfsek.terra.addons.image.converter.mapping.ColorMapping;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class ExactBiomeColorConverterTemplate extends ExactColorConverterTemplate<Biome> {
+    
+    @Value("match")
+    private ColorMapping<Biome> match;
+
+    @Value("else")
+    private Biome fallback;
+    
+    @Value("ignore-alpha")
+    @Default
+    private boolean ignoreAlpha = true;
+
+    @Override
+    protected ColorMapping<Biome> getMapping() {
+        return match;
+    }
+
+    @Override
+    protected Biome getFallback() {
+        return fallback;
+    }
+    
+    @Override
+    protected boolean ignoreAlpha() {
+        return ignoreAlpha;
+    }
+}

common/addons/biome-provider-image-v2/src/main/java/com/dfsek/terra/addons/biome/image/v2/config/converter/mapping/DefinedBiomeColorMappingTemplate.java

@@ -0,0 +1,24 @@
+package com.dfsek.terra.addons.biome.image.v2.config.converter.mapping;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import java.util.Map;
+
+import com.dfsek.terra.addons.image.config.ColorLoader.ColorString;
+import com.dfsek.terra.addons.image.converter.mapping.ColorMapping;
+import com.dfsek.terra.addons.image.util.MapUtil;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class DefinedBiomeColorMappingTemplate implements ObjectTemplate<ColorMapping<Biome>> {
+    
+    @Value("map")
+    Map<ColorString, Biome> map;
+    
+    @Override
+    public ColorMapping<Biome> get() {
+        var map = MapUtil.mapKeys(this.map, ColorString::getColor);
+        return () -> map;
+    }
+}

common/addons/biome-provider-image-v2/src/main/resources/terra.addon.yml

@@ -0,0 +1,14 @@
+schema-version: 1
+contributors:
+  - Terra contributors
+id: biome-provider-image-v2
+version: @VERSION@
+entrypoints:
+  - "com.dfsek.terra.addons.biome.image.v2.ImageBiomeProviderAddon"
+website:
+  issues: https://github.com/PolyhedralDev/Terra/issues
+  source: https://github.com/PolyhedralDev/Terra
+  docs: https://terra.polydev.org
+license: MIT License
+depends:
+  library-image: "1.+"

common/addons/biome-provider-image/src/main/java/com/dfsek/terra/addons/biome/image/ImageBiomeProviderAddon.java

@@ -8,6 +8,8 @@
 package com.dfsek.terra.addons.biome.image;
 
 import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.function.Supplier;
 
@@ -24,6 +26,9 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
 
 
 public class ImageBiomeProviderAddon implements AddonInitializer {
+    
+    private static final Logger logger = LoggerFactory.getLogger(ImageBiomeProviderAddon.class);
+    
     public static final TypeKey<Supplier<ObjectTemplate<BiomeProvider>>> PROVIDER_REGISTRY_KEY = new TypeKey<>() {
     };
     
@@ -45,5 +50,6 @@ public class ImageBiomeProviderAddon implements AddonInitializer {
                                               () -> new ImageProviderTemplate(event.getPack().getRegistry(Biome.class)));
                 })
                 .failThrough();
+        logger.warn("The biome-provider-image addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the biome-provider-image-v2 addon for future pack development instead.");
     }
 }

common/addons/biome-provider-pipeline-v2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2021 Polyhedral Development
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

common/addons/biome-provider-pipeline-v2/README.md

@@ -0,0 +1,12 @@
+# biome-provider-pipeline-2
+
+The second version of the Biome Pipeline, a procedural biome provider that uses a series
+of "stages" to apply "mutations" to a 2D grid of biomes.
+
+Version 2 is a re-implementation of the original addon with the primary goal of providing
+consistent scaling for noise relative to the world
+(See https://github.com/PolyhedralDev/Terra/issues/264 for more details), and has been
+included as a separate addon to maintain parity with packs utilizing the first version. 
+
+This addon registers the `PIPELINE` biome provider type, and all associated
+configurations.

common/addons/biome-provider-pipeline-v2/build.gradle.kts

@@ -0,0 +1,12 @@
+version = version("1.0.0")
+
+dependencies {
+    compileOnlyApi(project(":common:addons:manifest-addon-loader"))
+    
+    implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+    testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+}
+
+tasks.named<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar>("shadowJar") {
+    relocate("net.jafama", "com.dfsek.terra.addons.biome.pipeline.lib.jafama")
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineAddon.java

@@ -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.v2;
+
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import java.util.function.Supplier;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.config.BiomePipelineTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.config.PipelineBiomeLoader;
+import com.dfsek.terra.addons.biome.pipeline.v2.config.source.SamplerSourceTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.expander.ExpanderStageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.BorderListStageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.BorderStageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.ReplaceListStageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.ReplaceStageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.SmoothStageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Source;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+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<Source>>> 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<Source>>> 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"), SmoothStageTemplate::new);
+                    stageRegistry.register(addon.key("REPLACE"), ReplaceStageTemplate::new);
+                    stageRegistry.register(addon.key("REPLACE_LIST"), ReplaceListStageTemplate::new);
+                    stageRegistry.register(addon.key("BORDER"), BorderStageTemplate::new);
+                    stageRegistry.register(addon.key("BORDER_LIST"), BorderListStageTemplate::new);
+                })
+                .failThrough();
+        platform.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(addon, ConfigPackPostLoadEvent.class)
+                .then(event -> {
+                    Registry<Biome> biomeRegistry = event.getPack().getRegistry(Biome.class);
+                    event.getPack().applyLoader(PipelineBiome.class, new PipelineBiomeLoader(biomeRegistry));
+                });
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/BiomePipelineColumn.java

@@ -0,0 +1,71 @@
+package com.dfsek.terra.addons.biome.pipeline.v2;
+
+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;
+
+
+public 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);
+        }
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/PipelineBiomeProvider.java

@@ -0,0 +1,115 @@
+package com.dfsek.terra.addons.biome.pipeline.v2;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.BiomeChunk;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Pipeline;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.SeededVector;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+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.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 PipelineBiomeProvider implements BiomeProvider {
+    
+    private final LoadingCache<SeededVector, BiomeChunk> biomeChunkCache;
+    private final int chunkSize;
+    private final int resolution;
+    private final NoiseSampler mutator;
+    private final double noiseAmp;
+    private final Set<Biome> biomes;
+    
+    public PipelineBiomeProvider(Pipeline pipeline, int resolution, NoiseSampler mutator, double noiseAmp) {
+        this.resolution = resolution;
+        this.mutator = mutator;
+        this.noiseAmp = noiseAmp;
+        this.chunkSize = pipeline.getChunkSize();
+        this.biomeChunkCache = Caffeine.newBuilder()
+                                       .maximumSize(64)
+                                       .build(pipeline::generateChunk);
+    
+        Set<PipelineBiome> biomeSet = new HashSet<>();
+        pipeline.getSource().getBiomes().forEach(biomeSet::add);
+        Iterable<PipelineBiome> result = biomeSet;
+        for(Stage stage : pipeline.getStages()) {
+            result = stage.getBiomes(result);
+        }
+        this.biomes = new HashSet<>();
+        Iterable<PipelineBiome> finalResult = result;
+        result.forEach(pipelineBiome -> {
+            if(pipelineBiome.isPlaceholder()) {
+            
+                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 placeholder biome \"" + pipelineBiome.getID() +
+                                                   "\". Ensure there is a stage to guarantee replacement of the placeholder biome. Biomes: " +
+                                                   biomeList);
+            }
+            this.biomes.add(pipelineBiome.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 chunkX = FastMath.floorDiv(x, chunkSize);
+        int chunkZ = FastMath.floorDiv(z, chunkSize);
+        
+        int chunkWorldX = chunkX * chunkSize;
+        int chunkWorldZ = chunkZ * chunkSize;
+        
+        int xInChunk = x - chunkWorldX;
+        int zInChunk = z - chunkWorldZ;
+        
+        return biomeChunkCache.get(new SeededVector(seed, chunkWorldX, chunkWorldZ)).get(xInChunk, zInChunk).getBiome();
+    }
+    
+    @Override
+    public Iterable<Biome> getBiomes() {
+        return biomes;
+    }
+    
+    @Override
+    public Optional<Biome> getBaseBiome(int x, int z, long seed) {
+        return Optional.of(getBiome(x, z, seed));
+    }
+    
+    @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;
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/BiomeChunk.java

@@ -0,0 +1,10 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api;
+
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+
+
+public interface BiomeChunk {
+    
+    PipelineBiome get(int xInChunk, int zInChunk);
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Expander.java

@@ -0,0 +1,29 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoint;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+
+
+/**
+ * Resizes the internal grid of a BiomeChunk when applied, serves the purpose of
+ * filling in null biomes as a result of this resizing.
+ */
+public interface Expander extends Stage {
+    
+    PipelineBiome fillBiome(ViewPoint viewPoint);
+    
+    @Override
+    default int maxRelativeReadDistance() {
+        return 0;
+    }
+    
+    @Override
+    default PipelineBiome apply(ViewPoint viewPoint) {
+        PipelineBiome currentBiome = viewPoint.getBiome();
+        if(currentBiome == null) {
+            return fillBiome(viewPoint);
+        } else {
+            return currentBiome;
+        }
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Pipeline.java

@@ -0,0 +1,14 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api;
+
+import java.util.List;
+
+
+public interface Pipeline {
+    BiomeChunk generateChunk(SeededVector worldCoordinates);
+    
+    int getChunkSize();
+    
+    Source getSource();
+    
+    List<Stage> getStages();
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/SeededVector.java

@@ -0,0 +1,19 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api;
+
+public record SeededVector(long seed, int x, int z) {
+    
+    @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)));
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Source.java

@@ -0,0 +1,11 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api;
+
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+
+
+public interface Source {
+    PipelineBiome get(long seed, int x, int z);
+    
+    Iterable<PipelineBiome> getBiomes();
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/Stage.java

@@ -0,0 +1,15 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoint;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+
+
+public interface Stage {
+    PipelineBiome apply(ViewPoint viewPoint);
+    
+    int maxRelativeReadDistance();
+    
+    default Iterable<PipelineBiome> getBiomes(Iterable<PipelineBiome> biomes) {
+        return biomes;
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/DelegatedPipelineBiome.java

@@ -0,0 +1,40 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api.biome;
+
+import java.util.Set;
+
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public final class DelegatedPipelineBiome implements PipelineBiome {
+    private final Biome biome;
+    
+    public DelegatedPipelineBiome(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 DelegatedPipelineBiome that)) return false;
+        return that.biome.equals(this.biome);
+    }
+    
+    @Override
+    public Set<String> getTags() {
+        return biome.getTags();
+    }
+    
+    @Override
+    public String getID() {
+        return biome.getID();
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PipelineBiome.java

@@ -0,0 +1,35 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api.biome;
+
+import java.util.Set;
+
+import com.dfsek.terra.api.registry.key.StringIdentifiable;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public interface PipelineBiome extends StringIdentifiable {
+    Biome getBiome();
+    
+    static PipelineBiome placeholder(String id) {
+        return new PlaceholderPipelineBiome(id);
+    }
+    
+    static PipelineBiome from(Biome biome) {
+        return new DelegatedPipelineBiome(biome);
+    }
+    
+    static PipelineBiome self() {
+        return SelfPipelineBiome.INSTANCE;
+    }
+    
+    Set<String> getTags();
+    
+    default boolean isPlaceholder() {
+        return false;
+    }
+    
+    default boolean isSelf() {
+        return false;
+    }
+    
+    
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/PlaceholderPipelineBiome.java

@@ -0,0 +1,51 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api.biome;
+
+import java.util.HashSet;
+import java.util.Set;
+
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+final class PlaceholderPipelineBiome implements PipelineBiome {
+    private final Set<String> tags;
+    private final String id;
+    
+    public PlaceholderPipelineBiome(String id) {
+        this.id = id;
+        tags = new HashSet<>();
+        tags.add(id);
+        tags.add("ALL");
+    }
+    
+    @Override
+    public Biome getBiome() {
+        throw new UnsupportedOperationException("Cannot get raw biome from placeholder pipeline biome");
+    }
+    
+    @Override
+    public Set<String> getTags() {
+        return tags;
+    }
+    
+    @Override
+    public String getID() {
+        return id;
+    }
+    
+    @Override
+    public boolean isPlaceholder() {
+        return true;
+    }
+    
+    @Override
+    public int hashCode() {
+        return id.hashCode();
+    }
+    
+    @Override
+    public boolean equals(Object obj) {
+        if(!(obj instanceof PlaceholderPipelineBiome that)) return false;
+        
+        return this.id.equals(that.id);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/api/biome/SelfPipelineBiome.java

@@ -0,0 +1,40 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.api.biome;
+
+import java.util.Collections;
+import java.util.Set;
+
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+final class SelfPipelineBiome implements PipelineBiome {
+    public static final SelfPipelineBiome INSTANCE = new SelfPipelineBiome();
+    
+    private SelfPipelineBiome() {
+
+    }
+    
+    @Override
+    public Biome getBiome() {
+        throw new UnsupportedOperationException("Cannot get biome from self delegate");
+    }
+    
+    @Override
+    public boolean isSelf() {
+        return true;
+    }
+    
+    @Override
+    public boolean isPlaceholder() {
+        return true;
+    }
+    
+    @Override
+    public Set<String> getTags() {
+        return Collections.emptySet();
+    }
+    
+    @Override
+    public String getID() {
+        return "SELF";
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/BiomePipelineTemplate.java

@@ -0,0 +1,59 @@
+/*
+ * 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.v2.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 java.util.List;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.PipelineBiomeProvider;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.PipelineImpl;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Source;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
+
+
+@SuppressWarnings({ "FieldMayBeFinal", "unused" })
+public class BiomePipelineTemplate 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("pipeline.source")
+    @Description("The Biome Source to use for initial population of biomes.")
+    private @Meta Source source;
+    
+    @Value("pipeline.stages")
+    @Description("A list of pipeline stages to apply to the result of #source")
+    private @Meta List<@Meta Stage> stages;
+    
+    @Value("blend.sampler")
+    @Default
+    @Description("A sampler to use for blending the edges of biomes via domain warping.")
+    protected @Meta NoiseSampler blendSampler = NoiseSampler.zero();
+    
+    @Value("blend.amplitude")
+    @Default
+    @Description("The amplitude at which to perform blending.")
+    protected @Meta double blendAmplitude = 0d;
+    
+    @Override
+    public BiomeProvider get() {
+        return new PipelineBiomeProvider(new PipelineImpl(source, stages, resolution, 128), resolution, blendSampler, blendAmplitude);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/PipelineBiomeLoader.java

@@ -0,0 +1,32 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.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.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.api.registry.Registry;
+import com.dfsek.terra.api.world.biome.Biome;
+
+
+public class PipelineBiomeLoader implements TypeLoader<PipelineBiome> {
+    private final Registry<Biome> biomeRegistry;
+    
+    public PipelineBiomeLoader(Registry<Biome> biomeRegistry) {
+        this.biomeRegistry = biomeRegistry;
+    }
+    
+    @Override
+    public PipelineBiome load(@NotNull AnnotatedType t, @NotNull Object c, @NotNull ConfigLoader loader, DepthTracker depthTracker)
+    throws LoadException {
+        if(c.equals("SELF")) return PipelineBiome.self();
+        return biomeRegistry
+                .getByID((String) c)
+                .map(PipelineBiome::from)
+                .orElseGet(() -> PipelineBiome.placeholder((String) c));
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SamplerSourceTemplate.java

@@ -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.v2.config.source;
+
+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.v2.api.Source;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.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 PipelineBiome> biomes;
+    
+    @Override
+    public Source get() {
+        return new SamplerSource(biomes, noise);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/source/SourceTemplate.java

@@ -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.v2.config.source;
+
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Source;
+
+
+public abstract class SourceTemplate implements ObjectTemplate<Source> {
+
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/StageTemplate.java

@@ -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.v2.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.v2.api.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;
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/expander/ExpanderStageTemplate.java

@@ -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.v2.config.stage.expander;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Expander;
+import com.dfsek.terra.addons.biome.pipeline.v2.stage.expander.FractalExpander;
+
+
+public class ExpanderStageTemplate extends StageTemplate {
+    @Override
+    public Expander get() {
+        return new FractalExpander(noise);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderListStageTemplate.java

@@ -0,0 +1,41 @@
+/*
+ * 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.v2.config.stage.mutator;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import java.util.Map;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.BorderListStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+@SuppressWarnings("unused")
+public class BorderListStageTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+    
+    @Value("default-replace")
+    private @Meta String defaultReplace;
+    
+    @Value("default-to")
+    private @Meta ProbabilityCollection<@Meta PipelineBiome> defaultTo;
+    
+    @Value("replace")
+    private @Meta Map<@Meta PipelineBiome, @Meta ProbabilityCollection<@Meta PipelineBiome>> replace;
+    
+    
+    @Override
+    public Stage get() {
+        return new BorderListStage(replace, from, defaultReplace, noise, defaultTo);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/BorderStageTemplate.java

@@ -0,0 +1,35 @@
+/*
+ * 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.v2.config.stage.mutator;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.BorderStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+@SuppressWarnings("unused")
+public class BorderStageTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+    
+    @Value("replace")
+    private @Meta String replace;
+    
+    @Value("to")
+    private @Meta ProbabilityCollection<@Meta PipelineBiome> to;
+    
+    @Override
+    public Stage get() {
+        return new BorderStage(from, replace, noise, to);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceListStageTemplate.java

@@ -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.v2.config.stage.mutator;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import java.util.Map;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.ReplaceListStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+@SuppressWarnings("unused")
+public class ReplaceListStageTemplate extends StageTemplate {
+    @Value("default-from")
+    private @Meta String defaultFrom;
+    
+    @Value("default-to")
+    private @Meta ProbabilityCollection<@Meta PipelineBiome> defaultTo;
+    
+    @Value("to")
+    private @Meta Map<@Meta PipelineBiome, @Meta ProbabilityCollection<@Meta PipelineBiome>> replace;
+    
+    @Override
+    public Stage get() {
+        return new ReplaceListStage(replace, defaultFrom, defaultTo, noise);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/ReplaceStageTemplate.java

@@ -0,0 +1,32 @@
+/*
+ * 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.v2.config.stage.mutator;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.ReplaceStage;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+@SuppressWarnings("unused")
+public class ReplaceStageTemplate extends StageTemplate {
+    @Value("from")
+    private @Meta String from;
+    
+    @Value("to")
+    private @Meta ProbabilityCollection<@Meta PipelineBiome> to;
+    
+    @Override
+    public Stage get() {
+        return new ReplaceStage(from, to, noise);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/config/stage/mutator/SmoothStageTemplate.java

@@ -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.v2.config.stage.mutator;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.StageTemplate;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.SmoothStage;
+
+
+public class SmoothStageTemplate extends StageTemplate {
+    @Override
+    public Stage get() {
+        return new SmoothStage(noise);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/BiomeChunkImpl.java

@@ -0,0 +1,217 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.pipeline;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.BiomeChunk;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Expander;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.SeededVector;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import net.jafama.FastMath;
+
+import java.util.List;
+
+
+public class BiomeChunkImpl implements BiomeChunk {
+    
+    private PipelineBiome[][] biomes;
+    private final SeededVector worldOrigin;
+    private final int chunkOriginArrayIndex;
+    private final int worldCoordinateScale;
+    
+    public BiomeChunkImpl(SeededVector worldOrigin, PipelineImpl pipeline) {
+        
+        this.worldOrigin = worldOrigin;
+        this.chunkOriginArrayIndex = pipeline.getChunkOriginArrayIndex();
+        this.worldCoordinateScale = pipeline.getResolution();
+        
+        int size = pipeline.getArraySize();
+        
+        int expanderCount = pipeline.getExpanderCount();
+        int expansionsApplied = 0;
+        
+        // Allocate working arrays
+        this.biomes = new PipelineBiome[size][size];
+        PipelineBiome[][] lookupArray = new PipelineBiome[size][size];
+        // A second lookup array is required such that stage application doesn't affect lookups, otherwise application may cascade
+        
+        // Construct working grid
+        int gridOrigin = 0;
+        int gridInterval = calculateGridInterval(expanderCount, expansionsApplied);
+        int gridSize = (size / gridInterval);
+        gridSize += expanderCount > 0 ? 1 : 0; // Add an extra border if expansion occurs
+        
+        // Fill working grid with initial cells
+        for(int gridX = 0; gridX < gridSize; gridX++) {
+            for(int gridZ = 0; gridZ < gridSize; gridZ++) {
+                int xIndex = gridOrigin + gridX * gridInterval;
+                int zIndex = gridOrigin + gridZ * gridInterval;
+                biomes[xIndex][zIndex] = pipeline.getSource().get(worldOrigin.seed(), xIndexToWorldCoordinate(xIndex), zIndexToWorldCoordinate(zIndex));
+            }
+        }
+        
+        for(Stage stage : pipeline.getStages()) {
+            if(stage instanceof Expander) {
+                // Shrink working grid size, the expander will fill in null cells (as a result of shrinking the grid) during mutation
+                expansionsApplied++;
+                gridInterval = calculateGridInterval(expanderCount, expansionsApplied);
+                gridSize = expandSize(gridSize);
+            }
+            
+            int stageReadDistance = stage.maxRelativeReadDistance();
+            if(stageReadDistance > 0) {
+                // Discard edges such that adjacent lookups are only ran on valid cells
+                gridSize = contractBordersFromSize(gridSize, stageReadDistance);
+                gridOrigin += stageReadDistance * gridInterval;
+            }
+            
+            // Cycle arrays, the previously populated array is swapped to be used for lookups, and the result of the stage application
+            // overwrites the previous lookup array. This saves having to allocate a new array copy each time
+            PipelineBiome[][] tempArray = biomes;
+            biomes = lookupArray;
+            lookupArray = tempArray;
+            
+            // Apply stage to working grid
+            for(int gridZ = 0; gridZ < gridSize; gridZ = gridZ + 1) {
+                for(int gridX = 0; gridX < gridSize; gridX = gridX + 1) {
+                    int xIndex = gridOrigin + gridX * gridInterval;
+                    int zIndex = gridOrigin + gridZ * gridInterval;
+                    biomes[xIndex][zIndex] = stage.apply(new ViewPoint(this, gridInterval, gridX, gridZ, xIndex, zIndex, lookupArray));
+                }
+            }
+        }
+    }
+    
+    @Override
+    public PipelineBiome get(int xInChunk, int zInChunk) {
+        int xIndex = xInChunk + chunkOriginArrayIndex;
+        int zIndex = zInChunk + chunkOriginArrayIndex;
+        return biomes[xIndex][zIndex];
+    }
+    
+    private int xIndexToWorldCoordinate(int xIndex) {
+        return (worldOrigin.x() + xIndex - chunkOriginArrayIndex) * worldCoordinateScale;
+    }
+    
+    private int zIndexToWorldCoordinate(int zIndex) {
+        return (worldOrigin.z() + zIndex - chunkOriginArrayIndex) * worldCoordinateScale;
+    }
+    
+    protected static int initialSizeToArraySize(int expanderCount, int initialSize) {
+        int size = initialSize;
+        for(int i = 0; i < expanderCount; i++) {
+            size = expandSize(size);
+        }
+        return size;
+    }
+    
+    protected static int calculateChunkOriginArrayIndex(int totalExpanderCount, List<Stage> stages) {
+        int finalGridOrigin = calculateFinalGridOrigin(totalExpanderCount, stages);
+        int initialGridInterval = calculateGridInterval(totalExpanderCount, 0);
+        
+        // Round the final grid origin up to the nearest multiple of initialGridInterval, such that each
+        // chunk samples points on the same overall grid.
+        // Without this, shared chunk borders (required because of adjacent cell reads) will not be identical
+        // because points would be sampled on grids at different offsets, resulting in artifacts at borders.
+        return FastMath.ceilToInt((double) finalGridOrigin / initialGridInterval) * initialGridInterval;
+    }
+    
+    private static int calculateFinalGridOrigin(int totalExpanderCount, List<Stage> stages) {
+        int gridOrigin = 0;
+        int expansionsApplied = 0;
+        int gridInterval = calculateGridInterval(totalExpanderCount, expansionsApplied);
+        for (Stage stage : stages) {
+            if (stage instanceof Expander) {
+                expansionsApplied++;
+                gridInterval = calculateGridInterval(totalExpanderCount, expansionsApplied);
+            }
+            gridOrigin += stage.maxRelativeReadDistance() * gridInterval;
+        }
+        return gridOrigin;
+    }
+    
+    protected static int calculateChunkSize(int arraySize, int chunkOriginArrayIndex, int totalExpanderCount) {
+        return contractBordersFromSize(arraySize, chunkOriginArrayIndex) - (totalExpanderCount > 0 ? 1 : 0);
+    }
+    
+    private static int expandSize(int size) {
+        return size * 2 - 1;
+    }
+    
+    private static int contractBordersFromSize(int size, int border) {
+        return size - border * 2;
+    }
+    
+    private static int calculateGridInterval(int totalExpansions, int expansionsApplied) {
+        return 1 << (totalExpansions - expansionsApplied);
+    }
+    
+    private SeededVector getOrigin() {
+        return worldOrigin;
+    }
+    
+    /**
+     * Represents a point on the operating grid within the biomes array
+     */
+    public static class ViewPoint {
+        private final BiomeChunkImpl chunk;
+        private final PipelineBiome biome;
+        private final int gridInterval;
+        private final int gridX;
+        private final int gridZ;
+        private final int xIndex;
+        private final int zIndex;
+        private final PipelineBiome[][] lookupArray;
+        
+        private ViewPoint(BiomeChunkImpl chunk, int gridInterval, int gridX, int gridZ, int xIndex, int zIndex, PipelineBiome[][] lookupArray) {
+            this.chunk = chunk;
+            this.gridInterval = gridInterval;
+            this.gridX = gridX;
+            this.gridZ = gridZ;
+            this.xIndex = xIndex;
+            this.zIndex = zIndex;
+            this.lookupArray = lookupArray;
+            this.biome = lookupArray[xIndex][zIndex];
+        }
+        
+        public PipelineBiome getRelativeBiome(int x, int z) {
+            int lookupXIndex = this.xIndex + x * gridInterval;
+            int lookupZIndex = this.zIndex + z * gridInterval;
+            return lookupArray[lookupXIndex][lookupZIndex];
+        }
+        
+        public PipelineBiome getBiome() {
+            return biome;
+        }
+        
+        /**
+         * @return X position of the point relative to the operating grid
+         */
+        public int gridX() {
+            return gridX;
+        }
+        
+        /**
+         * @return Z position of the point relative to the operating grid
+         */
+        public int gridZ() {
+            return gridZ;
+        }
+        
+        /**
+         * @return X position of the point in the world
+         */
+        public int worldX() {
+            return chunk.xIndexToWorldCoordinate(xIndex);
+        }
+        
+        /**
+         * @return Z position of the point in the world
+         */
+        public int worldZ() {
+            return chunk.zIndexToWorldCoordinate(zIndex);
+        }
+        
+        public long worldSeed() {
+            return chunk.getOrigin().seed();
+        }
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/pipeline/PipelineImpl.java

@@ -0,0 +1,92 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.pipeline;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
+import java.util.List;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.BiomeChunk;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Expander;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Pipeline;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.SeededVector;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Source;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+
+
+public class PipelineImpl implements Pipeline {
+    
+    private static final Logger logger = LoggerFactory.getLogger(PipelineImpl.class);
+    
+    private final Source source;
+    private final List<Stage> stages;
+    private final int chunkSize;
+    private final int expanderCount;
+    private final int arraySize;
+    private final int chunkOriginArrayIndex;
+    private final int resolution;
+    
+    public PipelineImpl(Source source, List<Stage> stages, int resolution, int idealChunkArraySize) {
+        this.source = source;
+        this.stages = stages;
+        this.resolution = resolution;
+        this.expanderCount = (int) stages.stream().filter(s -> s instanceof Expander).count();
+        
+        // Optimize for the ideal array size
+        int arraySize;
+        int chunkOriginArrayIndex;
+        int chunkSize;
+        int initialSize = 1;
+        while (true) {
+            arraySize = BiomeChunkImpl.initialSizeToArraySize(expanderCount, initialSize);
+            chunkOriginArrayIndex = BiomeChunkImpl.calculateChunkOriginArrayIndex(expanderCount, stages);
+            chunkSize = BiomeChunkImpl.calculateChunkSize(arraySize, chunkOriginArrayIndex, expanderCount);
+            if (chunkSize > 1 && arraySize >= idealChunkArraySize) break;
+            initialSize++;
+        }
+        
+        this.arraySize = arraySize;
+        this.chunkOriginArrayIndex = chunkOriginArrayIndex;
+        this.chunkSize = chunkSize;
+    
+        logger.debug("Initialized a new biome pipeline:");
+        logger.debug("Array size: {} (Target: {})", arraySize, idealChunkArraySize);
+        logger.debug("Internal array origin: {}", chunkOriginArrayIndex);
+        logger.debug("Chunk size: {}", chunkSize);
+    }
+    
+    @Override
+    public BiomeChunk generateChunk(SeededVector worldCoordinates) {
+        return new BiomeChunkImpl(worldCoordinates, this);
+    }
+    
+    @Override
+    public int getChunkSize() {
+        return chunkSize;
+    }
+    
+    @Override
+    public Source getSource() {
+        return source;
+    }
+    
+    @Override
+    public List<Stage> getStages() {
+        return stages;
+    }
+    
+    protected int getExpanderCount() {
+        return expanderCount;
+    }
+    
+    protected int getArraySize() {
+        return arraySize;
+    }
+    
+    protected int getChunkOriginArrayIndex() {
+        return chunkOriginArrayIndex;
+    }
+    
+    protected int getResolution() {
+        return resolution;
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SamplerSource.java

@@ -0,0 +1,27 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.source;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Source;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class SamplerSource implements Source {
+    private final ProbabilityCollection<PipelineBiome> biomes;
+    private final NoiseSampler sampler;
+    
+    public SamplerSource(ProbabilityCollection<PipelineBiome> biomes, NoiseSampler sampler) {
+        this.biomes = biomes;
+        this.sampler = sampler;
+    }
+    
+    @Override
+    public PipelineBiome get(long seed, int x, int z) {
+        return biomes.get(sampler, x, z, seed);
+    }
+    
+    @Override
+    public Iterable<PipelineBiome> getBiomes() {
+        return biomes.getContents();
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/source/SingleSource.java

@@ -0,0 +1,27 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.source;
+
+import java.util.Collections;
+import java.util.Set;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Source;
+
+
+public class SingleSource implements Source {
+    
+    private final PipelineBiome biome;
+    
+    public SingleSource(PipelineBiome biome) {
+        this.biome = biome;
+    }
+    
+    @Override
+    public PipelineBiome get(long seed, int x, int z) {
+        return biome;
+    }
+    
+    @Override
+    public Set<PipelineBiome> getBiomes() {
+        return Collections.singleton(biome);
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/expander/FractalExpander.java

@@ -0,0 +1,37 @@
+package com.dfsek.terra.addons.biome.pipeline.v2.stage.expander;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Expander;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
+public class FractalExpander implements Expander {
+    
+    private final NoiseSampler sampler;
+    
+    public FractalExpander(NoiseSampler sampler) {
+        this.sampler = sampler;
+    }
+    
+    @Override
+    public PipelineBiome fillBiome(BiomeChunkImpl.ViewPoint viewPoint) {
+
+        int xMod2 = viewPoint.gridX() % 2;
+        int zMod2 = viewPoint.gridZ() % 2;
+        
+        double roll = sampler.noise(viewPoint.worldSeed(), viewPoint.worldX(), viewPoint.worldZ());
+        
+        if (xMod2 == 1 && zMod2 == 0) { // Pick one of 2 neighbors on X axis randomly
+            return roll > 0 ? viewPoint.getRelativeBiome(-1, 0) : viewPoint.getRelativeBiome(1, 0);
+            
+        } else if (xMod2 == 0 && zMod2 == 1) { // Pick one of 2 neighbors on Z axis randomly
+            return roll > 0 ? viewPoint.getRelativeBiome(0, -1) : viewPoint.getRelativeBiome(0, 1);
+            
+        } else { // Pick one of 4 corners randomly
+            return roll > 0 ?
+                   roll >  0.25 ? viewPoint.getRelativeBiome(-1, 1) : viewPoint.getRelativeBiome(1, 1) :
+                   roll > -0.25 ? viewPoint.getRelativeBiome(-1, -1) : viewPoint.getRelativeBiome(1, -1);
+        }
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderListStage.java

@@ -0,0 +1,86 @@
+/*
+ * 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.v2.stage.mutators;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Map;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+import com.dfsek.terra.api.util.vector.Vector2Int;
+
+
+public class BorderListStage implements Stage {
+    private final String border;
+    private final NoiseSampler noiseSampler;
+    private final ProbabilityCollection<PipelineBiome> replaceDefault;
+    private final String defaultReplace;
+    private final Map<PipelineBiome, ProbabilityCollection<PipelineBiome>> replace;
+    
+    private final Vector2Int[] borderPoints;
+    
+    public BorderListStage(Map<PipelineBiome, ProbabilityCollection<PipelineBiome>> replace, String border, String defaultReplace,
+                           NoiseSampler noiseSampler, ProbabilityCollection<PipelineBiome> replaceDefault) {
+        this.border = border;
+        this.noiseSampler = noiseSampler;
+        this.replaceDefault = replaceDefault;
+        this.defaultReplace = defaultReplace;
+        this.replace = replace;
+    
+        List<Vector2Int> points = new ArrayList<>();
+        for(int x = -1; x <= 1; x++) {
+            for(int z = -1; z <= 1; z++) {
+                if(x == 0 && z == 0) continue;
+                points.add(Vector2Int.of(x, z));
+            }
+        }
+        this.borderPoints = points.toArray(new Vector2Int[0]);
+        
+    }
+    
+    @Override
+    public Iterable<PipelineBiome> getBiomes(Iterable<PipelineBiome> biomes) {
+        Set<PipelineBiome> biomeSet = new HashSet<>();
+        biomes.forEach(biomeSet::add);
+        biomeSet.addAll(replaceDefault.getContents().stream().filter(Predicate.not(PipelineBiome::isSelf)).toList());
+        replace.forEach((biome, collection) -> biomeSet.addAll(collection.getContents()));
+        return biomeSet;
+    }
+    
+    @Override
+    public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) {
+        PipelineBiome center = viewPoint.getBiome();
+        if(center.getTags().contains(defaultReplace)) {
+            for(Vector2Int point : borderPoints) {
+                PipelineBiome current = viewPoint.getRelativeBiome(point.getX(), point.getZ());
+                if(current != null && current.getTags().contains(border)) {
+                    if(replace.containsKey(center)) {
+                        PipelineBiome replacement = replace.get(center).get(noiseSampler, viewPoint.worldX(), viewPoint.worldZ(),
+                                                                      viewPoint.worldSeed());
+                        return replacement.isSelf() ? center : replacement;
+                    }
+                    PipelineBiome replacement = replaceDefault.get(noiseSampler, viewPoint.worldX(), viewPoint.worldZ(), viewPoint.worldSeed());
+                    return replacement.isSelf() ? center : replacement;
+                }
+            }
+        }
+        return center;
+    }
+    
+    @Override
+    public int maxRelativeReadDistance() {
+        return 1;
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/BorderStage.java

@@ -0,0 +1,81 @@
+/*
+ * 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.v2.stage.mutators;
+
+import java.util.ArrayList;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+import java.util.function.Predicate;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+import com.dfsek.terra.api.util.vector.Vector2Int;
+
+
+public class BorderStage implements Stage {
+    private final String border;
+    private final NoiseSampler noiseSampler;
+    private final ProbabilityCollection<PipelineBiome> replace;
+    private final String replaceTag;
+    private final Vector2Int[] borderPoints;
+    
+    public BorderStage(String border, String replaceTag, NoiseSampler noiseSampler, ProbabilityCollection<PipelineBiome> replace) {
+        this.border = border;
+        this.noiseSampler = noiseSampler;
+        this.replace = replace;
+        this.replaceTag = replaceTag;
+        List<Vector2Int> points = new ArrayList<>();
+        for(int x = -1; x <= 1; x++) {
+            for(int z = -1; z <= 1; z++) {
+                if(x == 0 && z == 0) continue;
+                points.add(Vector2Int.of(x, z));
+            }
+        }
+        this.borderPoints = points.toArray(new Vector2Int[0]);
+    }
+    
+    @Override
+    public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) {
+        PipelineBiome center = viewPoint.getBiome();
+        if(center.getTags().contains(replaceTag)) {
+            for(Vector2Int point : borderPoints) {
+                PipelineBiome current = viewPoint.getRelativeBiome(point.getX(), point.getZ());
+                if(current != null && current.getTags().contains(border)) {
+                    PipelineBiome replacement = replace.get(noiseSampler, viewPoint.worldX(), viewPoint.worldZ(), viewPoint.worldSeed());
+                    return replacement.isSelf() ? center : replacement;
+                }
+            }
+        }
+        return center;
+    }
+    
+    @Override
+    public Iterable<PipelineBiome> getBiomes(Iterable<PipelineBiome> biomes) {
+        Set<PipelineBiome> biomeSet = new HashSet<>();
+        biomes.forEach(biomeSet::add);
+        biomeSet.addAll(
+                replace
+                        .getContents()
+                        .stream()
+                        .filter(
+                                Predicate.not(PipelineBiome::isSelf)
+                               )
+                        .toList()
+                       );
+        return biomeSet;
+    }
+    
+    @Override
+    public int maxRelativeReadDistance() {
+        return 1;
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceListStage.java

@@ -0,0 +1,78 @@
+/*
+ * 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.v2.stage.mutators;
+
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class ReplaceListStage implements Stage {
+    private final Map<PipelineBiome, ProbabilityCollection<PipelineBiome>> replace;
+    private final NoiseSampler sampler;
+    private final ProbabilityCollection<PipelineBiome> replaceDefault;
+    private final String defaultTag;
+    
+    public ReplaceListStage(Map<PipelineBiome, ProbabilityCollection<PipelineBiome>> replace, String defaultTag,
+                            ProbabilityCollection<PipelineBiome> replaceDefault, NoiseSampler sampler) {
+        this.replace = replace;
+        this.sampler = sampler;
+        this.defaultTag = defaultTag;
+        this.replaceDefault = replaceDefault;
+    }
+    
+    @Override
+    public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) {
+        PipelineBiome center = viewPoint.getBiome();
+        if(replace.containsKey(center)) {
+            PipelineBiome biome = replace.get(center).get(sampler, viewPoint.worldX(), viewPoint.worldZ(), viewPoint.worldSeed());
+            return biome.isSelf() ? viewPoint.getBiome() : biome;
+        }
+        if(viewPoint.getBiome().getTags().contains(defaultTag)) {
+            PipelineBiome biome = replaceDefault.get(sampler, viewPoint.worldX(), viewPoint.worldZ(), viewPoint.worldSeed());
+            return biome.isSelf() ? viewPoint.getBiome() : biome;
+        }
+        return center;
+    }
+    
+    @Override
+    public int maxRelativeReadDistance() {
+        return 0;
+    }
+    
+    @Override
+    public Iterable<PipelineBiome> getBiomes(Iterable<PipelineBiome> biomes) {
+        Set<PipelineBiome> biomeSet = new HashSet<>();
+        
+        Set<PipelineBiome> 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;
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/ReplaceStage.java

@@ -0,0 +1,63 @@
+/*
+ * 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.v2.stage.mutators;
+
+import java.util.HashSet;
+import java.util.Set;
+import java.util.stream.Stream;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl;
+import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.collection.ProbabilityCollection;
+
+
+public class ReplaceStage implements Stage {
+    private final String replaceableTag;
+    private final ProbabilityCollection<PipelineBiome> replace;
+    private final NoiseSampler sampler;
+    
+    public ReplaceStage(String replaceable, ProbabilityCollection<PipelineBiome> replace, NoiseSampler sampler) {
+        this.replaceableTag = replaceable;
+        this.replace = replace;
+        this.sampler = sampler;
+    }
+    
+    @Override
+    public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) {
+        if(viewPoint.getBiome().getTags().contains(replaceableTag)) {
+            PipelineBiome biome = replace.get(sampler, viewPoint.worldX(), viewPoint.worldZ(), viewPoint.worldSeed());
+            return biome.isSelf() ? viewPoint.getBiome() : biome;
+        }
+        return viewPoint.getBiome();
+    }
+    
+    @Override
+    public int maxRelativeReadDistance() {
+        return 0;
+    }
+    
+    @Override
+    public Iterable<PipelineBiome> getBiomes(Iterable<PipelineBiome> biomes) {
+        Set<PipelineBiome> biomeSet = new HashSet<>();
+        Set<PipelineBiome> 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;
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/java/com/dfsek/terra/addons/biome/pipeline/v2/stage/mutators/SmoothStage.java

@@ -0,0 +1,56 @@
+/*
+ * 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.v2.stage.mutators;
+
+import java.util.Objects;
+
+import com.dfsek.terra.addons.biome.pipeline.v2.api.Stage;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
+public class SmoothStage implements Stage {
+    
+    private final NoiseSampler sampler;
+    
+    public SmoothStage(NoiseSampler sampler) {
+        this.sampler = sampler;
+    }
+    
+    @Override
+    public PipelineBiome apply(BiomeChunkImpl.ViewPoint viewPoint) {
+        PipelineBiome top = viewPoint.getRelativeBiome(1, 0);
+        PipelineBiome bottom = viewPoint.getRelativeBiome(-1, 0);
+        PipelineBiome left = viewPoint.getRelativeBiome(0, 1);
+        PipelineBiome right = viewPoint.getRelativeBiome(0, -1);
+        
+        double roll = sampler.noise(viewPoint.worldSeed(), viewPoint.worldX(), viewPoint.worldZ());
+        
+        boolean vert = Objects.equals(top, bottom);
+        boolean horiz = Objects.equals(left, right);
+    
+        if(vert && horiz) {
+            return roll > 0 ?
+                   roll > 0.25 ? left : right :
+                   roll > -0.25 ? top : bottom;
+        }
+        if(vert) {
+            return roll > 0 ? top : bottom;
+        }
+        if(horiz) {
+            return roll > 0 ? left : right;
+        }
+        return viewPoint.getBiome();
+    }
+    
+    @Override
+    public int maxRelativeReadDistance() {
+        return 1;
+    }
+}

common/addons/biome-provider-pipeline-v2/src/main/resources/terra.addon.yml

@@ -0,0 +1,12 @@
+schema-version: 1
+contributors:
+  - Terra contributors
+id: biome-provider-pipeline-v2
+version: @VERSION@
+entrypoints:
+  - "com.dfsek.terra.addons.biome.pipeline.v2.BiomePipelineAddon"
+website:
+  issues: https://github.com/PolyhedralDev/Terra/issues
+  source: https://github.com/PolyhedralDev/Terra
+  docs: https://terra.polydev.org
+license: MIT License

common/addons/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java

@@ -8,6 +8,8 @@
 package com.dfsek.terra.addons.biome.pipeline;
 
 import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.util.function.Supplier;
 
@@ -39,6 +41,8 @@ import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
 
 public class BiomePipelineAddon implements AddonInitializer {
     
+    private static final Logger logger = LoggerFactory.getLogger(BiomePipelineAddon.class);
+    
     public static final TypeKey<Supplier<ObjectTemplate<BiomeSource>>> SOURCE_REGISTRY_KEY = new TypeKey<>() {
     };
     
@@ -85,5 +89,7 @@ public class BiomePipelineAddon implements AddonInitializer {
                     Registry<Biome> biomeRegistry = event.getPack().getRegistry(Biome.class);
                     event.getPack().applyLoader(BiomeDelegate.class, new BiomeDelegateLoader(biomeRegistry));
                 });
+        
+        logger.warn("The biome-provider-pipeline addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the biome-provider-pipeline-v2 addon for future pack development instead.");
     }
 }

common/addons/chunk-generator-noise-3d/build.gradle.kts

@@ -1,4 +1,4 @@
-version = version("1.1.0")
+version = version("1.2.0")
 
 dependencies {
     compileOnlyApi(project(":common:addons:manifest-addon-loader"))

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/NoiseChunkGenerator3DAddon.java

@@ -11,9 +11,10 @@ import com.dfsek.terra.addons.chunkgenerator.config.NoiseChunkGeneratorPackConfi
 import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseConfigTemplate;
 import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties;
 import com.dfsek.terra.addons.chunkgenerator.config.palette.BiomePaletteTemplate;
-import com.dfsek.terra.addons.chunkgenerator.config.palette.PaletteInfo;
-import com.dfsek.terra.addons.chunkgenerator.config.palette.SlantLayer;
+import com.dfsek.terra.addons.chunkgenerator.config.palette.slant.SlantLayerTemplate;
 import com.dfsek.terra.addons.chunkgenerator.generation.NoiseChunkGenerator3D;
+import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo;
+import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder;
 import com.dfsek.terra.addons.manifest.api.AddonInitializer;
 import com.dfsek.terra.api.Platform;
 import com.dfsek.terra.api.addon.BaseAddon;
@@ -36,15 +37,20 @@ public class NoiseChunkGenerator3DAddon implements AddonInitializer {
     
     @Override
     public void initialize() {
-        PropertyKey<PaletteInfo> paletteInfoPropertyKey = Context.create(PaletteInfo.class);
+        PropertyKey<BiomePaletteInfo> paletteInfoPropertyKey = Context.create(BiomePaletteInfo.class);
         PropertyKey<BiomeNoiseProperties> noisePropertiesPropertyKey = Context.create(BiomeNoiseProperties.class);
         platform.getEventManager()
                 .getHandler(FunctionalEventHandler.class)
                 .register(addon, ConfigPackPreLoadEvent.class)
                 .priority(1000)
                 .then(event -> {
+                    
+                    event.getPack().applyLoader(SlantHolder.CalculationMethod.class,
+                                                (type, o, loader, depthTracker) -> SlantHolder.CalculationMethod.valueOf((String) o));
+
                     NoiseChunkGeneratorPackConfigTemplate config = event.loadTemplate(new NoiseChunkGeneratorPackConfigTemplate());
-            
+                    event.getPack().getContext().put(config);
+                    
                     event.getPack()
                          .getOrCreateRegistry(ChunkGeneratorProvider.class)
                          .register(addon.key("NOISE_3D"),
@@ -53,7 +59,7 @@ public class NoiseChunkGenerator3DAddon implements AddonInitializer {
                                                                      config.getVerticalRes(), noisePropertiesPropertyKey,
                                                                      paletteInfoPropertyKey));
                     event.getPack()
-                         .applyLoader(SlantLayer.class, SlantLayer::new);
+                         .applyLoader(SlantHolder.Layer.class, SlantLayerTemplate::new);
                 })
                 .failThrough();
         
@@ -62,8 +68,10 @@ public class NoiseChunkGenerator3DAddon implements AddonInitializer {
                 .register(addon, ConfigurationLoadEvent.class)
                 .then(event -> {
                     if(event.is(Biome.class)) {
+                        NoiseChunkGeneratorPackConfigTemplate config = event.getPack().getContext().get(NoiseChunkGeneratorPackConfigTemplate.class);
+                        
                         event.getLoadedObject(Biome.class).getContext().put(paletteInfoPropertyKey,
-                                                                            event.load(new BiomePaletteTemplate(platform)).get());
+                                                                            event.load(new BiomePaletteTemplate(platform, config.getSlantCalculationMethod())).get());
                         event.getLoadedObject(Biome.class).getContext().put(noisePropertiesPropertyKey,
                                                                             event.load(new BiomeNoiseConfigTemplate()).get());
                     }

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/NoiseChunkGeneratorPackConfigTemplate.java

@@ -4,10 +4,12 @@ import com.dfsek.tectonic.api.config.template.ConfigTemplate;
 import com.dfsek.tectonic.api.config.template.annotations.Default;
 import com.dfsek.tectonic.api.config.template.annotations.Value;
 
+import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder;
 import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.properties.Properties;
 
 
-public class NoiseChunkGeneratorPackConfigTemplate implements ConfigTemplate {
+public class NoiseChunkGeneratorPackConfigTemplate implements ConfigTemplate, Properties {
     @Value("blend.terrain.elevation")
     @Default
     private @Meta int elevationBlend = 4;
@@ -20,6 +22,10 @@ public class NoiseChunkGeneratorPackConfigTemplate implements ConfigTemplate {
     @Default
     private @Meta int verticalRes = 2;
     
+    @Value("slant.calculation-method")
+    @Default
+    private SlantHolder.@Meta CalculationMethod slantCalculationMethod = SlantHolder.CalculationMethod.Derivative;
+    
     public int getElevationBlend() {
         return elevationBlend;
     }
@@ -31,4 +37,8 @@ public class NoiseChunkGeneratorPackConfigTemplate implements ConfigTemplate {
     public int getVerticalRes() {
         return verticalRes;
     }
+    
+    public SlantHolder.CalculationMethod getSlantCalculationMethod() {
+        return slantCalculationMethod;
+    }
 }

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/BiomePaletteTemplate.java

@@ -15,25 +15,23 @@ import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
 import java.util.Collections;
 import java.util.List;
 import java.util.Map;
-import java.util.Map.Entry;
-import java.util.TreeMap;
 
 import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
-import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolderBuilder;
-import com.dfsek.terra.addons.chunkgenerator.palette.SlantHolder;
+import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo;
+import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder;
 import com.dfsek.terra.api.Platform;
 import com.dfsek.terra.api.block.state.BlockState;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.world.chunk.generation.util.Palette;
 
 
-public class BiomePaletteTemplate implements ObjectTemplate<PaletteInfo> {
+public class BiomePaletteTemplate implements ObjectTemplate<BiomePaletteInfo> {
     private final Platform platform;
     
     @Value("slant")
     @Default
     @Description("The slant palettes to use in this biome.")
-    private @Meta List<@Meta SlantLayer> slant = Collections.emptyList();
+    private @Meta List<SlantHolder.@Meta Layer> slantLayers = Collections.emptyList();
     
     @Value("slant-depth")
     @Default
@@ -63,27 +61,16 @@ public class BiomePaletteTemplate implements ObjectTemplate<PaletteInfo> {
     @Default
     private @Meta boolean updatePalette = false;
     
-    public BiomePaletteTemplate(Platform platform) { this.platform = platform; }
+    private final SlantHolder.CalculationMethod slantCalculationMethod;
+    
+    public BiomePaletteTemplate(Platform platform, SlantHolder.CalculationMethod slantCalculationMethod) {
+        this.platform = platform;
+        this.slantCalculationMethod = slantCalculationMethod;
+    }
     
     @Override
-    public PaletteInfo get() {
-        PaletteHolderBuilder builder = new PaletteHolderBuilder();
-        for(Map<Palette, Integer> layer : palettes) {
-            for(Entry<Palette, Integer> entry : layer.entrySet()) {
-                builder.add(entry.getValue(), entry.getKey());
-            }
-        }
-        
-        TreeMap<Double, PaletteHolder> slantLayers = new TreeMap<>();
-        double minThreshold = Double.MAX_VALUE;
-        
-        for(SlantLayer layer : slant) {
-            double threshold = layer.getThreshold();
-            if(threshold < minThreshold) minThreshold = threshold;
-            slantLayers.put(threshold, layer.getPalette());
-        }
-        
-        return new PaletteInfo(builder.build(), SlantHolder.of(slantLayers, minThreshold), oceanPalette, seaLevel, slantDepth,
-                               updatePalette);
+    public BiomePaletteInfo get() {
+        return new BiomePaletteInfo(PaletteHolder.of(palettes), SlantHolder.of(slantLayers, slantDepth, slantCalculationMethod),
+                                    oceanPalette, seaLevel, updatePalette);
     }
 }

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/PaletteInfo.java

@@ -1,22 +0,0 @@
-/*
- * 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.chunkgenerator.config.palette;
-
-import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
-import com.dfsek.terra.addons.chunkgenerator.palette.SlantHolder;
-import com.dfsek.terra.api.properties.Properties;
-import com.dfsek.terra.api.world.chunk.generation.util.Palette;
-
-
-public record PaletteInfo(PaletteHolder paletteHolder,
-                          SlantHolder slantHolder,
-                          Palette ocean,
-                          int seaLevel,
-                          int maxSlantDepth,
-                          boolean updatePaletteWhenCarving) implements Properties {
-}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/SlantLayer.java

@@ -1,42 +0,0 @@
-package com.dfsek.terra.addons.chunkgenerator.config.palette;
-
-import com.dfsek.tectonic.api.config.template.annotations.Value;
-import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
-
-import java.util.List;
-import java.util.Map;
-import java.util.Map.Entry;
-
-import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
-import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolderBuilder;
-import com.dfsek.terra.api.config.meta.Meta;
-import com.dfsek.terra.api.world.chunk.generation.util.Palette;
-
-
-public class SlantLayer implements ObjectTemplate<SlantLayer> {
-    @Value("threshold")
-    private @Meta double threshold;
-    
-    @Value("palette")
-    private @Meta List<@Meta Map<@Meta Palette, @Meta Integer>> palettes;
-    
-    @Override
-    public SlantLayer get() {
-        return this;
-    }
-    
-    public double getThreshold() {
-        return threshold;
-    }
-    
-    public PaletteHolder getPalette() {
-        PaletteHolderBuilder builder = new PaletteHolderBuilder();
-        for(Map<Palette, Integer> layer : palettes) {
-            for(Entry<Palette, Integer> entry : layer.entrySet()) {
-                builder.add(entry.getValue(), entry.getKey());
-            }
-        }
-        
-        return builder.build();
-    }
-}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/config/palette/slant/SlantLayerTemplate.java

@@ -0,0 +1,27 @@
+package com.dfsek.terra.addons.chunkgenerator.config.palette.slant;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import java.util.List;
+import java.util.Map;
+
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
+import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.world.chunk.generation.util.Palette;
+
+
+public class SlantLayerTemplate implements ObjectTemplate<SlantHolder.Layer> {
+    
+    @Value("threshold")
+    private @Meta double threshold;
+    
+    @Value("palette")
+    private @Meta List<@Meta Map<@Meta Palette, @Meta Integer>> palettes;
+    
+    @Override
+    public SlantHolder.Layer get() {
+        return new SlantHolder.Layer(PaletteHolder.of(palettes), threshold);
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/NoiseChunkGenerator3D.java

@@ -12,7 +12,7 @@ import net.jafama.FastMath;
 import org.jetbrains.annotations.NotNull;
 
 import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties;
-import com.dfsek.terra.addons.chunkgenerator.config.palette.PaletteInfo;
+import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.PaletteUtil;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.LazilyEvaluatedInterpolator;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D;
@@ -40,13 +40,13 @@ public class NoiseChunkGenerator3D implements ChunkGenerator {
     private final int carverHorizontalResolution;
     private final int carverVerticalResolution;
     
-    private final PropertyKey<PaletteInfo> paletteInfoPropertyKey;
+    private final PropertyKey<BiomePaletteInfo> paletteInfoPropertyKey;
     private final PropertyKey<BiomeNoiseProperties> noisePropertiesKey;
     
     public NoiseChunkGenerator3D(ConfigPack pack, Platform platform, int elevationBlend, int carverHorizontalResolution,
                                  int carverVerticalResolution,
                                  PropertyKey<BiomeNoiseProperties> noisePropertiesKey,
-                                 PropertyKey<PaletteInfo> paletteInfoPropertyKey) {
+                                 PropertyKey<BiomePaletteInfo> paletteInfoPropertyKey) {
         this.platform = platform;
         this.air = platform.getWorldHandle().air();
         this.carverHorizontalResolution = carverHorizontalResolution;
@@ -97,7 +97,7 @@ public class NoiseChunkGenerator3D implements ChunkGenerator {
                 for(int y = world.getMaxHeight() - 1; y >= world.getMinHeight(); y--) {
                     Biome biome = biomeColumn.get(y);
                     
-                    PaletteInfo paletteInfo = biome.getContext().get(paletteInfoPropertyKey);
+                    BiomePaletteInfo paletteInfo = biome.getContext().get(paletteInfoPropertyKey);
                     
                     int sea = paletteInfo.seaLevel();
                     Palette seaPalette = paletteInfo.ocean();
@@ -131,7 +131,7 @@ public class NoiseChunkGenerator3D implements ChunkGenerator {
         Biome biome = biomeProvider.getBiome(x, y, z, world.getSeed());
         Sampler3D sampler = samplerCache.get(x, z, world, biomeProvider);
         
-        PaletteInfo paletteInfo = biome.getContext().get(paletteInfoPropertyKey);
+        BiomePaletteInfo paletteInfo = biome.getContext().get(paletteInfoPropertyKey);
         
         int fdX = FastMath.floorMod(x, 16);
         int fdZ = FastMath.floorMod(z, 16);
@@ -155,6 +155,16 @@ public class NoiseChunkGenerator3D implements ChunkGenerator {
         return biomeProvider.getBiome(x, y, z, world.getSeed()).getContext().get(paletteInfoPropertyKey).paletteHolder().getPalette(y);
     }
     
+    public double getSlant(int x, int y, int z, WorldProperties world, BiomeProvider biomeProvider) {
+        int fdX = FastMath.floorMod(x, 16);
+        int fdZ = FastMath.floorMod(z, 16);
+        return biomeProvider.getBiome(x, y, z, world.getSeed())
+                            .getContext()
+                            .get(paletteInfoPropertyKey)
+                            .slantHolder()
+                            .calculateSlant(samplerCache.get(x, z, world, biomeProvider), fdX, y, fdZ);
+    }
+    
     public SamplerProvider samplerProvider() {
         return samplerCache;
     }

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/generation/math/PaletteUtil.java

@@ -7,40 +7,23 @@
 
 package com.dfsek.terra.addons.chunkgenerator.generation.math;
 
-import com.dfsek.terra.addons.chunkgenerator.config.palette.PaletteInfo;
+import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D;
-import com.dfsek.terra.addons.chunkgenerator.palette.SlantHolder;
+import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder;
 import com.dfsek.terra.api.world.chunk.generation.util.Palette;
 
 
 public final class PaletteUtil {
-    /**
-     * Derivative constant.
-     */
-    private static final double DERIVATIVE_DIST = 0.55;
     
-    public static Palette getPalette(int x, int y, int z, Sampler3D sampler, PaletteInfo paletteInfo, int depth) {
-        SlantHolder slant = paletteInfo.slantHolder();
-        if(!slant.isEmpty() && depth <= paletteInfo.maxSlantDepth()) {
-            double slope = derivative(sampler, x, y, z);
-            if(slope > slant.getMinSlope()) {
-                return slant.getPalette(slope).getPalette(y);
+    public static Palette getPalette(int x, int y, int z, Sampler3D sampler, BiomePaletteInfo paletteInfo, int depth) {
+        SlantHolder slantHolder = paletteInfo.slantHolder();
+        if(slantHolder.isAboveDepth(depth)) {
+            double slant = slantHolder.calculateSlant(sampler, x, y, z);
+            if(slantHolder.isInSlantThreshold(slant)) {
+                return slantHolder.getPalette(slant).getPalette(y);
             }
         }
         
         return paletteInfo.paletteHolder().getPalette(y);
     }
-    
-    public static double derivative(Sampler3D sampler, double x, double y, double z) {
-        double baseSample = sampler.sample(x, y, z);
-        
-        double xVal1 = (sampler.sample(x + DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST;
-        double xVal2 = (sampler.sample(x - DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST;
-        double zVal1 = (sampler.sample(x, y, z + DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST;
-        double zVal2 = (sampler.sample(x, y, z - DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST;
-        double yVal1 = (sampler.sample(x, y + DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST;
-        double yVal2 = (sampler.sample(x, y - DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST;
-        
-        return Math.sqrt(((xVal2 - xVal1) * (xVal2 - xVal1)) + ((zVal2 - zVal1) * (zVal2 - zVal1)) + ((yVal2 - yVal1) * (yVal2 - yVal1)));
-    }
 }

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/BiomePaletteInfo.java

@@ -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.chunkgenerator.palette;
+
+import com.dfsek.terra.addons.chunkgenerator.palette.slant.SlantHolder;
+import com.dfsek.terra.api.properties.Properties;
+import com.dfsek.terra.api.world.chunk.generation.util.Palette;
+
+
+public record BiomePaletteInfo(PaletteHolder paletteHolder,
+                               SlantHolder slantHolder,
+                               Palette ocean,
+                               int seaLevel,
+                               boolean updatePaletteWhenCarving) implements Properties {
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolder.java

@@ -7,6 +7,13 @@
 
 package com.dfsek.terra.addons.chunkgenerator.palette;
 
+import net.jafama.FastMath;
+
+import java.util.List;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.TreeMap;
+
 import com.dfsek.terra.api.world.chunk.generation.util.Palette;
 
 
@@ -27,4 +34,43 @@ public class PaletteHolder {
                  : palettes[palettes.length - 1]
                : palettes[0];
     }
+    
+    public static PaletteHolder of(List<Map<Palette, Integer>> palettes) {
+        PaletteHolderBuilder builder = new PaletteHolderBuilder();
+        for(Map<Palette, Integer> layer : palettes) {
+            for(Entry<Palette, Integer> entry : layer.entrySet()) {
+                builder.add(entry.getValue(), entry.getKey());
+            }
+        }
+        return builder.build();
+    }
+    
+    private static class PaletteHolderBuilder {
+        private final TreeMap<Integer, Palette> paletteMap = new TreeMap<>();
+        
+        public PaletteHolderBuilder add(int y, Palette palette) {
+            paletteMap.put(y, palette);
+            return this;
+        }
+        
+        public PaletteHolder build() {
+            
+            int min = FastMath.min(paletteMap.keySet().stream().min(Integer::compareTo).orElse(0), 0);
+            int max = FastMath.max(paletteMap.keySet().stream().max(Integer::compareTo).orElse(255), 255);
+            
+            Palette[] palettes = new Palette[paletteMap.lastKey() + 1 - min];
+            for(int y = min; y <= FastMath.max(paletteMap.lastKey(), max); y++) {
+                Palette d = null;
+                for(Entry<Integer, Palette> e : paletteMap.entrySet()) {
+                    if(e.getKey() >= y) {
+                        d = e.getValue();
+                        break;
+                    }
+                }
+                if(d == null) throw new IllegalArgumentException("No palette for Y=" + y);
+                palettes[y - min] = d;
+            }
+            return new PaletteHolder(palettes, -min);
+        }
+    }
 }

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/PaletteHolderBuilder.java

@@ -1,45 +0,0 @@
-/*
- * 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.chunkgenerator.palette;
-
-import net.jafama.FastMath;
-
-import java.util.Map;
-import java.util.TreeMap;
-
-import com.dfsek.terra.api.world.chunk.generation.util.Palette;
-
-
-public class PaletteHolderBuilder {
-    private final TreeMap<Integer, Palette> paletteMap = new TreeMap<>();
-    
-    public PaletteHolderBuilder add(int y, Palette palette) {
-        paletteMap.put(y, palette);
-        return this;
-    }
-    
-    public PaletteHolder build() {
-        
-        int min = FastMath.min(paletteMap.keySet().stream().min(Integer::compareTo).orElse(0), 0);
-        int max = FastMath.max(paletteMap.keySet().stream().max(Integer::compareTo).orElse(255), 255);
-        
-        Palette[] palettes = new Palette[paletteMap.lastKey() + 1 - min];
-        for(int y = min; y <= FastMath.max(paletteMap.lastKey(), max); y++) {
-            Palette d = null;
-            for(Map.Entry<Integer, Palette> e : paletteMap.entrySet()) {
-                if(e.getKey() >= y) {
-                    d = e.getValue();
-                    break;
-                }
-            }
-            if(d == null) throw new IllegalArgumentException("No palette for Y=" + y);
-            palettes[y - min] = d;
-        }
-        return new PaletteHolder(palettes, -min);
-    }
-}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/SlantHolder.java

@@ -1,64 +0,0 @@
-/*
- * 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.chunkgenerator.palette;
-
-
-import java.util.Map.Entry;
-import java.util.TreeMap;
-
-
-public class SlantHolder {
-    private final TreeMap<Double, PaletteHolder> layers;
-    private final double minSlope;
-    
-    private SlantHolder(TreeMap<Double, PaletteHolder> layers, double minSlope) {
-        this.layers = layers;
-        this.minSlope = minSlope;
-    }
-    
-    public static SlantHolder of(TreeMap<Double, PaletteHolder> layers, double minSlope) {
-        if(layers.size() == 1) {
-            Entry<Double, PaletteHolder> firstEntry = layers.firstEntry();
-            return new Single(firstEntry.getValue(), minSlope);
-        }
-        return new SlantHolder(layers, minSlope);
-    }
-    
-    public boolean isEmpty() {
-        return layers.isEmpty();
-    }
-    
-    public PaletteHolder getPalette(double slope) {
-        return layers.floorEntry(slope).getValue();
-    }
-    
-    public double getMinSlope() {
-        return minSlope;
-    }
-    
-    private static final class Single extends SlantHolder {
-        
-        private final PaletteHolder layers;
-        
-        public Single(PaletteHolder layers, double minSlope) {
-            super(of(minSlope, layers), minSlope);
-            this.layers = layers;
-        }
-        
-        private static TreeMap<Double, PaletteHolder> of(double v, PaletteHolder layer) {
-            TreeMap<Double, PaletteHolder> map = new TreeMap<>();
-            map.put(v, layer);
-            return map;
-        }
-        
-        @Override
-        public PaletteHolder getPalette(double slope) {
-            return layers;
-        }
-    }
-}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/MultipleSlantHolder.java

@@ -0,0 +1,47 @@
+/*
+ * 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.chunkgenerator.palette.slant;
+
+
+import java.util.List;
+import java.util.NavigableMap;
+import java.util.TreeMap;
+import java.util.stream.Collectors;
+import java.util.stream.Stream;
+
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
+
+
+public class MultipleSlantHolder extends SlantHolderImpl {
+    private final NavigableMap<Double, PaletteHolder> layers;
+    private final double slantThreshold;
+    
+    MultipleSlantHolder(List<SlantHolder.Layer> slant, int slantDepth, CalculationMethod calculationMethod) {
+        super(slantDepth, calculationMethod);
+        NavigableMap<Double, PaletteHolder> layers = new TreeMap<>(slant.stream().collect(Collectors.toMap(SlantHolder.Layer::threshold, SlantHolder.Layer::palette)));
+        Stream<Double> thresholds = layers.keySet().stream();
+        double slantThreshold = floorToThreshold ?
+                                thresholds.min(Double::compare).orElseThrow() :
+                                thresholds.max(Double::compare).orElseThrow();
+        this.layers = layers;
+        this.slantThreshold = slantThreshold;
+    }
+    
+    @Override
+    protected double getSlantThreshold() {
+        return slantThreshold;
+    }
+    
+    @Override
+    public PaletteHolder getPalette(double slant) {
+        return (floorToThreshold ?
+                layers.floorEntry(slant) :
+                layers.ceilingEntry(slant)
+        ).getValue();
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SingleSlantHolder.java

@@ -0,0 +1,24 @@
+package com.dfsek.terra.addons.chunkgenerator.palette.slant;
+
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
+
+
+final class SingleSlantHolder extends SlantHolderImpl {
+    
+    private final SlantHolder.Layer layer;
+    
+    public SingleSlantHolder(SlantHolder.Layer layer, int slantDepth, CalculationMethod calculationMethod) {
+        super(slantDepth, calculationMethod);
+        this.layer = layer;
+    }
+    
+    @Override
+    public PaletteHolder getPalette(double slant) {
+        return layer.palette();
+    }
+    
+    @Override
+    protected double getSlantThreshold() {
+        return layer.threshold();
+    }
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolder.java

@@ -0,0 +1,116 @@
+package com.dfsek.terra.addons.chunkgenerator.palette.slant;
+
+import java.util.List;
+
+import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D;
+import com.dfsek.terra.addons.chunkgenerator.palette.PaletteHolder;
+import com.dfsek.terra.api.util.vector.Vector3;
+
+
+public interface SlantHolder {
+    
+    static SlantHolder of(List<SlantHolder.Layer> layers, int slantDepth, CalculationMethod calculationMethod) {
+        if(layers.isEmpty()) {
+            return EMPTY;
+        } else if(layers.size() == 1) {
+            return new SingleSlantHolder(layers.get(0), slantDepth, calculationMethod);
+        }
+        return new MultipleSlantHolder(layers, slantDepth, calculationMethod);
+    }
+    
+    double calculateSlant(Sampler3D sampler, double x, double y, double z);
+    
+    boolean isAboveDepth(int depth);
+    
+    boolean isInSlantThreshold(double slant);
+    
+    PaletteHolder getPalette(double slant);
+    
+    record Layer(PaletteHolder palette, double threshold)  {
+    }
+    
+    enum CalculationMethod {
+        DotProduct {
+            private static final Vector3 DOT_PRODUCT_DIRECTION = Vector3.of(0, 1, 0);
+        
+            private static final Vector3[] DOT_PRODUCT_SAMPLE_POINTS = {
+                    Vector3.of(0, 0, -DERIVATIVE_DIST),
+                    Vector3.of(0, 0, DERIVATIVE_DIST),
+                    Vector3.of(0, -DERIVATIVE_DIST, 0),
+                    Vector3.of(0, DERIVATIVE_DIST, 0),
+                    Vector3.of(-DERIVATIVE_DIST, 0, 0),
+                    Vector3.of(DERIVATIVE_DIST, 0, 0)
+            };
+            
+            @Override
+            public double slant(Sampler3D sampler, double x, double y, double z) {
+                Vector3.Mutable normalApproximation = Vector3.Mutable.of(0, 0, 0);
+                for(Vector3 point : DOT_PRODUCT_SAMPLE_POINTS) {
+                    var scalar = -sampler.sample(x+point.getX(), y+point.getY(), z+point.getZ());
+                    normalApproximation.add(point.mutable().multiply(scalar));
+                }
+                return DOT_PRODUCT_DIRECTION.dot(normalApproximation.normalize());
+            }
+        
+            @Override
+            public boolean floorToThreshold() {
+                return false;
+            }
+        },
+        
+        Derivative {
+            @Override
+            public double slant(Sampler3D sampler, double x, double y, double z) {
+                double baseSample = sampler.sample(x, y, z);
+        
+                double xVal1 = (sampler.sample(x + DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST;
+                double xVal2 = (sampler.sample(x - DERIVATIVE_DIST, y, z) - baseSample) / DERIVATIVE_DIST;
+                double zVal1 = (sampler.sample(x, y, z + DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST;
+                double zVal2 = (sampler.sample(x, y, z - DERIVATIVE_DIST) - baseSample) / DERIVATIVE_DIST;
+                double yVal1 = (sampler.sample(x, y + DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST;
+                double yVal2 = (sampler.sample(x, y - DERIVATIVE_DIST, z) - baseSample) / DERIVATIVE_DIST;
+        
+                return Math.sqrt(((xVal2 - xVal1) * (xVal2 - xVal1)) + ((zVal2 - zVal1) * (zVal2 - zVal1)) + ((yVal2 - yVal1) * (yVal2 - yVal1)));
+            }
+        
+            @Override
+            public boolean floorToThreshold() {
+                return true;
+            }
+        };
+        
+        private static final double DERIVATIVE_DIST = 0.55;
+        
+        public abstract double slant(Sampler3D sampler, double x, double y, double z);
+        
+        /*
+         * Controls whether palettes should be applied before or after their respective thresholds.
+         *
+         * If true, slant values will map to the palette of the next floor threshold, otherwise they
+         * will map to the ceiling.
+         */
+        public abstract boolean floorToThreshold();
+    }
+    
+    SlantHolder EMPTY = new SlantHolder() {
+        @Override
+        public double calculateSlant(Sampler3D sampler, double x, double y, double z) {
+            throw new UnsupportedOperationException("Empty holder should not calculate slant");
+        }
+        
+        @Override
+        public boolean isAboveDepth(int depth) {
+            return false;
+        }
+        
+        @Override
+        public boolean isInSlantThreshold(double slant) {
+            return false;
+        }
+        
+        @Override
+        public PaletteHolder getPalette(double slant) {
+            throw new UnsupportedOperationException("Empty holder cannot return a palette");
+        }
+    };
+}

common/addons/chunk-generator-noise-3d/src/main/java/com/dfsek/terra/addons/chunkgenerator/palette/slant/SlantHolderImpl.java

@@ -0,0 +1,38 @@
+package com.dfsek.terra.addons.chunkgenerator.palette.slant;
+
+import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D;
+
+
+public abstract class SlantHolderImpl implements SlantHolder {
+    private final SlantHolder.CalculationMethod calculationMethod;
+    
+    private final int slantDepth;
+    
+    protected final boolean floorToThreshold;
+    
+    protected SlantHolderImpl(int slantDepth, CalculationMethod calculationMethod) {
+        this.floorToThreshold = calculationMethod.floorToThreshold();
+        this.calculationMethod = calculationMethod;
+        this.slantDepth = slantDepth;
+    }
+    
+    protected abstract double getSlantThreshold();
+    
+    @Override
+    public final double calculateSlant(Sampler3D sampler, double x, double y, double z) {
+        return calculationMethod.slant(sampler, x, y, z);
+    }
+    
+    @Override
+    public final boolean isAboveDepth(int depth) {
+        return depth <= slantDepth;
+    }
+    
+    @Override
+    public final boolean isInSlantThreshold(double slant) {
+        return (floorToThreshold ?
+                slant > getSlantThreshold() :
+                slant < getSlantThreshold()
+        );
+    }
+}

common/addons/config-noise-function/build.gradle.kts

@@ -1,6 +1,6 @@
 import com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar
 
-version = version("1.0.0")
+version = version("1.1.0")
 
 dependencies {
     compileOnlyApi(project(":common:addons:manifest-addon-loader"))

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/NoiseAddon.java

@@ -14,6 +14,7 @@ import java.util.Map;
 import java.util.function.Supplier;
 
 import com.dfsek.terra.addons.manifest.api.AddonInitializer;
+import com.dfsek.terra.addons.noise.config.CubicSplinePointTemplate;
 import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler;
 import com.dfsek.terra.addons.noise.config.templates.BinaryArithmeticTemplate;
 import com.dfsek.terra.addons.noise.config.templates.DomainWarpTemplate;
@@ -21,8 +22,10 @@ import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate;
 import com.dfsek.terra.addons.noise.config.templates.ImageSamplerTemplate;
 import com.dfsek.terra.addons.noise.config.templates.KernelTemplate;
 import com.dfsek.terra.addons.noise.config.templates.LinearHeightmapSamplerTemplate;
+import com.dfsek.terra.addons.noise.config.templates.TranslateSamplerTemplate;
 import com.dfsek.terra.addons.noise.config.templates.noise.CellularNoiseTemplate;
 import com.dfsek.terra.addons.noise.config.templates.noise.ConstantNoiseTemplate;
+import com.dfsek.terra.addons.noise.config.templates.noise.DistanceSamplerTemplate;
 import com.dfsek.terra.addons.noise.config.templates.noise.ExpressionFunctionTemplate;
 import com.dfsek.terra.addons.noise.config.templates.noise.GaborNoiseTemplate;
 import com.dfsek.terra.addons.noise.config.templates.noise.SimpleNoiseTemplate;
@@ -30,11 +33,14 @@ import com.dfsek.terra.addons.noise.config.templates.noise.fractal.BrownianMotio
 import com.dfsek.terra.addons.noise.config.templates.noise.fractal.PingPongTemplate;
 import com.dfsek.terra.addons.noise.config.templates.noise.fractal.RidgedFractalTemplate;
 import com.dfsek.terra.addons.noise.config.templates.normalizer.ClampNormalizerTemplate;
+import com.dfsek.terra.addons.noise.config.templates.normalizer.CubicSplineNormalizerTemplate;
+import com.dfsek.terra.addons.noise.config.templates.normalizer.ExpressionNormalizerTemplate;
 import com.dfsek.terra.addons.noise.config.templates.normalizer.LinearNormalizerTemplate;
 import com.dfsek.terra.addons.noise.config.templates.normalizer.NormalNormalizerTemplate;
 import com.dfsek.terra.addons.noise.config.templates.normalizer.PosterizationNormalizerTemplate;
 import com.dfsek.terra.addons.noise.config.templates.normalizer.ProbabilityNormalizerTemplate;
 import com.dfsek.terra.addons.noise.config.templates.normalizer.ScaleNormalizerTemplate;
+import com.dfsek.terra.addons.noise.math.CubicSpline;
 import com.dfsek.terra.addons.noise.samplers.arithmetic.AdditionSampler;
 import com.dfsek.terra.addons.noise.samplers.arithmetic.DivisionSampler;
 import com.dfsek.terra.addons.noise.samplers.arithmetic.MaxSampler;
@@ -42,6 +48,7 @@ import com.dfsek.terra.addons.noise.samplers.arithmetic.MinSampler;
 import com.dfsek.terra.addons.noise.samplers.arithmetic.MultiplicationSampler;
 import com.dfsek.terra.addons.noise.samplers.arithmetic.SubtractionSampler;
 import com.dfsek.terra.addons.noise.samplers.noise.CellularSampler;
+import com.dfsek.terra.addons.noise.samplers.noise.DistanceSampler;
 import com.dfsek.terra.addons.noise.samplers.noise.random.GaussianNoiseSampler;
 import com.dfsek.terra.addons.noise.samplers.noise.random.PositiveWhiteNoiseSampler;
 import com.dfsek.terra.addons.noise.samplers.noise.random.WhiteNoiseSampler;
@@ -83,8 +90,11 @@ public class NoiseAddon implements AddonInitializer {
                                     (type, o, loader, depthTracker) -> CellularSampler.DistanceFunction.valueOf((String) o))
                        .applyLoader(CellularSampler.ReturnType.class,
                                     (type, o, loader, depthTracker) -> CellularSampler.ReturnType.valueOf((String) o))
+                       .applyLoader(DistanceSampler.DistanceFunction.class,
+                                    (type, o, loader, depthTracker) -> DistanceSampler.DistanceFunction.valueOf((String) o))
                        .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new)
-                       .applyLoader(FunctionTemplate.class, FunctionTemplate::new);
+                       .applyLoader(FunctionTemplate.class, FunctionTemplate::new)
+                       .applyLoader(CubicSpline.Point.class, CubicSplinePointTemplate::new);
             
                   noiseRegistry.register(addon.key("LINEAR"), LinearNormalizerTemplate::new);
                   noiseRegistry.register(addon.key("NORMAL"), NormalNormalizerTemplate::new);
@@ -92,9 +102,10 @@ public class NoiseAddon implements AddonInitializer {
                   noiseRegistry.register(addon.key("PROBABILITY"), ProbabilityNormalizerTemplate::new);
                   noiseRegistry.register(addon.key("SCALE"), ScaleNormalizerTemplate::new);
                   noiseRegistry.register(addon.key("POSTERIZATION"), PosterizationNormalizerTemplate::new);
-            
+                  noiseRegistry.register(addon.key("CUBIC_SPLINE"), CubicSplineNormalizerTemplate::new);
+    
                   noiseRegistry.register(addon.key("IMAGE"), ImageSamplerTemplate::new);
-            
+    
                   noiseRegistry.register(addon.key("DOMAIN_WARP"), DomainWarpTemplate::new);
             
                   noiseRegistry.register(addon.key("FBM"), BrownianMotionTemplate::new);
@@ -116,12 +127,15 @@ public class NoiseAddon implements AddonInitializer {
                   noiseRegistry.register(addon.key("WHITE_NOISE"), () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new));
                   noiseRegistry.register(addon.key("POSITIVE_WHITE_NOISE"), () -> new SimpleNoiseTemplate(PositiveWhiteNoiseSampler::new));
                   noiseRegistry.register(addon.key("GAUSSIAN"), () -> new SimpleNoiseTemplate(GaussianNoiseSampler::new));
+                  
+                  noiseRegistry.register(addon.key("DISTANCE"), DistanceSamplerTemplate::new);
             
                   noiseRegistry.register(addon.key("CONSTANT"), ConstantNoiseTemplate::new);
             
                   noiseRegistry.register(addon.key("KERNEL"), KernelTemplate::new);
             
                   noiseRegistry.register(addon.key("LINEAR_HEIGHTMAP"), LinearHeightmapSamplerTemplate::new);
+                  noiseRegistry.register(addon.key("TRANSLATE"), TranslateSamplerTemplate::new);
             
                   noiseRegistry.register(addon.key("ADD"), () -> new BinaryArithmeticTemplate<>(AdditionSampler::new));
                   noiseRegistry.register(addon.key("SUB"), () -> new BinaryArithmeticTemplate<>(SubtractionSampler::new));
@@ -134,7 +148,7 @@ public class NoiseAddon implements AddonInitializer {
                   Map<String, DimensionApplicableNoiseSampler> packSamplers = new LinkedHashMap<>();
                   Map<String, FunctionTemplate> packFunctions = new LinkedHashMap<>();
                   noiseRegistry.register(addon.key("EXPRESSION"), () -> new ExpressionFunctionTemplate(packSamplers, packFunctions));
-            
+                  noiseRegistry.register(addon.key("EXPRESSION_NORMALIZER"), () -> new ExpressionNormalizerTemplate(packSamplers, packFunctions));
             
                   NoiseConfigPackTemplate template = event.loadTemplate(new NoiseConfigPackTemplate());
                   packSamplers.putAll(template.getSamplers());

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/CubicSplinePointTemplate.java

@@ -0,0 +1,25 @@
+package com.dfsek.terra.addons.noise.config;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
+
+import com.dfsek.terra.addons.noise.math.CubicSpline.Point;
+import com.dfsek.terra.api.config.meta.Meta;
+
+
+public class CubicSplinePointTemplate implements ObjectTemplate<Point> {
+    
+    @Value("from")
+    private @Meta double from;
+    
+    @Value("to")
+    private @Meta double to;
+    
+    @Value("gradient")
+    private @Meta double gradient;
+    
+    @Override
+    public Point get() {
+        return new Point(from, to, gradient);
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/ImageSamplerTemplate.java

@@ -8,6 +8,8 @@
 package com.dfsek.terra.addons.noise.config.templates;
 
 import com.dfsek.tectonic.api.config.template.annotations.Value;
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
 
 import java.awt.image.BufferedImage;
 
@@ -19,6 +21,10 @@ import com.dfsek.terra.api.noise.NoiseSampler;
 @SuppressWarnings({ "unused", "FieldMayBeFinal" })
 public class ImageSamplerTemplate extends SamplerTemplate<ImageSampler> {
     
+    private static final Logger logger = LoggerFactory.getLogger(ImageSamplerTemplate.class);
+    
+    private static boolean used = false;
+    
     @Value("image")
     private @Meta BufferedImage image;
     
@@ -30,6 +36,12 @@ public class ImageSamplerTemplate extends SamplerTemplate<ImageSampler> {
     
     @Override
     public NoiseSampler get() {
+        if(!used) {
+            logger.warn("The IMAGE NoiseSampler implemented by the config-noise-function addon is deprecated. " +
+                        "It is recommended to use the IMAGE NoiseSampler implemented by the config-noise-image " +
+                        "addon instead.");
+            used = true;
+        }
         return new ImageSampler(image, channel, frequency);
     }
 }

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/LinearHeightmapSamplerTemplate.java

@@ -4,6 +4,7 @@ import com.dfsek.tectonic.api.config.template.annotations.Default;
 import com.dfsek.tectonic.api.config.template.annotations.Value;
 
 import com.dfsek.terra.addons.noise.samplers.LinearHeightmapSampler;
+import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
 
@@ -11,14 +12,14 @@ import com.dfsek.terra.api.noise.NoiseSampler;
 public class LinearHeightmapSamplerTemplate extends SamplerTemplate<LinearHeightmapSampler> {
     @Value("sampler")
     @Default
-    private NoiseSampler sampler = NoiseSampler.zero();
+    private @Meta NoiseSampler sampler = NoiseSampler.zero();
     
     @Value("base")
-    private double base;
+    private @Meta double base;
     
     @Value("scale")
     @Default
-    private double scale = 1;
+    private @Meta double scale = 1;
     
     @Override
     public NoiseSampler get() {

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/TranslateSamplerTemplate.java

@@ -0,0 +1,32 @@
+package com.dfsek.terra.addons.noise.config.templates;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.noise.samplers.TranslateSampler;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
+public class TranslateSamplerTemplate extends SamplerTemplate<TranslateSampler> {
+    
+    @Value("sampler")
+    private NoiseSampler sampler;
+    
+    @Value("x")
+    @Default
+    private @Meta double x = 0;
+    
+    @Value("y")
+    @Default
+    private @Meta double y = 0;
+    
+    @Value("z")
+    @Default
+    private @Meta double z = 0;
+    
+    @Override
+    public NoiseSampler get() {
+        return new TranslateSampler(sampler, x, y ,z);
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/DistanceSamplerTemplate.java

@@ -0,0 +1,42 @@
+package com.dfsek.terra.addons.noise.config.templates.noise;
+
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.noise.config.templates.SamplerTemplate;
+import com.dfsek.terra.addons.noise.samplers.noise.DistanceSampler;
+import com.dfsek.terra.addons.noise.samplers.noise.DistanceSampler.DistanceFunction;
+import com.dfsek.terra.api.config.meta.Meta;
+
+
+public class DistanceSamplerTemplate extends SamplerTemplate<DistanceSampler> {
+    
+    @Value("distance-function")
+    @Default
+    private DistanceSampler.@Meta DistanceFunction distanceFunction = DistanceFunction.Euclidean;
+    
+    @Value("point.x")
+    @Default
+    private @Meta double x = 0;
+    
+    @Value("point.y")
+    @Default
+    private @Meta double y = 0;
+    
+    @Value("point.z")
+    @Default
+    private @Meta double z = 0;
+    
+    @Value("normalize")
+    @Default
+    private @Meta boolean normalize = false;
+    
+    @Value("radius")
+    @Default
+    private @Meta double normalizeRadius = 100;
+    
+    @Override
+    public DistanceSampler get() {
+        return new DistanceSampler(distanceFunction, x, y, z, normalize, normalizeRadius);
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/noise/ExpressionFunctionTemplate.java

@@ -8,7 +8,6 @@
 package com.dfsek.terra.addons.noise.config.templates.noise;
 
 import com.dfsek.paralithic.eval.tokenizer.ParseException;
-import com.dfsek.paralithic.functions.Function;
 import com.dfsek.tectonic.api.config.template.annotations.Default;
 import com.dfsek.tectonic.api.config.template.annotations.Value;
 
@@ -19,17 +18,16 @@ import java.util.Map;
 import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler;
 import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate;
 import com.dfsek.terra.addons.noise.config.templates.SamplerTemplate;
-import com.dfsek.terra.addons.noise.paralithic.defined.UserDefinedFunction;
-import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction2;
-import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3;
 import com.dfsek.terra.addons.noise.samplers.noise.ExpressionFunction;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+import static com.dfsek.terra.addons.noise.paralithic.FunctionUtil.convertFunctionsAndSamplers;
+
 
 @SuppressWarnings({ "FieldMayBeFinal", "unused" })
 public class ExpressionFunctionTemplate extends SamplerTemplate<ExpressionFunction> {
-    private final Map<String, DimensionApplicableNoiseSampler> otherFunctions;
+    private final Map<String, DimensionApplicableNoiseSampler> globalSamplers;
     private final Map<String, FunctionTemplate> globalFunctions;
     @Value("variables")
     @Default
@@ -43,44 +41,19 @@ public class ExpressionFunctionTemplate extends SamplerTemplate<ExpressionFuncti
     @Default
     private @Meta LinkedHashMap<String, @Meta FunctionTemplate> functions = new LinkedHashMap<>();
     
-    public ExpressionFunctionTemplate(Map<String, DimensionApplicableNoiseSampler> otherFunctions, Map<String, FunctionTemplate> samplers) {
-        this.otherFunctions = otherFunctions;
-        this.globalFunctions = samplers;
+    public ExpressionFunctionTemplate(Map<String, DimensionApplicableNoiseSampler> globalSamplers, Map<String, FunctionTemplate> globalFunctions) {
+        this.globalSamplers = globalSamplers;
+        this.globalFunctions = globalFunctions;
     }
     
     @Override
     public NoiseSampler get() {
+        var mergedFunctions = new HashMap<>(globalFunctions); mergedFunctions.putAll(functions);
+        var mergedSamplers = new HashMap<>(globalSamplers); mergedSamplers.putAll(samplers);
         try {
-            Map<String, Function> noiseFunctionMap = generateFunctions();
-            return new ExpressionFunction(noiseFunctionMap, expression, vars);
+            return new ExpressionFunction(convertFunctionsAndSamplers(mergedFunctions, mergedSamplers), expression, vars);
         } catch(ParseException e) {
             throw new RuntimeException("Failed to parse expression.", e);
         }
     }
-    
-    private Map<String, Function> generateFunctions() throws ParseException {
-        Map<String, Function> noiseFunctionMap = new HashMap<>();
-        
-        for(Map.Entry<String, FunctionTemplate> entry : globalFunctions.entrySet()) {
-            noiseFunctionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue()));
-        }
-        
-        for(Map.Entry<String, FunctionTemplate> entry : functions.entrySet()) {
-            noiseFunctionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue()));
-        }
-        
-        otherFunctions.forEach((id, function) -> {
-            if(function.getDimensions() == 2) {
-                noiseFunctionMap.put(id, new NoiseFunction2(function.getSampler()));
-            } else noiseFunctionMap.put(id, new NoiseFunction3(function.getSampler()));
-        });
-        
-        samplers.forEach((id, function) -> {
-            if(function.getDimensions() == 2) {
-                noiseFunctionMap.put(id, new NoiseFunction2(function.getSampler()));
-            } else noiseFunctionMap.put(id, new NoiseFunction3(function.getSampler()));
-        });
-        
-        return noiseFunctionMap;
-    }
 }

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/CubicSplineNormalizerTemplate.java

@@ -0,0 +1,23 @@
+package com.dfsek.terra.addons.noise.config.templates.normalizer;
+
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.noise.math.CubicSpline;
+import com.dfsek.terra.addons.noise.math.CubicSpline.Point;
+import com.dfsek.terra.addons.noise.normalizer.CubicSplineNoiseSampler;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+import java.util.List;
+
+
+public class CubicSplineNormalizerTemplate extends NormalizerTemplate<CubicSplineNoiseSampler> {
+    
+    @Value("points")
+    private @Meta List<@Meta Point> points;
+    
+    @Override
+    public NoiseSampler get() {
+        return new CubicSplineNoiseSampler(function, new CubicSpline(points));
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/config/templates/normalizer/ExpressionNormalizerTemplate.java

@@ -0,0 +1,63 @@
+/*
+ * 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.noise.config.templates.normalizer;
+
+import com.dfsek.paralithic.eval.tokenizer.ParseException;
+import com.dfsek.tectonic.api.config.template.annotations.Default;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler;
+import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate;
+import com.dfsek.terra.addons.noise.normalizer.ExpressionNormalizer;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+import java.util.HashMap;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import static com.dfsek.terra.addons.noise.paralithic.FunctionUtil.convertFunctionsAndSamplers;
+
+
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
+public class ExpressionNormalizerTemplate extends NormalizerTemplate<ExpressionNormalizer> {
+    
+    private final Map<String, DimensionApplicableNoiseSampler> globalSamplers;
+    private final Map<String, FunctionTemplate> globalFunctions;
+    
+    @Value("expression")
+    private @Meta String expression;
+    
+    @Value("variables")
+    @Default
+    private @Meta Map<String, @Meta Double> vars = new HashMap<>();
+    
+    @Value("samplers")
+    @Default
+    private @Meta LinkedHashMap<String, @Meta DimensionApplicableNoiseSampler> samplers = new LinkedHashMap<>();
+    
+    @Value("functions")
+    @Default
+    private @Meta LinkedHashMap<String, @Meta FunctionTemplate> functions = new LinkedHashMap<>();
+    
+    public ExpressionNormalizerTemplate(Map<String, DimensionApplicableNoiseSampler> globalSamplers, Map<String, FunctionTemplate> globalFunctions) {
+        this.globalSamplers = globalSamplers;
+        this.globalFunctions = globalFunctions;
+    }
+    
+    @Override
+    public NoiseSampler get() {
+        var mergedFunctions = new HashMap<>(globalFunctions); mergedFunctions.putAll(functions);
+        var mergedSamplers = new HashMap<>(globalSamplers); mergedSamplers.putAll(samplers);
+        try {
+            return new ExpressionNormalizer(function, convertFunctionsAndSamplers(mergedFunctions, mergedSamplers), expression, vars);
+        } catch(ParseException e) {
+            throw new RuntimeException("Failed to parse expression.", e);
+        }
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/math/CubicSpline.java

@@ -0,0 +1,89 @@
+package com.dfsek.terra.addons.noise.math;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+
+public class CubicSpline {
+    
+    private final double[] fromValues;
+    private final double[] toValues;
+    private final double[] gradients;
+    
+    public CubicSpline(List<Point> points) {
+        Collections.sort(points);
+        
+        this.fromValues = new double[points.size()];
+        this.toValues = new double[points.size()];
+        this.gradients = new double[points.size()];
+        
+        for(int i = 0; i < points.size(); i++) {
+            fromValues[i] = points.get(i).from;
+            toValues[i] = points.get(i).to;
+            gradients[i] = points.get(i).gradient;
+        }
+    }
+    
+    public double apply(double in) {
+        return calculate(in, fromValues, toValues, gradients);
+    }
+    
+    public static double calculate(double in, double[] fromValues, double[] toValues, double[] gradients) {
+        int pointIdx = floorBinarySearch(in, fromValues) - 1;
+        
+        int pointIdxLast = fromValues.length - 1;
+        
+        if (pointIdx < 0) { // If to left of first point return linear function intersecting said point using point's gradient
+            return gradients[0] * (in - fromValues[0]) + toValues[0];
+        } else if (pointIdx == pointIdxLast) { // Do same if to right of last point
+            return gradients[pointIdxLast] * (in - fromValues[pointIdxLast]) + toValues[pointIdxLast];
+        } else {
+            double fromLeft = fromValues[pointIdx];
+            double fromRight = fromValues[pointIdx + 1];
+            
+            double toLeft = toValues[pointIdx];
+            double toRight = toValues[pointIdx + 1];
+            
+            double gradientLeft =  gradients[pointIdx];
+            double gradientRight = gradients[pointIdx + 1];
+            
+            double fromDelta = fromRight - fromLeft;
+            double toDelta = toRight - toLeft;
+            
+            double t = (in - fromLeft) / fromDelta;
+            
+            return lerp(t, toLeft, toRight) + t * (1.0F - t) * lerp(t, gradientLeft * fromDelta - toDelta, -gradientRight * fromDelta + toDelta);
+        }
+    }
+    
+    private static int floorBinarySearch(double targetValue, double[] values) {
+        int left = 0;
+        int right = values.length;
+        int idx = right - left;
+        while (idx > 0) {
+            int halfDelta = idx / 2;
+            int mid = left + halfDelta;
+            if (targetValue < values[mid]) {
+                idx = halfDelta;
+            } else {
+                left = mid + 1;
+                idx -= halfDelta + 1;
+            }
+        }
+        return left;
+    }
+    
+    private static double lerp(double t, double a, double b) {
+        return a + t * (b - a);
+    }
+    
+    public record Point(double from, double to, double gradient) implements Comparable<Point> {
+        
+        @Override
+        public int compareTo(@NotNull CubicSpline.Point o) {
+            return Double.compare(from, o.from);
+        }
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/CubicSplineNoiseSampler.java

@@ -0,0 +1,20 @@
+package com.dfsek.terra.addons.noise.normalizer;
+
+import com.dfsek.terra.addons.noise.math.CubicSpline;
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
+public class CubicSplineNoiseSampler extends Normalizer {
+    
+    private final CubicSpline spline;
+    
+    public CubicSplineNoiseSampler(NoiseSampler sampler, CubicSpline spline) {
+        super(sampler);
+        this.spline = spline;
+    }
+    
+    @Override
+    public double normalize(double in) {
+        return spline.apply(in);
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/normalizer/ExpressionNormalizer.java

@@ -0,0 +1,33 @@
+package com.dfsek.terra.addons.noise.normalizer;
+
+import com.dfsek.paralithic.Expression;
+import com.dfsek.paralithic.eval.parser.Parser;
+import com.dfsek.paralithic.eval.parser.Scope;
+import com.dfsek.paralithic.eval.tokenizer.ParseException;
+import com.dfsek.paralithic.functions.Function;
+
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+import java.util.Map;
+
+
+public class ExpressionNormalizer extends Normalizer {
+    
+    private final Expression expression;
+    
+    public ExpressionNormalizer(NoiseSampler sampler, Map<String, Function> functions, String eq, Map<String, Double> vars)
+    throws ParseException {
+        super(sampler);
+        Parser p = new Parser();
+        Scope scope = new Scope();
+        scope.addInvocationVariable("in");
+        vars.forEach(scope::create);
+        functions.forEach(p::registerFunction);
+        expression = p.parse(eq, scope);
+    }
+    
+    @Override
+    public double normalize(double in) {
+        return expression.evaluate(in);
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/paralithic/FunctionUtil.java

@@ -0,0 +1,31 @@
+package com.dfsek.terra.addons.noise.paralithic;
+
+import com.dfsek.paralithic.eval.tokenizer.ParseException;
+import com.dfsek.paralithic.functions.Function;
+
+import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler;
+import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate;
+import com.dfsek.terra.addons.noise.paralithic.defined.UserDefinedFunction;
+import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction2;
+import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3;
+
+import java.util.HashMap;
+import java.util.Map;
+
+
+public class FunctionUtil {
+    private FunctionUtil() {}
+    
+    public static Map<String, Function> convertFunctionsAndSamplers(Map<String, FunctionTemplate> functions,
+                                                                    Map<String, DimensionApplicableNoiseSampler> samplers) throws ParseException {
+        Map<String, Function> functionMap = new HashMap<>();
+        for(Map.Entry<String, FunctionTemplate> entry : functions.entrySet()) {
+            functionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue()));
+        }
+        samplers.forEach((id, sampler) -> functionMap.put(id,
+                                                          sampler.getDimensions() == 2 ?
+                                                          new NoiseFunction2(sampler.getSampler()) :
+                                                          new NoiseFunction3(sampler.getSampler())));
+        return functionMap;
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/TranslateSampler.java

@@ -0,0 +1,27 @@
+package com.dfsek.terra.addons.noise.samplers;
+
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
+public class TranslateSampler implements NoiseSampler {
+    
+    private final NoiseSampler sampler;
+    private final double dx, dy, dz;
+    
+    public TranslateSampler(NoiseSampler sampler, double dx, double dy, double dz) {
+        this.sampler = sampler;
+        this.dx = dx;
+        this.dy = dy;
+        this.dz = dz;
+    }
+    
+    @Override
+    public double noise(long seed, double x, double y) {
+        return sampler.noise(seed, x - dx, y - dz);
+    }
+    
+    @Override
+    public double noise(long seed, double x, double y, double z) {
+        return sampler.noise(seed, x - dx, y - dy, z - dz);
+    }
+}

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/CellularSampler.java

@@ -240,99 +240,37 @@ public class CellularSampler extends NoiseFunction {
         double centerX = x;
         double centerY = y;
         
-        switch(distanceFunction) {
-            default:
-            case Euclidean:
-            case EuclideanSq:
-                for(int xi = xr - 1; xi <= xr + 1; xi++) {
-                    int yPrimed = yPrimedBase;
-                    
-                    for(int yi = yr - 1; yi <= yr + 1; yi++) {
-                        int hash = hash(seed, xPrimed, yPrimed);
-                        int idx = hash & (255 << 1);
-                        
-                        double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter;
-                        double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
-                        
-                        double newDistance = vecX * vecX + vecY * vecY;
-                        
-                        distance1 = fastMax(fastMin(distance1, newDistance), distance0);
-                        if(newDistance < distance0) {
-                            distance0 = newDistance;
-                            closestHash = hash;
-                            centerX = ((xi + RAND_VECS_2D[idx] * cellularJitter) / frequency);
-                            centerY = ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / frequency);
-                        } else if(newDistance < distance1) {
-                            distance2 = distance1;
-                            distance1 = newDistance;
-                        } else if(newDistance < distance2) {
-                            distance2 = newDistance;
-                        }
-                        yPrimed += PRIME_Y;
-                    }
-                    xPrimed += PRIME_X;
+        for(int xi = xr - 1; xi <= xr + 1; xi++) {
+            int yPrimed = yPrimedBase;
+            
+            for(int yi = yr - 1; yi <= yr + 1; yi++) {
+                int hash = hash(seed, xPrimed, yPrimed);
+                int idx = hash & (255 << 1);
+                
+                double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter;
+                double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
+                
+                double newDistance = switch(distanceFunction) {
+                    case Manhattan -> fastAbs(vecX) + fastAbs(vecY);
+                    case Hybrid -> (fastAbs(vecX) + fastAbs(vecY)) + (vecX * vecX + vecY * vecY);
+                    default -> vecX * vecX + vecY * vecY;
+                };
+                
+                distance1 = fastMax(fastMin(distance1, newDistance), distance0);
+                if(newDistance < distance0) {
+                    distance0 = newDistance;
+                    closestHash = hash;
+                    centerX = ((xi + RAND_VECS_2D[idx] * cellularJitter) / frequency);
+                    centerY = ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / frequency);
+                } else if(newDistance < distance1) {
+                    distance2 = distance1;
+                    distance1 = newDistance;
+                } else if(newDistance < distance2) {
+                    distance2 = newDistance;
                 }
-                break;
-            case Manhattan:
-                for(int xi = xr - 1; xi <= xr + 1; xi++) {
-                    int yPrimed = yPrimedBase;
-                    
-                    for(int yi = yr - 1; yi <= yr + 1; yi++) {
-                        int hash = hash(seed, xPrimed, yPrimed);
-                        int idx = hash & (255 << 1);
-                        
-                        double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter;
-                        double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
-                        
-                        double newDistance = fastAbs(vecX) + fastAbs(vecY);
-                        
-                        distance1 = fastMax(fastMin(distance1, newDistance), distance0);
-                        if(newDistance < distance0) {
-                            distance0 = newDistance;
-                            closestHash = hash;
-                            centerX = ((xi + RAND_VECS_2D[idx] * cellularJitter) / frequency);
-                            centerY = ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / frequency);
-                        } else if(newDistance < distance1) {
-                            distance2 = distance1;
-                            distance1 = newDistance;
-                        } else if(newDistance < distance2) {
-                            distance2 = newDistance;
-                        }
-                        yPrimed += PRIME_Y;
-                    }
-                    xPrimed += PRIME_X;
-                }
-                break;
-            case Hybrid:
-                for(int xi = xr - 1; xi <= xr + 1; xi++) {
-                    int yPrimed = yPrimedBase;
-                    
-                    for(int yi = yr - 1; yi <= yr + 1; yi++) {
-                        int hash = hash(seed, xPrimed, yPrimed);
-                        int idx = hash & (255 << 1);
-                        
-                        double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter;
-                        double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
-                        
-                        double newDistance = (fastAbs(vecX) + fastAbs(vecY)) + (vecX * vecX + vecY * vecY);
-                        
-                        distance1 = fastMax(fastMin(distance1, newDistance), distance0);
-                        if(newDistance < distance0) {
-                            distance0 = newDistance;
-                            closestHash = hash;
-                            centerX = ((xi + RAND_VECS_2D[idx] * cellularJitter) / frequency);
-                            centerY = ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / frequency);
-                        } else if(newDistance < distance1) {
-                            distance2 = distance1;
-                            distance1 = newDistance;
-                        } else if(newDistance < distance2) {
-                            distance2 = newDistance;
-                        }
-                        yPrimed += PRIME_Y;
-                    }
-                    xPrimed += PRIME_X;
-                }
-                break;
+                yPrimed += PRIME_Y;
+            }
+            xPrimed += PRIME_X;
         }
         
         if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) {
@@ -351,6 +289,7 @@ public class CellularSampler extends NoiseFunction {
             case Distance2Mul -> distance1 * distance0 * 0.5 - 1;
             case Distance2Div -> distance0 / distance1 - 1;
             case NoiseLookup -> noiseLookup.noise(sl, centerX, centerY);
+            case LocalNoiseLookup -> noiseLookup.noise(sl, x / frequency - centerX, y / frequency - centerY);
             case Distance3 -> distance2 - 1;
             case Distance3Add -> (distance2 + distance0) * 0.5 - 1;
             case Distance3Sub -> distance2 - distance0 - 1;
@@ -382,120 +321,47 @@ public class CellularSampler extends NoiseFunction {
         double centerY = y;
         double centerZ = z;
         
-        switch(distanceFunction) {
-            case Euclidean:
-            case EuclideanSq:
-                for(int xi = xr - 1; xi <= xr + 1; xi++) {
-                    int yPrimed = yPrimedBase;
+        for(int xi = xr - 1; xi <= xr + 1; xi++) {
+            int yPrimed = yPrimedBase;
+            
+            for(int yi = yr - 1; yi <= yr + 1; yi++) {
+                int zPrimed = zPrimedBase;
+                
+                for(int zi = zr - 1; zi <= zr + 1; zi++) {
+                    int hash = hash(seed, xPrimed, yPrimed, zPrimed);
+                    int idx = hash & (255 << 2);
                     
-                    for(int yi = yr - 1; yi <= yr + 1; yi++) {
-                        int zPrimed = zPrimedBase;
-                        
-                        for(int zi = zr - 1; zi <= zr + 1; zi++) {
-                            int hash = hash(seed, xPrimed, yPrimed, zPrimed);
-                            int idx = hash & (255 << 2);
-                            
-                            double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter;
-                            double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
-                            double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
-                            
-                            double newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ;
-                            
-                            if(newDistance < distance0) {
-                                distance0 = newDistance;
-                                closestHash = hash;
-                                centerX = ((xi + RAND_VECS_3D[idx] * cellularJitter) / frequency);
-                                centerY = ((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / frequency);
-                                centerZ = ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / frequency);
-                            } else if(newDistance < distance1) {
-                                distance2 = distance1;
-                                distance1 = newDistance;
-                            } else if(newDistance < distance2) {
-                                distance2 = newDistance;
-                            }
-                            zPrimed += PRIME_Z;
-                        }
-                        yPrimed += PRIME_Y;
-                    }
-                    xPrimed += PRIME_X;
-                }
-                break;
-            case Manhattan:
-                for(int xi = xr - 1; xi <= xr + 1; xi++) {
-                    int yPrimed = yPrimedBase;
+                    double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter;
+                    double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
+                    double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
                     
-                    for(int yi = yr - 1; yi <= yr + 1; yi++) {
-                        int zPrimed = zPrimedBase;
-                        
-                        for(int zi = zr - 1; zi <= zr + 1; zi++) {
-                            int hash = hash(seed, xPrimed, yPrimed, zPrimed);
-                            int idx = hash & (255 << 2);
-                            
-                            double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter;
-                            double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
-                            double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
-                            
-                            double newDistance = fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ);
-                            
-                            if(newDistance < distance0) {
-                                distance0 = newDistance;
-                                closestHash = hash;
-                                centerX = ((xi + RAND_VECS_3D[idx] * cellularJitter) / frequency);
-                                centerY = ((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / frequency);
-                                centerZ = ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / frequency);
-                            } else if(newDistance < distance1) {
-                                distance2 = distance1;
-                                distance1 = newDistance;
-                            } else if(newDistance < distance2) {
-                                distance2 = newDistance;
-                            }
-                            zPrimed += PRIME_Z;
-                        }
-                        yPrimed += PRIME_Y;
-                    }
-                    xPrimed += PRIME_X;
-                }
-                break;
-            case Hybrid:
-                for(int xi = xr - 1; xi <= xr + 1; xi++) {
-                    int yPrimed = yPrimedBase;
-                    
-                    for(int yi = yr - 1; yi <= yr + 1; yi++) {
-                        int zPrimed = zPrimedBase;
-                        
-                        for(int zi = zr - 1; zi <= zr + 1; zi++) {
-                            int hash = hash(seed, xPrimed, yPrimed, zPrimed);
-                            int idx = hash & (255 << 2);
-                            
-                            double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter;
-                            double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
-                            double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
-                            
-                            double newDistance = (fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ)) +
-                                                 (vecX * vecX + vecY * vecY + vecZ * vecZ);
-                            
+                    double newDistance = 0;
+                    switch(distanceFunction) {
+                        case Euclidean, EuclideanSq -> newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ;
+                        case Manhattan -> newDistance = fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ);
+                        case Hybrid -> {
+                            newDistance = (fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ);
                             distance1 = fastMax(fastMin(distance1, newDistance), distance0);
-                            if(newDistance < distance0) {
-                                distance0 = newDistance;
-                                closestHash = hash;
-                                centerX = ((xi + RAND_VECS_3D[idx] * cellularJitter) / frequency);
-                                centerY = ((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / frequency);
-                                centerZ = ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / frequency);
-                            } else if(newDistance < distance1) {
-                                distance2 = distance1;
-                                distance1 = newDistance;
-                            } else if(newDistance < distance2) {
-                                distance2 = newDistance;
-                            }
-                            zPrimed += PRIME_Z;
                         }
-                        yPrimed += PRIME_Y;
                     }
-                    xPrimed += PRIME_X;
+                    
+                    if(newDistance < distance0) {
+                        distance0 = newDistance;
+                        closestHash = hash;
+                        centerX = ((xi + RAND_VECS_3D[idx] * cellularJitter) / frequency);
+                        centerY = ((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / frequency);
+                        centerZ = ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / frequency);
+                    } else if(newDistance < distance1) {
+                        distance2 = distance1;
+                        distance1 = newDistance;
+                    } else if(newDistance < distance2) {
+                        distance2 = newDistance;
+                    }
+                    zPrimed += PRIME_Z;
                 }
-                break;
-            default:
-                break;
+                yPrimed += PRIME_Y;
+            }
+            xPrimed += PRIME_X;
         }
         
         if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) {
@@ -514,6 +380,7 @@ public class CellularSampler extends NoiseFunction {
             case Distance2Mul -> distance1 * distance0 * 0.5 - 1;
             case Distance2Div -> distance0 / distance1 - 1;
             case NoiseLookup -> noiseLookup.noise(sl, centerX, centerY, centerZ);
+            case LocalNoiseLookup -> noiseLookup.noise(sl, x / frequency - centerX, y / frequency - centerY, z / frequency - centerZ);
             case Distance3 -> distance2 - 1;
             case Distance3Add -> (distance2 + distance0) * 0.5 - 1;
             case Distance3Sub -> distance2 - distance0 - 1;
@@ -540,6 +407,7 @@ public class CellularSampler extends NoiseFunction {
         Distance2Mul,
         Distance2Div,
         NoiseLookup,
+        LocalNoiseLookup,
         Distance3,
         Distance3Add,
         Distance3Sub,

common/addons/config-noise-function/src/main/java/com/dfsek/terra/addons/noise/samplers/noise/DistanceSampler.java

@@ -0,0 +1,66 @@
+package com.dfsek.terra.addons.noise.samplers.noise;
+
+
+public class DistanceSampler extends NoiseFunction {
+    
+    private final DistanceFunction distanceFunction;
+    private final double ox, oy, oz;
+    private final boolean normalize;
+    private final double radius;
+    
+    private final double distanceAtRadius;
+    
+    public DistanceSampler(DistanceFunction distanceFunction, double ox, double oy, double oz, boolean normalize, double radius) {
+        frequency = 1;
+        this.distanceFunction = distanceFunction;
+        this.ox = ox;
+        this.oy = oy;
+        this.oz = oz;
+        this.normalize = normalize;
+        this.radius = radius;
+        this.distanceAtRadius = distance2d(distanceFunction, radius, 0); // distance2d and distance3d should return the same value
+    }
+   
+    @Override
+    public double getNoiseRaw(long seed, double x, double y) {
+        double dx = x - ox;
+        double dy = y - oz;
+        if (normalize && (fastAbs(dx) > radius || fastAbs(dy) > radius)) return 1;
+        double dist = distance2d(distanceFunction, dx, dy);
+        if (normalize) return fastMin(((2*dist)/distanceAtRadius)-1, 1);
+        return dist;
+    }
+    
+    @Override
+    public double getNoiseRaw(long seed, double x, double y, double z) {
+        double dx = x - ox;
+        double dy = y - oy;
+        double dz = z - oz;
+        if(normalize && (fastAbs(dx) > radius || fastAbs(dy) > radius || fastAbs(dz) > radius)) return 1;
+        double dist = distance3d(distanceFunction, dx, dy, dz);
+        if (normalize) return fastMin(((2*dist)/distanceAtRadius)-1, 1);
+        return dist;
+    }
+    
+    private static double distance2d(DistanceFunction distanceFunction, double x, double z) {
+        return switch(distanceFunction) {
+            case Euclidean -> fastSqrt(x*x + z*z);
+            case EuclideanSq -> x*x + z*z;
+            case Manhattan -> fastAbs(x) + fastAbs(z);
+        };
+    }
+    
+    private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) {
+        return switch(distanceFunction) {
+            case Euclidean -> fastSqrt(x*x + y*y + z*z);
+            case EuclideanSq -> x*x + y*y + z*z;
+            case Manhattan -> fastAbs(x) + fastAbs(y) + fastAbs(z);
+        };
+    }
+    
+    public enum DistanceFunction {
+        Euclidean,
+        EuclideanSq,
+        Manhattan
+    }
+}

common/addons/config-ore-v2/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2020-2021 Polyhedral Development
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

common/addons/config-ore-v2/README.md

@@ -0,0 +1,3 @@
+# config-ore-v2
+
+Registers the default configuration for Terra Ores, `ORE`.

common/addons/config-ore-v2/build.gradle.kts

@@ -0,0 +1,11 @@
+version = version("1.0.0")
+
+dependencies {
+    compileOnlyApi(project(":common:addons:manifest-addon-loader"))
+    implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+    testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+}
+
+tasks.named<com.github.jengelman.gradle.plugins.shadow.tasks.ShadowJar>("shadowJar") {
+    relocate("net.jafama", "com.dfsek.terra.addons.ore.lib.jafama")
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreAddon.java

@@ -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.ore.v2;
+
+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.ConfigPackPreLoadEvent;
+import com.dfsek.terra.api.event.functional.FunctionalEventHandler;
+import com.dfsek.terra.api.inject.annotations.Inject;
+
+
+public class OreAddon implements AddonInitializer {
+    @Inject
+    private Platform platform;
+    
+    @Inject
+    private BaseAddon addon;
+    
+    @Override
+    public void initialize() {
+        platform.getEventManager()
+                .getHandler(FunctionalEventHandler.class)
+                .register(addon, ConfigPackPreLoadEvent.class)
+                .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1))
+                .failThrough();
+    }
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreConfigType.java

@@ -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.ore.v2;
+
+import com.dfsek.terra.api.Platform;
+import com.dfsek.terra.api.config.ConfigFactory;
+import com.dfsek.terra.api.config.ConfigPack;
+import com.dfsek.terra.api.config.ConfigType;
+import com.dfsek.terra.api.structure.Structure;
+import com.dfsek.terra.api.util.reflection.TypeKey;
+
+
+public class OreConfigType implements ConfigType<OreTemplate, Structure> {
+    public static final TypeKey<Structure> ORE_TYPE_TOKEN = new TypeKey<>() {
+    };
+    private final OreFactory factory = new OreFactory();
+    
+    @Override
+    public OreTemplate getTemplate(ConfigPack pack, Platform platform) {
+        return new OreTemplate();
+    }
+    
+    @Override
+    public ConfigFactory<OreTemplate, Structure> getFactory() {
+        return factory;
+    }
+    
+    @Override
+    public TypeKey<Structure> getTypeKey() {
+        return ORE_TYPE_TOKEN;
+    }
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreFactory.java

@@ -0,0 +1,24 @@
+/*
+ * 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.ore.v2;
+
+import com.dfsek.terra.addons.ore.v2.ores.VanillaOre;
+import com.dfsek.terra.api.Platform;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.config.ConfigFactory;
+import com.dfsek.terra.api.structure.Structure;
+
+
+public class OreFactory implements ConfigFactory<OreTemplate, Structure> {
+    @Override
+    public VanillaOre build(OreTemplate config, Platform platform) {
+        BlockState m = config.getMaterial();
+        return new VanillaOre(m, config.getSize(), config.getReplaceable(), config.doPhysics(), config.isExposed(),
+                              config.getMaterialOverrides());
+    }
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/OreTemplate.java

@@ -0,0 +1,80 @@
+/*
+ * 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.ore.v2;
+
+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.Final;
+import com.dfsek.tectonic.api.config.template.annotations.Value;
+
+import java.util.HashMap;
+import java.util.Map;
+
+import com.dfsek.terra.api.block.BlockType;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.config.AbstractableTemplate;
+import com.dfsek.terra.api.config.meta.Meta;
+import com.dfsek.terra.api.util.collection.MaterialSet;
+
+
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
+public class OreTemplate implements AbstractableTemplate {
+    @Value("id")
+    @Final
+    private String id;
+    
+    @Value("material")
+    private @Meta BlockState material;
+    
+    @Value("material-overrides")
+    @Default
+    private @Meta Map<@Meta BlockType, @Meta BlockState> materials = new HashMap<>();
+    
+    @Value("replace")
+    private @Meta MaterialSet replaceable;
+    
+    @Value("physics")
+    @Default
+    private @Meta boolean physics = false;
+    
+    @Value("size")
+    private @Meta double size;
+    
+    @Value("exposed")
+    @Default
+    @Description("The chance that ore blocks bordering air will be discarded as candidates for ore. 0 = 0%, 1 = 100%")
+    private @Meta double exposed = 0.0f;
+    
+    public boolean doPhysics() {
+        return physics;
+    }
+    
+    public double getSize() {
+        return size;
+    }
+    
+    public BlockState getMaterial() {
+        return material;
+    }
+    
+    public MaterialSet getReplaceable() {
+        return replaceable;
+    }
+    
+    public String getID() {
+        return id;
+    }
+    
+    public Map<BlockType, BlockState> getMaterialOverrides() {
+        return materials;
+    }
+    
+    public double isExposed() {
+        return exposed;
+    }
+}

common/addons/config-ore-v2/src/main/java/com/dfsek/terra/addons/ore/v2/ores/VanillaOre.java

@@ -0,0 +1,188 @@
+/*
+ * 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.ore.v2.ores;
+
+import net.jafama.FastMath;
+
+import java.util.BitSet;
+import java.util.Map;
+import java.util.Random;
+
+import com.dfsek.terra.api.block.BlockType;
+import com.dfsek.terra.api.block.state.BlockState;
+import com.dfsek.terra.api.structure.Structure;
+import com.dfsek.terra.api.util.Rotation;
+import com.dfsek.terra.api.util.collection.MaterialSet;
+import com.dfsek.terra.api.util.vector.Vector3Int;
+import com.dfsek.terra.api.world.WritableWorld;
+
+
+public class VanillaOre implements Structure {
+    
+    private final BlockState material;
+    
+    private final double size;
+    private final MaterialSet replaceable;
+    private final boolean applyGravity;
+    private final double exposed;
+    private final Map<BlockType, BlockState> materials;
+    
+    public VanillaOre(BlockState material, double size, MaterialSet replaceable, boolean applyGravity,
+                      double exposed, Map<BlockType, BlockState> materials) {
+        this.material = material;
+        this.size = size;
+        this.replaceable = replaceable;
+        this.applyGravity = applyGravity;
+        this.exposed = exposed;
+        this.materials = materials;
+    }
+    
+    protected static boolean shouldNotDiscard(Random random, double chance) {
+        if(chance <= 0.0F) {
+            return true;
+        } else if(chance >= 1.0F) {
+            return false;
+        } else {
+            return random.nextFloat() >= chance;
+        }
+    }
+    
+    public static double lerp(double t, double v0, double v1) {
+        return v0 + t * (v1 - v0);
+    }
+    
+    @Override
+    public boolean generate(Vector3Int location, WritableWorld world, Random random, Rotation rotation) {
+        float f = random.nextFloat() * (float) Math.PI;
+        double g = size / 8.0F;
+        int i = (int) FastMath.ceil((size / 16.0F * 2.0F + 1.0F) / 2.0F);
+        double startX = (double) location.getX() + FastMath.sin(f) * g;
+        double endX = (double) location.getX() - FastMath.sin(f) * g;
+        double startZ = (double) location.getZ() + FastMath.cos(f) * g;
+        double endZ = (double) location.getZ() - FastMath.cos(f) * g;
+        double startY = location.getY() + random.nextInt(3) - 2;
+        double endY = location.getY() + random.nextInt(3) - 2;
+        int x = (int) (location.getX() - FastMath.ceil(g) - i);
+        int y = location.getY() - 2 - i;
+        int z = (int) (location.getZ() - FastMath.ceil(g) - i);
+        int horizontalSize = (int) (2 * (FastMath.ceil(g) + i));
+        int verticalSize = 2 * (2 + i);
+        
+        int i1 = 0;
+        BitSet bitSet = new BitSet(horizontalSize * verticalSize * horizontalSize);
+        
+        int j1 = (int) size;
+        double[] ds = new double[j1 * 4];
+        
+        for(int k1 = 0; k1 < j1; ++k1) {
+            float f1 = (float) k1 / (float) j1;
+            double d1 = lerp(f1, startX, endX);
+            double e1 = lerp(f1, startY, endY);
+            double g1 = lerp(f1, startZ, endZ);
+            double h1 = random.nextDouble() * (double) j1 / 16.0;
+            double l1 = ((FastMath.sin((float) Math.PI * f1) + 1.0F) * h1 + 1.0) / 2.0;
+            ds[k1 * 4] = d1;
+            ds[k1 * 4 + 1] = e1;
+            ds[k1 * 4 + 2] = g1;
+            ds[k1 * 4 + 3] = l1;
+        }
+        
+        for(int k1 = 0; k1 < j1 - 1; ++k1) {
+            if(!(ds[k1 * 4 + 3] <= 0.0)) {
+                for(int m1 = k1 + 1; m1 < j1; ++m1) {
+                    if(!(ds[m1 * 4 + 3] <= 0.0)) {
+                        double d1 = ds[k1 * 4] - ds[m1 * 4];
+                        double e1 = ds[k1 * 4 + 1] - ds[m1 * 4 + 1];
+                        double g1 = ds[k1 * 4 + 2] - ds[m1 * 4 + 2];
+                        double h1 = ds[k1 * 4 + 3] - ds[m1 * 4 + 3];
+                        if(h1 * h1 > d1 * d1 + e1 * e1 + g1 * g1) {
+                            if(h1 > 0.0) {
+                                ds[m1 * 4 + 3] = -1.0;
+                            } else {
+                                ds[k1 * 4 + 3] = -1.0;
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        for(int m1 = 0; m1 < j1; ++m1) {
+            double d1 = ds[m1 * 4 + 3];
+            if(!(d1 < 0.0)) {
+                double e1 = ds[m1 * 4];
+                double g1 = ds[m1 * 4 + 1];
+                double h1 = ds[m1 * 4 + 2];
+                int n1 = (int) FastMath.max(FastMath.floor(e1 - d1), x);
+                int o1 = (int) FastMath.max(FastMath.floor(g1 - d1), y);
+                int p1 = (int) FastMath.max(FastMath.floor(h1 - d1), z);
+                int q1 = (int) FastMath.max(FastMath.floor(e1 + d1), n1);
+                int r1 = (int) FastMath.max(FastMath.floor(g1 + d1), o1);
+                int s1 = (int) FastMath.max(FastMath.floor(h1 + d1), p1);
+                
+                for(int t1 = n1; t1 <= q1; ++t1) {
+                    double u1 = ((double) t1 + 0.5 - e1) / d1;
+                    if(u1 * u1 < 1.0) {
+                        for(int v1 = o1; v1 <= r1; ++v1) {
+                            double w1 = ((double) v1 + 0.5 - g1) / d1;
+                            if(u1 * u1 + w1 * w1 < 1.0) {
+                                for(int aa = p1; aa <= s1; ++aa) {
+                                    double ab = ((double) aa + 0.5 - h1) / d1;
+                                    if(u1 * u1 + w1 * w1 + ab * ab < 1.0 && !(v1 < world.getMinHeight() || v1 >= world.getMaxHeight())) {
+                                        int ac = t1 - x + (v1 - y) * horizontalSize + (aa - z) * horizontalSize * verticalSize;
+                                        if(!bitSet.get(ac)) {
+                                            bitSet.set(ac);
+                                            
+                                            BlockType block = world.getBlockState(x, y, z).getBlockType();
+                                            
+                                            if(shouldPlace(block, random, world, t1, v1, aa)) {
+                                                world.setBlockState(t1, v1, aa, getMaterial(block), isApplyGravity());
+                                                ++i1;
+                                                break;
+                                            }
+                                        }
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        
+        
+        return i1 > 0;
+    }
+    
+    public boolean shouldPlace(BlockType type, Random random, WritableWorld world, int x, int y, int z) {
+        if(!getReplaceable().contains(type)) {
+            return false;
+        } else if(shouldNotDiscard(random, exposed)) {
+            return true;
+        } else {
+            return !(world.getBlockState(x, y, z - 1).isAir() ||
+                     world.getBlockState(x, y, z + 1).isAir() ||
+                     world.getBlockState(x, y - 1, z).isAir() ||
+                     world.getBlockState(x, y + 1, z).isAir() ||
+                     world.getBlockState(x - 1, y, z).isAir() ||
+                     world.getBlockState(x + 1, y, z).isAir());
+        }
+    }
+    
+    public BlockState getMaterial(BlockType replace) {
+        return materials.getOrDefault(replace, material);
+    }
+    
+    public MaterialSet getReplaceable() {
+        return replaceable;
+    }
+    
+    public boolean isApplyGravity() {
+        return applyGravity;
+    }
+}

common/addons/config-ore-v2/src/main/resources/terra.addon.yml

@@ -0,0 +1,12 @@
+schema-version: 1
+contributors:
+  - Terra contributors
+id: config-ore-v2
+version: @VERSION@
+entrypoints:
+  - "com.dfsek.terra.addons.ore.v2.OreAddon"
+website:
+  issues: https://github.com/PolyhedralDev/Terra/issues
+  source: https://github.com/PolyhedralDev/Terra
+  docs: https://terra.polydev.org
+license: MIT License

common/addons/config-ore/src/main/java/com/dfsek/terra/addons/ore/OreAddon.java

@@ -14,8 +14,13 @@ 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 org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+
 
 public class OreAddon implements AddonInitializer {
+    private static final Logger logger = LoggerFactory.getLogger(OreAddon.class);
+    
     @Inject
     private Platform platform;
     
@@ -29,5 +34,7 @@ public class OreAddon implements AddonInitializer {
                 .register(addon, ConfigPackPreLoadEvent.class)
                 .then(event -> event.getPack().registerConfigType(new OreConfigType(), addon.key("ORE"), 1))
                 .failThrough();
+        
+        logger.warn("The ore-config addon is deprecated and scheduled for removal in Terra 7.0. It is recommended to use the ore-config-v2 addon for future pack development instead.");
     }
 }

common/addons/library-image/build.gradle.kts

@@ -0,0 +1,8 @@
+version = version("1.0.0")
+
+dependencies {
+    compileOnlyApi(project(":common:addons:manifest-addon-loader"))
+    
+    implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+    testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
+}