Reformat all code

Signed-off-by: solonovamax <solonovamax@12oclockpoint.com>

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

@@ -1,6 +1,11 @@
 package com.dfsek.terra.addons.noise;
 
 import com.dfsek.tectonic.loading.object.ObjectTemplate;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.function.Supplier;
+
 import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler;
 import com.dfsek.terra.addons.noise.config.templates.DomainWarpTemplate;
 import com.dfsek.terra.addons.noise.config.templates.ImageSamplerTemplate;
@@ -37,70 +42,69 @@ import com.dfsek.terra.api.noise.NoiseSampler;
 import com.dfsek.terra.api.registry.CheckedRegistry;
 import com.dfsek.terra.api.util.reflection.TypeKey;
 
-import java.util.HashMap;
-import java.util.Map;
-import java.util.function.Supplier;
 
 @Addon("config-noise-function")
 @Author("Terra")
 @Version("1.0.0")
 public class NoiseAddon extends TerraAddon {
+    public static final TypeKey<Supplier<ObjectTemplate<NoiseSampler>>> NOISE_SAMPLER_TOKEN = new TypeKey<>() {
+    };
     @Inject
     private TerraPlugin plugin;
-
-    public static final TypeKey<Supplier<ObjectTemplate<NoiseSampler>>> NOISE_SAMPLER_TOKEN = new TypeKey<>() {};
-
+    
     @Override
     public void initialize() {
         plugin.getEventManager()
-                .getHandler(FunctionalEventHandler.class)
-                .register(this, ConfigPackPreLoadEvent.class)
-                .then(event -> {
-                    CheckedRegistry<Supplier<ObjectTemplate<NoiseSampler>>> noiseRegistry = event.getPack().getOrCreateRegistry(NOISE_SAMPLER_TOKEN);
-                    event.getPack()
-                            .applyLoader(CellularSampler.DistanceFunction.class, (t, o, l) -> CellularSampler.DistanceFunction.valueOf((String) o))
-                            .applyLoader(CellularSampler.ReturnType.class, (t, o, l) -> CellularSampler.ReturnType.valueOf((String) o))
-                            .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new);
-
-                    noiseRegistry.register("LINEAR", LinearNormalizerTemplate::new);
-                    noiseRegistry.register("NORMAL", NormalNormalizerTemplate::new);
-                    noiseRegistry.register("CLAMP", ClampNormalizerTemplate::new);
-
-                    noiseRegistry.register("IMAGE", ImageSamplerTemplate::new);
-
-                    noiseRegistry.register("DOMAIN_WARP", DomainWarpTemplate::new);
-
-                    noiseRegistry.register("FBM", BrownianMotionTemplate::new);
-                    noiseRegistry.register("PING_PONG", PingPongTemplate::new);
-                    noiseRegistry.register("RIDGED", RidgedFractalTemplate::new);
-
-                    noiseRegistry.register("OPEN_SIMPLEX_2", () -> new SimpleNoiseTemplate(OpenSimplex2Sampler::new));
-                    noiseRegistry.register("OPEN_SIMPLEX_2S", () -> new SimpleNoiseTemplate(OpenSimplex2SSampler::new));
-                    noiseRegistry.register("PERLIN", () -> new SimpleNoiseTemplate(PerlinSampler::new));
-                    noiseRegistry.register("SIMPLEX", () -> new SimpleNoiseTemplate(SimplexSampler::new));
-                    noiseRegistry.register("GABOR", GaborNoiseTemplate::new);
-
-
-                    noiseRegistry.register("VALUE", () -> new SimpleNoiseTemplate(ValueSampler::new));
-                    noiseRegistry.register("VALUE_CUBIC", () -> new SimpleNoiseTemplate(ValueCubicSampler::new));
-
-                    noiseRegistry.register("CELLULAR", CellularNoiseTemplate::new);
-
-                    noiseRegistry.register("WHITE_NOISE", () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new));
-                    noiseRegistry.register("GAUSSIAN", () -> new SimpleNoiseTemplate(GaussianNoiseSampler::new));
-
-                    noiseRegistry.register("CONSTANT", ConstantNoiseTemplate::new);
-
-                    noiseRegistry.register("KERNEL", KernelTemplate::new);
-
-                    Map<String, DimensionApplicableNoiseSampler> packFunctions = new HashMap<>();
-                    noiseRegistry.register("EXPRESSION", () -> new ExpressionFunctionTemplate(packFunctions));
-
-
-                    NoiseConfigPackTemplate template = new NoiseConfigPackTemplate();
-                    event.loadTemplate(template);
-                    packFunctions.putAll(template.getNoiseBuilderMap());
-                })
-                .failThrough();
+              .getHandler(FunctionalEventHandler.class)
+              .register(this, ConfigPackPreLoadEvent.class)
+              .then(event -> {
+                  CheckedRegistry<Supplier<ObjectTemplate<NoiseSampler>>> noiseRegistry = event.getPack().getOrCreateRegistry(
+                          NOISE_SAMPLER_TOKEN);
+                  event.getPack()
+                       .applyLoader(CellularSampler.DistanceFunction.class,
+                                    (t, o, l) -> CellularSampler.DistanceFunction.valueOf((String) o))
+                       .applyLoader(CellularSampler.ReturnType.class, (t, o, l) -> CellularSampler.ReturnType.valueOf((String) o))
+                       .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new);
+            
+                  noiseRegistry.register("LINEAR", LinearNormalizerTemplate::new);
+                  noiseRegistry.register("NORMAL", NormalNormalizerTemplate::new);
+                  noiseRegistry.register("CLAMP", ClampNormalizerTemplate::new);
+            
+                  noiseRegistry.register("IMAGE", ImageSamplerTemplate::new);
+            
+                  noiseRegistry.register("DOMAIN_WARP", DomainWarpTemplate::new);
+            
+                  noiseRegistry.register("FBM", BrownianMotionTemplate::new);
+                  noiseRegistry.register("PING_PONG", PingPongTemplate::new);
+                  noiseRegistry.register("RIDGED", RidgedFractalTemplate::new);
+            
+                  noiseRegistry.register("OPEN_SIMPLEX_2", () -> new SimpleNoiseTemplate(OpenSimplex2Sampler::new));
+                  noiseRegistry.register("OPEN_SIMPLEX_2S", () -> new SimpleNoiseTemplate(OpenSimplex2SSampler::new));
+                  noiseRegistry.register("PERLIN", () -> new SimpleNoiseTemplate(PerlinSampler::new));
+                  noiseRegistry.register("SIMPLEX", () -> new SimpleNoiseTemplate(SimplexSampler::new));
+                  noiseRegistry.register("GABOR", GaborNoiseTemplate::new);
+            
+            
+                  noiseRegistry.register("VALUE", () -> new SimpleNoiseTemplate(ValueSampler::new));
+                  noiseRegistry.register("VALUE_CUBIC", () -> new SimpleNoiseTemplate(ValueCubicSampler::new));
+            
+                  noiseRegistry.register("CELLULAR", CellularNoiseTemplate::new);
+            
+                  noiseRegistry.register("WHITE_NOISE", () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new));
+                  noiseRegistry.register("GAUSSIAN", () -> new SimpleNoiseTemplate(GaussianNoiseSampler::new));
+            
+                  noiseRegistry.register("CONSTANT", ConstantNoiseTemplate::new);
+            
+                  noiseRegistry.register("KERNEL", KernelTemplate::new);
+            
+                  Map<String, DimensionApplicableNoiseSampler> packFunctions = new HashMap<>();
+                  noiseRegistry.register("EXPRESSION", () -> new ExpressionFunctionTemplate(packFunctions));
+            
+            
+                  NoiseConfigPackTemplate template = new NoiseConfigPackTemplate();
+                  event.loadTemplate(template);
+                  packFunctions.putAll(template.getNoiseBuilderMap());
+              })
+              .failThrough();
     }
 }

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

@@ -2,15 +2,17 @@ package com.dfsek.terra.addons.noise;
 
 import com.dfsek.tectonic.annotations.Value;
 import com.dfsek.tectonic.config.ConfigTemplate;
+
+import java.util.Map;
+
 import com.dfsek.terra.addons.noise.config.DimensionApplicableNoiseSampler;
 import com.dfsek.terra.api.config.meta.Meta;
 
