Reformat code

2026-06-16 22:01:07 +00:00 · 2023-11-02 18:47:36 -06:00
parent d696e4fd24
commit 81a96d6b76
224 changed files with 1156 additions and 1075 deletions
@@ -95,7 +95,7 @@ public class NoiseAddon implements AddonInitializer {
                       .applyLoader(DimensionApplicableNoiseSampler.class, DimensionApplicableNoiseSampler::new)
                       .applyLoader(FunctionTemplate.class, FunctionTemplate::new)
                       .applyLoader(CubicSpline.Point.class, CubicSplinePointTemplate::new);
-            
+                  
                  noiseRegistry.register(addon.key("LINEAR"), LinearNormalizerTemplate::new);
                  noiseRegistry.register(addon.key("NORMAL"), NormalNormalizerTemplate::new);
                  noiseRegistry.register(addon.key("CLAMP"), ClampNormalizerTemplate::new);
@@ -103,53 +103,54 @@ public class NoiseAddon implements AddonInitializer {
                  noiseRegistry.register(addon.key("SCALE"), ScaleNormalizerTemplate::new);
                  noiseRegistry.register(addon.key("POSTERIZATION"), PosterizationNormalizerTemplate::new);
                  noiseRegistry.register(addon.key("CUBIC_SPLINE"), CubicSplineNormalizerTemplate::new);
-    
+                  
                  noiseRegistry.register(addon.key("IMAGE"), ImageSamplerTemplate::new);
-    
+                  
                  noiseRegistry.register(addon.key("DOMAIN_WARP"), DomainWarpTemplate::new);
-            
+                  
                  noiseRegistry.register(addon.key("FBM"), BrownianMotionTemplate::new);
                  noiseRegistry.register(addon.key("PING_PONG"), PingPongTemplate::new);
                  noiseRegistry.register(addon.key("RIDGED"), RidgedFractalTemplate::new);
-            
+                  
                  noiseRegistry.register(addon.key("OPEN_SIMPLEX_2"), () -> new SimpleNoiseTemplate(OpenSimplex2Sampler::new));
                  noiseRegistry.register(addon.key("OPEN_SIMPLEX_2S"), () -> new SimpleNoiseTemplate(OpenSimplex2SSampler::new));
                  noiseRegistry.register(addon.key("PERLIN"), () -> new SimpleNoiseTemplate(PerlinSampler::new));
                  noiseRegistry.register(addon.key("SIMPLEX"), () -> new SimpleNoiseTemplate(SimplexSampler::new));
                  noiseRegistry.register(addon.key("GABOR"), GaborNoiseTemplate::new);
-            
-            
+                  
+                  
                  noiseRegistry.register(addon.key("VALUE"), () -> new SimpleNoiseTemplate(ValueSampler::new));
                  noiseRegistry.register(addon.key("VALUE_CUBIC"), () -> new SimpleNoiseTemplate(ValueCubicSampler::new));
-            
+                  
                  noiseRegistry.register(addon.key("CELLULAR"), CellularNoiseTemplate::new);
-            
+                  
                  noiseRegistry.register(addon.key("WHITE_NOISE"), () -> new SimpleNoiseTemplate(WhiteNoiseSampler::new));
                  noiseRegistry.register(addon.key("POSITIVE_WHITE_NOISE"), () -> new SimpleNoiseTemplate(PositiveWhiteNoiseSampler::new));
                  noiseRegistry.register(addon.key("GAUSSIAN"), () -> new SimpleNoiseTemplate(GaussianNoiseSampler::new));
                  
                  noiseRegistry.register(addon.key("DISTANCE"), DistanceSamplerTemplate::new);
-            
+                  
                  noiseRegistry.register(addon.key("CONSTANT"), ConstantNoiseTemplate::new);
-            
+                  
                  noiseRegistry.register(addon.key("KERNEL"), KernelTemplate::new);
-            
+                  
                  noiseRegistry.register(addon.key("LINEAR_HEIGHTMAP"), LinearHeightmapSamplerTemplate::new);
                  noiseRegistry.register(addon.key("TRANSLATE"), TranslateSamplerTemplate::new);
-            
+                  
                  noiseRegistry.register(addon.key("ADD"), () -> new BinaryArithmeticTemplate<>(AdditionSampler::new));
                  noiseRegistry.register(addon.key("SUB"), () -> new BinaryArithmeticTemplate<>(SubtractionSampler::new));
                  noiseRegistry.register(addon.key("MUL"), () -> new BinaryArithmeticTemplate<>(MultiplicationSampler::new));
                  noiseRegistry.register(addon.key("DIV"), () -> new BinaryArithmeticTemplate<>(DivisionSampler::new));
                  noiseRegistry.register(addon.key("MAX"), () -> new BinaryArithmeticTemplate<>(MaxSampler::new));
                  noiseRegistry.register(addon.key("MIN"), () -> new BinaryArithmeticTemplate<>(MinSampler::new));
-            
-            
+                  
+                  
                  Map<String, DimensionApplicableNoiseSampler> packSamplers = new LinkedHashMap<>();
                  Map<String, FunctionTemplate> packFunctions = new LinkedHashMap<>();
                  noiseRegistry.register(addon.key("EXPRESSION"), () -> new ExpressionFunctionTemplate(packSamplers, packFunctions));
-                  noiseRegistry.register(addon.key("EXPRESSION_NORMALIZER"), () -> new ExpressionNormalizerTemplate(packSamplers, packFunctions));
-            
+                  noiseRegistry.register(addon.key("EXPRESSION_NORMALIZER"),
+                                         () -> new ExpressionNormalizerTemplate(packSamplers, packFunctions));
+                  
                  NoiseConfigPackTemplate template = event.loadTemplate(new NoiseConfigPackTemplate());
                  packSamplers.putAll(template.getSamplers());
                  packFunctions.putAll(template.getFunctions());
@@ -27,6 +27,6 @@ public class TranslateSamplerTemplate extends SamplerTemplate<TranslateSampler>
    
    @Override
    public NoiseSampler get() {
-        return new TranslateSampler(sampler, x, y ,z);
+        return new TranslateSampler(sampler, x, y, z);
    }
 }
@@ -41,15 +41,18 @@ public class ExpressionFunctionTemplate extends SamplerTemplate<ExpressionFuncti
    @Default
    private @Meta LinkedHashMap<String, @Meta FunctionTemplate> functions = new LinkedHashMap<>();
    
-    public ExpressionFunctionTemplate(Map<String, DimensionApplicableNoiseSampler> globalSamplers, Map<String, FunctionTemplate> globalFunctions) {
+    public ExpressionFunctionTemplate(Map<String, DimensionApplicableNoiseSampler> globalSamplers,
+                                      Map<String, FunctionTemplate> globalFunctions) {
        this.globalSamplers = globalSamplers;
        this.globalFunctions = globalFunctions;
    }
    
    @Override
    public NoiseSampler get() {
-        var mergedFunctions = new HashMap<>(globalFunctions); mergedFunctions.putAll(functions);
-        var mergedSamplers = new HashMap<>(globalSamplers); mergedSamplers.putAll(samplers);
+        var mergedFunctions = new HashMap<>(globalFunctions);
+        mergedFunctions.putAll(functions);
+        var mergedSamplers = new HashMap<>(globalSamplers);
+        mergedSamplers.putAll(samplers);
        try {
            return new ExpressionFunction(convertFunctionsAndSamplers(mergedFunctions, mergedSamplers), expression, vars);
        } catch(ParseException e) {
@@ -45,15 +45,18 @@ public class ExpressionNormalizerTemplate extends NormalizerTemplate<ExpressionN
    @Default
    private @Meta LinkedHashMap<String, @Meta FunctionTemplate> functions = new LinkedHashMap<>();
    
-    public ExpressionNormalizerTemplate(Map<String, DimensionApplicableNoiseSampler> globalSamplers, Map<String, FunctionTemplate> globalFunctions) {
+    public ExpressionNormalizerTemplate(Map<String, DimensionApplicableNoiseSampler> globalSamplers,
+                                        Map<String, FunctionTemplate> globalFunctions) {
        this.globalSamplers = globalSamplers;
        this.globalFunctions = globalFunctions;
    }
    
    @Override
    public NoiseSampler get() {
-        var mergedFunctions = new HashMap<>(globalFunctions); mergedFunctions.putAll(functions);
-        var mergedSamplers = new HashMap<>(globalSamplers); mergedSamplers.putAll(samplers);
+        var mergedFunctions = new HashMap<>(globalFunctions);
+        mergedFunctions.putAll(functions);
+        var mergedSamplers = new HashMap<>(globalSamplers);
+        mergedSamplers.putAll(samplers);
        try {
            return new ExpressionNormalizer(function, convertFunctionsAndSamplers(mergedFunctions, mergedSamplers), expression, vars);
        } catch(ParseException e) {
@@ -28,18 +28,14 @@ public class CubicSpline {
        }
    }
    
-    public double apply(double in) {
-        return calculate(in, fromValues, toValues, gradients);
-    }
-    
    public static double calculate(double in, double[] fromValues, double[] toValues, double[] gradients) {
        int pointIdx = floorBinarySearch(in, fromValues) - 1;
        
        int pointIdxLast = fromValues.length - 1;
        
-        if (pointIdx < 0) { // If to left of first point return linear function intersecting said point using point's gradient
+        if(pointIdx < 0) { // If to left of first point return linear function intersecting said point using point's gradient
            return gradients[0] * (in - fromValues[0]) + toValues[0];
-        } else if (pointIdx == pointIdxLast) { // Do same if to right of last point
+        } else if(pointIdx == pointIdxLast) { // Do same if to right of last point
            return gradients[pointIdxLast] * (in - fromValues[pointIdxLast]) + toValues[pointIdxLast];
        } else {
            double fromLeft = fromValues[pointIdx];
@@ -48,7 +44,7 @@ public class CubicSpline {
            double toLeft = toValues[pointIdx];
            double toRight = toValues[pointIdx + 1];
            
-            double gradientLeft =  gradients[pointIdx];
+            double gradientLeft = gradients[pointIdx];
            double gradientRight = gradients[pointIdx + 1];
            
            double fromDelta = fromRight - fromLeft;
@@ -56,7 +52,8 @@ public class CubicSpline {
            
            double t = (in - fromLeft) / fromDelta;
            
-            return lerp(t, toLeft, toRight) + t * (1.0F - t) * lerp(t, gradientLeft * fromDelta - toDelta, -gradientRight * fromDelta + toDelta);
+            return lerp(t, toLeft, toRight) + t * (1.0F - t) * lerp(t, gradientLeft * fromDelta - toDelta,
+                                                                    -gradientRight * fromDelta + toDelta);
        }
    }
    
@@ -64,10 +61,10 @@ public class CubicSpline {
        int left = 0;
        int right = values.length;
        int idx = right - left;
-        while (idx > 0) {
+        while(idx > 0) {
            int halfDelta = idx / 2;
            int mid = left + halfDelta;
-            if (targetValue < values[mid]) {
+            if(targetValue < values[mid]) {
                idx = halfDelta;
            } else {
                left = mid + 1;
@@ -76,6 +73,11 @@ public class CubicSpline {
        }
        return left;
    }
+    
+    public double apply(double in) {
+        return calculate(in, fromValues, toValues, gradients);
+    }
+    

    public record Point(double from, double to, double gradient) implements Comparable<Point> {
        
@@ -14,10 +14,11 @@ import com.dfsek.terra.addons.noise.paralithic.noise.NoiseFunction3;


 public class FunctionUtil {
-    private FunctionUtil() {}
+    private FunctionUtil() { }
    
    public static Map<String, Function> convertFunctionsAndSamplers(Map<String, FunctionTemplate> functions,
-                                                                    Map<String, DimensionApplicableNoiseSampler> samplers) throws ParseException {
+                                                                    Map<String, DimensionApplicableNoiseSampler> samplers)
+    throws ParseException {
        Map<String, Function> functionMap = new HashMap<>();
        for(Map.Entry<String, FunctionTemplate> entry : functions.entrySet()) {
            functionMap.put(entry.getKey(), UserDefinedFunction.newInstance(entry.getValue()));
@@ -20,14 +20,30 @@ public class DistanceSampler extends NoiseFunction {
        this.radius = radius;
        this.distanceAtRadius = distance2d(distanceFunction, radius, 0); // distance2d and distance3d should return the same value
    }
-   
+    
+    private static double distance2d(DistanceFunction distanceFunction, double x, double z) {
+        return switch(distanceFunction) {
+            case Euclidean -> Math.sqrt(x * x + z * z);
+            case EuclideanSq -> x * x + z * z;
+            case Manhattan -> Math.abs(x) + Math.abs(z);
+        };
+    }
+    
+    private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) {
+        return switch(distanceFunction) {
+            case Euclidean -> Math.sqrt(x * x + y * y + z * z);
+            case EuclideanSq -> x * x + y * y + z * z;
+            case Manhattan -> Math.abs(x) + Math.abs(y) + Math.abs(z);
+        };
+    }
+    
    @Override
    public double getNoiseRaw(long seed, double x, double y) {
        double dx = x - ox;
        double dy = y - oz;
-        if (normalize && (Math.abs(dx) > radius || Math.abs(dy) > radius)) return 1;
+        if(normalize && (Math.abs(dx) > radius || Math.abs(dy) > radius)) return 1;
        double dist = distance2d(distanceFunction, dx, dy);
-        if (normalize) return Math.min(((2*dist)/distanceAtRadius)-1, 1);
+        if(normalize) return Math.min(((2 * dist) / distanceAtRadius) - 1, 1);
        return dist;
    }
    
@@ -38,26 +54,10 @@ public class DistanceSampler extends NoiseFunction {
        double dz = z - oz;
        if(normalize && (Math.abs(dx) > radius || Math.abs(dy) > radius || Math.abs(dz) > radius)) return 1;
        double dist = distance3d(distanceFunction, dx, dy, dz);
-        if (normalize) return Math.min(((2*dist)/distanceAtRadius)-1, 1);
+        if(normalize) return Math.min(((2 * dist) / distanceAtRadius) - 1, 1);
        return dist;
    }
    
-    private static double distance2d(DistanceFunction distanceFunction, double x, double z) {
-        return switch(distanceFunction) {
-            case Euclidean -> Math.sqrt(x*x + z*z);
-            case EuclideanSq -> x*x + z*z;
-            case Manhattan -> Math.abs(x) + Math.abs(z);
-        };
-    }
-    
-    private static double distance3d(DistanceFunction distanceFunction, double x, double y, double z) {
-        return switch(distanceFunction) {
-            case Euclidean -> Math.sqrt(x*x + y*y + z*z);
-            case EuclideanSq -> x*x + y*y + z*z;
-            case Manhattan -> Math.abs(x) + Math.abs(y) + Math.abs(z);
-        };
-    }
-    
    public enum DistanceFunction {
        Euclidean,
        EuclideanSq,
@@ -17,11 +17,10 @@ public class GaborNoiseSampler extends NoiseFunction {
    private double a = 0.1;
    private double f0 = 0.625;
    private double kernelRadius = (Math.sqrt(-Math.log(0.05) / Math.PI) / a);
-    private double impulsesPerKernel = 64d;
    private double impulseDensity = (impulsesPerKernel / (Math.PI * kernelRadius * kernelRadius));
    private double impulsesPerCell = impulseDensity * kernelRadius * kernelRadius;
    private double g = Math.exp(-impulsesPerCell);
-    
+    private double impulsesPerKernel = 64d;
    private double omega0 = Math.PI * 0.25;
    private boolean isotropic = true;
    
@@ -72,8 +71,9 @@ public class GaborNoiseSampler extends NoiseFunction {
    }
    
    private double gabor(double omega_0, double x, double y) {
-        return k * (Math.exp(-Math.PI * (a * a) * (x * x + y * y)) * MathUtil.cos(2 * Math.PI * f0 * (x * MathUtil.cos(omega_0) + y * MathUtil.sin(
-                omega_0))));
+        return k * (Math.exp(-Math.PI * (a * a) * (x * x + y * y)) * MathUtil.cos(2 * Math.PI * f0 * (x * MathUtil.cos(omega_0) +
+                                                                                                      y * MathUtil.sin(
+                                                                                                              omega_0))));
    }
    
    public void setA(double a) {
@@ -15,7 +15,7 @@ public abstract class NoiseFunction implements NoiseSampler {
    protected static final int PRIME_X = 501125321;
    protected static final int PRIME_Y = 1136930381;
    protected static final int PRIME_Z = 1720413743;
-
+    
    protected double frequency = 0.02d;
    protected long salt;
    
@@ -33,11 +33,11 @@ public class ValueCubicSampler extends ValueStyleNoise {
                MathUtil.cubicLerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), valCoord(seed, x2, y0), valCoord(seed, x3, y0),
                                   xs),
                MathUtil.cubicLerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), valCoord(seed, x2, y1), valCoord(seed, x3, y1),
-                          xs),
+                                   xs),
                MathUtil.cubicLerp(valCoord(seed, x0, y2), valCoord(seed, x1, y2), valCoord(seed, x2, y2), valCoord(seed, x3, y2),
-                          xs),
+                                   xs),
                MathUtil.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));
    }
    
@@ -69,43 +69,43 @@ public class ValueCubicSampler extends ValueStyleNoise {
        return MathUtil.cubicLerp(
                MathUtil.cubicLerp(
                        MathUtil.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),
                        MathUtil.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),
                        MathUtil.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),
                        MathUtil.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),
                MathUtil.cubicLerp(
                        MathUtil.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),
                        MathUtil.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),
                        MathUtil.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),
                        MathUtil.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),
                MathUtil.cubicLerp(
                        MathUtil.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),
                        MathUtil.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),
                        MathUtil.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),
                        MathUtil.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),
                MathUtil.cubicLerp(
                        MathUtil.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),
                        MathUtil.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),
                        MathUtil.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),
                        MathUtil.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));
    }
@@ -1,12 +1,12 @@
 schema-version: 1
 contributors:
-  - Terra contributors
+    - Terra contributors
 id: config-noise-function
 version: @VERSION@
 entrypoints:
-  - "com.dfsek.terra.addons.noise.NoiseAddon"
+    - "com.dfsek.terra.addons.noise.NoiseAddon"
 website:
-  issues: https://github.com/PolyhedralDev/Terra/issues
-  source: https://github.com/PolyhedralDev/Terra
-  docs: https://terra.polydev.org
+    issues: https://github.com/PolyhedralDev/Terra/issues
+    source: https://github.com/PolyhedralDev/Terra
+    docs: https://terra.polydev.org
 license: MIT License