From 47fa31515d958036d5e98636d123de72655ccadc Mon Sep 17 00:00:00 2001 From: cyberpwn Date: Thu, 13 Jan 2022 07:16:45 -0500 Subject: [PATCH] Switch! --- .../volmit/iris/util/data/palette/Mth.java | 18 +- .../iris/util/inventorygui/RandomColor.java | 46 +- .../math/KochanekBartelsInterpolation.java | 18 +- .../com/volmit/iris/util/math/MathHelper.java | 27 +- .../com/volmit/iris/util/math/VectorMath.java | 80 ++-- .../iris/util/nbt/mca/palette/MCAMth.java | 18 +- .../com/volmit/iris/util/noise/FastNoise.java | 450 +++++++----------- .../iris/util/noise/FastNoiseDouble.java | 150 +++--- 8 files changed, 329 insertions(+), 478 deletions(-) diff --git a/src/main/java/com/volmit/iris/util/data/palette/Mth.java b/src/main/java/com/volmit/iris/util/data/palette/Mth.java index a4aa6f132..849d561ca 100644 --- a/src/main/java/com/volmit/iris/util/data/palette/Mth.java +++ b/src/main/java/com/volmit/iris/util/data/palette/Mth.java @@ -473,7 +473,7 @@ public class Mth { float var6 = var2 * (1.0F - var4 * var1); float var7 = var2 * (1.0F - (1.0F - var4) * var1); switch(var3) { - case 0: + case 0 -> { var8 = var2; var9 = var7; var10 = var5; @@ -481,7 +481,8 @@ public class Mth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 1: + } + case 1 -> { var8 = var6; var9 = var2; var10 = var5; @@ -489,7 +490,8 @@ public class Mth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 2: + } + case 2 -> { var8 = var5; var9 = var2; var10 = var7; @@ -497,7 +499,8 @@ public class Mth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 3: + } + case 3 -> { var8 = var5; var9 = var6; var10 = var2; @@ -505,7 +508,8 @@ public class Mth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 4: + } + case 4 -> { var8 = var7; var9 = var5; var10 = var2; @@ -513,7 +517,8 @@ public class Mth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 5: + } + case 5 -> { var8 = var2; var9 = var5; var10 = var6; @@ -521,6 +526,7 @@ public class Mth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; + } } throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2); } diff --git a/src/main/java/com/volmit/iris/util/inventorygui/RandomColor.java b/src/main/java/com/volmit/iris/util/inventorygui/RandomColor.java index ac32bf375..b9cd7eba3 100644 --- a/src/main/java/com/volmit/iris/util/inventorygui/RandomColor.java +++ b/src/main/java/com/volmit/iris/util/inventorygui/RandomColor.java @@ -157,18 +157,13 @@ public class RandomColor { private int pickSaturation(ColorInfo colorInfo, SaturationType saturationType, Luminosity luminosity) { if(saturationType != null) { - switch(saturationType) { - case RANDOM: - return randomWithin(new Range(0, 100)); - case MONOCHROME: - return 0; - case HIGH: - return randomWithin(new Range(75, 100)); - case MEDIUM: - return randomWithin(new Range(55, 75)); - case LOW: - return randomWithin(new Range(35, 55)); - } + return switch(saturationType) { + case RANDOM -> randomWithin(new Range(0, 100)); + case MONOCHROME -> 0; + case HIGH -> randomWithin(new Range(75, 100)); + case MEDIUM -> randomWithin(new Range(55, 75)); + case LOW -> randomWithin(new Range(35, 55)); + }; } if(colorInfo == null) { @@ -182,15 +177,9 @@ public class RandomColor { if(luminosity != null) { switch(luminosity) { - case LIGHT: - min = 55; - break; - case BRIGHT: - min = max - 10; - break; - case DARK: - max = 55; - break; + case LIGHT -> min = 55; + case BRIGHT -> min = max - 10; + case DARK -> max = 55; } } @@ -215,19 +204,12 @@ public class RandomColor { if(luminosity != null) { switch(luminosity) { - - case DARK: - max = min + 20; - break; - - case LIGHT: - min = (max + min) / 2; - break; - - case RANDOM: + case DARK -> max = min + 20; + case LIGHT -> min = (max + min) / 2; + case RANDOM -> { min = 0; max = 100; - break; + } } } diff --git a/src/main/java/com/volmit/iris/util/math/KochanekBartelsInterpolation.java b/src/main/java/com/volmit/iris/util/math/KochanekBartelsInterpolation.java index 6c5449d12..fe5c2fc39 100644 --- a/src/main/java/com/volmit/iris/util/math/KochanekBartelsInterpolation.java +++ b/src/main/java/com/volmit/iris/util/math/KochanekBartelsInterpolation.java @@ -203,19 +203,15 @@ public class KochanekBartelsInterpolation implements PathInterpolation { * Assumes a < b. */ private double arcLengthRecursive(int indexLeft, double remainderLeft, int indexRight, double remainderRight) { - switch(indexRight - indexLeft) { - case 0: - return arcLengthRecursive(indexLeft, remainderLeft, remainderRight); - - case 1: + return switch(indexRight - indexLeft) { + case 0 -> arcLengthRecursive(indexLeft, remainderLeft, remainderRight); + case 1 -> // This case is merely a speed-up for a very common case - return arcLengthRecursive(indexLeft, remainderLeft, 1.0) + arcLengthRecursive(indexLeft, remainderLeft, 1.0) + arcLengthRecursive(indexRight, 0.0, remainderRight); - - default: - return arcLengthRecursive(indexLeft, remainderLeft, indexRight - 1, 1.0) - + arcLengthRecursive(indexRight, 0.0, remainderRight); - } + default -> arcLengthRecursive(indexLeft, remainderLeft, indexRight - 1, 1.0) + + arcLengthRecursive(indexRight, 0.0, remainderRight); + }; } private double arcLengthRecursive(int index, double remainderLeft, double remainderRight) { diff --git a/src/main/java/com/volmit/iris/util/math/MathHelper.java b/src/main/java/com/volmit/iris/util/math/MathHelper.java index 8089dd35e..5fd6e3c4c 100644 --- a/src/main/java/com/volmit/iris/util/math/MathHelper.java +++ b/src/main/java/com/volmit/iris/util/math/MathHelper.java @@ -467,38 +467,37 @@ public class MathHelper { float var9; float var10; switch(var3) { - case 0: + case 0 -> { var8 = var2; var9 = var7; var10 = var5; - break; - case 1: + } + case 1 -> { var8 = var6; var9 = var2; var10 = var5; - break; - case 2: + } + case 2 -> { var8 = var5; var9 = var2; var10 = var7; - break; - case 3: + } + case 3 -> { var8 = var5; var9 = var6; var10 = var2; - break; - case 4: + } + case 4 -> { var8 = var7; var9 = var5; var10 = var2; - break; - case 5: + } + case 5 -> { var8 = var2; var9 = var5; var10 = var6; - break; - default: - throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2); + } + default -> throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2); } int var11 = clamp((int) (var8 * 255.0F), 0, 255); diff --git a/src/main/java/com/volmit/iris/util/math/VectorMath.java b/src/main/java/com/volmit/iris/util/math/VectorMath.java index ec6de00ce..5a965bcac 100644 --- a/src/main/java/com/volmit/iris/util/math/VectorMath.java +++ b/src/main/java/com/volmit/iris/util/math/VectorMath.java @@ -266,85 +266,71 @@ public class VectorMath { KList faces = new KList<>(); switch(f) { - case DOWN: - faces.add(BlockFace.DOWN); - break; - case EAST: - faces.add(BlockFace.EAST); - break; - case EAST_NORTH_EAST: + case DOWN -> faces.add(BlockFace.DOWN); + case EAST -> faces.add(BlockFace.EAST); + case EAST_NORTH_EAST -> { faces.add(BlockFace.EAST); faces.add(BlockFace.EAST); faces.add(BlockFace.NORTH); - break; - case EAST_SOUTH_EAST: + } + case EAST_SOUTH_EAST -> { faces.add(BlockFace.EAST); faces.add(BlockFace.EAST); faces.add(BlockFace.SOUTH); - break; - case NORTH: - faces.add(BlockFace.NORTH); - break; - case NORTH_EAST: + } + case NORTH -> faces.add(BlockFace.NORTH); + case NORTH_EAST -> { faces.add(BlockFace.NORTH); faces.add(BlockFace.EAST); - break; - case NORTH_NORTH_EAST: + } + case NORTH_NORTH_EAST -> { faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH); faces.add(BlockFace.EAST); - break; - case NORTH_NORTH_WEST: + } + case NORTH_NORTH_WEST -> { faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH); faces.add(BlockFace.WEST); - break; - case NORTH_WEST: + } + case NORTH_WEST -> { faces.add(BlockFace.NORTH); faces.add(BlockFace.WEST); - break; - case SELF: - faces.add(BlockFace.SELF); - break; - case SOUTH: - faces.add(BlockFace.SOUTH); - break; - case SOUTH_EAST: + } + case SELF -> faces.add(BlockFace.SELF); + case SOUTH -> faces.add(BlockFace.SOUTH); + case SOUTH_EAST -> { faces.add(BlockFace.SOUTH); faces.add(BlockFace.EAST); - break; - case SOUTH_SOUTH_EAST: + } + case SOUTH_SOUTH_EAST -> { faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH); faces.add(BlockFace.EAST); - break; - case SOUTH_SOUTH_WEST: + } + case SOUTH_SOUTH_WEST -> { faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH); faces.add(BlockFace.WEST); - break; - case SOUTH_WEST: + } + case SOUTH_WEST -> { faces.add(BlockFace.SOUTH); faces.add(BlockFace.WEST); - break; - case UP: - faces.add(BlockFace.UP); - break; - case WEST: - faces.add(BlockFace.WEST); - break; - case WEST_NORTH_WEST: + } + case UP -> faces.add(BlockFace.UP); + case WEST -> faces.add(BlockFace.WEST); + case WEST_NORTH_WEST -> { faces.add(BlockFace.WEST); faces.add(BlockFace.WEST); faces.add(BlockFace.NORTH); - break; - case WEST_SOUTH_WEST: + } + case WEST_SOUTH_WEST -> { faces.add(BlockFace.WEST); faces.add(BlockFace.WEST); faces.add(BlockFace.SOUTH); - break; - default: - break; + } + default -> { + } } return faces; diff --git a/src/main/java/com/volmit/iris/util/nbt/mca/palette/MCAMth.java b/src/main/java/com/volmit/iris/util/nbt/mca/palette/MCAMth.java index f11853070..8ee735815 100644 --- a/src/main/java/com/volmit/iris/util/nbt/mca/palette/MCAMth.java +++ b/src/main/java/com/volmit/iris/util/nbt/mca/palette/MCAMth.java @@ -473,7 +473,7 @@ public class MCAMth { float var6 = var2 * (1.0F - var4 * var1); float var7 = var2 * (1.0F - (1.0F - var4) * var1); switch(var3) { - case 0: + case 0 -> { var8 = var2; var9 = var7; var10 = var5; @@ -481,7 +481,8 @@ public class MCAMth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 1: + } + case 1 -> { var8 = var6; var9 = var2; var10 = var5; @@ -489,7 +490,8 @@ public class MCAMth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 2: + } + case 2 -> { var8 = var5; var9 = var2; var10 = var7; @@ -497,7 +499,8 @@ public class MCAMth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 3: + } + case 3 -> { var8 = var5; var9 = var6; var10 = var2; @@ -505,7 +508,8 @@ public class MCAMth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 4: + } + case 4 -> { var8 = var7; var9 = var5; var10 = var2; @@ -513,7 +517,8 @@ public class MCAMth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; - case 5: + } + case 5 -> { var8 = var2; var9 = var5; var10 = var6; @@ -521,6 +526,7 @@ public class MCAMth { var12 = clamp((int) (var9 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255); return var11 << 16 | var12 << 8 | var13; + } } throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2); } diff --git a/src/main/java/com/volmit/iris/util/noise/FastNoise.java b/src/main/java/com/volmit/iris/util/noise/FastNoise.java index 358085faf..036146156 100644 --- a/src/main/java/com/volmit/iris/util/noise/FastNoise.java +++ b/src/main/java/com/volmit/iris/util/noise/FastNoise.java @@ -204,21 +204,21 @@ public class FastNoise { hash &= 31; float a = yd, b = zd, c = wd; // X,Y,Z switch(hash >> 3) { // OR, DEPENDING ON HIGH ORDER 2 BITS: - case 1: + case 1 -> { a = wd; b = xd; c = yd; - break; // W,X,Y - case 2: + } // W,X,Y + case 2 -> { a = zd; b = wd; c = xd; - break; // Z,W,X - case 3: + } // Z,W,X + case 3 -> { a = yd; b = zd; c = wd; - break; // Y,Z,W + } // Y,Z,W } return ((hash & 4) == 0 ? -a : a) + ((hash & 2) == 0 ? -b : b) + ((hash & 1) == 0 ? -c : c); } @@ -332,66 +332,46 @@ public class FastNoise { case Value: return SingleValue(m_seed, x, y, z); case ValueFractal: - switch(m_fractalType) { - case FBM: - return SingleValueFractalFBM(x, y, z); - case Billow: - return SingleValueFractalBillow(x, y, z); - case RigidMulti: - return SingleValueFractalRigidMulti(x, y, z); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleValueFractalFBM(x, y, z); + case Billow -> SingleValueFractalBillow(x, y, z); + case RigidMulti -> SingleValueFractalRigidMulti(x, y, z); + default -> 0; + }; case Perlin: return SinglePerlin(m_seed, x, y, z); case PerlinFractal: - switch(m_fractalType) { - case FBM: - return SinglePerlinFractalFBM(x, y, z); - case Billow: - return SinglePerlinFractalBillow(x, y, z); - case RigidMulti: - return SinglePerlinFractalRigidMulti(x, y, z); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SinglePerlinFractalFBM(x, y, z); + case Billow -> SinglePerlinFractalBillow(x, y, z); + case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z); + default -> 0; + }; case Simplex: return SingleSimplex(m_seed, x, y, z); case SimplexFractal: - switch(m_fractalType) { - case FBM: - return SingleSimplexFractalFBM(x, y, z); - case Billow: - return SingleSimplexFractalBillow(x, y, z); - case RigidMulti: - return SingleSimplexFractalRigidMulti(x, y, z); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleSimplexFractalFBM(x, y, z); + case Billow -> SingleSimplexFractalBillow(x, y, z); + case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z); + default -> 0; + }; case Cellular: - switch(m_cellularReturnType) { - case CellValue: - case NoiseLookup: - case Distance: - return SingleCellular(x, y, z); - default: - return SingleCellular2Edge(x, y, z); - } + return switch(m_cellularReturnType) { + case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z); + default -> SingleCellular2Edge(x, y, z); + }; case WhiteNoise: return GetWhiteNoise(x, y, z); case Cubic: return SingleCubic(m_seed, x, y, z); case CubicFractal: - switch(m_fractalType) { - case FBM: - return SingleCubicFractalFBM(x, y, z); - case Billow: - return SingleCubicFractalBillow(x, y, z); - case RigidMulti: - return SingleCubicFractalRigidMulti(x, y, z); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleCubicFractalFBM(x, y, z); + case Billow -> SingleCubicFractalBillow(x, y, z); + case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z); + default -> 0; + }; default: return 0; } @@ -405,66 +385,46 @@ public class FastNoise { case Value: return SingleValue(m_seed, x, y); case ValueFractal: - switch(m_fractalType) { - case FBM: - return SingleValueFractalFBM(x, y); - case Billow: - return SingleValueFractalBillow(x, y); - case RigidMulti: - return SingleValueFractalRigidMulti(x, y); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleValueFractalFBM(x, y); + case Billow -> SingleValueFractalBillow(x, y); + case RigidMulti -> SingleValueFractalRigidMulti(x, y); + default -> 0; + }; case Perlin: return SinglePerlin(m_seed, x, y); case PerlinFractal: - switch(m_fractalType) { - case FBM: - return SinglePerlinFractalFBM(x, y); - case Billow: - return SinglePerlinFractalBillow(x, y); - case RigidMulti: - return SinglePerlinFractalRigidMulti(x, y); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SinglePerlinFractalFBM(x, y); + case Billow -> SinglePerlinFractalBillow(x, y); + case RigidMulti -> SinglePerlinFractalRigidMulti(x, y); + default -> 0; + }; case Simplex: return SingleSimplex(m_seed, x, y); case SimplexFractal: - switch(m_fractalType) { - case FBM: - return SingleSimplexFractalFBM(x, y); - case Billow: - return SingleSimplexFractalBillow(x, y); - case RigidMulti: - return SingleSimplexFractalRigidMulti(x, y); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleSimplexFractalFBM(x, y); + case Billow -> SingleSimplexFractalBillow(x, y); + case RigidMulti -> SingleSimplexFractalRigidMulti(x, y); + default -> 0; + }; case Cellular: - switch(m_cellularReturnType) { - case CellValue: - case NoiseLookup: - case Distance: - return SingleCellular(x, y); - default: - return SingleCellular2Edge(x, y); - } + return switch(m_cellularReturnType) { + case CellValue, NoiseLookup, Distance -> SingleCellular(x, y); + default -> SingleCellular2Edge(x, y); + }; case WhiteNoise: return GetWhiteNoise(x, y); case Cubic: return SingleCubic(m_seed, x, y); case CubicFractal: - switch(m_fractalType) { - case FBM: - return SingleCubicFractalFBM(x, y); - case Billow: - return SingleCubicFractalBillow(x, y); - case RigidMulti: - return SingleCubicFractalRigidMulti(x, y); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleCubicFractalFBM(x, y); + case Billow -> SingleCubicFractalBillow(x, y); + case RigidMulti -> SingleCubicFractalRigidMulti(x, y); + default -> 0; + }; default: return 0; } @@ -518,16 +478,12 @@ public class FastNoise { y *= m_frequency; z *= m_frequency; - switch(m_fractalType) { - case FBM: - return SingleValueFractalFBM(x, y, z); - case Billow: - return SingleValueFractalBillow(x, y, z); - case RigidMulti: - return SingleValueFractalRigidMulti(x, y, z); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleValueFractalFBM(x, y, z); + case Billow -> SingleValueFractalBillow(x, y, z); + case RigidMulti -> SingleValueFractalRigidMulti(x, y, z); + default -> 0; + }; } private float SingleValueFractalFBM(float x, float y, float z) { @@ -595,22 +551,21 @@ public class FastNoise { float xs, ys, zs; switch(m_interp) { - default: - case Linear: + case Linear -> { xs = x - x0; ys = y - y0; zs = z - z0; - break; - case Hermite: + } + case Hermite -> { xs = InterpHermiteFunc(x - x0); ys = InterpHermiteFunc(y - y0); zs = InterpHermiteFunc(z - z0); - break; - case Quintic: + } + case Quintic -> { xs = InterpQuinticFunc(x - x0); ys = InterpQuinticFunc(y - y0); zs = InterpQuinticFunc(z - z0); - break; + } } float xf00 = Lerp(ValCoord3D(seed, x0, y0, z0), ValCoord3D(seed, x1, y0, z0), xs); @@ -628,16 +583,12 @@ public class FastNoise { x *= m_frequency; y *= m_frequency; - switch(m_fractalType) { - case FBM: - return SingleValueFractalFBM(x, y); - case Billow: - return SingleValueFractalBillow(x, y); - case RigidMulti: - return SingleValueFractalRigidMulti(x, y); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleValueFractalFBM(x, y); + case Billow -> SingleValueFractalBillow(x, y); + case RigidMulti -> SingleValueFractalRigidMulti(x, y); + default -> 0; + }; } private float SingleValueFractalFBM(float x, float y) { @@ -699,19 +650,18 @@ public class FastNoise { float xs, ys; switch(m_interp) { - default: - case Linear: + case Linear -> { xs = x - x0; ys = y - y0; - break; - case Hermite: + } + case Hermite -> { xs = InterpHermiteFunc(x - x0); ys = InterpHermiteFunc(y - y0); - break; - case Quintic: + } + case Quintic -> { xs = InterpQuinticFunc(x - x0); ys = InterpQuinticFunc(y - y0); - break; + } } float xf0 = Lerp(ValCoord2D(seed, x0, y0), ValCoord2D(seed, x1, y0), xs); @@ -726,16 +676,12 @@ public class FastNoise { y *= m_frequency; z *= m_frequency; - switch(m_fractalType) { - case FBM: - return SinglePerlinFractalFBM(x, y, z); - case Billow: - return SinglePerlinFractalBillow(x, y, z); - case RigidMulti: - return SinglePerlinFractalRigidMulti(x, y, z); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SinglePerlinFractalFBM(x, y, z); + case Billow -> SinglePerlinFractalBillow(x, y, z); + case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z); + default -> 0; + }; } private float SinglePerlinFractalFBM(float x, float y, float z) { @@ -803,22 +749,21 @@ public class FastNoise { float xs, ys, zs; switch(m_interp) { - default: - case Linear: + case Linear -> { xs = x - x0; ys = y - y0; zs = z - z0; - break; - case Hermite: + } + case Hermite -> { xs = InterpHermiteFunc(x - x0); ys = InterpHermiteFunc(y - y0); zs = InterpHermiteFunc(z - z0); - break; - case Quintic: + } + case Quintic -> { xs = InterpQuinticFunc(x - x0); ys = InterpQuinticFunc(y - y0); zs = InterpQuinticFunc(z - z0); - break; + } } float xd0 = x - x0; @@ -843,16 +788,12 @@ public class FastNoise { x *= m_frequency; y *= m_frequency; - switch(m_fractalType) { - case FBM: - return SinglePerlinFractalFBM(x, y); - case Billow: - return SinglePerlinFractalBillow(x, y); - case RigidMulti: - return SinglePerlinFractalRigidMulti(x, y); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SinglePerlinFractalFBM(x, y); + case Billow -> SinglePerlinFractalBillow(x, y); + case RigidMulti -> SinglePerlinFractalRigidMulti(x, y); + default -> 0; + }; } private float SinglePerlinFractalFBM(float x, float y) { @@ -915,19 +856,18 @@ public class FastNoise { float xs, ys; switch(m_interp) { - default: - case Linear: + case Linear -> { xs = x - x0; ys = y - y0; - break; - case Hermite: + } + case Hermite -> { xs = InterpHermiteFunc(x - x0); ys = InterpHermiteFunc(y - y0); - break; - case Quintic: + } + case Quintic -> { xs = InterpQuinticFunc(x - x0); ys = InterpQuinticFunc(y - y0); - break; + } } float xd0 = x - x0; @@ -947,16 +887,12 @@ public class FastNoise { y *= m_frequency; z *= m_frequency; - switch(m_fractalType) { - case FBM: - return SingleSimplexFractalFBM(x, y, z); - case Billow: - return SingleSimplexFractalBillow(x, y, z); - case RigidMulti: - return SingleSimplexFractalRigidMulti(x, y, z); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleSimplexFractalFBM(x, y, z); + case Billow -> SingleSimplexFractalBillow(x, y, z); + case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z); + default -> 0; + }; } private float SingleSimplexFractalFBM(float x, float y, float z) { @@ -1130,16 +1066,12 @@ public class FastNoise { x *= m_frequency; y *= m_frequency; - switch(m_fractalType) { - case FBM: - return SingleSimplexFractalFBM(x, y); - case Billow: - return SingleSimplexFractalBillow(x, y); - case RigidMulti: - return SingleSimplexFractalRigidMulti(x, y); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleSimplexFractalFBM(x, y); + case Billow -> SingleSimplexFractalBillow(x, y); + case RigidMulti -> SingleSimplexFractalRigidMulti(x, y); + default -> 0; + }; } private float SingleSimplexFractalFBM(float x, float y) { @@ -1353,16 +1285,12 @@ public class FastNoise { y *= m_frequency; z *= m_frequency; - switch(m_fractalType) { - case FBM: - return SingleCubicFractalFBM(x, y, z); - case Billow: - return SingleCubicFractalBillow(x, y, z); - case RigidMulti: - return SingleCubicFractalRigidMulti(x, y, z); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleCubicFractalFBM(x, y, z); + case Billow -> SingleCubicFractalBillow(x, y, z); + case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z); + default -> 0; + }; } private float SingleCubicFractalFBM(float x, float y, float z) { @@ -1449,16 +1377,12 @@ public class FastNoise { x *= m_frequency; y *= m_frequency; - switch(m_fractalType) { - case FBM: - return SingleCubicFractalFBM(x, y); - case Billow: - return SingleCubicFractalBillow(x, y); - case RigidMulti: - return SingleCubicFractalRigidMulti(x, y); - default: - return 0; - } + return switch(m_fractalType) { + case FBM -> SingleCubicFractalFBM(x, y); + case Billow -> SingleCubicFractalBillow(x, y); + case RigidMulti -> SingleCubicFractalRigidMulti(x, y); + default -> 0; + }; } private float SingleCubicFractalFBM(float x, float y) { @@ -1542,14 +1466,10 @@ public class FastNoise { y *= m_frequency; z *= m_frequency; - switch(m_cellularReturnType) { - case CellValue: - case NoiseLookup: - case Distance: - return SingleCellular(x, y, z); - default: - return SingleCellular2Edge(x, y, z); - } + return switch(m_cellularReturnType) { + case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z); + default -> SingleCellular2Edge(x, y, z); + }; } private float SingleCellular(float x, float y, float z) { @@ -1711,48 +1631,34 @@ public class FastNoise { break; } - switch(m_cellularReturnType) { - case Distance2: - return distance2 - 1; - case Distance2Add: - return distance2 + distance - 1; - case Distance2Sub: - return distance2 - distance - 1; - case Distance2Mul: - return distance2 * distance - 1; - case Distance2Div: - return distance / distance2 - 1; - default: - return 0; - } + return switch(m_cellularReturnType) { + case Distance2 -> distance2 - 1; + case Distance2Add -> distance2 + distance - 1; + case Distance2Sub -> distance2 - distance - 1; + case Distance2Mul -> distance2 * distance - 1; + case Distance2Div -> distance / distance2 - 1; + default -> 0; + }; } public float GetCellular(float x, float y, ProceduralStream sourceNoise, double iscale) { x *= m_frequency; y *= m_frequency; - switch(m_cellularReturnType) { - case CellValue: - case NoiseLookup: - case Distance: - return SingleCellular(x, y, sourceNoise, iscale); - default: - return SingleCellular2Edge(x, y); - } + return switch(m_cellularReturnType) { + case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, sourceNoise, iscale); + default -> SingleCellular2Edge(x, y); + }; } public float GetCellular(float x, float y) { x *= m_frequency; y *= m_frequency; - switch(m_cellularReturnType) { - case CellValue: - case NoiseLookup: - case Distance: - return SingleCellular(x, y); - default: - return SingleCellular2Edge(x, y); - } + return switch(m_cellularReturnType) { + case CellValue, NoiseLookup, Distance -> SingleCellular(x, y); + default -> SingleCellular2Edge(x, y); + }; } private float SingleCellular(float x, float y) { @@ -1971,20 +1877,14 @@ public class FastNoise { break; } - switch(m_cellularReturnType) { - case Distance2: - return distance2 - 1; - case Distance2Add: - return distance2 + distance - 1; - case Distance2Sub: - return distance2 - distance - 1; - case Distance2Mul: - return distance2 * distance - 1; - case Distance2Div: - return distance / distance2 - 1; - default: - return 0; - } + return switch(m_cellularReturnType) { + case Distance2 -> distance2 - 1; + case Distance2Add -> distance2 + distance - 1; + case Distance2Sub -> distance2 - distance - 1; + case Distance2Mul -> distance2 * distance - 1; + case Distance2Div -> distance / distance2 - 1; + default -> 0; + }; } public void GradientPerturb(Vector3f v3) { @@ -2019,22 +1919,21 @@ public class FastNoise { float xs, ys, zs; switch(m_interp) { - default: - case Linear: + case Linear -> { xs = xf - x0; ys = yf - y0; zs = zf - z0; - break; - case Hermite: + } + case Hermite -> { xs = InterpHermiteFunc(xf - x0); ys = InterpHermiteFunc(yf - y0); zs = InterpHermiteFunc(zf - z0); - break; - case Quintic: + } + case Quintic -> { xs = InterpQuinticFunc(xf - x0); ys = InterpQuinticFunc(yf - y0); zs = InterpQuinticFunc(zf - z0); - break; + } } Float3 vec0 = CELL_3D[Hash3D(seed, x0, y0, z0) & 255]; @@ -2103,19 +2002,18 @@ public class FastNoise { float xs, ys; switch(m_interp) { - default: - case Linear: + case Linear -> { xs = xf - x0; ys = yf - y0; - break; - case Hermite: + } + case Hermite -> { xs = InterpHermiteFunc(xf - x0); ys = InterpHermiteFunc(yf - y0); - break; - case Quintic: + } + case Quintic -> { xs = InterpQuinticFunc(xf - x0); ys = InterpQuinticFunc(yf - y0); - break; + } } Float2 vec0 = CELL_2D[Hash2D(seed, x0, y0) & 255]; diff --git a/src/main/java/com/volmit/iris/util/noise/FastNoiseDouble.java b/src/main/java/com/volmit/iris/util/noise/FastNoiseDouble.java index 96af95eb9..d7756044f 100644 --- a/src/main/java/com/volmit/iris/util/noise/FastNoiseDouble.java +++ b/src/main/java/com/volmit/iris/util/noise/FastNoiseDouble.java @@ -325,98 +325,76 @@ public class FastNoiseDouble { y *= m_frequency; z *= m_frequency; - switch(m_noiseType) { - case Value: - return SingleValue(m_seed, x, y, z); - case ValueFractal: - return switch(m_fractalType) { - case FBM -> SingleValueFractalFBM(x, y, z); - case Billow -> SingleValueFractalBillow(x, y, z); - case RigidMulti -> SingleValueFractalRigidMulti(x, y, z); - }; - case Perlin: - return SinglePerlin(m_seed, x, y, z); - case PerlinFractal: - return switch(m_fractalType) { - case FBM -> SinglePerlinFractalFBM(x, y, z); - case Billow -> SinglePerlinFractalBillow(x, y, z); - case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z); - }; - case Simplex: - return SingleSimplex(m_seed, x, y, z); - case SimplexFractal: - return switch(m_fractalType) { - case FBM -> SingleSimplexFractalFBM(x, y, z); - case Billow -> SingleSimplexFractalBillow(x, y, z); - case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z); - }; - case Cellular: - return switch(m_cellularReturnType) { - case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z); - default -> SingleCellular2Edge(x, y, z); - }; - case WhiteNoise: - return GetWhiteNoise(x, y, z); - case Cubic: - return SingleCubic(m_seed, x, y, z); - case CubicFractal: - return switch(m_fractalType) { - case FBM -> SingleCubicFractalFBM(x, y, z); - case Billow -> SingleCubicFractalBillow(x, y, z); - case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z); - }; - default: - return 0; - } + return switch(m_noiseType) { + case Value -> SingleValue(m_seed, x, y, z); + case ValueFractal -> switch(m_fractalType) { + case FBM -> SingleValueFractalFBM(x, y, z); + case Billow -> SingleValueFractalBillow(x, y, z); + case RigidMulti -> SingleValueFractalRigidMulti(x, y, z); + }; + case Perlin -> SinglePerlin(m_seed, x, y, z); + case PerlinFractal -> switch(m_fractalType) { + case FBM -> SinglePerlinFractalFBM(x, y, z); + case Billow -> SinglePerlinFractalBillow(x, y, z); + case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z); + }; + case Simplex -> SingleSimplex(m_seed, x, y, z); + case SimplexFractal -> switch(m_fractalType) { + case FBM -> SingleSimplexFractalFBM(x, y, z); + case Billow -> SingleSimplexFractalBillow(x, y, z); + case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z); + }; + case Cellular -> switch(m_cellularReturnType) { + case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z); + default -> SingleCellular2Edge(x, y, z); + }; + case WhiteNoise -> GetWhiteNoise(x, y, z); + case Cubic -> SingleCubic(m_seed, x, y, z); + case CubicFractal -> switch(m_fractalType) { + case FBM -> SingleCubicFractalFBM(x, y, z); + case Billow -> SingleCubicFractalBillow(x, y, z); + case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z); + }; + default -> 0; + }; } public double GetNoise(double x, double y) { x *= m_frequency; y *= m_frequency; - switch(m_noiseType) { - case Value: - return SingleValue(m_seed, x, y); - case ValueFractal: - return switch(m_fractalType) { - case FBM -> SingleValueFractalFBM(x, y); - case Billow -> SingleValueFractalBillow(x, y); - case RigidMulti -> SingleValueFractalRigidMulti(x, y); - }; - case Perlin: - return SinglePerlin(m_seed, x, y); - case PerlinFractal: - return switch(m_fractalType) { - case FBM -> SinglePerlinFractalFBM(x, y); - case Billow -> SinglePerlinFractalBillow(x, y); - case RigidMulti -> SinglePerlinFractalRigidMulti(x, y); - }; - case Simplex: - return SingleSimplex(m_seed, x, y); - case SimplexFractal: - return switch(m_fractalType) { - case FBM -> SingleSimplexFractalFBM(x, y); - case Billow -> SingleSimplexFractalBillow(x, y); - case RigidMulti -> SingleSimplexFractalRigidMulti(x, y); - }; - case Cellular: - return switch(m_cellularReturnType) { - case CellValue, NoiseLookup, Distance -> SingleCellular(x, y); - default -> SingleCellular2Edge(x, y); - }; - case WhiteNoise: - return GetWhiteNoise(x, y); - case Cubic: - return SingleCubic(m_seed, x, y); - case CubicFractal: - return switch(m_fractalType) { - case FBM -> SingleCubicFractalFBM(x, y); - case Billow -> SingleCubicFractalBillow(x, y); - case RigidMulti -> SingleCubicFractalRigidMulti(x, y); - }; - default: - return 0; - } + return switch(m_noiseType) { + case Value -> SingleValue(m_seed, x, y); + case ValueFractal -> switch(m_fractalType) { + case FBM -> SingleValueFractalFBM(x, y); + case Billow -> SingleValueFractalBillow(x, y); + case RigidMulti -> SingleValueFractalRigidMulti(x, y); + }; + case Perlin -> SinglePerlin(m_seed, x, y); + case PerlinFractal -> switch(m_fractalType) { + case FBM -> SinglePerlinFractalFBM(x, y); + case Billow -> SinglePerlinFractalBillow(x, y); + case RigidMulti -> SinglePerlinFractalRigidMulti(x, y); + }; + case Simplex -> SingleSimplex(m_seed, x, y); + case SimplexFractal -> switch(m_fractalType) { + case FBM -> SingleSimplexFractalFBM(x, y); + case Billow -> SingleSimplexFractalBillow(x, y); + case RigidMulti -> SingleSimplexFractalRigidMulti(x, y); + }; + case Cellular -> switch(m_cellularReturnType) { + case CellValue, NoiseLookup, Distance -> SingleCellular(x, y); + default -> SingleCellular2Edge(x, y); + }; + case WhiteNoise -> GetWhiteNoise(x, y); + case Cubic -> SingleCubic(m_seed, x, y); + case CubicFractal -> switch(m_fractalType) { + case FBM -> SingleCubicFractalFBM(x, y); + case Billow -> SingleCubicFractalBillow(x, y); + case RigidMulti -> SingleCubicFractalRigidMulti(x, y); + }; + default -> 0; + }; } private long DoubleCast2Long(double f) {