Merge branch 'ver/6.4.0' into dev/image-caching

hotspot has intrinsics for almost everything we use it for

README.md

@@ -47,14 +47,7 @@ JARs are produced in `platforms/<platform>/build/libs`.
 To run Minecraft with Terra in the IDE (for testing) use the following tasks:
 
 * Bukkit
-    * `installPaper` - Install a [Paper](https://github.com/PaperMC/Paper) test
-      server. (Only needs to be run once).
-    * `installPurpur` - Install a [Purpur](https://github.com/pl3xgaming/Purpur)
-      test server. (Only needs to be run once).
-    * `runPaper` - Run the Paper test server with Terra (`installPaper` must
-      have been run previously).
-    * `runPurpur` - Run the Purpur test server with Terra (`installPurpur` must
-      have been run previously).
+    * `runServer` - Run the Paper test server with Terra installed.
 * Fabric
     * `runClient` - Run a Minecraft Fabric client with Terra installed.
     * `runServer` - Run a Minecraft Fabric server with Terra installed.

build.gradle.kts

@@ -1,8 +1,8 @@
 preRelease(true)
 
-versionProjects(":common:api", version("6.2.1"))
-versionProjects(":common:implementation", version("6.2.1"))
-versionProjects(":platforms", version("6.2.1"))
+versionProjects(":common:api", version("6.4.0"))
+versionProjects(":common:implementation", version("6.4.0"))
+versionProjects(":platforms", version("6.4.0"))
 
 
 allprojects {

buildSrc/build.gradle.kts

@@ -3,15 +3,6 @@ plugins {
     kotlin("jvm") version embeddedKotlinVersion
 }
 
-buildscript {
-    configurations.all {
-        resolutionStrategy {
-            force("org.ow2.asm:asm:9.3") // TODO: remove when ShadowJar updates ASM version
-            force("org.ow2.asm:asm-commons:9.3")
-        }
-    }
-}
-
 repositories {
     mavenCentral()
     gradlePluginPortal()
@@ -24,11 +15,12 @@ repositories {
 }
 
 dependencies {
-    implementation("gradle.plugin.com.github.jengelman.gradle.plugins:shadow:+")
-    implementation("io.papermc.paperweight.userdev:io.papermc.paperweight.userdev.gradle.plugin:1.3.5")
+    //TODO Allow pulling from Versions.kt
+    implementation("com.github.johnrengelman", "shadow", "8.1.1")
+    implementation("io.papermc.paperweight.userdev", "io.papermc.paperweight.userdev.gradle.plugin","1.5.6")
     
-    implementation("org.ow2.asm:asm:9.3")
-    implementation("org.ow2.asm:asm-tree:9.3")
-    implementation("com.dfsek.tectonic:common:4.2.0")
-    implementation("org.yaml:snakeyaml:1.27")
+    implementation("org.ow2.asm", "asm", "9.5")
+    implementation("org.ow2.asm", "asm-tree", "9.5")
+    implementation("com.dfsek.tectonic", "common", "4.2.0")
+    implementation("org.yaml", "snakeyaml", "2.2")
 }

buildSrc/src/main/kotlin/DependencyConfig.kt

@@ -48,6 +48,9 @@ fun Project.configureDependencies() {
         maven("https://jitpack.io") {
             name = "JitPack"
         }
+        maven("https://nexuslite.gcnt.net/repos/other/") {
+            name = "GCNT"
+        }
     }
     
     dependencies {
@@ -58,4 +61,4 @@ fun Project.configureDependencies() {
         compileOnly("com.google.guava:guava:30.0-jre")
         testImplementation("com.google.guava:guava:30.0-jre")
     }
-}
+}

buildSrc/src/main/kotlin/Versions.kt

@@ -1,70 +1,70 @@
 object Versions {
     object Libraries {
-        const val tectonic = "4.2.0"
-        const val paralithic = "0.7.0"
-        const val strata = "1.1.1"
+        const val tectonic = "4.2.1"
+        const val paralithic = "0.7.1"
+        const val strata = "1.3.2"
         
-        const val cloud = "1.7.0"
+        const val cloud = "1.8.4"
         
-        const val slf4j = "1.7.36"
-        const val log4j_slf4j_impl = "2.14.1"
+        const val slf4j = "2.0.9"
+        const val log4j_slf4j_impl = "2.20.0"
         
         object Internal {
-            const val apacheText = "1.9"
-            const val jafama = "2.3.2"
-            const val apacheIO = "2.6"
-            const val fastutil = "8.5.6"
+            const val shadow = "8.1.1"
+            const val apacheText = "1.10.0"
+            const val apacheIO = "2.14.0"
+            const val guava = "32.1.3-jre"
+            const val asm = "9.5"
+            const val snakeYml = "2.2"
         }
     }
     
     object Fabric {
-        const val fabricLoader = "0.14.8"
-        const val fabricAPI = "0.57.0+1.19"
-    }
-    
-    object Quilt {
-        const val quiltLoader = "0.17.0"
-        const val fabricApi = "2.0.0-beta.4+0.57.0-1.19"
+        const val fabricAPI = "0.90.0+${Mod.minecraft}"
     }
+//
+//    object Quilt {
+//        const val quiltLoader = "0.20.2"
+//        const val fabricApi = "7.3.1+0.89.3-1.20.1"
+//    }
     
     object Mod {
-        const val mixin = "0.11.2+mixin.0.8.5"
+        const val mixin = "0.12.5+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.2"
+        const val yarn = "$minecraft+build.4"
+        const val fabricLoader = "0.14.23"
         
-        const val architecuryLoom = "0.12.0.290"
-        const val architecturyPlugin = "3.4-SNAPSHOT"
+        const val architecuryLoom = "1.3.357"
+        const val architecturyPlugin = "3.4.146"
         
-        const val loomQuiltflower = "1.7.1"
-        
-        const val lazyDfu = "0.1.2"
+        const val loomVineflower = "1.11.0"
     }
     
     object Forge {
-        const val forge = "${Mod.minecraft}-41.0.63"
-        const val burningwave = "12.53.0"
+        const val forge = "${Mod.minecraft}-48.0.13"
+        const val burningwave = "12.63.0"
     }
     
     object Bukkit {
         const val paper = "1.18.2-R0.1-SNAPSHOT"
         const val paperLib = "1.0.5"
-        const val minecraft = "1.19.2"
+        const val foliaLib = "0.2.5"
+        const val minecraft = "1.20.2"
         const val reflectionRemapper = "0.1.0-SNAPSHOT"
-        const val paperDevBundle = "1.19.2-R0.1-SNAPSHOT"
+        const val paperDevBundle = "1.20.2-R0.1-SNAPSHOT"
+        const val runPaper = "2.2.0"
+        const val paperWeight = "1.5.6"
     }
-    
-    object Sponge {
-        const val sponge = "9.0.0-SNAPSHOT"
-        const val mixin = "0.8.2"
-        const val minecraft = "1.17.1"
-    }
-    
+//
+//    object Sponge {
+//        const val sponge = "9.0.0-SNAPSHOT"
+//        const val mixin = "0.8.2"
+//        const val minecraft = "1.17.1"
+//    }
+//
     object CLI {
         const val nbt = "6.1"
-        const val logback = "1.2.9"
-        const val commonsIO = "2.7"
-        const val guava = "31.0.1-jre"
+        const val logback = "1.4.11"
     }
 }

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,8 @@
+version = version("1.0.0")
+
+dependencies {
+    compileOnlyApi(project(":common:addons:manifest-addon-loader"))
+    compileOnlyApi(project(":common:addons:library-image"))
+
+
+}

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.colorsampler.ColorSampler;
+import com.dfsek.terra.addons.image.converter.ColorConverter;
+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.colorsampler.ColorSampler;
+import com.dfsek.terra.addons.image.converter.ColorConverter;
+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/build.gradle.kts

@@ -2,10 +2,6 @@ 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.image.lib.jafama")
-}
+
+}

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

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.biome.image;
 
-import net.jafama.FastMath;
-
 import java.awt.Color;
 import java.awt.image.BufferedImage;
 import java.util.HashMap;
@@ -34,7 +32,7 @@ public class ImageBiomeProvider implements BiomeProvider {
     }
     
     private static int distance(Color a, Color b) {
-        return FastMath.abs(a.getRed() - b.getRed()) + FastMath.abs(a.getGreen() - b.getGreen()) + FastMath.abs(a.getBlue() - b.getBlue());
+        return Math.abs(a.getRed() - b.getRed()) + Math.abs(a.getGreen() - b.getGreen()) + Math.abs(a.getBlue() - b.getBlue());
     }
     
     @Override
@@ -70,14 +68,14 @@ public class ImageBiomeProvider implements BiomeProvider {
         CENTER {
             @Override
             public Color getColor(BufferedImage image, int x, int z) {
-                return new Color(image.getRGB(FastMath.floorMod(x - image.getWidth() / 2, image.getWidth()),
-                                              FastMath.floorMod(z - image.getHeight() / 2, image.getHeight())));
+                return new Color(image.getRGB(Math.floorMod(x - image.getWidth() / 2, image.getWidth()),
+                                              Math.floorMod(z - image.getHeight() / 2, image.getHeight())));
             }
         },
         NONE {
             @Override
             public Color getColor(BufferedImage image, int x, int z) {
-                return new Color(image.getRGB(FastMath.floorMod(x, image.getWidth()), FastMath.floorMod(z, image.getHeight())));
+                return new Color(image.getRGB(Math.floorMod(x, image.getWidth()), Math.floorMod(z, image.getHeight())));
             }
         };
         

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,7 @@ public class ImageBiomeProviderAddon implements AddonInitializer {
                                               () -> new ImageProviderTemplate(event.getPack().getRegistry(Biome.class)));
                 })
                 .failThrough();