-import java.util.Map;
 
 public class NoiseConfigPackTemplate implements ConfigTemplate {
     @Value("noise")
     private @Meta Map<String, @Meta DimensionApplicableNoiseSampler> noiseBuilderMap;
-
+    
     public Map<String, DimensionApplicableNoiseSampler> getNoiseBuilderMap() {
         return noiseBuilderMap;
     }

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

@@ -2,26 +2,28 @@ package com.dfsek.terra.addons.noise.config;
 
 import com.dfsek.tectonic.annotations.Value;
 import com.dfsek.tectonic.loading.object.ObjectTemplate;
+
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class DimensionApplicableNoiseSampler implements ObjectTemplate<DimensionApplicableNoiseSampler> {
     @Value("dimensions")
     private @Meta int dimensions;
-
+    
     @Value(".")
     private @Meta NoiseSampler sampler;
-
-    public int getDimensions() {
-        return dimensions;
-    }
-
-    public NoiseSampler getSampler() {
-        return sampler;
-    }
-
+    
     @Override
     public DimensionApplicableNoiseSampler get() {
         return this;
     }
+    
+    public int getDimensions() {
+        return dimensions;
+    }
+    
+    public NoiseSampler getSampler() {
+        return sampler;
+    }
 }

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

@@ -2,22 +2,24 @@ package com.dfsek.terra.addons.noise.config.templates;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.samplers.DomainWarpedSampler;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-@SuppressWarnings({"unused", "FieldMayBeFinal"})
+
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
 public class DomainWarpTemplate extends SamplerTemplate<DomainWarpedSampler> {
     @Value("warp")
     private @Meta NoiseSampler warp;
-
+    
     @Value("function")
     private @Meta NoiseSampler function;
-
+    
     @Value("amplitude")
     @Default
     private @Meta double amplitude = 1;
-
+    
     @Override
     public NoiseSampler get() {
         return new DomainWarpedSampler(function, warp, amplitude);

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

@@ -2,28 +2,30 @@ package com.dfsek.terra.addons.noise.config.templates;
 
 import com.dfsek.tectonic.annotations.Value;
 import com.dfsek.tectonic.loading.object.ObjectTemplate;
-import com.dfsek.terra.api.config.meta.Meta;
 
 import java.util.List;
 
+import com.dfsek.terra.api.config.meta.Meta;
+
+
 @SuppressWarnings("unused")
 public class FunctionTemplate implements ObjectTemplate<FunctionTemplate> {
     @Value("arguments")
     private List<String> args;
-
+    
     @Value("function")
     private @Meta String function;
-
-    public List<String> getArgs() {
-        return args;
-    }
-
-    public String getFunction() {
-        return function;
-    }
-
+    
     @Override
     public FunctionTemplate get() {
         return this;
     }
+    
+    public List<String> getArgs() {
+        return args;
+    }
+    
+    public String getFunction() {
+        return function;
+    }
 }

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

@@ -1,24 +1,26 @@
 package com.dfsek.terra.addons.noise.config.templates;
 
 import com.dfsek.tectonic.annotations.Value;
+
+import java.awt.image.BufferedImage;
+
 import com.dfsek.terra.addons.noise.samplers.ImageSampler;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-import java.awt.image.BufferedImage;
 
-@SuppressWarnings({"unused", "FieldMayBeFinal"})
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
 public class ImageSamplerTemplate extends SamplerTemplate<ImageSampler> {
-
+    
     @Value("image")
     private @Meta BufferedImage image;
-
+    
     @Value("frequency")
     private @Meta double frequency;
-
+    
     @Value("channel")
     private ImageSampler.@Meta Channel channel;
-
+    
     @Override
     public NoiseSampler get() {
         return new ImageSampler(image, channel, frequency);

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

@@ -2,60 +2,61 @@ package com.dfsek.terra.addons.noise.config.templates;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
-import com.dfsek.tectonic.config.ValidatedConfigTemplate;
 import com.dfsek.tectonic.exception.ValidationException;
+
+import java.util.List;
+
 import com.dfsek.terra.addons.noise.samplers.KernelSampler;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-import java.util.List;
-
-@SuppressWarnings({"unused", "FieldMayBeFinal"})
-public class KernelTemplate extends SamplerTemplate<KernelSampler> implements ValidatedConfigTemplate {
 
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
+public class KernelTemplate extends SamplerTemplate<KernelSampler> {
+    
     @Value("kernel")
     private @Meta List<@Meta List<@Meta Double>> kernel;
-
+    
     @Value("factor")
     @Default
     private @Meta double factor = 1;
-
+    
     @Value("function")
     private @Meta NoiseSampler function;
-
+    
     @Value("frequency")
     @Default
     private @Meta double frequency = 1;
-
+    
     @Override
     public NoiseSampler get() {
         double[][] k = new double[kernel.size()][kernel.get(0).size()];
-
+        
         for(int x = 0; x < kernel.size(); x++) {
             for(int y = 0; y < kernel.get(x).size(); y++) {
                 k[x][y] = kernel.get(x).get(y) * factor;
             }
         }
-
+        
         KernelSampler sampler = new KernelSampler(k, function);
         sampler.setFrequency(frequency);
         return sampler;
     }
-
+    
     @Override
     public boolean validate() throws ValidationException {
-
+        
         if(kernel.isEmpty()) throw new ValidationException("Kernel must not be empty.");
-
+        
         int len = kernel.get(0).size();
-
+        
         if(len == 0) throw new ValidationException("Kernel row must contain data.");
-
+        
         for(int i = 0; i < kernel.size(); i++) {
             if(kernel.get(i).size() != len)
                 throw new ValidationException("Kernel row " + i + " size mismatch. Expected " + len + ", found " + kernel.get(i).size());
         }
-
+        
         return super.validate();
     }
 }

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

@@ -5,22 +5,24 @@ import com.dfsek.tectonic.annotations.Value;
 import com.dfsek.tectonic.config.ValidatedConfigTemplate;
 import com.dfsek.tectonic.exception.ValidationException;
 import com.dfsek.tectonic.loading.object.ObjectTemplate;
+
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 @SuppressWarnings("FieldMayBeFinal")
 public abstract class SamplerTemplate<T extends NoiseSampler> implements ValidatedConfigTemplate, ObjectTemplate<NoiseSampler> {
     @Value("dimensions")
     @Default
     private @Meta int dimensions = 2;
-
-    public int getDimensions() {
-        return dimensions;
-    }
-
+    
     @Override
     public boolean validate() throws ValidationException {
         if(dimensions != 2 && dimensions != 3) throw new ValidationException("Illegal amount of dimensions: " + dimensions);
         return true;
     }
+    
+    public int getDimensions() {
+        return dimensions;
+    }
 }

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

@@ -2,30 +2,32 @@ package com.dfsek.terra.addons.noise.config.templates.noise;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.samplers.noise.CellularSampler;
 import com.dfsek.terra.addons.noise.samplers.noise.simplex.OpenSimplex2Sampler;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 @SuppressWarnings("FieldMayBeFinal")
 public class CellularNoiseTemplate extends NoiseTemplate<CellularSampler> {
     @Value("distance")
     @Default
     private CellularSampler.@Meta DistanceFunction cellularDistanceFunction = CellularSampler.DistanceFunction.EuclideanSq;
-
+    
     @Value("return")
     @Default
     private CellularSampler.@Meta ReturnType cellularReturnType = CellularSampler.ReturnType.Distance;
-
+    
     @Value("jitter")
     @Default
     private @Meta double cellularJitter = 1.0D;
-
-
+    
+    
     @Value("lookup")
     @Default
     private @Meta NoiseSampler lookup = new OpenSimplex2Sampler();
-
+    
     @Override
     public NoiseSampler get() {
         CellularSampler sampler = new CellularSampler();

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

@@ -2,17 +2,19 @@ package com.dfsek.terra.addons.noise.config.templates.noise;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.config.templates.SamplerTemplate;
 import com.dfsek.terra.addons.noise.samplers.noise.ConstantSampler;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 @SuppressWarnings("FieldMayBeFinal")
 public class ConstantNoiseTemplate extends SamplerTemplate<ConstantSampler> {
     @Value("value")
     @Default
     private @Meta double value = 0d;
-
+    
     @Override
     public NoiseSampler get() {
         return new ConstantSampler(value);

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

@@ -6,8 +6,12 @@ import com.dfsek.paralithic.eval.tokenizer.ParseException;
 import com.dfsek.paralithic.functions.Function;
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
-import com.dfsek.tectonic.config.ValidatedConfigTemplate;
 import com.dfsek.tectonic.exception.ValidationException;
+
+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.config.templates.SamplerTemplate;
@@ -18,33 +22,29 @@ 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 java.util.HashMap;
-import java.util.LinkedHashMap;
-import java.util.Map;
 
-
-@SuppressWarnings({"FieldMayBeFinal", "unused"})
-public class ExpressionFunctionTemplate extends SamplerTemplate<ExpressionFunction> implements ValidatedConfigTemplate {
+@SuppressWarnings({ "FieldMayBeFinal", "unused" })
+public class ExpressionFunctionTemplate extends SamplerTemplate<ExpressionFunction> {
     private final Map<String, DimensionApplicableNoiseSampler> otherFunctions;
     @Value("variables")
     @Default
     private @Meta Map<String, @Meta Double> vars = new HashMap<>();
-
+    
     @Value("expression")
     private @Meta String equation;
-
+    
     @Value("functions")
     @Default
     private @Meta LinkedHashMap<String, @Meta DimensionApplicableNoiseSampler> functions = new LinkedHashMap<>();
-
+    
     @Value("functions")
     @Default
     private @Meta LinkedHashMap<String, @Meta FunctionTemplate> expressions = new LinkedHashMap<>();
-
+    
     public ExpressionFunctionTemplate(Map<String, DimensionApplicableNoiseSampler> otherFunctions) {
         this.otherFunctions = otherFunctions;
     }
-
+    
     @Override
     public NoiseSampler get() {
         try {
@@ -54,7 +54,7 @@ public class ExpressionFunctionTemplate extends SamplerTemplate<ExpressionFuncti
             throw new IllegalStateException(e);
         }
     }
-
+    
     @Override
     public boolean validate() throws ValidationException {
         try {
@@ -65,26 +65,26 @@ public class ExpressionFunctionTemplate extends SamplerTemplate<ExpressionFuncti
         }
         return super.validate();
     }
-
+    
     private Map<String, Function> generateFunctions() throws ParseException {
         Map<String, Function> noiseFunctionMap = new HashMap<>();
-
+        
         for(Map.Entry<String, FunctionTemplate> entry : expressions.entrySet()) {
             noiseFunctionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue(), new Parser(), new Scope()));
         }
-
+        
         otherFunctions.forEach((id, function) -> {
             if(function.getDimensions() == 2) {
                 noiseFunctionMap.put(id, new NoiseFunction2(function.getSampler()));
             } else noiseFunctionMap.put(id, new NoiseFunction3(function.getSampler()));
         });
-
+        
         functions.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/noise/GaborNoiseTemplate.java

@@ -2,31 +2,33 @@ package com.dfsek.terra.addons.noise.config.templates.noise;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.samplers.noise.GaborNoiseSampler;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class GaborNoiseTemplate extends NoiseTemplate<GaborNoiseSampler> {
     @Value("rotation")
     @Default
-    private @Meta double rotation = 0.25;
-
+    private final @Meta double rotation = 0.25;
+    
     @Value("isotropic")
     @Default
-    private @Meta boolean isotropic = true;
-
+    private final @Meta boolean isotropic = true;
+    
     @Value("deviation")
     @Default
-    private @Meta double deviation = 1.0;
-
+    private final @Meta double deviation = 1.0;
+    
     @Value("impulses")
     @Default
-    private @Meta double impulses = 64d;
-
+    private final @Meta double impulses = 64d;
+    
     @Value("frequency_0")
     @Default
-    private @Meta double f0 = 0.625;
-
+    private final @Meta double f0 = 0.625;
+    
     @Override
     public NoiseSampler get() {
         GaborNoiseSampler gaborNoiseSampler = new GaborNoiseSampler();

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

@@ -2,17 +2,18 @@ package com.dfsek.terra.addons.noise.config.templates.noise;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.config.templates.SamplerTemplate;
 import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
 import com.dfsek.terra.api.config.meta.Meta;
-import com.dfsek.terra.api.noise.NoiseSampler;
 
-@SuppressWarnings({"unused", "FieldMayBeFinal"})
+
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
 public abstract class NoiseTemplate<T extends NoiseFunction> extends SamplerTemplate<T> {
     @Value("frequency")
     @Default
     protected @Meta double frequency = 0.02d;
-
+    
     @Value("salt")
     @Default
     protected @Meta long salt = 0;

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

@@ -1,18 +1,18 @@
 package com.dfsek.terra.addons.noise.config.templates.noise;
 
+import java.util.function.Supplier;
+
 import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-import java.util.function.Function;
-import java.util.function.Supplier;
 
 public class SimpleNoiseTemplate extends NoiseTemplate<NoiseFunction> {
     private final Supplier<NoiseFunction> samplerSupplier;
-
+    
     public SimpleNoiseTemplate(Supplier<NoiseFunction> samplerSupplier) {
         this.samplerSupplier = samplerSupplier;
     }
-
+    
     @Override
     public NoiseSampler get() {
         NoiseFunction sampler = samplerSupplier.get();

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

@@ -3,6 +3,7 @@ package com.dfsek.terra.addons.noise.config.templates.noise.fractal;
 import com.dfsek.terra.addons.noise.samplers.noise.fractal.BrownianMotionSampler;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class BrownianMotionTemplate extends FractalTemplate<BrownianMotionSampler> {
     @Override
     public NoiseSampler get() {

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

@@ -2,28 +2,30 @@ package com.dfsek.terra.addons.noise.config.templates.noise.fractal;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.config.templates.SamplerTemplate;
 import com.dfsek.terra.addons.noise.samplers.noise.fractal.FractalNoiseFunction;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public abstract class FractalTemplate<T extends FractalNoiseFunction> extends SamplerTemplate<T> {
     @Value("octaves")
     @Default
     protected @Meta int octaves = 3;
-
+    
     @Value("gain")
     @Default
     protected @Meta double fractalGain = 0.5D;
-
+    
     @Value("lacunarity")
     @Default
     protected @Meta double fractalLacunarity = 2.0D;
-
+    
     @Value("weighted-strength")
     @Default
     protected @Meta double weightedStrength = 0.0D;
-
+    
     @Value("function")
     protected @Meta NoiseSampler function;
 }

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

@@ -2,16 +2,18 @@ package com.dfsek.terra.addons.noise.config.templates.noise.fractal;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.samplers.noise.fractal.PingPongSampler;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-@SuppressWarnings({"unused", "FieldMayBeFinal"})
+
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
 public class PingPongTemplate extends FractalTemplate<PingPongSampler> {
     @Value("ping-pong")
     @Default
     private @Meta double pingPong = 2.0D;
-
+    
     @Override
     public NoiseSampler get() {
         PingPongSampler sampler = new PingPongSampler(function);

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

@@ -3,6 +3,7 @@ package com.dfsek.terra.addons.noise.config.templates.noise.fractal;
 import com.dfsek.terra.addons.noise.samplers.noise.fractal.RidgedFractalSampler;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class RidgedFractalTemplate extends FractalTemplate<RidgedFractalSampler> {
     @Override
     public NoiseSampler get() {

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

@@ -1,18 +1,20 @@
 package com.dfsek.terra.addons.noise.config.templates.normalizer;
 
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.normalizer.ClampNormalizer;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-@SuppressWarnings({"unused", "FieldMayBeFinal"})
+
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
 public class ClampNormalizerTemplate extends NormalizerTemplate<ClampNormalizer> {
     @Value("max")
     private @Meta double max;
-
+    
     @Value("min")
     private @Meta double min;
-
+    
     @Override
     public NoiseSampler get() {
         return new ClampNormalizer(function, min, max);

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

@@ -1,18 +1,20 @@
 package com.dfsek.terra.addons.noise.config.templates.normalizer;
 
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.normalizer.LinearNormalizer;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-@SuppressWarnings({"unused", "FieldMayBeFinal"})
+
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
 public class LinearNormalizerTemplate extends NormalizerTemplate<LinearNormalizer> {
     @Value("max")
     private @Meta double max;
-
+    
     @Value("min")
     private @Meta double min;
-
+    
     @Override
     public NoiseSampler get() {
         return new LinearNormalizer(function, min, max);

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

@@ -2,22 +2,24 @@ package com.dfsek.terra.addons.noise.config.templates.normalizer;
 
 import com.dfsek.tectonic.annotations.Default;
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.normalizer.NormalNormalizer;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-@SuppressWarnings({"unused", "FieldMayBeFinal"})
+
+@SuppressWarnings({ "unused", "FieldMayBeFinal" })
 public class NormalNormalizerTemplate extends NormalizerTemplate<NormalNormalizer> {
     @Value("mean")
     private @Meta double mean;
-
+    
     @Value("standard-deviation")
     private @Meta double stdDev;
-
+    
     @Value("groups")
     @Default
     private @Meta int groups = 16384;
-
+    
     @Override
     public NoiseSampler get() {
         return new NormalNormalizer(function, groups, mean, stdDev);

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

@@ -1,11 +1,13 @@
 package com.dfsek.terra.addons.noise.config.templates.normalizer;
 
 import com.dfsek.tectonic.annotations.Value;
+
 import com.dfsek.terra.addons.noise.config.templates.SamplerTemplate;
 import com.dfsek.terra.addons.noise.normalizer.Normalizer;
 import com.dfsek.terra.api.config.meta.Meta;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public abstract class NormalizerTemplate<T extends Normalizer> extends SamplerTemplate<T> {
     @Value("function")
     protected @Meta NoiseSampler function;

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

@@ -1,18 +1,20 @@
 package com.dfsek.terra.addons.noise.normalizer;
 
-import com.dfsek.terra.api.noise.NoiseSampler;
 import net.jafama.FastMath;
 
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
 public class ClampNormalizer extends Normalizer {
     private final double min;
     private final double max;
-
+    
     public ClampNormalizer(NoiseSampler sampler, double min, double max) {
         super(sampler);
         this.min = min;
         this.max = max;
     }
-
+    
     @Override
     public double normalize(double in) {
         return FastMath.max(FastMath.min(in, max), min);

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

@@ -2,19 +2,20 @@ package com.dfsek.terra.addons.noise.normalizer;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 /**
  * Normalizer to linearly scale data's range.
  */
 public class LinearNormalizer extends Normalizer {
     private final double min;
     private final double max;
-
+    
     public LinearNormalizer(NoiseSampler sampler, double min, double max) {
         super(sampler);
         this.min = min;
         this.max = max;
     }
-
+    
     @Override
     public double normalize(double in) {
         return (in - min) * (2 / (max - min)) - 1;

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

@@ -1,25 +1,27 @@
 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;
-import net.jafama.FastMath;
+
 
 /**
  * Normalizer to redistribute normally distributed data to a continuous distribution via an automatically generated lookup table.
  */
 public class NormalNormalizer extends Normalizer {
-
+    
     private final double[] lookup;
-
+    
     public NormalNormalizer(NoiseSampler sampler, int buckets, double mean, double standardDeviation) {
         super(sampler);
         this.lookup = new double[buckets];
-
+        
         for(int i = 0; i < buckets; i++) {
             lookup[i] = MathUtil.normalInverse((double) i / buckets, mean, standardDeviation);
         }
     }
-
+    
     @Override
     public double normalize(double in) {
         int start = 0;
@@ -34,12 +36,12 @@ public class NormalNormalizer extends Normalizer {
         }
         double left = FastMath.abs(lookup[start] - in);
         double right = FastMath.abs(lookup[end] - in);
-
+        
         double fin;
         if(left <= right) {
             fin = (double) start / (lookup.length);
         } else fin = (double) end / (lookup.length);
-
+        
         return (fin - 0.5) * 2;
     }
 }

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

@@ -2,20 +2,21 @@ package com.dfsek.terra.addons.noise.normalizer;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public abstract class Normalizer implements NoiseSampler {
     private final NoiseSampler sampler;
-
+    
     public Normalizer(NoiseSampler sampler) {
         this.sampler = sampler;
     }
-
+    
     public abstract double normalize(double in);
-
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y) {
         return normalize(sampler.getNoiseSeeded(seed, x, y));
     }
-
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y, double z) {
         return normalize(sampler.getNoiseSeeded(seed, x, y, z));

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

@@ -6,44 +6,45 @@ import com.dfsek.paralithic.eval.parser.Scope;
 import com.dfsek.paralithic.eval.tokenizer.ParseException;
 import com.dfsek.paralithic.functions.dynamic.Context;
 import com.dfsek.paralithic.functions.dynamic.DynamicFunction;
+
 import com.dfsek.terra.addons.noise.config.templates.FunctionTemplate;
 
 
 public class UserDefinedFunction implements DynamicFunction {
     private final Expression expression;
     private final int args;
-
+    
     protected UserDefinedFunction(Expression expression, int args) {
         this.expression = expression;
         this.args = args;
     }
-
+    
     public static UserDefinedFunction newInstance(FunctionTemplate template, Parser parser, Scope parent) throws ParseException {
-
+        
         Scope functionScope = new Scope().withParent(parent);
-
+        
         template.getArgs().forEach(functionScope::addInvocationVariable);
-
+        
         return new UserDefinedFunction(parser.parse(template.getFunction(), functionScope), template.getArgs().size());
     }
-
+    
     @Override
     public double eval(double... args) {
         return expression.evaluate(args);
     }
-
+    
     @Override
     public double eval(Context context, double... args) {
         return expression.evaluate(context, args);
     }
-
-    @Override
-    public boolean isStateless() {
-        return true;
-    }
-
+    
     @Override
     public int getArgNumber() {
         return args;
     }
+    
+    @Override
+    public boolean isStateless() {
+        return true;
+    }
 }

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

@@ -2,32 +2,32 @@ package com.dfsek.terra.addons.noise.paralithic.noise;
 
 import com.dfsek.paralithic.functions.dynamic.Context;
 import com.dfsek.paralithic.functions.dynamic.DynamicFunction;
-import com.dfsek.terra.addons.noise.util.HashMapDoubleDouble;
+
 import com.dfsek.terra.api.noise.NoiseSampler;
 
 
 public class NoiseFunction2 implements DynamicFunction {
     private final NoiseSampler gen;
-
+    
     public NoiseFunction2(NoiseSampler gen) {
         this.gen = gen;
     }
-
-    @Override
-    public int getArgNumber() {
-        return 2;
-    }
-
+    
     @Override
     public double eval(double... args) {
         throw new UnsupportedOperationException("Cannot evaluate seeded function without seed context.");
     }
-
+    
     @Override
     public double eval(Context context, double... args) {
         return gen.getNoiseSeeded(((SeedContext) context).getSeed(), args[0], args[1]);
     }
-
+    
+    @Override
+    public int getArgNumber() {
+        return 2;
+    }
+    
     @Override
     public boolean isStateless() {
         return false;

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

@@ -2,30 +2,32 @@ package com.dfsek.terra.addons.noise.paralithic.noise;
 
 import com.dfsek.paralithic.functions.dynamic.Context;
 import com.dfsek.paralithic.functions.dynamic.DynamicFunction;
+
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class NoiseFunction3 implements DynamicFunction {
     private final NoiseSampler gen;
-
+    
     public NoiseFunction3(NoiseSampler gen) {
         this.gen = gen;
     }
-
-    @Override
-    public int getArgNumber() {
-        return 3;
-    }
-
+    
     @Override
     public double eval(double... args) {
         throw new UnsupportedOperationException("Cannot evaluate seeded function without seed context.");
     }
-
+    
     @Override
     public double eval(Context context, double... args) {
         return gen.getNoiseSeeded(((SeedContext) context).getSeed(), args[0], args[1], args[2]);
     }
-
+    
+    @Override
+    public int getArgNumber() {
+        return 3;
+    }
+    
     @Override
     public boolean isStateless() {
         return false;

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

@@ -2,13 +2,14 @@ package com.dfsek.terra.addons.noise.paralithic.noise;
 
 import com.dfsek.paralithic.functions.dynamic.Context;
 
+
 public class SeedContext implements Context {
     private final long seed;
-
+    
     public SeedContext(long seed) {
         this.seed = seed;
     }
-
+    
     public long getSeed() {
         return seed;
     }

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

@@ -2,31 +2,32 @@ package com.dfsek.terra.addons.noise.samplers;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class DomainWarpedSampler implements NoiseSampler {
     private final NoiseSampler function;
     private final NoiseSampler warp;
     private final double amplitude;
-
+    
     public DomainWarpedSampler(NoiseSampler function, NoiseSampler warp, double amplitude) {
         this.function = function;
         this.warp = warp;
         this.amplitude = amplitude;
     }
-
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y) {
         return function.getNoiseSeeded(seed++,
-                x + warp.getNoiseSeeded(seed++, x, y) * amplitude,
-                y + warp.getNoiseSeeded(seed, x, y) * amplitude
-        );
+                                       x + warp.getNoiseSeeded(seed++, x, y) * amplitude,
+                                       y + warp.getNoiseSeeded(seed, x, y) * amplitude
+                                      );
     }
-
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y, double z) {
         return function.getNoiseSeeded(seed++,
-                x + warp.getNoiseSeeded(seed++, x, y, z) * amplitude,
-                y + warp.getNoiseSeeded(seed++, x, y, z) * amplitude,
-                z + warp.getNoiseSeeded(seed, x, y, z) * amplitude
-        );
+                                       x + warp.getNoiseSeeded(seed++, x, y, z) * amplitude,
+                                       y + warp.getNoiseSeeded(seed++, x, y, z) * amplitude,
+                                       z + warp.getNoiseSeeded(seed, x, y, z) * amplitude
+                                      );
     }
 }

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

@@ -1,60 +1,68 @@
 package com.dfsek.terra.addons.noise.samplers;
 
-import com.dfsek.terra.api.noise.NoiseSampler;
 import net.jafama.FastMath;
 
 import java.awt.image.BufferedImage;
 
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
 public class ImageSampler implements NoiseSampler {
     private final BufferedImage image;
     private final Channel channel;
-
+    
     private final double frequency;
-
+    
     public ImageSampler(BufferedImage image, Channel channel, double frequency) {
         this.image = image;
         this.channel = channel;
         this.frequency = frequency;
     }
-
+    
     @Override
     public double getNoiseSeeded(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) * 2;
+        return ((channel.getChannel(image.getRGB(FastMath.floorMod(FastMath.floorToInt(x * frequency), image.getWidth()),
+                                                 FastMath.floorMod(FastMath.floorToInt(y * frequency), image.getHeight()))) / 255D) - 0.5) *
+               2;
     }
-
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y, double z) {
         return getNoiseSeeded(seed, x, y);
     }
-
+    
     public enum Channel {
         RED {
             @Override
             public int getChannel(int mashed) {
                 return (mashed >> 16) & 0xff;
             }
-        }, GREEN {
+        },
+        GREEN {
             @Override
             public int getChannel(int mashed) {
                 return (mashed >> 8) & 0xff;
             }
-        }, BLUE {
+        },
+        BLUE {
             @Override
             public int getChannel(int mashed) {
                 return mashed & 0xff;
             }
-        }, GRAYSCALE {
+        },
+        GRAYSCALE {
             @Override
             public int getChannel(int mashed) {
                 return (RED.getChannel(mashed) + GREEN.getChannel(mashed) + BLUE.getChannel(mashed)) / 3;
             }
-        }, ALPHA {
+        },
+        ALPHA {
             @Override
             public int getChannel(int mashed) {
                 return (mashed >> 24) & 0xff;
             }
         };
-
+        
         public abstract int getChannel(int mashed);
     }
 }

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

@@ -2,48 +2,49 @@ package com.dfsek.terra.addons.noise.samplers;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class KernelSampler implements NoiseSampler {
     private final double[][] kernel;
     private final NoiseSampler in;
     private double frequency = 1;
-
+    
     public KernelSampler(double[][] kernel, NoiseSampler in) {
         this.kernel = kernel;
         this.in = in;
     }
-
+    
+    public void setFrequency(double frequency) {
+        this.frequency = frequency;
+    }
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y) {
         x *= frequency;
         y *= frequency;
         double accumulator = 0;
-
+        
         for(int kx = 0; kx < kernel.length; kx++) {
             for(int ky = 0; ky < kernel[kx].length; ky++) {
                 accumulator += in.getNoiseSeeded(seed, x + kx, y + ky) * kernel[kx][ky];
             }
         }
-
+        
         return accumulator;
     }
-
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y, double z) {
         x *= frequency;
         y *= frequency;
         z *= frequency;
         double accumulator = 0;
-
+        
         for(int kx = 0; kx < kernel.length; kx++) {
             for(int ky = 0; ky < kernel[kx].length; ky++) {
                 accumulator += in.getNoiseSeeded(seed, x + kx, y, z + ky) * kernel[kx][ky];
             }
         }
-
+        
         return accumulator;
     }
-
-    public void setFrequency(double frequency) {
-        this.frequency = frequency;
-    }
 }

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

@@ -5,6 +5,7 @@ import com.dfsek.terra.api.noise.NoiseSampler;
 import com.dfsek.terra.api.vector.Vector2;
 import com.dfsek.terra.api.vector.Vector3;
 
+
 /**
  * NoiseSampler implementation for Cellular (Voronoi/Worley) Noise.
  */
@@ -117,7 +118,7 @@ public class CellularSampler extends NoiseFunction {
             -0.1842489331d, -0.9777375055d, -0.1004076743d, 0, 0.0775473789d, -0.9111505856d, 0.4047110257d, 0, 0.1399838409d,
             0.7601631212d, -0.6344734459d, 0, 0.4484419361d, -0.845289248d, 0.2904925424d, 0
     };
-
+    
     private static final double[] RAND_VECS_2D = {
             -0.2700222198d, -0.9628540911d, 0.3863092627d, -0.9223693152d, 0.04444859006d, -0.999011673d, -0.5992523158d, -0.8005602176d,
             -0.7819280288d, 0.6233687174d, 0.9464672271d, 0.3227999196d, -0.6514146797d, -0.7587218957d, 0.9378472289d, 0.347048376d,
@@ -183,70 +184,70 @@ public class CellularSampler extends NoiseFunction {
             -0.6995302564d, 0.7146029809d, 0.5263414922d, -0.85027327d, -0.5395221479d, 0.841971408d, 0.6579370318d, 0.7530729462d,
             0.01426758847d, -0.9998982128d, -0.6734383991d, 0.7392433447d, 0.639412098d, -0.7688642071d, 0.9211571421d, 0.3891908523d,
             -0.146637214d, -0.9891903394d, -0.782318098d, 0.6228791163d, -0.5039610839d, -0.8637263605d, -0.7743120191d, -0.6328039957d,
-    };
-
-
+            };
+    
+    
     private DistanceFunction distanceFunction = DistanceFunction.EuclideanSq;
     private ReturnType returnType = ReturnType.Distance;
     private double jitterModifier = 1.0;
-
+    
     private NoiseSampler noiseLookup;
-
+    
     public CellularSampler() {
         noiseLookup = new OpenSimplex2Sampler();
     }
-
+    
     public void setDistanceFunction(DistanceFunction distanceFunction) {
         this.distanceFunction = distanceFunction;
     }
-
+    
     public void setJitterModifier(double jitterModifier) {
         this.jitterModifier = jitterModifier;
     }
-
+    
     public void setNoiseLookup(NoiseSampler noiseLookup) {
         this.noiseLookup = noiseLookup;
     }
-
+    
     public void setReturnType(ReturnType returnType) {
         this.returnType = returnType;
     }
-
+    
     @Override
     public double getNoiseRaw(long sl, double x, double y) {
         int seed = (int) sl;
         int xr = fastRound(x);
         int yr = fastRound(y);
-
+        
         double distance0 = Double.MAX_VALUE;
         double distance1 = Double.MAX_VALUE;
         double distance2 = Double.MAX_VALUE;
-
+        
         int closestHash = 0;
-
+        
         double cellularJitter = 0.43701595 * jitterModifier;
-
+        
         int xPrimed = (xr - 1) * PRIME_X;
         int yPrimedBase = (yr - 1) * PRIME_Y;
-
+        
         Vector2 center = new Vector2(x, 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;
@@ -267,16 +268,16 @@ public class CellularSampler extends NoiseFunction {
             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;
@@ -297,16 +298,16 @@ public class CellularSampler extends NoiseFunction {
             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;
@@ -325,14 +326,14 @@ public class CellularSampler extends NoiseFunction {
                 }
                 break;
         }
-
+        
         if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) {
             distance0 = fastSqrt(distance0);
             if(returnType != ReturnType.CellValue) {
                 distance1 = fastSqrt(distance1);
             }
         }
-
+        
         switch(returnType) {
             case CellValue:
                 return closestHash * (1 / 2147483648.0);
@@ -364,46 +365,46 @@ public class CellularSampler extends NoiseFunction {
                 return 0;
         }
     }
-
+    
     @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);
-
+        
         double distance0 = Double.MAX_VALUE;
         double distance1 = Double.MAX_VALUE;
         double distance2 = Double.MAX_VALUE;
         int closestHash = 0;
-
+        
         double cellularJitter = 0.39614353 * jitterModifier;
-
+        
         int xPrimed = (xr - 1) * PRIME_X;
         int yPrimedBase = (yr - 1) * PRIME_Y;
         int zPrimedBase = (zr - 1) * PRIME_Z;
-
+        
         Vector3 center = new Vector3(x, y, z);
-
+        
         switch(distanceFunction) {
             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 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;
@@ -426,20 +427,20 @@ public class CellularSampler extends NoiseFunction {
             case Manhattan:
                 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);
-
+                            
                             if(newDistance < distance0) {
                                 distance0 = newDistance;
                                 closestHash = hash;
@@ -462,21 +463,21 @@ public class CellularSampler extends NoiseFunction {
             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);
-
+                                                 (vecX * vecX + vecY * vecY + vecZ * vecZ);
+                            
                             distance1 = fastMax(fastMin(distance1, newDistance), distance0);
                             if(newDistance < distance0) {
                                 distance0 = newDistance;
@@ -500,14 +501,14 @@ public class CellularSampler extends NoiseFunction {
             default:
                 break;
         }
-
+        
         if(distanceFunction == DistanceFunction.Euclidean && returnType != ReturnType.CellValue) {
             distance0 = fastSqrt(distance0);
             if(returnType != ReturnType.CellValue) {
                 distance1 = fastSqrt(distance1);
             }
         }
-
+        
         switch(returnType) {
             case CellValue:
                 return closestHash * (1 / 2147483648.0);
@@ -539,15 +540,15 @@ public class CellularSampler extends NoiseFunction {
                 return 0;
         }
     }
-
+    
     public enum DistanceFunction {
         Euclidean,
         EuclideanSq,
         Manhattan,
         Hybrid
     }
-
-
+    
+    
     public enum ReturnType {
         CellValue,
         Distance,

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

@@ -5,16 +5,16 @@ package com.dfsek.terra.addons.noise.samplers.noise;
  */
 public class ConstantSampler extends NoiseFunction {
     private final double constant;
-
+    
     public ConstantSampler(double constant) {
         this.constant = constant;
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y) {
         return constant;
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y, double z) {
         return constant;

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

@@ -5,37 +5,39 @@ import com.dfsek.paralithic.eval.parser.Parser;
 import com.dfsek.paralithic.eval.parser.Scope;
 import com.dfsek.paralithic.eval.tokenizer.ParseException;
 import com.dfsek.paralithic.functions.Function;
-import com.dfsek.terra.addons.noise.paralithic.noise.SeedContext;
 
 import java.util.Map;
 
+import com.dfsek.terra.addons.noise.paralithic.noise.SeedContext;
+
+
 /**
  * NoiseSampler implementation using a Paralithic expression.
  */
 public class ExpressionFunction extends NoiseFunction {
     private final Expression expression;
-
+    
     public ExpressionFunction(Map<String, Function> functions, String eq, Map<String, Double> vars) throws ParseException {
         Parser p = new Parser();
         Scope scope = new Scope();
-
+        
         scope.addInvocationVariable("x");
         scope.addInvocationVariable("y");
         scope.addInvocationVariable("z");
-
+        
         vars.forEach(scope::create);
-
+        
         functions.forEach(p::registerFunction);
-
+        
         expression = p.parse(eq, scope);
         frequency = 1;
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y) {
         return expression.evaluate(new SeedContext(seed), x, 0, y);
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y, double z) {
         return expression.evaluate(new SeedContext(seed), x, y, z);

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

@@ -1,8 +1,10 @@
 package com.dfsek.terra.addons.noise.samplers.noise;
 
-import com.dfsek.terra.addons.noise.samplers.noise.random.WhiteNoiseSampler;
 import net.jafama.FastMath;
 
+import com.dfsek.terra.addons.noise.samplers.noise.random.WhiteNoiseSampler;
+
+
 public class GaborNoiseSampler extends NoiseFunction {
     private final WhiteNoiseSampler rand;
     private double k = 1.0;
@@ -13,58 +15,21 @@ public class GaborNoiseSampler extends NoiseFunction {
     private boolean isotropic = true;
     private double impulsesPerKernel = 64d;
     private double impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius));
-
     private double impulsesPerCell = impulseDensity * kernelRadius * kernelRadius;
     private double g = FastMath.exp(-impulsesPerCell);
-
-
+    
+    
     public GaborNoiseSampler() {
         rand = new WhiteNoiseSampler();
     }
-
-    public void setIsotropic(boolean isotropic) {
-        this.isotropic = isotropic;
-    }
-
-    public void setImpulsesPerKernel(double impulsesPerKernel) {
-        this.impulsesPerKernel = impulsesPerKernel;
-        recalculateRadiusAndDensity();
-    }
-
-    public void setA(double a) {
-        this.a = a;
-        recalculateRadiusAndDensity();
-    }
-
-    public void setFrequency0(double f0) {
-        this.f0 = f0;
-    }
-
-    public void setRotation(double omega0) {
-        this.omega0 = Math.PI * omega0;
-    }
-
-    public void setDeviation(double k) {
-        this.k = k;
-    }
-
+    
     private void recalculateRadiusAndDensity() {
         kernelRadius = (FastMath.sqrt(-FastMath.log(0.05) / Math.PI) / this.a);
         impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius));
         impulsesPerCell = impulseDensity * kernelRadius * kernelRadius;
         g = FastMath.exp(-impulsesPerCell);
     }
-
-    @Override
-    public double getNoiseRaw(long seed, double x, double z) {
-        return gaborNoise(seed, x, z);
-    }
-
-    @Override
-    public double getNoiseRaw(long seed, double x, double y, double z) {
-        return gaborNoise(seed, x, z);
-    }
-
+    
     private double gaborNoise(long seed, double x, double y) {
         x /= kernelRadius;
         y /= kernelRadius;
@@ -80,25 +45,63 @@ public class GaborNoiseSampler extends NoiseFunction {
         }
         return noise;
     }
-
+    
     private double calculateCell(long seed, int xi, int yi, double x, double y) {
         long mashedSeed = murmur64(31L * xi + yi) + seed;
-
+        
         double gaussianSource = (rand.getNoiseRaw(mashedSeed++) + 1) / 2;
         int impulses = 0;
         while(gaussianSource > g) {
             impulses++;
             gaussianSource *= (rand.getNoiseRaw(mashedSeed++) + 1) / 2;
         }
-
+        
         double noise = 0;
         for(int i = 0; i < impulses; i++) {
-            noise += rand.getNoiseRaw(mashedSeed++) * gabor(isotropic ? (rand.getNoiseRaw(mashedSeed++) + 1) * Math.PI : omega0, x * kernelRadius, y * kernelRadius);
+            noise += rand.getNoiseRaw(mashedSeed++) * gabor(isotropic ? (rand.getNoiseRaw(mashedSeed++) + 1) * Math.PI : omega0,
+                                                            x * kernelRadius, y * kernelRadius);
         }
         return noise;
     }
-
+    
     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(omega_0))));
+        return k * (FastMath.exp(-Math.PI * (a * a) * (x * x + y * y)) * fastCos(2 * Math.PI * f0 * (x * fastCos(omega_0) + y * fastSin(
+                omega_0))));
+    }
+    
+    public void setA(double a) {
+        this.a = a;
+        recalculateRadiusAndDensity();
+    }
+    
+    public void setDeviation(double k) {
+        this.k = k;
+    }
+    
+    public void setFrequency0(double f0) {
+        this.f0 = f0;
+    }
+    
+    public void setImpulsesPerKernel(double impulsesPerKernel) {
+        this.impulsesPerKernel = impulsesPerKernel;
+        recalculateRadiusAndDensity();
+    }
+    
+    public void setIsotropic(boolean isotropic) {
+        this.isotropic = isotropic;
+    }
+    
+    public void setRotation(double omega0) {
+        this.omega0 = Math.PI * omega0;
+    }
+    
+    @Override
+    public double getNoiseRaw(long seed, double x, double z) {
+        return gaborNoise(seed, x, z);
+    }
+    
+    @Override
+    public double getNoiseRaw(long seed, double x, double y, double z) {
+        return gaborNoise(seed, x, z);
     }
 }

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

@@ -1,8 +1,10 @@
 package com.dfsek.terra.addons.noise.samplers.noise;
 
-import com.dfsek.terra.api.noise.NoiseSampler;
 import net.jafama.FastMath;
 
+import com.dfsek.terra.api.noise.NoiseSampler;
+
+
 @SuppressWarnings("ManualMinMaxCalculation")
 public abstract class NoiseFunction implements NoiseSampler {
     // Hashing
@@ -12,90 +14,84 @@ public abstract class NoiseFunction implements NoiseSampler {
     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;
-
-    public void setSalt(long salt) {
-        this.salt = salt;
-    }
-
+    
     public NoiseFunction() {
         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;
-
+        
         hash *= 0x27d4eb2d;
         return hash;
     }
-
+    
     protected static int hash(int seed, int xPrimed, int yPrimed) {
         int hash = seed ^ xPrimed ^ yPrimed;
-
+        
         hash *= 0x27d4eb2d;
         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) {
@@ -106,38 +102,42 @@ public abstract class NoiseFunction implements NoiseSampler {
         h ^= h >>> 33;
         return h;
     }
-
-    private static double sinLookup(int a) {
-        return a >= 0 ? sin[a % (modulus)] : -sin[-a % (modulus)];
-    }
-
+    
     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;
+    }
+    
     public double getFrequency() {
         return frequency;
     }
-
+    
     public void setFrequency(double frequency) {
         this.frequency = frequency;
     }
-
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y) {
         return getNoiseRaw(seed + salt, x * frequency, y * frequency);
     }
-
+    
     @Override
     public double getNoiseSeeded(long seed, double x, double y, double z) {
         return getNoiseRaw(seed + salt, x * frequency, y * frequency, z * frequency);
     }
-
+    
     public abstract double getNoiseRaw(long seed, double x, double y);
-
+    
     public abstract double getNoiseRaw(long seed, double x, double y, double z);
 }

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

@@ -2,45 +2,46 @@ package com.dfsek.terra.addons.noise.samplers.noise.fractal;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class BrownianMotionSampler extends FractalNoiseFunction {
     public BrownianMotionSampler(NoiseSampler input) {
         super(input);
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y) {
         double sum = 0;
         double amp = fractalBounding;
-
+        
         for(int i = 0; i < octaves; i++) {
             double noise = input.getNoiseSeeded(seed++, x, y);
             sum += noise * amp;
             amp *= lerp(1.0, fastMin(noise + 1, 2) * 0.5, weightedStrength);
-
+            
             x *= lacunarity;
             y *= lacunarity;
             amp *= gain;
         }
-
+        
         return sum;
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y, double z) {
         double sum = 0;
         double amp = fractalBounding;
-
+        
         for(int i = 0; i < octaves; i++) {
             double noise = input.getNoiseSeeded(seed++, x, y, z);
             sum += noise * amp;
             amp *= lerp(1.0, (noise + 1) * 0.5, weightedStrength);
-
+            
             x *= lacunarity;
             y *= lacunarity;
             z *= lacunarity;
             amp *= gain;
         }
-
+        
         return sum;
     }
 }

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

@@ -3,6 +3,7 @@ package com.dfsek.terra.addons.noise.samplers.noise.fractal;
 import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public abstract class FractalNoiseFunction extends NoiseFunction {
     protected final NoiseSampler input;
     protected double fractalBounding = 1 / 1.75;
@@ -10,16 +11,12 @@ public abstract class FractalNoiseFunction extends NoiseFunction {
     protected double gain = 0.5;
     protected double lacunarity = 2.0d;
     protected double weightedStrength = 0.0d;
-
+    
     public FractalNoiseFunction(NoiseSampler input) {
         this.input = input;
         frequency = 1;
     }
-
-    public void setWeightedStrength(double weightedStrength) {
-        this.weightedStrength = weightedStrength;
-    }
-
+    
     protected void calculateFractalBounding() {
         double gain = fastAbs(this.gain);
         double amp = gain;
@@ -30,18 +27,22 @@ public abstract class FractalNoiseFunction extends NoiseFunction {
         }
         fractalBounding = 1 / ampFractal;
     }
-
-    public void setOctaves(int octaves) {
-        this.octaves = octaves;
-        calculateFractalBounding();
-    }
-
+    
     public void setGain(double gain) {
         this.gain = gain;
         calculateFractalBounding();
     }
-
+    
     public void setLacunarity(double lacunarity) {
         this.lacunarity = lacunarity;
     }
+    
+    public void setOctaves(int octaves) {
+        this.octaves = octaves;
+        calculateFractalBounding();
+    }
+    
+    public void setWeightedStrength(double weightedStrength) {
+        this.weightedStrength = weightedStrength;
+    }
 }

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

@@ -2,57 +2,58 @@ package com.dfsek.terra.addons.noise.samplers.noise.fractal;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
 
+
 public class PingPongSampler extends FractalNoiseFunction {
     private double pingPongStrength = 2.0;
-
+    
     public PingPongSampler(NoiseSampler input) {
         super(input);
     }
-
-
+    
+    
     private static double pingPong(double t) {
         t -= (int) (t * 0.5f) << 1;
         return t < 1 ? t : 2 - t;
     }
-
+    
     public void setPingPongStrength(double strength) {
         this.pingPongStrength = strength;
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y) {
         double sum = 0;
         double amp = fractalBounding;
-
+        
         for(int i = 0; i < octaves; i++) {
             double noise = pingPong((input.getNoiseSeeded(seed++, x, y) + 1) * pingPongStrength);
             sum += (noise - 0.5) * 2 * amp;
             amp *= lerp(1.0, noise, weightedStrength);
-
+            
             x *= lacunarity;
             y *= lacunarity;
             amp *= gain;
         }
-
+        
         return sum;
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y, double z) {
         double sum = 0;
         double amp = fractalBounding;
-
+        
         for(int i = 0; i < octaves; i++) {
             double noise = pingPong((input.getNoiseSeeded(seed++, x, y, z) + 1) * pingPongStrength);
             sum += (noise - 0.5) * 2 * amp;
             amp *= lerp(1.0, noise, weightedStrength);
-
+            
             x *= lacunarity;
             y *= lacunarity;
             z *= lacunarity;
             amp *= gain;
         }
-
+        
         return sum;
     }
 }

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

@@ -2,46 +2,47 @@ package com.dfsek.terra.addons.noise.samplers.noise.fractal;
 
 import com.dfsek.terra.api.noise.NoiseSampler;
 
-public class RidgedFractalSampler extends FractalNoiseFunction {
 
+public class RidgedFractalSampler extends FractalNoiseFunction {
+    
     public RidgedFractalSampler(NoiseSampler input) {
         super(input);
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y) {
         double sum = 0;
         double amp = fractalBounding;
-
+        
         for(int i = 0; i < octaves; i++) {
             double noise = fastAbs(input.getNoiseSeeded(seed++, x, y));
             sum += (noise * -2 + 1) * amp;
             amp *= lerp(1.0, 1 - noise, weightedStrength);
-
+            
             x *= lacunarity;
             y *= lacunarity;
             amp *= gain;
         }
-
+        
         return sum;
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y, double z) {
         double sum = 0;
         double amp = fractalBounding;
-
+        
         for(int i = 0; i < octaves; i++) {
             double noise = fastAbs(input.getNoiseSeeded(seed++, x, y, z));
             sum += (noise * -2 + 1) * amp;
             amp *= lerp(1.0, 1 - noise, weightedStrength);
-
+            
             x *= lacunarity;
             y *= lacunarity;
             z *= lacunarity;
             amp *= gain;
         }
-
+        
         return sum;
     }
 }

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

@@ -2,16 +2,17 @@ package com.dfsek.terra.addons.noise.samplers.noise.random;
 
 import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
 
+
 /**
  * NoiseSampler implementation to provide random, normally distributed (Gaussian) noise.
  */
 public class GaussianNoiseSampler extends NoiseFunction {
     private final WhiteNoiseSampler whiteNoiseSampler; // Back with a white noise sampler.
-
+    
     public GaussianNoiseSampler() {
         whiteNoiseSampler = new WhiteNoiseSampler();
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y) {
         double v1, v2, s;
@@ -23,7 +24,7 @@ public class GaussianNoiseSampler extends NoiseFunction {
         double multiplier = StrictMath.sqrt(-2 * StrictMath.log(s) / s);
         return v1 * multiplier;
     }
-
+    
     @Override
     public double getNoiseRaw(long seed, double x, double y, double z) {
         double v1, v2, s;

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

@@ -2,50 +2,52 @@ package com.dfsek.terra.addons.noise.samplers.noise.random;
 
 import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
 
+
 /**
  * NoiseSampler implementation to produce random, uniformly distributed (white) noise.
  */
 public class WhiteNoiseSampler extends NoiseFunction {
-    private static final long POSITIVE_POW1 = 0b01111111111L << 52; // Bits that when applied to the exponent/sign section of a double, produce a positive number with a power of 1.
-
+    private static final long POSITIVE_POW1 = 0b01111111111L << 52;
+    // Bits that when applied to the exponent/sign section of a double, produce a positive number with a power of 1.
+    
     public WhiteNoiseSampler() {
     }
-
-    public double getNoiseRaw(long seed) {
-        return (Double.longBitsToDouble((murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2;
-    }
-
-    @Override
-    public double getNoiseRaw(long seed, double x, double y) {
-        return (getNoiseUnmapped(seed, x, y) - 1.5) * 2;
-    }
-
-    @Override
-    public double getNoiseRaw(long seed, double x, double y, double z) {
-        return (getNoiseUnmapped(seed, x, y, z) - 1.5) * 2;
-    }
-
-    public double getNoiseUnmapped(long seed, double x, double y, double z) {
-        long base = ((randomBits(seed, x, y, z)) & 0x000fffffffffffffL) | POSITIVE_POW1; // Sign and exponent
-        return Double.longBitsToDouble(base);
-    }
-
-    public double getNoiseUnmapped(long seed, double x, double y) {
-        long base = (randomBits(seed, x, y) & 0x000fffffffffffffL) | POSITIVE_POW1; // Sign and exponent
-        return Double.longBitsToDouble(base);
-    }
-
+    
     public long randomBits(long seed, double x, double y, double z) {
         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);
     }
-
+    
     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);
     }
+    
+    public double getNoiseRaw(long seed) {
+        return (Double.longBitsToDouble((murmur64(seed) & 0x000fffffffffffffL) | POSITIVE_POW1) - 1.5) * 2;
+    }
+    
+    @Override
+    public double getNoiseRaw(long seed, double x, double y) {
+        return (getNoiseUnmapped(seed, x, y) - 1.5) * 2;
+    }
+    
+    @Override
+    public double getNoiseRaw(long seed, double x, double y, double z) {
+        return (getNoiseUnmapped(seed, x, y, z) - 1.5) * 2;
+    }
+    
+    public double getNoiseUnmapped(long seed, double x, double y, double z) {
+        long base = ((randomBits(seed, x, y, z)) & 0x000fffffffffffffL) | POSITIVE_POW1; // Sign and exponent
+        return Double.longBitsToDouble(base);
+    }
+    
+    public double getNoiseUnmapped(long seed, double x, double y) {
+        long base = (randomBits(seed, x, y) & 0x000fffffffffffffL) | POSITIVE_POW1; // Sign and exponent
+        return Double.longBitsToDouble(base);
+    }
 }

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

@@ -9,38 +9,38 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
     public double getNoiseRaw(long sl, double x, double y) {
         int seed = (int) sl;
         // 2D OpenSimplex2S case is a modified 2D simplex noise.
-
+        
         final double SQRT3 = 1.7320508075688772935274463415059;
         final double G2 = (3 - SQRT3) / 6;
-
+        
         final double F2 = 0.5f * (SQRT3 - 1);
         double s = (x + y) * F2;
         x += s;
         y += s;
-
-
+        
+        
         int i = fastFloor(x);
         int j = fastFloor(y);
         double xi = x - i;
         double yi = y - j;
-
+        
         i *= PRIME_X;
         j *= PRIME_Y;
         int i1 = i + PRIME_X;
         int j1 = j + PRIME_Y;
-
+        
         double t = (xi + yi) * G2;
         double x0 = xi - t;
         double y0 = yi - t;
-
+        
         double a0 = (2.0 / 3.0) - x0 * x0 - y0 * y0;
         double value = (a0 * a0) * (a0 * a0) * gradCoord(seed, i, j, x0, y0);
-
+        
         double a1 = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0);
         double x1 = x0 - (1 - 2 * G2);
         double y1 = y0 - (1 - 2 * G2);
         value += (a1 * a1) * (a1 * a1) * gradCoord(seed, i1, j1, x1, y1);
-
+        
         // Nested conditionals were faster than compact bit logic/arithmetic.
         double xmyi = xi - yi;
         if(t > G2) {
@@ -59,7 +59,7 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
                     value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i, j + PRIME_Y, x2, y2);
                 }
             }
-
+            
             if(yi - xmyi > 1) {
                 double x3 = x0 + (3 * G2 - 1);
                 double y3 = y0 + (3 * G2 - 2);
@@ -91,7 +91,7 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
                     value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i + PRIME_X, j, x2, y2);
                 }
             }
-
+            
             if(yi < xmyi) {
                 double x2 = x0 - G2;
                 double y2 = y0 - (G2 - 1);
@@ -108,10 +108,10 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
                 }
             }
         }
-
+        
         return value * 18.24196194486065;
     }
-
+    
     @Override
     @SuppressWarnings("NumericOverflow")
     public double getNoiseRaw(long sl, double x, double y, double z) {
@@ -122,59 +122,62 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
         x = r - x;
         y = r - y;
         z = r - z;
-
-
+        
+        
         int i = fastFloor(x);
         int j = fastFloor(y);
         int k = fastFloor(z);
         double xi = x - i;
         double yi = y - j;
         double zi = z - k;
-
+        
         i *= PRIME_X;
         j *= PRIME_Y;
         k *= PRIME_Z;
         int seed2 = seed + 1293373;
-
+        
         int xNMask = (int) (-0.5 - xi);
         int yNMask = (int) (-0.5 - yi);
         int zNMask = (int) (-0.5 - zi);
-
+        
         double x0 = xi + xNMask;
         double y0 = yi + yNMask;
         double z0 = zi + zNMask;
         double a0 = 0.75 - x0 * x0 - y0 * y0 - z0 * z0;
-        double value = (a0 * a0) * (a0 * a0) * gradCoord(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0, y0,
-                z0);
-
+        double value = (a0 * a0) * (a0 * a0) * gradCoord(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0,
+                                                         y0,
+                                                         z0);
+        
         double x1 = xi - 0.5;
         double y1 = yi - 0.5;
         double z1 = zi - 0.5;
         double a1 = 0.75 - x1 * x1 - y1 * y1 - z1 * z1;
         value += (a1 * a1) * (a1 * a1) * gradCoord(seed2, i + PRIME_X, j + PRIME_Y, k + PRIME_Z, x1, y1, z1);
-
+        
         double xAFlipMask0 = ((xNMask | 1) << 1) * x1;
         double yAFlipMask0 = ((yNMask | 1) << 1) * y1;
         double zAFlipMask0 = ((zNMask | 1) << 1) * z1;
         double xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0;
         double yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0;
         double zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0;
-
+        
         boolean skip5 = false;
         double a2 = xAFlipMask0 + a0;
         if(a2 > 0) {
             double x2 = x0 - (xNMask | 1);
-            value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x2, y0,
-                    z0);
+            value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x2,
+                                                       y0,
+                                                       z0);
         } else {
             double a3 = yAFlipMask0 + zAFlipMask0 + a0;
             if(a3 > 0) {
                 double y3 = y0 - (yNMask | 1);
                 double z3 = z0 - (zNMask | 1);
-                value += (a3 * a3) * (a3 * a3) * gradCoord(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x0,
-                        y3, z3);
+                value += (a3 * a3) * (a3 * a3) * gradCoord(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (~zNMask & PRIME_Z),
+                                                           x0,
+                                                           y3, z3);
             }
-
+            
             double a4 = xAFlipMask1 + a1;
             if(a4 > 0) {
                 double x4 = (xNMask | 1) + x1;
@@ -182,22 +185,24 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
                 skip5 = true;
             }
         }
-
+        
         boolean skip9 = false;
         double a6 = yAFlipMask0 + a0;
         if(a6 > 0) {
             double y6 = y0 - (yNMask | 1);
-            value += (a6 * a6) * (a6 * a6) * gradCoord(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0, y6,
-                    z0);
+            value += (a6 * a6) * (a6 * a6) * gradCoord(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0,
+                                                       y6,
+                                                       z0);
         } else {
             double a7 = xAFlipMask0 + zAFlipMask0 + a0;
             if(a7 > 0) {
                 double x7 = x0 - (xNMask | 1);
                 double z7 = z0 - (zNMask | 1);
-                value += (a7 * a7) * (a7 * a7) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x7,
-                        y0, z7);
+                value += (a7 * a7) * (a7 * a7) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z),
+                                                           x7,
+                                                           y0, z7);
             }
-
+            
             double a8 = yAFlipMask1 + a1;
             if(a8 > 0) {
                 double y8 = (yNMask | 1) + y1;
@@ -205,22 +210,24 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
                 skip9 = true;
             }
         }
-
+        
         boolean skipD = false;
         double aA = zAFlipMask0 + a0;
         if(aA > 0) {
             double zA = z0 - (zNMask | 1);
-            value += (aA * aA) * (aA * aA) * gradCoord(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x0, y0,
-                    zA);
+            value += (aA * aA) * (aA * aA) * gradCoord(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x0,
+                                                       y0,
+                                                       zA);
         } else {
             double aB = xAFlipMask0 + yAFlipMask0 + a0;
             if(aB > 0) {
                 double xB = x0 - (xNMask | 1);
                 double yB = y0 - (yNMask | 1);
-                value += (aB * aB) * (aB * aB) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), xB,
-                        yB, z0);
+                value += (aB * aB) * (aB * aB) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z),
+                                                           xB,
+                                                           yB, z0);
             }
-
+            
             double aC = zAFlipMask1 + a1;
             if(aC > 0) {
                 double zC = (zNMask | 1) + z1;
@@ -228,37 +235,38 @@ public class OpenSimplex2SSampler extends SimplexStyleSampler {
                 skipD = true;
             }
         }
-
+        
         if(!skip5) {
             double a5 = yAFlipMask1 + zAFlipMask1 + a1;
             if(a5 > 0) {
                 double y5 = (yNMask | 1) + y1;
                 double z5 = (zNMask | 1) + z1;
                 value += (a5 * a5) * (a5 * a5) * gradCoord(seed2, i + PRIME_X, j + (yNMask & (PRIME_Y << 1)), k + (zNMask & (PRIME_Z << 1)),
-                        x1, y5, z5);
+                                                           x1, y5, z5);
             }
         }
-
+        
         if(!skip9) {
             double a9 = xAFlipMask1 + zAFlipMask1 + a1;
             if(a9 > 0) {
                 double x9 = (xNMask | 1) + x1;
                 double z9 = (zNMask | 1) + z1;
-                value += (a9 * a9) * (a9 * a9) * gradCoord(seed2, i + (xNMask & (PRIME_X << 1)), j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)), x9,
-                        y1, z9);
+                value += (a9 * a9) * (a9 * a9) * gradCoord(seed2, i + (xNMask & (PRIME_X << 1)), j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)),
+                                                           x9,
+                                                           y1, z9);
             }
         }
-
+        
         if(!skipD) {
             double aD = xAFlipMask1 + yAFlipMask1 + a1;
             if(aD > 0) {
                 double xD = (xNMask | 1) + x1;
                 double yD = (yNMask | 1) + y1;
                 value += (aD * aD) * (aD * aD) * gradCoord(seed2, i + (xNMask & (PRIME_X << 1)), j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z,
-                        xD, yD, z1);
+                                                           xD, yD, z1);
             }
         }
-
+        
         return value * 9.046026385208288;
     }
 }

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

@@ -5,39 +5,39 @@ package com.dfsek.terra.addons.noise.samplers.noise.simplex;
  */
 public class OpenSimplex2Sampler extends SimplexStyleSampler {
     private static final double SQRT3 = 1.7320508075688772935274463415059;
-
+    
     @Override
     public double getNoiseRaw(long sl, double x, double y) {
         int seed = (int) sl;
         // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex.
         final double G2 = (3 - SQRT3) / 6;
-
+        
         final double F2 = 0.5f * (SQRT3 - 1);
         double s = (x + y) * F2;
         x += s;
         y += s;
-
-
+        
+        
         int i = fastFloor(x);
         int j = fastFloor(y);
         double xi = x - i;
         double yi = y - j;
-
+        
         double t = (xi + yi) * G2;
         double x0 = xi - t;
         double y0 = yi - t;
-
+        
         i *= PRIME_X;
         j *= PRIME_Y;
-
+        
         double n0, n1, n2;
-
+        
         double a = 0.5 - x0 * x0 - y0 * y0;
         if(a <= 0) n0 = 0;
         else {
             n0 = (a * a) * (a * a) * gradCoord(seed, i, j, x0, y0);
         }
-
+        
         double c = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
         if(c <= 0) n2 = 0;
         else {
@@ -45,7 +45,7 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler {
             double y2 = y0 + (2 * G2 - 1);
             n2 = (c * c) * (c * c) * gradCoord(seed, i + PRIME_X, j + PRIME_Y, x2, y2);
         }
-
+        
         if(y0 > x0) {
             double x1 = x0 + G2;
             double y1 = y0 + (G2 - 1);
@@ -63,10 +63,10 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler {
                 n1 = (b * b) * (b * b) * gradCoord(seed, i + PRIME_X, j, x1, y1);
             }
         }
-
+        
         return (n0 + n1 + n2) * 99.83685446303647f;
     }
-
+    
     @Override
     public double getNoiseRaw(long sl, double x, double y, double z) {
         int seed = (int) sl;
@@ -76,35 +76,35 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler {
         x = r - x;
         y = r - y;
         z = r - z;
-
-
+        
+        
         int i = fastRound(x);
         int j = fastRound(y);
         int k = fastRound(z);
         double x0 = x - i;
         double y0 = y - j;
         double z0 = z - k;
-
+        
         int xNSign = (int) (-1.0 - x0) | 1;
         int yNSign = (int) (-1.0 - y0) | 1;
         int zNSign = (int) (-1.0 - z0) | 1;
-
+        
         double ax0 = xNSign * -x0;
         double ay0 = yNSign * -y0;
         double az0 = zNSign * -z0;
-
+        
         i *= PRIME_X;
         j *= PRIME_Y;
         k *= PRIME_Z;
-
+        
         double value = 0;
         double a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
-
+        
         for(int l = 0; ; l++) {
             if(a > 0) {
                 value += (a * a) * (a * a) * gradCoord(seed, i, j, k, x0, y0, z0);
             }
-
+            
             if(ax0 >= ay0 && ax0 >= az0) {
                 double b = a + ax0 + ax0;
                 if(b > 1) {
@@ -124,30 +124,30 @@ public class OpenSimplex2Sampler extends SimplexStyleSampler {
                     value += (b * b) * (b * b) * gradCoord(seed, i, j, k - zNSign * PRIME_Z, x0, y0, z0 + zNSign);
                 }
             }
-
+            
             if(l == 1) break;
-
+            
             ax0 = 0.5 - ax0;
             ay0 = 0.5 - ay0;
             az0 = 0.5 - az0;
-
+            
             x0 = xNSign * ax0;
             y0 = yNSign * ay0;
             z0 = zNSign * az0;
-
+            
             a += (0.75 - ax0) - (ay0 + az0);
-
+            
             i += (xNSign >> 1) & PRIME_X;
             j += (yNSign >> 1) & PRIME_Y;
             k += (zNSign >> 1) & PRIME_Z;
-
+            
             xNSign = -xNSign;
             yNSign = -yNSign;
             zNSign = -zNSign;
-
+            
             seed = ~seed;
         }
-
+        
         return value * 32.69428253173828125;
     }
 }

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

@@ -9,59 +9,59 @@ public class PerlinSampler extends SimplexStyleSampler {
         int seed = (int) sl;
         int x0 = fastFloor(x);
         int y0 = fastFloor(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);
-
+        
         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);
-
+        
         return 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);
-
+        
         double xd0 = x - x0;
         double yd0 = y - y0;
         double zd0 = z - z0;
         double xd1 = xd0 - 1;
         double yd1 = yd0 - 1;
         double zd1 = zd0 - 1;
-
+        
         double xs = interpQuintic(xd0);
         double ys = interpQuintic(yd0);
         double zs = interpQuintic(zd0);
-
+        
         x0 *= PRIME_X;
         y0 *= PRIME_Y;
         z0 *= PRIME_Z;
         int x1 = x0 + PRIME_X;
         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 yf0 = lerp(xf00, xf10, ys);
         double yf1 = lerp(xf01, xf11, ys);
-
+        
         return lerp(yf0, yf1, zs) * 0.964921414852142333984375;
     }
 }

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

@@ -4,66 +4,66 @@ public class SimplexSampler extends SimplexStyleSampler {
     private static final Double2[] GRAD_2D = {
             new Double2(-1, -1), new Double2(1, -1), new Double2(-1, 1), new Double2(1, 1),
             new Double2(0, -1), new Double2(-1, 0), new Double2(0, 1), new Double2(1, 0),
-    };
+            };
     private static final Double3[] GRAD_3D = {
             new Double3(1, 1, 0), new Double3(-1, 1, 0), new Double3(1, -1, 0), new Double3(-1, -1, 0),
             new Double3(1, 0, 1), new Double3(-1, 0, 1), new Double3(1, 0, -1), new Double3(-1, 0, -1),
             new Double3(0, 1, 1), new Double3(0, -1, 1), new Double3(0, 1, -1), new Double3(0, -1, -1),
             new Double3(1, 1, 0), new Double3(0, -1, 1), new Double3(-1, 1, 0), new Double3(0, -1, -1),
-    };
-
+            };
+    
     private static final double F2 = 1.0 / 2.0;
     private static final double F3 = (1.0 / 3.0);
     private static final double G2 = 1.0 / 4.0;
     private static final double G3 = (1.0 / 6.0);
     private static final double G33 = G3 * 3 - 1;
-
+    
     private static final int X_PRIME = 1619;
     private static final int Y_PRIME = 31337;
     private static final int Z_PRIME = 6971;
-
-
+    
+    
     private static double gradCoord3D(int seed, int x, int y, int z, double xd, double yd, double zd) {
         int hash = seed;
         hash ^= X_PRIME * x;
         hash ^= Y_PRIME * y;
         hash ^= Z_PRIME * z;
-
+        
         hash = hash * hash * hash * 60493;
         hash = (hash >> 13) ^ hash;
-
+        
         Double3 g = GRAD_3D[hash & 15];
-
+        
         return xd * g.x + yd * g.y + zd * g.z;
     }
-
+    
     private static double gradCoord2D(int seed, int x, int y, double xd, double yd) {
         int hash = seed;
         hash ^= X_PRIME * x;
         hash ^= Y_PRIME * y;
-
+        
         hash = hash * hash * hash * 60493;
         hash = (hash >> 13) ^ hash;
-
+        
         Double2 g = GRAD_2D[hash & 7];
-
+        
         return xd * g.x + yd * g.y;
     }
-
+    
     @Override
     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);
-
+        
         t = (i + j) * G2;
         double X0 = i - t;
         double Y0 = j - t;
-
+        
         double x0 = x - X0;
         double y0 = y - Y0;
-
+        
         int i1, j1;
         if(x0 > y0) {
             i1 = 1;
@@ -72,14 +72,14 @@ public class SimplexSampler extends SimplexStyleSampler {
             i1 = 0;
             j1 = 1;
         }
-
+        
         double x1 = x0 - i1 + G2;
         double y1 = y0 - j1 + G2;
         double x2 = x0 - 1 + F2;
         double y2 = y0 - 1 + F2;
-
+        
         double n0, n1, n2;
-
+        
         t = 0.5 - x0 * x0 - y0 * y0;
         if(t < 0) {
             n0 = 0;
@@ -87,7 +87,7 @@ public class SimplexSampler extends SimplexStyleSampler {
             t *= t;
             n0 = t * t * gradCoord2D(seed, i, j, x0, y0);
         }
-
+        
         t = 0.5 - x1 * x1 - y1 * y1;
         if(t < 0) {
             n1 = 0;
@@ -95,7 +95,7 @@ public class SimplexSampler extends SimplexStyleSampler {
             t *= t;
             n1 = t * t * gradCoord2D(seed, i + i1, j + j1, x1, y1);
         }
-
+        
         t = 0.5 - x2 * x2 - y2 * y2;
         if(t < 0) {
             n2 = 0;
@@ -103,10 +103,10 @@ public class SimplexSampler extends SimplexStyleSampler {
             t *= t;
             n2 = t * t * gradCoord2D(seed, i + 1, j + 1, x2, y2);
         }
-
+        
         return 50 * (n0 + n1 + n2);
     }
-
+    
     @Override
     public double getNoiseRaw(long sl, double x, double y, double z) {
         int seed = (int) sl;
@@ -114,15 +114,15 @@ public class SimplexSampler extends SimplexStyleSampler {
         int i = fastFloor(x + t);
         int j = fastFloor(y + t);
         int k = fastFloor(z + t);
-
+        
         t = (i + j + k) * G3;
         double x0 = x - (i - t);
         double y0 = y - (j - t);
         double z0 = z - (k - t);
-
+        
         int i1, j1, k1;
         int i2, j2, k2;
-
+        
         if(x0 >= y0) {
             if(y0 >= z0) {
                 i1 = 1;
@@ -173,7 +173,7 @@ public class SimplexSampler extends SimplexStyleSampler {
                 k2 = 0;
             }
         }
-
+        
         double x1 = x0 - i1 + G3;
         double y1 = y0 - j1 + G3;
         double z1 = z0 - k1 + G3;
@@ -183,16 +183,16 @@ public class SimplexSampler extends SimplexStyleSampler {
         double x3 = x0 + G33;
         double y3 = y0 + G33;
         double z3 = z0 + G33;
-
+        
         double n0, n1, n2, n3;
-
+        
         t = 0.6 - x0 * x0 - y0 * y0 - z0 * z0;
         if(t < 0) n0 = 0;
         else {
             t *= t;
             n0 = t * t * gradCoord3D(seed, i, j, k, x0, y0, z0);
         }
-
+        
         t = 0.6 - x1 * x1 - y1 * y1 - z1 * z1;
         if(t < 0) {
             n1 = 0;
@@ -200,7 +200,7 @@ public class SimplexSampler extends SimplexStyleSampler {
             t *= t;
             n1 = t * t * gradCoord3D(seed, i + i1, j + j1, k + k1, x1, y1, z1);
         }
-
+        
         t = 0.6 - x2 * x2 - y2 * y2 - z2 * z2;
         if(t < 0) {
             n2 = 0;
@@ -208,7 +208,7 @@ public class SimplexSampler extends SimplexStyleSampler {
             t *= t;
             n2 = t * t * gradCoord3D(seed, i + i2, j + j2, k + k2, x2, y2, z2);
         }
-
+        
         t = 0.6 - x3 * x3 - y3 * y3 - z3 * z3;
         if(t < 0) {
             n3 = 0;
@@ -216,22 +216,23 @@ public class SimplexSampler extends SimplexStyleSampler {
             t *= t;
             n3 = t * t * gradCoord3D(seed, i + 1, j + 1, k + 1, x3, y3, z3);
         }
-
+        
         return 32 * (n0 + n1 + n2 + n3);
     }
-
+    
     private static class Double2 {
         public final double x, y;
-
+        
         public Double2(double x, double y) {
             this.x = x;
             this.y = y;
         }
     }
-
+    
+    
     private static class Double3 {
         public final double x, y, z;
-
+        
         public Double3(double x, double y, double z) {
             this.x = x;
             this.y = y;

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

@@ -2,6 +2,7 @@ package com.dfsek.terra.addons.noise.samplers.noise.simplex;
 
 import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
 
+
 /**
  * Abstract NoiseSampler implementation for simplex-style noise functions.
  */
@@ -50,8 +51,8 @@ public abstract class SimplexStyleSampler extends NoiseFunction {
             0.38268343236509d, 0.923879532511287d, 0.923879532511287d, 0.38268343236509d, 0.923879532511287d, -0.38268343236509d,
             0.38268343236509d, -0.923879532511287d, -0.38268343236509d, -0.923879532511287d, -0.923879532511287d, -0.38268343236509d,
             -0.923879532511287d, 0.38268343236509d, -0.38268343236509d, 0.923879532511287d,
-    };
-
+            };
+    
     protected static final double[] GRADIENTS_3D = {
             0, 1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0,
             1, 0, 1, 0, -1, 0, 1, 0, 1, 0, -1, 0, -1, 0, -1, 0,
@@ -70,27 +71,27 @@ public abstract class SimplexStyleSampler extends NoiseFunction {
             1, 1, 0, 0, -1, 1, 0, 0, 1, -1, 0, 0, -1, -1, 0, 0,
             1, 1, 0, 0, 0, -1, 1, 0, -1, 1, 0, 0, 0, -1, -1, 0
     };
-
+    
     protected static double gradCoord(int seed, int xPrimed, int yPrimed, double xd, double yd) {
         int hash = hash(seed, xPrimed, yPrimed);
         hash ^= hash >> 15;
         hash &= 127 << 1;
-
+        
         double xg = GRADIENTS_2_D[hash];
         double yg = GRADIENTS_2_D[hash | 1];
-
+        
         return xd * xg + yd * yg;
     }
-
+    
     protected static double gradCoord(int seed, int xPrimed, int yPrimed, int zPrimed, double xd, double yd, double zd) {
         int hash = hash(seed, xPrimed, yPrimed, zPrimed);
         hash ^= hash >> 15;
         hash &= 63 << 2;
-
+        
         double xg = GRADIENTS_3D[hash];
         double yg = GRADIENTS_3D[hash | 1];
         double zg = GRADIENTS_3D[hash | 2];
-
+        
         return xd * xg + yd * yg + zd * zg;
     }
 }

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

@@ -6,10 +6,10 @@ public class ValueCubicSampler extends ValueStyleNoise {
         int seed = (int) sl;
         int x1 = fastFloor(x);
         int y1 = fastFloor(y);
-
+        
         double xs = x - x1;
         double ys = y - y1;
-
+        
         x1 *= PRIME_X;
         y1 *= PRIME_Y;
         int x0 = x1 - PRIME_X;
@@ -18,34 +18,34 @@ public class ValueCubicSampler extends ValueStyleNoise {
         int y2 = y1 + PRIME_Y;
         int x3 = x1 + (PRIME_X << 1);
         int y3 = y1 + (PRIME_Y << 1);
-
+        
         return cubicLerp(
                 cubicLerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), valCoord(seed, x2, y0), valCoord(seed, x3, y0),
-                        xs),
+                          xs),
                 cubicLerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), valCoord(seed, x2, y1), valCoord(seed, x3, y1),
-                        xs),
+                          xs),
                 cubicLerp(valCoord(seed, x0, y2), valCoord(seed, x1, y2), valCoord(seed, x2, y2), valCoord(seed, x3, y2),
-                        xs),
+                          xs),
                 cubicLerp(valCoord(seed, x0, y3), valCoord(seed, x1, y3), valCoord(seed, x2, y3), valCoord(seed, x3, y3),
-                        xs),
+                          xs),
                 ys) * (1 / (1.5 * 1.5));
     }
-
+    
     @Override
     public double getNoiseRaw(long sl, double x, double y, double z) {
         int seed = (int) sl;
         int x1 = fastFloor(x);
         int y1 = fastFloor(y);
         int z1 = fastFloor(z);
-
+        
         double xs = x - x1;
         double ys = y - y1;
         double zs = z - z1;
-
+        
         x1 *= PRIME_X;
         y1 *= PRIME_Y;
         z1 *= PRIME_Z;
-
+        
         int x0 = x1 - PRIME_X;
         int y0 = y1 - PRIME_Y;
         int z0 = z1 - PRIME_Z;
@@ -55,47 +55,47 @@ public class ValueCubicSampler extends ValueStyleNoise {
         int x3 = x1 + (PRIME_X << 1);
         int y3 = y1 + (PRIME_Y << 1);
         int z3 = z1 + (PRIME_Z << 1);
-
+        
         return cubicLerp(
                 cubicLerp(
                         cubicLerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), valCoord(seed, x2, y0, z0),
-                                valCoord(seed, x3, y0, z0), xs),
+                                  valCoord(seed, x3, y0, z0), xs),
                         cubicLerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), valCoord(seed, x2, y1, z0),
-                                valCoord(seed, x3, y1, z0), xs),
+                                  valCoord(seed, x3, y1, z0), xs),
                         cubicLerp(valCoord(seed, x0, y2, z0), valCoord(seed, x1, y2, z0), valCoord(seed, x2, y2, z0),
-                                valCoord(seed, x3, y2, z0), xs),
+                                  valCoord(seed, x3, y2, z0), xs),
                         cubicLerp(valCoord(seed, x0, y3, z0), valCoord(seed, x1, y3, z0), valCoord(seed, x2, y3, z0),
-                                valCoord(seed, x3, y3, z0), xs),
+                                  valCoord(seed, x3, y3, z0), xs),
                         ys),
                 cubicLerp(
                         cubicLerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), valCoord(seed, x2, y0, z1),
-                                valCoord(seed, x3, y0, z1), xs),
+                                  valCoord(seed, x3, y0, z1), xs),
                         cubicLerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), valCoord(seed, x2, y1, z1),
-                                valCoord(seed, x3, y1, z1), xs),
+                                  valCoord(seed, x3, y1, z1), xs),
                         cubicLerp(valCoord(seed, x0, y2, z1), valCoord(seed, x1, y2, z1), valCoord(seed, x2, y2, z1),
-                                valCoord(seed, x3, y2, z1), xs),
+                                  valCoord(seed, x3, y2, z1), xs),
                         cubicLerp(valCoord(seed, x0, y3, z1), valCoord(seed, x1, y3, z1), valCoord(seed, x2, y3, z1),
-                                valCoord(seed, x3, y3, z1), xs),
+                                  valCoord(seed, x3, y3, z1), xs),
                         ys),
                 cubicLerp(
                         cubicLerp(valCoord(seed, x0, y0, z2), valCoord(seed, x1, y0, z2), valCoord(seed, x2, y0, z2),
-                                valCoord(seed, x3, y0, z2), xs),
+                                  valCoord(seed, x3, y0, z2), xs),
                         cubicLerp(valCoord(seed, x0, y1, z2), valCoord(seed, x1, y1, z2), valCoord(seed, x2, y1, z2),
-                                valCoord(seed, x3, y1, z2), xs),
+                                  valCoord(seed, x3, y1, z2), xs),
                         cubicLerp(valCoord(seed, x0, y2, z2), valCoord(seed, x1, y2, z2), valCoord(seed, x2, y2, z2),
-                                valCoord(seed, x3, y2, z2), xs),
+                                  valCoord(seed, x3, y2, z2), xs),
                         cubicLerp(valCoord(seed, x0, y3, z2), valCoord(seed, x1, y3, z2), valCoord(seed, x2, y3, z2),
-                                valCoord(seed, x3, y3, z2), xs),
+                                  valCoord(seed, x3, y3, z2), xs),
                         ys),
                 cubicLerp(
                         cubicLerp(valCoord(seed, x0, y0, z3), valCoord(seed, x1, y0, z3), valCoord(seed, x2, y0, z3),
-                                valCoord(seed, x3, y0, z3), xs),
+                                  valCoord(seed, x3, y0, z3), xs),
                         cubicLerp(valCoord(seed, x0, y1, z3), valCoord(seed, x1, y1, z3), valCoord(seed, x2, y1, z3),
-                                valCoord(seed, x3, y1, z3), xs),
+                                  valCoord(seed, x3, y1, z3), xs),
                         cubicLerp(valCoord(seed, x0, y2, z3), valCoord(seed, x1, y2, z3), valCoord(seed, x2, y2, z3),
-                                valCoord(seed, x3, y2, z3), xs),
+                                  valCoord(seed, x3, y2, z3), xs),
                         cubicLerp(valCoord(seed, x0, y3, z3), valCoord(seed, x1, y3, z3), valCoord(seed, x2, y3, z3),
-                                valCoord(seed, x3, y3, z3), xs),
+                                  valCoord(seed, x3, y3, z3), xs),
                         ys),
                 zs) * (1 / (1.5 * 1.5 * 1.5));
     }

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

