mirrors/Iris
1
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2025-07-18 10:12:53 +00:00
Code Issues Packages Projects Releases Wiki Activity

Switch!

Browse Source
This commit is contained in:
cyberpwn 2022-01-13 07:16:45 -05:00
parent 7e45c17078
commit 47fa31515d
8 changed files with 329 additions and 478 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
src/main/java/com/volmit/iris/util/data/palette/Mth.java
View File

@ -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);
}

46
src/main/java/com/volmit/iris/util/inventorygui/RandomColor.java
View File

@ -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;
}
}
}

18
src/main/java/com/volmit/iris/util/math/KochanekBartelsInterpolation.java
View File

@ -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) {

27
src/main/java/com/volmit/iris/util/math/MathHelper.java
View File

@ -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);

80
src/main/java/com/volmit/iris/util/math/VectorMath.java
View File

@ -266,85 +266,71 @@ public class VectorMath {
KList<BlockFace> 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;

18
src/main/java/com/volmit/iris/util/nbt/mca/palette/MCAMth.java
View File

@ -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);
}

450
src/main/java/com/volmit/iris/util/noise/FastNoise.java
View File

@ -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<Double> 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];

150
src/main/java/com/volmit/iris/util/noise/FastNoiseDouble.java
View File

@ -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) {