+        if(platform.getTerraConfig().isDebugLog())
+            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/build.gradle.kts

@@ -2,11 +2,4 @@ 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

@@ -11,6 +11,9 @@ import com.dfsek.tectonic.api.config.template.object.ObjectTemplate;
 
 import java.util.function.Supplier;
 
+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.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;
@@ -20,9 +23,6 @@ import com.dfsek.terra.addons.biome.pipeline.v2.config.stage.mutator.BorderStage
 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;

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

@@ -1,19 +1,19 @@
 package com.dfsek.terra.addons.biome.pipeline.v2;
 
+import com.github.benmanes.caffeine.cache.Caffeine;
+import com.github.benmanes.caffeine.cache.LoadingCache;
+
+import java.util.Comparator;
+import java.util.HashSet;
+import java.util.Optional;
+import java.util.Set;
+import java.util.stream.StreamSupport;
+
 import com.dfsek.terra.addons.biome.pipeline.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.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;
@@ -36,7 +36,7 @@ public class PipelineBiomeProvider implements BiomeProvider {
         this.noiseAmp = noiseAmp;
         this.chunkSize = pipeline.getChunkSize();
         this.biomeChunkCache = Caffeine.newBuilder()
-                                       .maximumSize(1024)
+                                       .maximumSize(64)
                                        .build(pipeline::generateChunk);
     
         Set<PipelineBiome> biomeSet = new HashSet<>();
@@ -80,8 +80,8 @@ public class PipelineBiomeProvider implements BiomeProvider {
         x /= resolution;
         z /= resolution;
         
-        int chunkX = FastMath.floorDiv(x, chunkSize);
-        int chunkZ = FastMath.floorDiv(z, chunkSize);
+        int chunkX = Math.floorDiv(x, chunkSize);
+        int chunkZ = Math.floorDiv(z, chunkSize);
         
         int chunkWorldX = chunkX * chunkSize;
         int chunkWorldZ = chunkZ * chunkSize;
@@ -97,6 +97,11 @@ public class PipelineBiomeProvider implements BiomeProvider {
         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);

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

@@ -1,7 +1,7 @@
 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;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoint;
 
 
 /**

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

@@ -1,7 +1,7 @@
 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;
+import com.dfsek.terra.addons.biome.pipeline.v2.pipeline.BiomeChunkImpl.ViewPoint;
 
 
 public interface Stage {

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

@@ -15,9 +15,9 @@ 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.addons.biome.pipeline.v2.pipeline.PipelineImpl;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
@@ -54,6 +54,6 @@ public class BiomePipelineTemplate implements ObjectTemplate<BiomeProvider> {
     
     @Override
     public BiomeProvider get() {
-        return new PipelineBiomeProvider(new PipelineImpl(source, stages, resolution, 500), resolution, blendSampler, blendAmplitude);
+        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/stage/expander/ExpanderStageTemplate.java

@@ -7,8 +7,8 @@
 
 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.config.stage.StageTemplate;
 import com.dfsek.terra.addons.biome.pipeline.v2.stage.expander.FractalExpander;
 
 

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

@@ -11,9 +11,9 @@ 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.config.stage.StageTemplate;
 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;

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

@@ -9,9 +9,9 @@ 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.config.stage.StageTemplate;
 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;

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

@@ -11,9 +11,9 @@ 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.config.stage.StageTemplate;
 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;

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

@@ -9,9 +9,9 @@ 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.config.stage.StageTemplate;
 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;

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

@@ -7,8 +7,8 @@
 
 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.config.stage.StageTemplate;
 import com.dfsek.terra.addons.biome.pipeline.v2.stage.mutators.SmoothStage;
 
 

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

@@ -1,13 +1,12 @@
 package com.dfsek.terra.addons.biome.pipeline.v2.pipeline;
 
+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.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 {
@@ -111,7 +110,7 @@ public class BiomeChunkImpl implements BiomeChunk {
         // 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;
+        return (int) Math.ceil((double) finalGridOrigin / initialGridInterval) * initialGridInterval;
     }
     
     private static int calculateFinalGridOrigin(int totalExpanderCount, List<Stage> stages) {

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

@@ -3,8 +3,8 @@ 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;
+import com.dfsek.terra.addons.biome.pipeline.v2.api.biome.PipelineBiome;
 
 
 public class SingleSource implements Source {

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

@@ -2,11 +2,4 @@ version = version("1.0.1")
 
 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/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineAddon.java

@@ -90,6 +90,7 @@ public class BiomePipelineAddon implements AddonInitializer {
                     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.");
+        if(platform.getTerraConfig().isDebugLog())
+            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/biome-provider-pipeline/src/main/java/com/dfsek/terra/addons/biome/pipeline/BiomePipelineProvider.java

@@ -9,7 +9,6 @@ package com.dfsek.terra.addons.biome.pipeline;
 
 import com.github.benmanes.caffeine.cache.Caffeine;
 import com.github.benmanes.caffeine.cache.LoadingCache;
-import net.jafama.FastMath;
 
 import java.util.Comparator;
 import java.util.HashSet;
@@ -86,8 +85,8 @@ public class BiomePipelineProvider implements BiomeProvider {
         x /= resolution;
         z /= resolution;
 
-        int fdX = FastMath.floorDiv(x, pipeline.getSize());
-        int fdZ = FastMath.floorDiv(z, pipeline.getSize());
+        int fdX = Math.floorDiv(x, pipeline.getSize());
+        int fdZ = Math.floorDiv(z, pipeline.getSize());
         return holderCache.get(new SeededVector(fdX, fdZ, seed)).getBiome(x - fdX * pipeline.getSize(),
                                                                           z - fdZ * pipeline.getSize()).getBiome();
     }

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

@@ -1,12 +1,5 @@
-version = version("1.1.0")
+version = version("1.2.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.chunkgenerator.lib.jafama")
 }

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.BiomePaletteInfo;
 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.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

@@ -8,15 +8,14 @@
 package com.dfsek.terra.addons.chunkgenerator.generation;
 
 
-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.generation.math.PaletteUtil;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.LazilyEvaluatedInterpolator;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.Sampler3D;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.samplers.SamplerProvider;
+import com.dfsek.terra.addons.chunkgenerator.palette.BiomePaletteInfo;
 import com.dfsek.terra.api.Platform;
 import com.dfsek.terra.api.block.state.BlockState;
 import com.dfsek.terra.api.config.ConfigPack;
@@ -40,13 +39,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 +96,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,10 +130,10 @@ 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);
+        int fdX = Math.floorMod(x, 16);
+        int fdZ = Math.floorMod(z, 16);
         
         Palette palette = PaletteUtil.getPalette(fdX, y, fdZ, sampler, paletteInfo, 0);
         double noise = sampler.sample(fdX, y, fdZ);
@@ -155,6 +154,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 = Math.floorMod(x, 16);
+        int fdZ = Math.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.generation.math.samplers.Sampler3D;
-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.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/generation/math/interpolation/ChunkInterpolator.java

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties;
 import com.dfsek.terra.api.properties.PropertyKey;
 import com.dfsek.terra.api.util.Column;
@@ -134,7 +132,7 @@ public class ChunkInterpolator {
     }
     
     private static int reRange(int value, int high) {
-        return FastMath.max(FastMath.min(value, high), 0);
+        return Math.max(Math.min(value, high), 0);
     }
     
     /**
@@ -146,7 +144,7 @@ public class ChunkInterpolator {
      * @return double - The interpolated noise at the coordinates.
      */
     public double getNoise(double x, double y, double z) {
-        return interpGrid[reRange(((int) x) / 4, 3)][(FastMath.max(FastMath.min(((int) y), max), min) - min) / 4][reRange(((int) z) / 4,
+        return interpGrid[reRange(((int) x) / 4, 3)][(Math.max(Math.min(((int) y), max), min) - min) / 4][reRange(((int) z) / 4,
                                                                                                                           3)].trilerp(
                 (x % 4) / 4, (y % 4) / 4, (z % 4) / 4);
     }

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

@@ -1,7 +1,5 @@
 package com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties;
 import com.dfsek.terra.api.properties.PropertyKey;
 import com.dfsek.terra.api.world.biome.generation.BiomeProvider;
@@ -30,8 +28,8 @@ public class LazilyEvaluatedInterpolator {
                                        PropertyKey<BiomeNoiseProperties> noisePropertiesKey, int min, int horizontalRes, int verticalRes,
                                        long seed) {
         this.noisePropertiesKey = noisePropertiesKey;
-        int hSamples = FastMath.ceilToInt(16.0 / horizontalRes);
-        int vSamples = FastMath.ceilToInt((double) (max - min) / verticalRes);
+        int hSamples = (int) Math.ceil(16.0 / horizontalRes);
+        int vSamples = (int) Math.ceil((double) (max - min) / verticalRes);
         this.zMul = (hSamples + 1);
         this.yMul = zMul * zMul;
         samples = new Double[yMul * (vSamples + 1)];
@@ -52,7 +50,7 @@ public class LazilyEvaluatedInterpolator {
             int xi = ox + chunkX;
             int zi = oz + chunkZ;
             
-            int y = FastMath.min(max, oy);
+            int y = Math.min(max, oy);
             
             sample = biomeProvider
                     .getBiome(xi, y, zi, seed)
@@ -93,7 +91,7 @@ public class LazilyEvaluatedInterpolator {
             return lerp_bottom;
         }
         
-        double yFrac = (double) FastMath.floorMod(y, verticalRes) / verticalRes;
+        double yFrac = (double) Math.floorMod(y, verticalRes) / verticalRes;
         
         
         double sample_0_1_0 = sample(xIndex, yIndex + 1, zIndex, x, y + verticalRes, z);

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

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.chunkgenerator.generation.math.samplers;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.ChunkInterpolator;
 import com.dfsek.terra.addons.chunkgenerator.generation.math.interpolation.ElevationInterpolator;
@@ -28,10 +26,10 @@ public class Sampler3D {
     }
     
     public double sample(double x, double y, double z) {
-        return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation(FastMath.roundToInt(x), FastMath.roundToInt(z));
+        return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation((int) Math.round(x), (int) Math.round(z));
     }
     
     public double sample(int x, int y, int z) {
-        return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation(FastMath.roundToInt(x), FastMath.roundToInt(z));
+        return interpolator.getNoise(x, y, z) + elevationInterpolator.getElevation(x, z);
     }
 }

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

@@ -19,7 +19,6 @@ package com.dfsek.terra.addons.chunkgenerator.generation.math.samplers;
 
 import com.github.benmanes.caffeine.cache.Cache;
 import com.github.benmanes.caffeine.cache.Caffeine;
-import net.jafama.FastMath;
 
 import com.dfsek.terra.addons.chunkgenerator.config.noise.BiomeNoiseProperties;
 import com.dfsek.terra.api.Platform;
@@ -45,8 +44,8 @@ public class SamplerProvider {
     }
     
     public Sampler3D get(int x, int z, WorldProperties world, BiomeProvider provider) {
-        int cx = FastMath.floorDiv(x, 16);
-        int cz = FastMath.floorDiv(z, 16);
+        int cx = Math.floorDiv(x, 16);
+        int cz = Math.floorDiv(z, 16);
         return getChunk(cx, cz, world, provider);
     }
     

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,11 @@
 
 package com.dfsek.terra.addons.chunkgenerator.palette;
 
+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 +32,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 = Math.min(paletteMap.keySet().stream().min(Integer::compareTo).orElse(0), 0);
+            int max = Math.max(paletteMap.keySet().stream().max(Integer::compareTo).orElse(255), 255);
+            
+            Palette[] palettes = new Palette[paletteMap.lastKey() + 1 - min];
+            for(int y = min; y <= Math.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-distributors/build.gradle.kts

@@ -2,11 +2,4 @@ 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.feature.distributor.lib.jafama")
-}

common/addons/config-distributors/src/main/java/com/dfsek/terra/addons/feature/distributor/distributors/PaddedGridDistributor.java

@@ -1,7 +1,5 @@
 package com.dfsek.terra.addons.feature.distributor.distributors;
 
-import net.jafama.FastMath;
-
 import java.util.Random;
 
 import com.dfsek.terra.api.structure.feature.Distributor;
@@ -21,21 +19,12 @@ public class PaddedGridDistributor implements Distributor {
         this.cellWidth = width + padding;
     }
     
-    private static long murmur64(long h) {
-        h ^= h >>> 33;
-        h *= 0xff51afd7ed558ccdL;
-        h ^= h >>> 33;
-        h *= 0xc4ceb9fe1a85ec53L;
-        h ^= h >>> 33;
-        return h;
-    }
-    
     @Override
     public boolean matches(int x, int z, long seed) {
-        int cellX = FastMath.floorDiv(x, cellWidth);
-        int cellZ = FastMath.floorDiv(z, cellWidth);
+        int cellX = Math.floorDiv(x, cellWidth);
+        int cellZ = Math.floorDiv(z, cellWidth);
         
-        Random random = new Random((murmur64(MathUtil.squash(cellX, cellZ)) ^ seed) + salt);
+        Random random = new Random((MathUtil.murmur64(MathUtil.squash(cellX, cellZ)) ^ seed) + salt);
         
         int pointX = random.nextInt(width) + cellX * cellWidth;
         int pointZ = random.nextInt(width) + cellZ * cellWidth;

common/addons/config-flora/build.gradle.kts

@@ -2,10 +2,4 @@ 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.flora.lib.jafama")
 }

common/addons/config-flora/src/main/java/com/dfsek/terra/addons/flora/flora/gen/TerraFlora.java

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.flora.flora.gen;
 
-import net.jafama.FastMath;
-
 import java.util.ArrayList;
 import java.util.EnumSet;
 import java.util.List;
@@ -60,7 +58,7 @@ public class TerraFlora implements Structure {
     }
     
     private ProbabilityCollection<BlockState> getStateCollection(int layer) {
-        return layers.get(FastMath.max(FastMath.min(layer, layers.size() - 1), 0));
+        return layers.get(Math.max(Math.min(layer, layers.size() - 1), 0));
     }
     
     private EnumSet<Direction> getFaces(Vector3Int b, WritableWorld world) {
@@ -82,8 +80,8 @@ public class TerraFlora implements Structure {
                 Direction.class);
         if(doRotation && faces.size() == 0) return false; // Don't plant if no faces are valid.
         
-        for(int i = 0; FastMath.abs(i) < size; i += c) { // Down if ceiling, up if floor
-            int lvl = (FastMath.abs(i));
+        for(int i = 0; Math.abs(i) < size; i += c) { // Down if ceiling, up if floor
+            int lvl = (Math.abs(i));
             BlockState data = getStateCollection((ceiling ? lvl : size - lvl - 1)).get(distribution, location.getX(), location.getY(),
                                                                                        location.getZ(), world.getSeed());
             if(doRotation) {

common/addons/config-locators/build.gradle.kts

@@ -2,11 +2,4 @@ version = version("1.1.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.feature.locator.lib.jafama")
-}
+}

common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/PatternLocator.java

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.feature.locator.locators;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.addons.feature.locator.patterns.Pattern;
 import com.dfsek.terra.api.structure.feature.BinaryColumn;
 import com.dfsek.terra.api.structure.feature.Locator;
@@ -27,8 +25,8 @@ public class PatternLocator implements Locator {
     
     @Override
     public BinaryColumn getSuitableCoordinates(Column<?> column) {
-        int min = FastMath.max(column.getMinY(), search.getMin());
-        int max = FastMath.min(column.getMaxY(), search.getMax());
+        int min = Math.max(column.getMinY(), search.getMin());
+        int max = Math.min(column.getMaxY(), search.getMax());
         if(min >= max) return BinaryColumn.getNull();
         return new BinaryColumn(min, max, y -> pattern.matches(y, column));
     }

common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/SurfaceLocator.java

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.feature.locator.locators;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.api.structure.feature.BinaryColumn;
 import com.dfsek.terra.api.structure.feature.Locator;
 import com.dfsek.terra.api.util.Range;
@@ -26,8 +24,8 @@ public class SurfaceLocator implements Locator {
     @Override
     public BinaryColumn getSuitableCoordinates(Column<?> column) {
         BinaryColumnBuilder builder = column.newBinaryColumn();
-        int max = FastMath.min(search.getMax(), column.getMaxY());
-        int min = FastMath.max(search.getMin(), column.getMinY());
+        int max = Math.min(search.getMax(), column.getMaxY());
+        int min = Math.max(search.getMin(), column.getMinY());
         if(min >= max) return builder.build();
         for(int y = min; y < max; y++) {
             if(column.getBlock(y).isAir() && !column.getBlock(y - 1).isAir()) {

common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/locators/TopLocator.java

@@ -22,7 +22,7 @@ public class TopLocator implements Locator {
     
     @Override
     public BinaryColumn getSuitableCoordinates(Column<?> column) {
-        for(int y : search) {
+        for(int y = search.getMax(); y >= search.getMin(); y--) {
             if(column.getBlock(y).isAir() && !column.getBlock(y - 1).isAir()) {
                 return new BinaryColumn(y, y + 1, yi -> true);
             }

common/addons/config-locators/src/main/java/com/dfsek/terra/addons/feature/locator/patterns/MatchPattern.java

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.feature.locator.patterns;
 
-import net.jafama.FastMath;
-
 import java.util.function.Predicate;
 
 import com.dfsek.terra.api.block.state.BlockState;
@@ -28,8 +26,8 @@ public class MatchPattern implements Pattern {
     
     @Override
     public boolean matches(int y, Column<?> column) {
-        int min = FastMath.max(column.getMinY(), range.getMin() + y);
-        int max = FastMath.min(column.getMaxY(), range.getMax() + y);
+        int min = Math.max(column.getMinY(), range.getMin() + y);
+        int max = Math.min(column.getMaxY(), range.getMax() + y);
         if(max <= min) return false;
         for(int i = min; i < max; i++) {
             if(!matches.test(column.getBlock(i))) return false;
@@ -39,8 +37,8 @@ public class MatchPattern implements Pattern {
     
     @Override
     public boolean matches(WritableWorld world, int x, int y, int z) {
-        int min = FastMath.max(world.getMinHeight(), range.getMin() + y);
-        int max = FastMath.min(world.getMaxHeight(), range.getMax() + y);
+        int min = Math.max(world.getMinHeight(), range.getMin() + y);
+        int max = Math.min(world.getMaxHeight(), range.getMax() + y);
         if(max <= min) return false;
         for(int i = min; i < max; i++) {
             if(!matches.test(world.getBlockState(x, i, z))) return false;

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

@@ -1,16 +1,8 @@
 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"))
     api("com.dfsek", "paralithic", Versions.Libraries.paralithic)
-    implementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
-    testImplementation("net.jafama", "jafama", Versions.Libraries.Internal.jafama)
 }
-
-
-tasks.named<ShadowJar>("shadowJar") {
-    relocate("com.dfsek.paralithic", "com.dfsek.terra.addons.noise.lib.paralithic")
-    relocate("net.jafama", "com.dfsek.terra.addons.noise.lib.jafama")
-}

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 java.util.List;
+
+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;
+
+
+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 java.util.HashMap;
+import java.util.LinkedHashMap;
+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.normalizer.ExpressionNormalizer;
+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({ "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,87 @@
+package com.dfsek.terra.addons.noise.math;
+
+import org.jetbrains.annotations.NotNull;
+
+import java.util.Collections;
+import java.util.List;
+
+import static com.dfsek.terra.api.util.MathUtil.lerp;
+
+
+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;
+    }
+
+    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/ClampNormalizer.java

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.noise.normalizer;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.api.noise.NoiseSampler;
 
 
@@ -24,6 +22,6 @@ public class ClampNormalizer extends Normalizer {
     
     @Override
     public double normalize(double in) {
-        return FastMath.max(FastMath.min(in, max), min);
+        return Math.max(Math.min(in, max), min);
     }
 }

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 java.util.Map;
+
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
+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/normalizer/NormalNormalizer.java

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.noise.normalizer;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.api.noise.NoiseSampler;
 import com.dfsek.terra.api.util.MathUtil;
 
@@ -41,8 +39,8 @@ public class NormalNormalizer extends Normalizer {
                 end = mid;
             }
         }
-        double left = FastMath.abs(lookup[start] - in);
-        double right = FastMath.abs(lookup[end] - in);
+        double left = Math.abs(lookup[start] - in);
+        double right = Math.abs(lookup[end] - in);
         
         double fin;
         if(left <= right) {

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

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.noise.normalizer;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.api.noise.NoiseSampler;
 
 
@@ -22,6 +20,6 @@ public class PosterizationNormalizer extends Normalizer {
     
     @Override
     public double normalize(double in) {
-        return FastMath.roundToInt((in + 1) / stepSize) * stepSize - 1;
+        return (int) Math.round((in + 1) / stepSize) * stepSize - 1;
     }
 }

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 java.util.HashMap;
+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.paralithic.defined.UserDefinedFunction;
+import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction2;
+import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3;
+
+
+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/ImageSampler.java

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.noise.samplers;
 
-import net.jafama.FastMath;
-
 import java.awt.image.BufferedImage;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
@@ -28,8 +26,8 @@ public class ImageSampler implements NoiseSampler {
     
     @Override
     public double noise(long seed, double x, double y) {
-        return ((channel.getChannel(image.getRGB(FastMath.floorMod(FastMath.floorToInt(x * frequency), image.getWidth()),
-                                                 FastMath.floorMod(FastMath.floorToInt(y * frequency), image.getHeight()))) / 255D) - 0.5) *
+        return ((channel.getChannel(image.getRGB(Math.floorMod((int) Math.floor(x * frequency), image.getWidth()),
+                                                 Math.floorMod((int) Math.floor(y * frequency), image.getHeight()))) / 255D) - 0.5) *
                2;
     }
     

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/arithmetic/MaxSampler.java

@@ -1,7 +1,5 @@
 package com.dfsek.terra.addons.noise.samplers.arithmetic;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.api.noise.NoiseSampler;
 
 
@@ -12,6 +10,6 @@ public class MaxSampler extends BinaryArithmeticSampler {
     
     @Override
     public double operate(double left, double right) {
-        return FastMath.max(left, right);
+        return Math.max(left, right);
     }
 }

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

@@ -1,7 +1,5 @@
 package com.dfsek.terra.addons.noise.samplers.arithmetic;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.api.noise.NoiseSampler;
 
 
@@ -12,6 +10,6 @@ public class MinSampler extends BinaryArithmeticSampler {
     
     @Override
     public double operate(double left, double right) {
-        return FastMath.min(left, right);
+        return Math.min(left, right);
     }
 }

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

@@ -7,8 +7,6 @@
 
 package com.dfsek.terra.addons.noise.samplers.noise;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.addons.noise.samplers.noise.simplex.OpenSimplex2Sampler;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
@@ -223,8 +221,8 @@ public class CellularSampler extends NoiseFunction {
     @Override
     public double getNoiseRaw(long sl, double x, double y) {
         int seed = (int) sl;
-        int xr = fastRound(x);
-        int yr = fastRound(y);
+        int xr = (int) Math.round(x);
+        int yr = (int) Math.round(y);
         
         double distance0 = Double.MAX_VALUE;
         double distance1 = Double.MAX_VALUE;
@@ -240,105 +238,43 @@ 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 -> Math.abs(vecX) + Math.abs(vecY);
+                    case Hybrid -> (Math.abs(vecX) + Math.abs(vecY)) + (vecX * vecX + vecY * vecY);
+                    default -> vecX * vecX + vecY * vecY;
+                };
+                
+                distance1 = Math.max(Math.min(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) {
-            distance0 = fastSqrt(distance0);
+            distance0 = Math.sqrt(distance0);
             if(returnType != ReturnType.CellValue) {
-                distance1 = fastSqrt(distance1);
+                distance1 = Math.sqrt(distance1);
             }
         }
         
@@ -351,21 +287,22 @@ 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;
             case Distance3Mul -> distance2 * distance0 - 1;
             case Distance3Div -> distance0 / distance2 - 1;
-            case Angle -> FastMath.atan2(y / frequency - centerY, x / frequency - centerX);
+            case Angle -> Math.atan2(y / frequency - centerY, x / frequency - centerX);
         };
     }
     
     @Override
     public double getNoiseRaw(long sl, double x, double y, double z) {
         int seed = (int) sl;
-        int xr = fastRound(x);
-        int yr = fastRound(y);
-        int zr = fastRound(z);
+        int xr = (int) Math.round(x);
+        int yr = (int) Math.round(y);
+        int zr = (int) Math.round(z);
         
         double distance0 = Double.MAX_VALUE;
         double distance1 = Double.MAX_VALUE;
@@ -382,126 +319,53 @@ 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;
+                    double newDistance = 0;
+                    switch(distanceFunction) {
+                        case Euclidean, EuclideanSq -> newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ;
+                        case Manhattan -> newDistance = Math.abs(vecX) + Math.abs(vecY) + Math.abs(vecZ);
+                        case Hybrid -> {
+                            newDistance = (Math.abs(vecX) + Math.abs(vecY) + Math.abs(vecZ)) + (vecX * vecX + vecY * vecY + vecZ * vecZ);
+                            distance1 = Math.max(Math.min(distance1, newDistance), distance0);
                         }
-                        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);
-                            
-                            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;
+                    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;
                     }
-                    xPrimed += PRIME_X;
+                    zPrimed += PRIME_Z;
                 }
-                break;
-            default:
-                break;
+                yPrimed += PRIME_Y;
+            }
+            xPrimed += PRIME_X;
         }
         
         if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) {
-            distance0 = fastSqrt(distance0);
+            distance0 = Math.sqrt(distance0);
             if(returnType != ReturnType.CellValue) {
-                distance1 = fastSqrt(distance1);
+                distance1 = Math.sqrt(distance1);
             }
         }
         
@@ -514,12 +378,13 @@ 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;
             case Distance3Mul -> distance2 * distance0 - 1;
             case Distance3Div -> distance0 / distance2 - 1;
-            case Angle -> FastMath.atan2(y / frequency - centerY, x / frequency - centerX);
+            case Angle -> Math.atan2(y / frequency - centerY, x / frequency - centerX);
         };
     }
     
@@ -540,6 +405,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 && (Math.abs(dx) > radius || Math.abs(dy) > radius)) return 1;
+        double dist = distance2d(distanceFunction, dx, dy);
+        if (normalize) return Math.min(((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 && (Math.abs(dx) > radius || Math.abs(dy) > radius || Math.abs(dz) > radius)) return 1;
+        double dist = distance3d(distanceFunction, dx, dy, dz);
+        if (normalize) return Math.min(((2*dist)/distanceAtRadius)-1, 1);
+        return dist;
+    }
+    
+    private static double distance2d(DistanceFunction distanceFunction, double x, double z) {
+        return switch(distanceFunction) {
+            case Euclidean -> Math.sqrt(x*x + z*z);
+            case EuclideanSq -> x*x + z*z;
+            case Manhattan -> Math.abs(x) + Math.abs(z);
+        };
+    }
+    
+    private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) {
+        return switch(distanceFunction) {
+            case Euclidean -> Math.sqrt(x*x + y*y + z*z);
+            case EuclideanSq -> x*x + y*y + z*z;
+            case Manhattan -> Math.abs(x) + Math.abs(y) + Math.abs(z);
+        };
+    }
+    
+    public enum DistanceFunction {
+        Euclidean,
+        EuclideanSq,
+        Manhattan
+    }
+}

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

@@ -7,9 +7,8 @@
 
 package com.dfsek.terra.addons.noise.samplers.noise;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.addons.noise.samplers.noise.random.WhiteNoiseSampler;
+import com.dfsek.terra.api.util.MathUtil;
 
 
 public class GaborNoiseSampler extends NoiseFunction {
@@ -17,11 +16,11 @@ public class GaborNoiseSampler extends NoiseFunction {
     private double k = 1.0;
     private double a = 0.1;
     private double f0 = 0.625;
-    private double kernelRadius = (FastMath.sqrt(-FastMath.log(0.05) / Math.PI) / a);
+    private double kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / a);
     private double impulsesPerKernel = 64d;
     private double impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius));
     private double impulsesPerCell = impulseDensity * kernelRadius * kernelRadius;
-    private double g = FastMath.exp(-impulsesPerCell);
+    private double g = Math.exp(-impulsesPerCell);
     
     private double omega0 = Math.PI * 0.25;
     private boolean isotropic = true;
@@ -32,17 +31,17 @@ public class GaborNoiseSampler extends NoiseFunction {
     }
     
     private void recalculateRadiusAndDensity() {
-        kernelRadius = (FastMath.sqrt(-FastMath.log(0.05) / Math.PI) / this.a);
+        kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / this.a);
         impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius));
         impulsesPerCell = impulseDensity * kernelRadius * kernelRadius;
-        g = FastMath.exp(-impulsesPerCell);
+        g = Math.exp(-impulsesPerCell);
     }
     
     private double gaborNoise(long seed, double x, double y) {
         x /= kernelRadius;
         y /= kernelRadius;
-        int xi = fastFloor(x);
-        int yi = fastFloor(y);
+        int xi = (int) Math.floor(x);
+        int yi = (int) Math.floor(y);
         double xf = x - xi;
         double yf = y - yi;
         double noise = 0;
@@ -55,7 +54,7 @@ public class GaborNoiseSampler extends NoiseFunction {
     }
     
     private double calculateCell(long seed, int xi, int yi, double x, double y) {
-        long mashedSeed = murmur64(31L * xi + yi) + seed;
+        long mashedSeed = MathUtil.murmur64(31L * xi + yi) + seed;
         
         double gaussianSource = (rand.getNoiseRaw(mashedSeed++) + 1) / 2;
         int impulses = 0;
@@ -73,7 +72,7 @@ public class GaborNoiseSampler extends NoiseFunction {
     }
     
     private double gabor(double omega_0, double x, double y) {
-        return k * (FastMath.exp(-Math.PI * (a * a) * (x * x + y * y)) * fastCos(2 * Math.PI * f0 * (x * fastCos(omega_0) + y * fastSin(
+        return k * (Math.exp(-Math.PI * (a * a) * (x * x + y * y)) * MathUtil.cos(2 * Math.PI * f0 * (x * MathUtil.cos(omega_0) + y * MathUtil.sin(
                 omega_0))));
     }
     

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

@@ -7,25 +7,15 @@
 
 package com.dfsek.terra.addons.noise.samplers.noise;
 
-import net.jafama.FastMath;
-
 import com.dfsek.terra.api.noise.NoiseSampler;
 
 
-@SuppressWarnings("ManualMinMaxCalculation")
 public abstract class NoiseFunction implements NoiseSampler {
     // Hashing
     protected static final int PRIME_X = 501125321;
     protected static final int PRIME_Y = 1136930381;
     protected static final int PRIME_Z = 1720413743;
-    static final int precision = 100;
-    static final int modulus = 360 * precision;
-    static final double[] sin = new double[360 * 100]; // lookup table
-    static {
-        for(int i = 0; i < sin.length; i++) {
-            sin[i] = (float) Math.sin((double) (i) / (precision));
-        }
-    }
+
     protected double frequency = 0.02d;
     protected long salt;
     
@@ -33,10 +23,6 @@ public abstract class NoiseFunction implements NoiseSampler {
         this.salt = 0;
     }
     
-    protected static int fastFloor(double f) {
-        return f >= 0 ? (int) f : (int) f - 1;
-    }
-    
     protected static int hash(int seed, int xPrimed, int yPrimed, int zPrimed) {
         int hash = seed ^ xPrimed ^ yPrimed ^ zPrimed;
         
@@ -51,77 +37,6 @@ public abstract class NoiseFunction implements NoiseSampler {
         return hash;
     }
     
-    protected static int fastRound(double f) {
-        return f >= 0 ? (int) (f + 0.5f) : (int) (f - 0.5);
-    }
-    
-    protected static double lerp(double a, double b, double t) {
-        return a + t * (b - a);
-    }
-    
-    protected static double interpHermite(double t) {
-        return t * t * (3 - 2 * t);
-    }
-    
-    protected static double interpQuintic(double t) {
-        return t * t * t * (t * (t * 6 - 15) + 10);
-    }
-    
-    protected static double cubicLerp(double a, double b, double c, double d, double t) {
-        double p = (d - c) - (a - b);
-        return t * t * t * p + t * t * ((a - b) - p) + t * (c - a) + b;
-    }
-    
-    protected static double fastMin(double a, double b) {
-        return a < b ? a : b;
-    }
-    
-    protected static double fastMax(double a, double b) {
-        return a > b ? a : b;
-    }
-    
-    protected static double fastAbs(double f) {
-        return f < 0 ? -f : f;
-    }
-    
-    protected static double fastSqrt(double f) {
-        return FastMath.sqrt(f);
-    }
-    
-    protected static int fastCeil(double f) {
-        int i = (int) f;
-        if(i < f) i++;
-        return i;
-    }
-    
-    /**
-     * Murmur64 hashing function
-     *
-     * @param h Input value
-     *
-     * @return Hashed value
-     */
-    protected static long murmur64(long h) {
-        h ^= h >>> 33;
-        h *= 0xff51afd7ed558ccdL;
-        h ^= h >>> 33;
-        h *= 0xc4ceb9fe1a85ec53L;
-        h ^= h >>> 33;
-        return h;
-    }
-    
-    protected static double fastSin(double a) {
-        return sinLookup((int) (a * precision + 0.5f));
-    }
-    
-    protected static double fastCos(double a) {
-        return sinLookup((int) ((a + Math.PI / 2) * precision + 0.5f));
-    }
-    
-    private static double sinLookup(int a) {
-        return a >= 0 ? sin[a % (modulus)] : -sin[-a % (modulus)];
-    }
-    
     public void setSalt(long salt) {
         this.salt = salt;
     }

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

@@ -8,6 +8,7 @@
 package com.dfsek.terra.addons.noise.samplers.noise.fractal;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.MathUtil;
 
 
 public class BrownianMotionSampler extends FractalNoiseFunction {
@@ -23,7 +24,7 @@ public class BrownianMotionSampler extends FractalNoiseFunction {
         for(int i = 0; i < octaves; i++) {
             double noise = input.noise(seed++, x, y);
             sum += noise * amp;
-            amp *= lerp(1.0, fastMin(noise + 1, 2) * 0.5, weightedStrength);
+            amp *= MathUtil.lerp(1.0, Math.min(noise + 1, 2) * 0.5, weightedStrength);
             
             x *= lacunarity;
             y *= lacunarity;
@@ -41,7 +42,7 @@ public class BrownianMotionSampler extends FractalNoiseFunction {
         for(int i = 0; i < octaves; i++) {
             double noise = input.noise(seed++, x, y, z);
             sum += noise * amp;
-            amp *= lerp(1.0, (noise + 1) * 0.5, weightedStrength);
+            amp *= MathUtil.lerp(1.0, (noise + 1) * 0.5, weightedStrength);
             
             x *= lacunarity;
             y *= lacunarity;

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

@@ -25,7 +25,7 @@ public abstract class FractalNoiseFunction extends NoiseFunction {
     }
     
     protected void calculateFractalBounding() {
-        double gain = fastAbs(this.gain);
+        double gain = Math.abs(this.gain);
         double amp = gain;
         double ampFractal = 1.0;
         for(int i = 1; i < octaves; i++) {

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

@@ -8,6 +8,7 @@
 package com.dfsek.terra.addons.noise.samplers.noise.fractal;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.MathUtil;
 
 
 public class PingPongSampler extends FractalNoiseFunction {
@@ -35,7 +36,7 @@ public class PingPongSampler extends FractalNoiseFunction {
         for(int i = 0; i < octaves; i++) {
             double noise = pingPong((input.noise(seed++, x, y) + 1) * pingPongStrength);
             sum += (noise - 0.5) * 2 * amp;
-            amp *= lerp(1.0, noise, weightedStrength);
+            amp *= MathUtil.lerp(1.0, noise, weightedStrength);
             
             x *= lacunarity;
             y *= lacunarity;
@@ -53,7 +54,7 @@ public class PingPongSampler extends FractalNoiseFunction {
         for(int i = 0; i < octaves; i++) {
             double noise = pingPong((input.noise(seed++, x, y, z) + 1) * pingPongStrength);
             sum += (noise - 0.5) * 2 * amp;
-            amp *= lerp(1.0, noise, weightedStrength);
+            amp *= MathUtil.lerp(1.0, noise, weightedStrength);
             
             x *= lacunarity;
             y *= lacunarity;

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

@@ -8,6 +8,7 @@
 package com.dfsek.terra.addons.noise.samplers.noise.fractal;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
+import com.dfsek.terra.api.util.MathUtil;
 
 
 public class RidgedFractalSampler extends FractalNoiseFunction {
@@ -22,9 +23,9 @@ public class RidgedFractalSampler extends FractalNoiseFunction {
         double amp = fractalBounding;
         
         for(int i = 0; i < octaves; i++) {
-            double noise = fastAbs(input.noise(seed++, x, y));
+            double noise = Math.abs(input.noise(seed++, x, y));
             sum += (noise * -2 + 1) * amp;
-            amp *= lerp(1.0, 1 - noise, weightedStrength);
+            amp *= MathUtil.lerp(1.0, 1 - noise, weightedStrength);
             
             x *= lacunarity;
             y *= lacunarity;
@@ -40,9 +41,9 @@ public class RidgedFractalSampler extends FractalNoiseFunction {
         double amp = fractalBounding;
         
         for(int i = 0; i < octaves; i++) {
-            double noise = fastAbs(input.noise(seed++, x, y, z));
+            double noise = Math.abs(input.noise(seed++, x, y, z));
             sum += (noise * -2 + 1) * amp;
-            amp *= lerp(1.0, 1 - noise, weightedStrength);
+            amp *= MathUtil.lerp(1.0, 1 - noise, weightedStrength);
             
             x *= lacunarity;
             y *= lacunarity;

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

@@ -7,6 +7,9 @@
 
 package com.dfsek.terra.addons.noise.samplers.noise.random;
 
+import com.dfsek.terra.api.util.MathUtil;
+
+
 /**
  * NoiseSampler implementation to produce random, uniformly distributed (white) noise.
  */
@@ -15,7 +18,7 @@ public class PositiveWhiteNoiseSampler extends WhiteNoiseSampler {
     // Bits that when applied to the exponent/sign section of a double, produce a positive number with a power of 1.
     
     public double getNoiseRaw(long seed) {
-        return (Double.longBitsToDouble((murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2;
+        return (Double.longBitsToDouble((MathUtil.murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2;
     }
     
     @Override

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

@@ -8,6 +8,7 @@
 package com.dfsek.terra.addons.noise.samplers.noise.random;
 
 import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
+import com.dfsek.terra.api.util.MathUtil;
 
 
 /**
@@ -24,18 +25,18 @@ public class WhiteNoiseSampler extends NoiseFunction {
         long hashX = Double.doubleToRawLongBits(x) ^ seed;
         long hashZ = Double.doubleToRawLongBits(y) ^ seed;
         long hash = (((hashX ^ (hashX >>> 32)) + ((hashZ ^ (hashZ >>> 32)) << 32)) ^ seed) + Double.doubleToRawLongBits(z);
-        return murmur64(hash);
+        return MathUtil.murmur64(hash);
     }
     
     public long randomBits(long seed, double x, double y) {
         long hashX = Double.doubleToRawLongBits(x) ^ seed;
         long hashZ = Double.doubleToRawLongBits(y) ^ seed;
         long hash = ((hashX ^ (hashX >>> 32)) + ((hashZ ^ (hashZ >>> 32)) << 32)) ^ seed;
-        return murmur64(hash);
+        return MathUtil.murmur64(hash);
     }
     
     public double getNoiseRaw(long seed) {
-        return (Double.longBitsToDouble((murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2;
+        return (Double.longBitsToDouble((MathUtil.murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2;
     }
     
     @Override

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

@@ -26,8 +26,8 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
         y += s;
         
         
-        int i = fastFloor(x);
-        int j = fastFloor(y);
+        int i = (int) Math.floor(x);
+        int j = (int) Math.floor(y);
         double xi = x - i;
         double yi = y - j;
         
@@ -131,9 +131,9 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
         z = r - z;
         
         
-        int i = fastFloor(x);
-        int j = fastFloor(y);
-        int k = fastFloor(z);
+        int i = (int) Math.floor(x);
+        int j = (int) Math.floor(y);
+        int k = (int) Math.floor(z);
         double xi = x - i;
         double yi = y - j;
         double zi = z - k;

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

@@ -25,8 +25,8 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler {
         y += s;
         
         
-        int i = fastFloor(x);
-        int j = fastFloor(y);
+        int i = (int) Math.floor(x);
+        int j = (int) Math.floor(y);
         double xi = x - i;
         double yi = y - j;
         
@@ -85,9 +85,9 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler {
         z = r - z;
         
         
-        int i = fastRound(x);
-        int j = fastRound(y);
-        int k = fastRound(z);
+        int i = (int) Math.round(x);
+        int j = (int) Math.round(y);
+        int k = (int) Math.round(z);
         double x0 = x - i;
         double y0 = y - j;
         double z0 = z - k;

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

@@ -7,6 +7,9 @@
 
 package com.dfsek.terra.addons.noise.samplers.noise.simplex;
 
+import com.dfsek.terra.api.util.MathUtil;
+
+
 /**
  * NoiseSampler implementation to provide Perlin Noise.
  */
@@ -14,34 +17,34 @@ public class PerlinSampler extends SimplexStyleSampler {
     @Override
     public double getNoiseRaw(long sl, double x, double y) {
         int seed = (int) sl;
-        int x0 = fastFloor(x);
-        int y0 = fastFloor(y);
+        int x0 = (int) Math.floor(x);
+        int y0 = (int) Math.floor(y);
         
         double xd0 = x - x0;
         double yd0 = y - y0;
         double xd1 = xd0 - 1;
         double yd1 = yd0 - 1;
         
-        double xs = interpQuintic(xd0);
-        double ys = interpQuintic(yd0);
+        double xs = MathUtil.interpQuintic(xd0);
+        double ys = MathUtil.interpQuintic(yd0);
         
         x0 *= PRIME_X;
         y0 *= PRIME_Y;
         int x1 = x0 + PRIME_X;
         int y1 = y0 + PRIME_Y;
         
-        double xf0 = lerp(gradCoord(seed, x0, y0, xd0, yd0), gradCoord(seed, x1, y0, xd1, yd0), xs);
-        double xf1 = lerp(gradCoord(seed, x0, y1, xd0, yd1), gradCoord(seed, x1, y1, xd1, yd1), xs);
+        double xf0 = MathUtil.lerp(gradCoord(seed, x0, y0, xd0, yd0), gradCoord(seed, x1, y0, xd1, yd0), xs);
+        double xf1 = MathUtil.lerp(gradCoord(seed, x0, y1, xd0, yd1), gradCoord(seed, x1, y1, xd1, yd1), xs);
         
-        return lerp(xf0, xf1, ys) * 1.4247691104677813;
+        return MathUtil.lerp(xf0, xf1, ys) * 1.4247691104677813;
     }
     
     @Override
     public double getNoiseRaw(long sl, double x, double y, double z) {
         int seed = (int) sl;
-        int x0 = fastFloor(x);
-        int y0 = fastFloor(y);
-        int z0 = fastFloor(z);
+        int x0 = (int) Math.floor(x);
+        int y0 = (int) Math.floor(y);
+        int z0 = (int) Math.floor(z);
         
         double xd0 = x - x0;
         double yd0 = y - y0;
@@ -50,9 +53,9 @@ public class PerlinSampler extends SimplexStyleSampler {
         double yd1 = yd0 - 1;
         double zd1 = zd0 - 1;
         
-        double xs = interpQuintic(xd0);
-        double ys = interpQuintic(yd0);
-        double zs = interpQuintic(zd0);
+        double xs = MathUtil.interpQuintic(xd0);
+        double ys = MathUtil.interpQuintic(yd0);
+        double zs = MathUtil.interpQuintic(zd0);
         
         x0 *= PRIME_X;
         y0 *= PRIME_Y;
@@ -61,14 +64,14 @@ public class PerlinSampler extends SimplexStyleSampler {
         int y1 = y0 + PRIME_Y;
         int z1 = z0 + PRIME_Z;
         
-        double xf00 = lerp(gradCoord(seed, x0, y0, z0, xd0, yd0, zd0), gradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs);
-        double xf10 = lerp(gradCoord(seed, x0, y1, z0, xd0, yd1, zd0), gradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs);
-        double xf01 = lerp(gradCoord(seed, x0, y0, z1, xd0, yd0, zd1), gradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs);
-        double xf11 = lerp(gradCoord(seed, x0, y1, z1, xd0, yd1, zd1), gradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs);
+        double xf00 = MathUtil.lerp(gradCoord(seed, x0, y0, z0, xd0, yd0, zd0), gradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs);
+        double xf10 = MathUtil.lerp(gradCoord(seed, x0, y1, z0, xd0, yd1, zd0), gradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs);
+        double xf01 = MathUtil.lerp(gradCoord(seed, x0, y0, z1, xd0, yd0, zd1), gradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs);
+        double xf11 = MathUtil.lerp(gradCoord(seed, x0, y1, z1, xd0, yd1, zd1), gradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs);
         
-        double yf0 = lerp(xf00, xf10, ys);
-        double yf1 = lerp(xf01, xf11, ys);
+        double yf0 = MathUtil.lerp(xf00, xf10, ys);
+        double yf1 = MathUtil.lerp(xf01, xf11, ys);
         
-        return lerp(yf0, yf1, zs) * 0.964921414852142333984375;
+        return MathUtil.lerp(yf0, yf1, zs) * 0.964921414852142333984375;
     }
 }

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

@@ -61,8 +61,8 @@ public class SimplexSampler extends SimplexStyleSampler {
     public double getNoiseRaw(long sl, double x, double y) {
         int seed = (int) sl;
         double t = (x + y) * F2;
-        int i = fastFloor(x + t);
-        int j = fastFloor(y + t);
+        int i = (int) Math.floor(x + t);
+        int j = (int) Math.floor(y + t);
         
         t = (i + j) * G2;
         double X0 = i - t;
@@ -118,9 +118,9 @@ public class SimplexSampler extends SimplexStyleSampler {
     public double getNoiseRaw(long sl, double x, double y, double z) {
         int seed = (int) sl;
         double t = (x + y + z) * F3;
-        int i = fastFloor(x + t);
-        int j = fastFloor(y + t);
-        int k = fastFloor(z + t);
+        int i = (int) Math.floor(x + t);
+        int j = (int) Math.floor(y + t);
+        int k = (int) Math.floor(z + t);
         
         t = (i + j + k) * G3;
         double x0 = x - (i - t);