@@ -6,47 +6,47 @@ public class ValueSampler extends ValueStyleNoise {
         int seed = (int) sl;
         int x0 = fastFloor(x);
         int y0 = fastFloor(y);
-
+        
         double xs = interpHermite(x - x0);
         double ys = interpHermite(y - y0);
-
+        
         x0 *= PRIME_X;
         y0 *= PRIME_Y;
         int x1 = x0 + PRIME_X;
         int y1 = y0 + PRIME_Y;
-
+        
         double xf0 = lerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), xs);
         double xf1 = lerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), xs);
-
+        
         return lerp(xf0, xf1, ys);
     }
-
+    
     @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);
-
+        
         double xs = interpHermite(x - x0);
         double ys = interpHermite(y - y0);
         double zs = interpHermite(z - z0);
-
+        
         x0 *= PRIME_X;
         y0 *= PRIME_Y;
         z0 *= PRIME_Z;
         int x1 = x0 + PRIME_X;
         int y1 = y0 + PRIME_Y;
         int z1 = z0 + PRIME_Z;
-
+        
         double xf00 = lerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), xs);
         double xf10 = lerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), xs);
         double xf01 = lerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), xs);
         double xf11 = lerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), xs);
-
+        
         double yf0 = lerp(xf00, xf10, ys);
         double yf1 = lerp(xf01, xf11, ys);
-
+        
         return lerp(yf0, yf1, zs);
     }
 }

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

@@ -2,19 +2,20 @@ package com.dfsek.terra.addons.noise.samplers.noise.value;
 
 import com.dfsek.terra.addons.noise.samplers.noise.NoiseFunction;
 
-public abstract class ValueStyleNoise extends NoiseFunction {
 
+public abstract class ValueStyleNoise extends NoiseFunction {
+    
     protected static double valCoord(int seed, int xPrimed, int yPrimed) {
         int hash = hash(seed, xPrimed, yPrimed);
-
+        
         hash *= hash;
         hash ^= hash << 19;
         return hash * (1 / 2147483648.0);
     }
-
+    
     protected static double valCoord(int seed, int xPrimed, int yPrimed, int zPrimed) {
         int hash = hash(seed, xPrimed, yPrimed, zPrimed);
-
+        
         hash *= hash;
         hash ^= hash << 19;
         return hash * (1 / 2147483648.0);

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

@@ -35,6 +35,7 @@ package com.dfsek.terra.addons.noise.util;
 
 import java.io.Serializable;
 
+
 public abstract class HashIntrinsic implements Serializable {
     public static final int FLOAT_EXP_BIT_MASK = 2139095040;
     public static final int FLOAT_SIGNIF_BIT_MASK = 8388607;
@@ -48,7 +49,7 @@ public abstract class HashIntrinsic implements Serializable {
     protected int threshold;
     protected float loadFactor;
     protected int capMinus1;
-
+    
     protected HashIntrinsic(int initialCapacity, float loadFactor) {
         if(initialCapacity <= 0) {
             throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);
@@ -56,11 +57,11 @@ public abstract class HashIntrinsic implements Serializable {
             if(initialCapacity > 1073741824) {
                 initialCapacity = 1073741824;
             }
-
+            
             int capacity;
             for(capacity = 1; capacity < initialCapacity; capacity <<= 1) {
             }
-
+            
             this.capMinus1 = capacity - 1;
             this.loadFactor = loadFactor;
             this.threshold = (int) ((float) capacity * loadFactor);
@@ -68,51 +69,51 @@ public abstract class HashIntrinsic implements Serializable {
             throw new IllegalArgumentException("Illegal load factor: " + loadFactor);
         }
     }
-
-    protected static int hashCodeLong(long value) {
-        return (int) (value ^ value >>> 32);
-    }
-
-    protected static int hashCodeFloat(float value) {
-        return floatToIntBits(value);
-    }
-
-    protected static int hashCodeDouble(double value) {
-        long bits = doubleToLongBits(value);
-        return (int) (bits ^ bits >>> 32);
-    }
-
+    
     public static int floatToIntBits(float value) {
         int result = Float.floatToRawIntBits(value);
         if((result & 2139095040) == 2139095040 && (result & 8388607) != 0) {
             result = 2143289344;
         }
-
+        
         return result;
     }
-
+    
     public static long doubleToLongBits(double value) {
         long result = Double.doubleToRawLongBits(value);
         if((result & 9218868437227405312L) == 9218868437227405312L && (result & 4503599627370495L) != 0L) {
             result = 9221120237041090560L;
         }
-
+        
         return result;
     }
-
+    
+    protected static int hashCodeLong(long value) {
+        return (int) (value ^ value >>> 32);
+    }
+    
+    protected static int hashCodeFloat(float value) {
+        return floatToIntBits(value);
+    }
+    
+    protected static int hashCodeDouble(double value) {
+        long bits = doubleToLongBits(value);
+        return (int) (bits ^ bits >>> 32);
+    }
+    
     protected static int tableIndex(int hc, int lm1) {
         hc ^= hc >>> 20 ^ hc >>> 12;
         hc ^= hc >>> 7 ^ hc >>> 4;
         return hc & lm1;
     }
-
+    
     public int size() {
         return this.size;
     }
-
+    
+    public abstract void clear();
+    
     public boolean isEmpty() {
         return this.size == 0;
     }
-
-    public abstract void clear();
 }

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

@@ -36,35 +36,36 @@ package com.dfsek.terra.addons.noise.util;
 import java.io.Serializable;
 import java.util.NoSuchElementException;
 
+
 public class HashMapDoubleDouble extends HashIntrinsic {
     private static final long serialVersionUID = 2109458761298324234L;
     private HashMapDoubleDouble.Entry[] table;
-
+    
     public HashMapDoubleDouble(int initialCapacity, float loadFactor) {
         super(initialCapacity, loadFactor);
         this.table = this.createTable(this.capMinus1 + 1);
     }
-
+    
     public HashMapDoubleDouble(int initialCapacity) {
         this(initialCapacity, 0.75F);
     }
-
+    
     public HashMapDoubleDouble() {
         this(16, 0.75F);
     }
-
+    
     public final boolean contains(double key) {
         int i = tableIndex(hashCodeDouble(key), this.capMinus1);
-
+        
         for(HashMapDoubleDouble.Entry e = this.table[i]; e != null; e = e.next) {
             if(e.key == key) {
                 return true;
             }
         }
-
+        
         return false;
     }
-
+    
     public boolean containsValue(double value) {
         for(int i = 0; i < this.table.length; ++i) {
             for(HashMapDoubleDouble.Entry e = this.table[i]; e != null; e = e.next) {
@@ -73,37 +74,25 @@ public class HashMapDoubleDouble extends HashIntrinsic {
                 }
             }
         }
-
+        
         return false;
     }
-
+    
     public double get(double key) {
         int i = tableIndex(hashCodeDouble(key), this.capMinus1);
-
+        
         for(HashMapDoubleDouble.Entry e = this.table[i]; e != null; e = e.next) {
             if(key == e.key) {
                 return e.value;
             }
         }
-
+        
         return 4.9E-324D;
     }
-
-    public HashMapDoubleDouble.Entry getEntry(double key) {
-        int i = tableIndex(hashCodeDouble(key), this.capMinus1);
-
-        for(HashMapDoubleDouble.Entry e = this.table[i]; e != null; e = e.next) {
-            if(key == e.key) {
-                return e;
-            }
-        }
-
-        return null;
-    }
-
+    
     public double put(double key, double value) {
         int i = tableIndex(hashCodeDouble(key), this.capMinus1);
-
+        
         for(HashMapDoubleDouble.Entry e = this.table[i]; e != null; e = e.next) {
             if(key == e.key) {
                 double oldValue = e.value;
@@ -111,20 +100,11 @@ public class HashMapDoubleDouble extends HashIntrinsic {
                 return oldValue;
             }
         }
-
+        
         this.addEntry(key, value, i);
         return 4.9E-324D;
     }
-
-    private void addEntry(double key, double value, int index) {
-        HashMapDoubleDouble.Entry e = this.table[index];
-        this.table[index] = new HashMapDoubleDouble.Entry(key, value, e);
-        if(this.size++ >= this.threshold) {
-            this.resize(2 * this.table.length);
-        }
-
-    }
-
+    
     public void resize(int newCapacity) {
         int oldCapacity = this.table.length;
         if(oldCapacity == 1073741824) {
@@ -137,30 +117,11 @@ public class HashMapDoubleDouble extends HashIntrinsic {
             this.threshold = (int) ((float) newCapacity * this.loadFactor);
         }
     }
-
-    private void transfer(HashMapDoubleDouble.Entry[] newTable) {
-        for(int j = 0; j < this.table.length; ++j) {
-            HashMapDoubleDouble.Entry e = this.table[j];
-            if(e != null) {
-                this.table[j] = null;
-
-                HashMapDoubleDouble.Entry next;
-                do {
-                    next = e.next;
-                    int i = tableIndex(hashCodeDouble(e.key), this.capMinus1);
-                    e.next = newTable[i];
-                    newTable[i] = e;
-                    e = next;
-                } while(next != null);
-            }
-        }
-
-    }
-
+    
     public final HashMapDoubleDouble.Entry remove(double key) {
         int i = tableIndex(hashCodeDouble(key), this.capMinus1);
         HashMapDoubleDouble.Entry prev = this.table[i];
-
+        
         HashMapDoubleDouble.Entry e;
         HashMapDoubleDouble.Entry next;
         for(e = prev; e != null; e = next) {
@@ -172,112 +133,152 @@ public class HashMapDoubleDouble extends HashIntrinsic {
                 } else {
                     prev.next = next;
                 }
-
+                
                 return e;
             }
-
+            
             prev = e;
         }
-
+        
         return e;
     }
-
+    
     public void clear() {
         for(int i = 0; i < this.table.length; ++i) {
             this.table[i] = null;
         }
-
+        
         this.size = 0;
     }
-
-    private HashMapDoubleDouble.Entry[] createTable(int capacity) {
-        return new HashMapDoubleDouble.Entry[capacity];
-    }
-
+    
     public long memoryEstimate(int ptrsize) {
         return (long) ptrsize * (long) (this.capMinus1 + this.size + 1) + (long) (this.size * 64 / 4);
     }
-
+    
     public HashMapDoubleDouble.Iterator iterator() {
         return new HashMapDoubleDouble.Iterator();
     }
-
+    
+    private void addEntry(double key, double value, int index) {
+        HashMapDoubleDouble.Entry e = this.table[index];
+        this.table[index] = new HashMapDoubleDouble.Entry(key, value, e);
+        if(this.size++ >= this.threshold) {
+            this.resize(2 * this.table.length);
+        }
+        
+    }
+    
+    private void transfer(HashMapDoubleDouble.Entry[] newTable) {
+        for(int j = 0; j < this.table.length; ++j) {
+            HashMapDoubleDouble.Entry e = this.table[j];
+            if(e != null) {
+                this.table[j] = null;
+                
+                HashMapDoubleDouble.Entry next;
+                do {
+                    next = e.next;
+                    int i = tableIndex(hashCodeDouble(e.key), this.capMinus1);
+                    e.next = newTable[i];
+                    newTable[i] = e;
+                    e = next;
+                } while(next != null);
+            }
+        }
+        
+    }
+    
+    private HashMapDoubleDouble.Entry[] createTable(int capacity) {
+        return new HashMapDoubleDouble.Entry[capacity];
+    }
+    
+    public HashMapDoubleDouble.Entry getEntry(double key) {
+        int i = tableIndex(hashCodeDouble(key), this.capMinus1);
+        
+        for(HashMapDoubleDouble.Entry e = this.table[i]; e != null; e = e.next) {
+            if(key == e.key) {
+                return e;
+            }
+        }
+        
+        return null;
+    }
+    
+    
     public static class Entry implements Serializable {
         private static final long serialVersionUID = 7972173983741231238L;
         private final double key;
         private double value;
         private HashMapDoubleDouble.Entry next;
-
+        
         public Entry(double key, double val, HashMapDoubleDouble.Entry n) {
             this.key = key;
             this.value = val;
             this.next = n;
         }
-
-        public final double getKey() {
-            return this.key;
-        }
-
-        public final double getValue() {
-            return this.value;
-        }
-
+        
         public final double setValue(double newValue) {
             double oldValue = this.value;
             this.value = newValue;
             return oldValue;
         }
-
+        
+        public final double getKey() {
+            return this.key;
+        }
+        
+        public final double getValue() {
+            return this.value;
+        }
+        
+        public final int hashCode() {
+            return hashCodeDouble(key) + hashCodeDouble(value);
+        }
+        
         public final boolean equals(Object o) {
             HashMapDoubleDouble.Entry e = (HashMapDoubleDouble.Entry) o;
             return this.key == e.key && this.value == e.value;
         }
-
+        
         public final String toString() {
             return this.key + " = " + this.value;
         }
-
-        public final int hashCode() {
-            return hashCodeDouble(key) + hashCodeDouble(value);
-        }
     }
-
+    
+    
     public class Iterator {
         HashMapDoubleDouble.Entry next;
         int index;
         HashMapDoubleDouble.Entry current;
-
+        
         Iterator() {
             if(HashMapDoubleDouble.this.size > 0) {
-                while(this.index < HashMapDoubleDouble.this.table.length && (this.next = HashMapDoubleDouble.this.table[this.index++]) == null) {
+                while(this.index < HashMapDoubleDouble.this.table.length &&
+                      (this.next = HashMapDoubleDouble.this.table[this.index++]) == null) {
                 }
             }
-
+            
         }
-
-        public final boolean hasNext() {
-            return this.next != null;
-        }
-
+        
         public HashMapDoubleDouble.Entry nextEntry() {
             HashMapDoubleDouble.Entry e = this.next;
             if(e == null) {
                 throw new NoSuchElementException();
             } else {
                 if((this.next = e.next) == null) {
-                    while(this.index < HashMapDoubleDouble.this.table.length && (this.next = HashMapDoubleDouble.this.table[this.index++]) == null) {
+                    while(this.index < HashMapDoubleDouble.this.table.length &&
+                          (this.next = HashMapDoubleDouble.this.table[this.index++]) == null) {
                     }
                 }
-
+                
                 this.current = e;
                 return e;
             }
         }
-
+        
         public double next() {
             return this.nextEntry().value;
         }
-
+        
         public void remove() {
             if(this.current == null) {
                 throw new IllegalStateException();
@@ -287,5 +288,9 @@ public class HashMapDoubleDouble extends HashIntrinsic {
                 HashMapDoubleDouble.this.remove(k);
             }
         }
+        
+        public final boolean hasNext() {
+            return this.next != null;
+        }
     }
 }