mirrors/Iris
1
0
Fork 0
mirror of https://github.com/VolmitSoftware/Iris.git synced 2025-07-18 18:23:06 +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 var6 = var2 * (1.0F - var4 * var1);
float var7 = var2 * (1.0F - (1.0F - var4) * var1); float var7 = var2 * (1.0F - (1.0F - var4) * var1);
switch(var3) { switch(var3) {
case 0: case 0 -> {
var8 = var2; var8 = var2;
var9 = var7; var9 = var7;
var10 = var5; var10 = var5;
@ -481,7 +481,8 @@ public class Mth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 1: }
case 1 -> {
var8 = var6; var8 = var6;
var9 = var2; var9 = var2;
var10 = var5; var10 = var5;
@ -489,7 +490,8 @@ public class Mth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 2: }
case 2 -> {
var8 = var5; var8 = var5;
var9 = var2; var9 = var2;
var10 = var7; var10 = var7;
@ -497,7 +499,8 @@ public class Mth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 3: }
case 3 -> {
var8 = var5; var8 = var5;
var9 = var6; var9 = var6;
var10 = var2; var10 = var2;
@ -505,7 +508,8 @@ public class Mth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 4: }
case 4 -> {
var8 = var7; var8 = var7;
var9 = var5; var9 = var5;
var10 = var2; var10 = var2;
@ -513,7 +517,8 @@ public class Mth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 5: }
case 5 -> {
var8 = var2; var8 = var2;
var9 = var5; var9 = var5;
var10 = var6; var10 = var6;
@ -521,6 +526,7 @@ public class Mth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
}
} }
throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2); 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) { private int pickSaturation(ColorInfo colorInfo, SaturationType saturationType, Luminosity luminosity) {
if(saturationType != null) { if(saturationType != null) {
switch(saturationType) { return switch(saturationType) {
case RANDOM: case RANDOM -> randomWithin(new Range(0, 100));
return randomWithin(new Range(0, 100)); case MONOCHROME -> 0;
case MONOCHROME: case HIGH -> randomWithin(new Range(75, 100));
return 0; case MEDIUM -> randomWithin(new Range(55, 75));
case HIGH: case LOW -> randomWithin(new Range(35, 55));
return randomWithin(new Range(75, 100)); };
case MEDIUM:
return randomWithin(new Range(55, 75));
case LOW:
return randomWithin(new Range(35, 55));
}
} }
if(colorInfo == null) { if(colorInfo == null) {
@ -182,15 +177,9 @@ public class RandomColor {
if(luminosity != null) { if(luminosity != null) {
switch(luminosity) { switch(luminosity) {
case LIGHT: case LIGHT -> min = 55;
min = 55; case BRIGHT -> min = max - 10;
break; case DARK -> max = 55;
case BRIGHT:
min = max - 10;
break;
case DARK:
max = 55;
break;
} }
} }
@ -215,19 +204,12 @@ public class RandomColor {
if(luminosity != null) { if(luminosity != null) {
switch(luminosity) { switch(luminosity) {
case DARK -> max = min + 20;
case DARK: case LIGHT -> min = (max + min) / 2;
max = min + 20; case RANDOM -> {
break;
case LIGHT:
min = (max + min) / 2;
break;
case RANDOM:
min = 0; min = 0;
max = 100; 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. * Assumes a < b.
*/ */
private double arcLengthRecursive(int indexLeft, double remainderLeft, int indexRight, double remainderRight) { private double arcLengthRecursive(int indexLeft, double remainderLeft, int indexRight, double remainderRight) {
switch(indexRight - indexLeft) { return switch(indexRight - indexLeft) {
case 0: case 0 -> arcLengthRecursive(indexLeft, remainderLeft, remainderRight);
return arcLengthRecursive(indexLeft, remainderLeft, remainderRight); case 1 ->
case 1:
// This case is merely a speed-up for a very common case // 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); + arcLengthRecursive(indexRight, 0.0, remainderRight);
default -> arcLengthRecursive(indexLeft, remainderLeft, indexRight - 1, 1.0)
default: + arcLengthRecursive(indexRight, 0.0, remainderRight);
return arcLengthRecursive(indexLeft, remainderLeft, indexRight - 1, 1.0) };
+ arcLengthRecursive(indexRight, 0.0, remainderRight);
}
} }
private double arcLengthRecursive(int index, double remainderLeft, double 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 var9;
float var10; float var10;
switch(var3) { switch(var3) {
case 0: case 0 -> {
var8 = var2; var8 = var2;
var9 = var7; var9 = var7;
var10 = var5; var10 = var5;
break; }
case 1: case 1 -> {
var8 = var6; var8 = var6;
var9 = var2; var9 = var2;
var10 = var5; var10 = var5;
break; }
case 2: case 2 -> {
var8 = var5; var8 = var5;
var9 = var2; var9 = var2;
var10 = var7; var10 = var7;
break; }
case 3: case 3 -> {
var8 = var5; var8 = var5;
var9 = var6; var9 = var6;
var10 = var2; var10 = var2;
break; }
case 4: case 4 -> {
var8 = var7; var8 = var7;
var9 = var5; var9 = var5;
var10 = var2; var10 = var2;
break; }
case 5: case 5 -> {
var8 = var2; var8 = var2;
var9 = var5; var9 = var5;
var10 = var6; var10 = var6;
break; }
default: default -> throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2);
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); 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<>(); KList<BlockFace> faces = new KList<>();
switch(f) { switch(f) {
case DOWN: case DOWN -> faces.add(BlockFace.DOWN);
faces.add(BlockFace.DOWN); case EAST -> faces.add(BlockFace.EAST);
break; case EAST_NORTH_EAST -> {
case EAST:
faces.add(BlockFace.EAST);
break;
case EAST_NORTH_EAST:
faces.add(BlockFace.EAST); faces.add(BlockFace.EAST);
faces.add(BlockFace.EAST); faces.add(BlockFace.EAST);
faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH);
break; }
case EAST_SOUTH_EAST: case EAST_SOUTH_EAST -> {
faces.add(BlockFace.EAST); faces.add(BlockFace.EAST);
faces.add(BlockFace.EAST); faces.add(BlockFace.EAST);
faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH);
break; }
case NORTH: case NORTH -> faces.add(BlockFace.NORTH);
faces.add(BlockFace.NORTH); case NORTH_EAST -> {
break;
case NORTH_EAST:
faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH);
faces.add(BlockFace.EAST); faces.add(BlockFace.EAST);
break; }
case NORTH_NORTH_EAST: case NORTH_NORTH_EAST -> {
faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH);
faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH);
faces.add(BlockFace.EAST); faces.add(BlockFace.EAST);
break; }
case NORTH_NORTH_WEST: case NORTH_NORTH_WEST -> {
faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH);
faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH);
faces.add(BlockFace.WEST); faces.add(BlockFace.WEST);
break; }
case NORTH_WEST: case NORTH_WEST -> {
faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH);
faces.add(BlockFace.WEST); faces.add(BlockFace.WEST);
break; }
case SELF: case SELF -> faces.add(BlockFace.SELF);
faces.add(BlockFace.SELF); case SOUTH -> faces.add(BlockFace.SOUTH);
break; case SOUTH_EAST -> {
case SOUTH:
faces.add(BlockFace.SOUTH);
break;
case SOUTH_EAST:
faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH);
faces.add(BlockFace.EAST); faces.add(BlockFace.EAST);
break; }
case SOUTH_SOUTH_EAST: case SOUTH_SOUTH_EAST -> {
faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH);
faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH);
faces.add(BlockFace.EAST); faces.add(BlockFace.EAST);
break; }
case SOUTH_SOUTH_WEST: case SOUTH_SOUTH_WEST -> {
faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH);
faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH);
faces.add(BlockFace.WEST); faces.add(BlockFace.WEST);
break; }
case SOUTH_WEST: case SOUTH_WEST -> {
faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH);
faces.add(BlockFace.WEST); faces.add(BlockFace.WEST);
break; }
case UP: case UP -> faces.add(BlockFace.UP);
faces.add(BlockFace.UP); case WEST -> faces.add(BlockFace.WEST);
break; case WEST_NORTH_WEST -> {
case WEST:
faces.add(BlockFace.WEST);
break;
case WEST_NORTH_WEST:
faces.add(BlockFace.WEST); faces.add(BlockFace.WEST);
faces.add(BlockFace.WEST); faces.add(BlockFace.WEST);
faces.add(BlockFace.NORTH); faces.add(BlockFace.NORTH);
break; }
case WEST_SOUTH_WEST: case WEST_SOUTH_WEST -> {
faces.add(BlockFace.WEST); faces.add(BlockFace.WEST);
faces.add(BlockFace.WEST); faces.add(BlockFace.WEST);
faces.add(BlockFace.SOUTH); faces.add(BlockFace.SOUTH);
break; }
default: default -> {
break; }
} }
return faces; 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 var6 = var2 * (1.0F - var4 * var1);
float var7 = var2 * (1.0F - (1.0F - var4) * var1); float var7 = var2 * (1.0F - (1.0F - var4) * var1);
switch(var3) { switch(var3) {
case 0: case 0 -> {
var8 = var2; var8 = var2;
var9 = var7; var9 = var7;
var10 = var5; var10 = var5;
@ -481,7 +481,8 @@ public class MCAMth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 1: }
case 1 -> {
var8 = var6; var8 = var6;
var9 = var2; var9 = var2;
var10 = var5; var10 = var5;
@ -489,7 +490,8 @@ public class MCAMth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 2: }
case 2 -> {
var8 = var5; var8 = var5;
var9 = var2; var9 = var2;
var10 = var7; var10 = var7;
@ -497,7 +499,8 @@ public class MCAMth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 3: }
case 3 -> {
var8 = var5; var8 = var5;
var9 = var6; var9 = var6;
var10 = var2; var10 = var2;
@ -505,7 +508,8 @@ public class MCAMth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 4: }
case 4 -> {
var8 = var7; var8 = var7;
var9 = var5; var9 = var5;
var10 = var2; var10 = var2;
@ -513,7 +517,8 @@ public class MCAMth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
case 5: }
case 5 -> {
var8 = var2; var8 = var2;
var9 = var5; var9 = var5;
var10 = var6; var10 = var6;
@ -521,6 +526,7 @@ public class MCAMth {
var12 = clamp((int) (var9 * 255.0F), 0, 255); var12 = clamp((int) (var9 * 255.0F), 0, 255);
var13 = clamp((int) (var10 * 255.0F), 0, 255); var13 = clamp((int) (var10 * 255.0F), 0, 255);
return var11 << 16 | var12 << 8 | var13; return var11 << 16 | var12 << 8 | var13;
}
} }
throw new RuntimeException("Something went wrong when converting from HSV to RGB. Input was " + var0 + ", " + var1 + ", " + var2); 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; hash &= 31;
float a = yd, b = zd, c = wd; // X,Y,Z float a = yd, b = zd, c = wd; // X,Y,Z
switch(hash >> 3) { // OR, DEPENDING ON HIGH ORDER 2 BITS: switch(hash >> 3) { // OR, DEPENDING ON HIGH ORDER 2 BITS:
case 1: case 1 -> {
a = wd; a = wd;
b = xd; b = xd;
c = yd; c = yd;
break; // W,X,Y } // W,X,Y
case 2: case 2 -> {
a = zd; a = zd;
b = wd; b = wd;
c = xd; c = xd;
break; // Z,W,X } // Z,W,X
case 3: case 3 -> {
a = yd; a = yd;
b = zd; b = zd;
c = wd; 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); 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: case Value:
return SingleValue(m_seed, x, y, z); return SingleValue(m_seed, x, y, z);
case ValueFractal: case ValueFractal:
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleValueFractalFBM(x, y, z);
return SingleValueFractalFBM(x, y, z); case Billow -> SingleValueFractalBillow(x, y, z);
case Billow: case RigidMulti -> SingleValueFractalRigidMulti(x, y, z);
return SingleValueFractalBillow(x, y, z); default -> 0;
case RigidMulti: };
return SingleValueFractalRigidMulti(x, y, z);
default:
return 0;
}
case Perlin: case Perlin:
return SinglePerlin(m_seed, x, y, z); return SinglePerlin(m_seed, x, y, z);
case PerlinFractal: case PerlinFractal:
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SinglePerlinFractalFBM(x, y, z);
return SinglePerlinFractalFBM(x, y, z); case Billow -> SinglePerlinFractalBillow(x, y, z);
case Billow: case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z);
return SinglePerlinFractalBillow(x, y, z); default -> 0;
case RigidMulti: };
return SinglePerlinFractalRigidMulti(x, y, z);
default:
return 0;
}
case Simplex: case Simplex:
return SingleSimplex(m_seed, x, y, z); return SingleSimplex(m_seed, x, y, z);
case SimplexFractal: case SimplexFractal:
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleSimplexFractalFBM(x, y, z);
return SingleSimplexFractalFBM(x, y, z); case Billow -> SingleSimplexFractalBillow(x, y, z);
case Billow: case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z);
return SingleSimplexFractalBillow(x, y, z); default -> 0;
case RigidMulti: };
return SingleSimplexFractalRigidMulti(x, y, z);
default:
return 0;
}
case Cellular: case Cellular:
switch(m_cellularReturnType) { return switch(m_cellularReturnType) {
case CellValue: case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z);
case NoiseLookup: default -> SingleCellular2Edge(x, y, z);
case Distance: };
return SingleCellular(x, y, z);
default:
return SingleCellular2Edge(x, y, z);
}
case WhiteNoise: case WhiteNoise:
return GetWhiteNoise(x, y, z); return GetWhiteNoise(x, y, z);
case Cubic: case Cubic:
return SingleCubic(m_seed, x, y, z); return SingleCubic(m_seed, x, y, z);
case CubicFractal: case CubicFractal:
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleCubicFractalFBM(x, y, z);
return SingleCubicFractalFBM(x, y, z); case Billow -> SingleCubicFractalBillow(x, y, z);
case Billow: case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z);
return SingleCubicFractalBillow(x, y, z); default -> 0;
case RigidMulti: };
return SingleCubicFractalRigidMulti(x, y, z);
default:
return 0;
}
default: default:
return 0; return 0;
} }
@ -405,66 +385,46 @@ public class FastNoise {
case Value: case Value:
return SingleValue(m_seed, x, y); return SingleValue(m_seed, x, y);
case ValueFractal: case ValueFractal:
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleValueFractalFBM(x, y);
return SingleValueFractalFBM(x, y); case Billow -> SingleValueFractalBillow(x, y);
case Billow: case RigidMulti -> SingleValueFractalRigidMulti(x, y);
return SingleValueFractalBillow(x, y); default -> 0;
case RigidMulti: };
return SingleValueFractalRigidMulti(x, y);
default:
return 0;
}
case Perlin: case Perlin:
return SinglePerlin(m_seed, x, y); return SinglePerlin(m_seed, x, y);
case PerlinFractal: case PerlinFractal:
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SinglePerlinFractalFBM(x, y);
return SinglePerlinFractalFBM(x, y); case Billow -> SinglePerlinFractalBillow(x, y);
case Billow: case RigidMulti -> SinglePerlinFractalRigidMulti(x, y);
return SinglePerlinFractalBillow(x, y); default -> 0;
case RigidMulti: };
return SinglePerlinFractalRigidMulti(x, y);
default:
return 0;
}
case Simplex: case Simplex:
return SingleSimplex(m_seed, x, y); return SingleSimplex(m_seed, x, y);
case SimplexFractal: case SimplexFractal:
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleSimplexFractalFBM(x, y);
return SingleSimplexFractalFBM(x, y); case Billow -> SingleSimplexFractalBillow(x, y);
case Billow: case RigidMulti -> SingleSimplexFractalRigidMulti(x, y);
return SingleSimplexFractalBillow(x, y); default -> 0;
case RigidMulti: };
return SingleSimplexFractalRigidMulti(x, y);
default:
return 0;
}
case Cellular: case Cellular:
switch(m_cellularReturnType) { return switch(m_cellularReturnType) {
case CellValue: case CellValue, NoiseLookup, Distance -> SingleCellular(x, y);
case NoiseLookup: default -> SingleCellular2Edge(x, y);
case Distance: };
return SingleCellular(x, y);
default:
return SingleCellular2Edge(x, y);
}
case WhiteNoise: case WhiteNoise:
return GetWhiteNoise(x, y); return GetWhiteNoise(x, y);
case Cubic: case Cubic:
return SingleCubic(m_seed, x, y); return SingleCubic(m_seed, x, y);
case CubicFractal: case CubicFractal:
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleCubicFractalFBM(x, y);
return SingleCubicFractalFBM(x, y); case Billow -> SingleCubicFractalBillow(x, y);
case Billow: case RigidMulti -> SingleCubicFractalRigidMulti(x, y);
return SingleCubicFractalBillow(x, y); default -> 0;
case RigidMulti: };
return SingleCubicFractalRigidMulti(x, y);
default:
return 0;
}
default: default:
return 0; return 0;
} }
@ -518,16 +478,12 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleValueFractalFBM(x, y, z);
return SingleValueFractalFBM(x, y, z); case Billow -> SingleValueFractalBillow(x, y, z);
case Billow: case RigidMulti -> SingleValueFractalRigidMulti(x, y, z);
return SingleValueFractalBillow(x, y, z); default -> 0;
case RigidMulti: };
return SingleValueFractalRigidMulti(x, y, z);
default:
return 0;
}
} }
private float SingleValueFractalFBM(float x, float y, float z) { private float SingleValueFractalFBM(float x, float y, float z) {
@ -595,22 +551,21 @@ public class FastNoise {
float xs, ys, zs; float xs, ys, zs;
switch(m_interp) { switch(m_interp) {
default: case Linear -> {
case Linear:
xs = x - x0; xs = x - x0;
ys = y - y0; ys = y - y0;
zs = z - z0; zs = z - z0;
break; }
case Hermite: case Hermite -> {
xs = InterpHermiteFunc(x - x0); xs = InterpHermiteFunc(x - x0);
ys = InterpHermiteFunc(y - y0); ys = InterpHermiteFunc(y - y0);
zs = InterpHermiteFunc(z - z0); zs = InterpHermiteFunc(z - z0);
break; }
case Quintic: case Quintic -> {
xs = InterpQuinticFunc(x - x0); xs = InterpQuinticFunc(x - x0);
ys = InterpQuinticFunc(y - y0); ys = InterpQuinticFunc(y - y0);
zs = InterpQuinticFunc(z - z0); zs = InterpQuinticFunc(z - z0);
break; }
} }
float xf00 = Lerp(ValCoord3D(seed, x0, y0, z0), ValCoord3D(seed, x1, y0, z0), xs); float xf00 = Lerp(ValCoord3D(seed, x0, y0, z0), ValCoord3D(seed, x1, y0, z0), xs);
@ -628,16 +583,12 @@ public class FastNoise {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleValueFractalFBM(x, y);
return SingleValueFractalFBM(x, y); case Billow -> SingleValueFractalBillow(x, y);
case Billow: case RigidMulti -> SingleValueFractalRigidMulti(x, y);
return SingleValueFractalBillow(x, y); default -> 0;
case RigidMulti: };
return SingleValueFractalRigidMulti(x, y);
default:
return 0;
}
} }
private float SingleValueFractalFBM(float x, float y) { private float SingleValueFractalFBM(float x, float y) {
@ -699,19 +650,18 @@ public class FastNoise {
float xs, ys; float xs, ys;
switch(m_interp) { switch(m_interp) {
default: case Linear -> {
case Linear:
xs = x - x0; xs = x - x0;
ys = y - y0; ys = y - y0;
break; }
case Hermite: case Hermite -> {
xs = InterpHermiteFunc(x - x0); xs = InterpHermiteFunc(x - x0);
ys = InterpHermiteFunc(y - y0); ys = InterpHermiteFunc(y - y0);
break; }
case Quintic: case Quintic -> {
xs = InterpQuinticFunc(x - x0); xs = InterpQuinticFunc(x - x0);
ys = InterpQuinticFunc(y - y0); ys = InterpQuinticFunc(y - y0);
break; }
} }
float xf0 = Lerp(ValCoord2D(seed, x0, y0), ValCoord2D(seed, x1, y0), xs); float xf0 = Lerp(ValCoord2D(seed, x0, y0), ValCoord2D(seed, x1, y0), xs);
@ -726,16 +676,12 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SinglePerlinFractalFBM(x, y, z);
return SinglePerlinFractalFBM(x, y, z); case Billow -> SinglePerlinFractalBillow(x, y, z);
case Billow: case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z);
return SinglePerlinFractalBillow(x, y, z); default -> 0;
case RigidMulti: };
return SinglePerlinFractalRigidMulti(x, y, z);
default:
return 0;
}
} }
private float SinglePerlinFractalFBM(float x, float y, float z) { private float SinglePerlinFractalFBM(float x, float y, float z) {
@ -803,22 +749,21 @@ public class FastNoise {
float xs, ys, zs; float xs, ys, zs;
switch(m_interp) { switch(m_interp) {
default: case Linear -> {
case Linear:
xs = x - x0; xs = x - x0;
ys = y - y0; ys = y - y0;
zs = z - z0; zs = z - z0;
break; }
case Hermite: case Hermite -> {
xs = InterpHermiteFunc(x - x0); xs = InterpHermiteFunc(x - x0);
ys = InterpHermiteFunc(y - y0); ys = InterpHermiteFunc(y - y0);
zs = InterpHermiteFunc(z - z0); zs = InterpHermiteFunc(z - z0);
break; }
case Quintic: case Quintic -> {
xs = InterpQuinticFunc(x - x0); xs = InterpQuinticFunc(x - x0);
ys = InterpQuinticFunc(y - y0); ys = InterpQuinticFunc(y - y0);
zs = InterpQuinticFunc(z - z0); zs = InterpQuinticFunc(z - z0);
break; }
} }
float xd0 = x - x0; float xd0 = x - x0;
@ -843,16 +788,12 @@ public class FastNoise {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SinglePerlinFractalFBM(x, y);
return SinglePerlinFractalFBM(x, y); case Billow -> SinglePerlinFractalBillow(x, y);
case Billow: case RigidMulti -> SinglePerlinFractalRigidMulti(x, y);
return SinglePerlinFractalBillow(x, y); default -> 0;
case RigidMulti: };
return SinglePerlinFractalRigidMulti(x, y);
default:
return 0;
}
} }
private float SinglePerlinFractalFBM(float x, float y) { private float SinglePerlinFractalFBM(float x, float y) {
@ -915,19 +856,18 @@ public class FastNoise {
float xs, ys; float xs, ys;
switch(m_interp) { switch(m_interp) {
default: case Linear -> {
case Linear:
xs = x - x0; xs = x - x0;
ys = y - y0; ys = y - y0;
break; }
case Hermite: case Hermite -> {
xs = InterpHermiteFunc(x - x0); xs = InterpHermiteFunc(x - x0);
ys = InterpHermiteFunc(y - y0); ys = InterpHermiteFunc(y - y0);
break; }
case Quintic: case Quintic -> {
xs = InterpQuinticFunc(x - x0); xs = InterpQuinticFunc(x - x0);
ys = InterpQuinticFunc(y - y0); ys = InterpQuinticFunc(y - y0);
break; }
} }
float xd0 = x - x0; float xd0 = x - x0;
@ -947,16 +887,12 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleSimplexFractalFBM(x, y, z);
return SingleSimplexFractalFBM(x, y, z); case Billow -> SingleSimplexFractalBillow(x, y, z);
case Billow: case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z);
return SingleSimplexFractalBillow(x, y, z); default -> 0;
case RigidMulti: };
return SingleSimplexFractalRigidMulti(x, y, z);
default:
return 0;
}
} }
private float SingleSimplexFractalFBM(float x, float y, float z) { private float SingleSimplexFractalFBM(float x, float y, float z) {
@ -1130,16 +1066,12 @@ public class FastNoise {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleSimplexFractalFBM(x, y);
return SingleSimplexFractalFBM(x, y); case Billow -> SingleSimplexFractalBillow(x, y);
case Billow: case RigidMulti -> SingleSimplexFractalRigidMulti(x, y);
return SingleSimplexFractalBillow(x, y); default -> 0;
case RigidMulti: };
return SingleSimplexFractalRigidMulti(x, y);
default:
return 0;
}
} }
private float SingleSimplexFractalFBM(float x, float y) { private float SingleSimplexFractalFBM(float x, float y) {
@ -1353,16 +1285,12 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleCubicFractalFBM(x, y, z);
return SingleCubicFractalFBM(x, y, z); case Billow -> SingleCubicFractalBillow(x, y, z);
case Billow: case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z);
return SingleCubicFractalBillow(x, y, z); default -> 0;
case RigidMulti: };
return SingleCubicFractalRigidMulti(x, y, z);
default:
return 0;
}
} }
private float SingleCubicFractalFBM(float x, float y, float z) { private float SingleCubicFractalFBM(float x, float y, float z) {
@ -1449,16 +1377,12 @@ public class FastNoise {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
switch(m_fractalType) { return switch(m_fractalType) {
case FBM: case FBM -> SingleCubicFractalFBM(x, y);
return SingleCubicFractalFBM(x, y); case Billow -> SingleCubicFractalBillow(x, y);
case Billow: case RigidMulti -> SingleCubicFractalRigidMulti(x, y);
return SingleCubicFractalBillow(x, y); default -> 0;
case RigidMulti: };
return SingleCubicFractalRigidMulti(x, y);
default:
return 0;
}
} }
private float SingleCubicFractalFBM(float x, float y) { private float SingleCubicFractalFBM(float x, float y) {
@ -1542,14 +1466,10 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
switch(m_cellularReturnType) { return switch(m_cellularReturnType) {
case CellValue: case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z);
case NoiseLookup: default -> SingleCellular2Edge(x, y, z);
case Distance: };
return SingleCellular(x, y, z);
default:
return SingleCellular2Edge(x, y, z);
}
} }
private float SingleCellular(float x, float y, float z) { private float SingleCellular(float x, float y, float z) {
@ -1711,48 +1631,34 @@ public class FastNoise {
break; break;
} }
switch(m_cellularReturnType) { return switch(m_cellularReturnType) {
case Distance2: case Distance2 -> distance2 - 1;
return distance2 - 1; case Distance2Add -> distance2 + distance - 1;
case Distance2Add: case Distance2Sub -> distance2 - distance - 1;
return distance2 + distance - 1; case Distance2Mul -> distance2 * distance - 1;
case Distance2Sub: case Distance2Div -> distance / distance2 - 1;
return distance2 - distance - 1; default -> 0;
case Distance2Mul: };
return distance2 * distance - 1;
case Distance2Div:
return distance / distance2 - 1;
default:
return 0;
}
} }
public float GetCellular(float x, float y, ProceduralStream<Double> sourceNoise, double iscale) { public float GetCellular(float x, float y, ProceduralStream<Double> sourceNoise, double iscale) {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
switch(m_cellularReturnType) { return switch(m_cellularReturnType) {
case CellValue: case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, sourceNoise, iscale);
case NoiseLookup: default -> SingleCellular2Edge(x, y);
case Distance: };
return SingleCellular(x, y, sourceNoise, iscale);
default:
return SingleCellular2Edge(x, y);
}
} }
public float GetCellular(float x, float y) { public float GetCellular(float x, float y) {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
switch(m_cellularReturnType) { return switch(m_cellularReturnType) {
case CellValue: case CellValue, NoiseLookup, Distance -> SingleCellular(x, y);
case NoiseLookup: default -> SingleCellular2Edge(x, y);
case Distance: };
return SingleCellular(x, y);
default:
return SingleCellular2Edge(x, y);
}
} }
private float SingleCellular(float x, float y) { private float SingleCellular(float x, float y) {
@ -1971,20 +1877,14 @@ public class FastNoise {
break; break;
} }
switch(m_cellularReturnType) { return switch(m_cellularReturnType) {
case Distance2: case Distance2 -> distance2 - 1;
return distance2 - 1; case Distance2Add -> distance2 + distance - 1;
case Distance2Add: case Distance2Sub -> distance2 - distance - 1;
return distance2 + distance - 1; case Distance2Mul -> distance2 * distance - 1;
case Distance2Sub: case Distance2Div -> distance / distance2 - 1;
return distance2 - distance - 1; default -> 0;
case Distance2Mul: };
return distance2 * distance - 1;
case Distance2Div:
return distance / distance2 - 1;
default:
return 0;
}
} }
public void GradientPerturb(Vector3f v3) { public void GradientPerturb(Vector3f v3) {
@ -2019,22 +1919,21 @@ public class FastNoise {
float xs, ys, zs; float xs, ys, zs;
switch(m_interp) { switch(m_interp) {
default: case Linear -> {
case Linear:
xs = xf - x0; xs = xf - x0;
ys = yf - y0; ys = yf - y0;
zs = zf - z0; zs = zf - z0;
break; }
case Hermite: case Hermite -> {
xs = InterpHermiteFunc(xf - x0); xs = InterpHermiteFunc(xf - x0);
ys = InterpHermiteFunc(yf - y0); ys = InterpHermiteFunc(yf - y0);
zs = InterpHermiteFunc(zf - z0); zs = InterpHermiteFunc(zf - z0);
break; }
case Quintic: case Quintic -> {
xs = InterpQuinticFunc(xf - x0); xs = InterpQuinticFunc(xf - x0);
ys = InterpQuinticFunc(yf - y0); ys = InterpQuinticFunc(yf - y0);
zs = InterpQuinticFunc(zf - z0); zs = InterpQuinticFunc(zf - z0);
break; }
} }
Float3 vec0 = CELL_3D[Hash3D(seed, x0, y0, z0) & 255]; Float3 vec0 = CELL_3D[Hash3D(seed, x0, y0, z0) & 255];
@ -2103,19 +2002,18 @@ public class FastNoise {
float xs, ys; float xs, ys;
switch(m_interp) { switch(m_interp) {
default: case Linear -> {
case Linear:
xs = xf - x0; xs = xf - x0;
ys = yf - y0; ys = yf - y0;
break; }
case Hermite: case Hermite -> {
xs = InterpHermiteFunc(xf - x0); xs = InterpHermiteFunc(xf - x0);
ys = InterpHermiteFunc(yf - y0); ys = InterpHermiteFunc(yf - y0);
break; }
case Quintic: case Quintic -> {
xs = InterpQuinticFunc(xf - x0); xs = InterpQuinticFunc(xf - x0);
ys = InterpQuinticFunc(yf - y0); ys = InterpQuinticFunc(yf - y0);
break; }
} }
Float2 vec0 = CELL_2D[Hash2D(seed, x0, y0) & 255]; 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; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
switch(m_noiseType) { return switch(m_noiseType) {
case Value: case Value -> SingleValue(m_seed, x, y, z);
return SingleValue(m_seed, x, y, z); case ValueFractal -> switch(m_fractalType) {
case ValueFractal: case FBM -> SingleValueFractalFBM(x, y, z);
return switch(m_fractalType) { case Billow -> SingleValueFractalBillow(x, y, z);
case FBM -> SingleValueFractalFBM(x, y, z); case RigidMulti -> SingleValueFractalRigidMulti(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 Perlin: case FBM -> SinglePerlinFractalFBM(x, y, z);
return SinglePerlin(m_seed, x, y, z); case Billow -> SinglePerlinFractalBillow(x, y, z);
case PerlinFractal: case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z);
return switch(m_fractalType) { };
case FBM -> SinglePerlinFractalFBM(x, y, z); case Simplex -> SingleSimplex(m_seed, x, y, z);
case Billow -> SinglePerlinFractalBillow(x, y, z); case SimplexFractal -> switch(m_fractalType) {
case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z); case FBM -> SingleSimplexFractalFBM(x, y, z);
}; case Billow -> SingleSimplexFractalBillow(x, y, z);
case Simplex: case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z);
return SingleSimplex(m_seed, x, y, z); };
case SimplexFractal: case Cellular -> switch(m_cellularReturnType) {
return switch(m_fractalType) { case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z);
case FBM -> SingleSimplexFractalFBM(x, y, z); default -> SingleCellular2Edge(x, y, z);
case Billow -> SingleSimplexFractalBillow(x, y, z); };
case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z); case WhiteNoise -> GetWhiteNoise(x, y, z);
}; case Cubic -> SingleCubic(m_seed, x, y, z);
case Cellular: case CubicFractal -> switch(m_fractalType) {
return switch(m_cellularReturnType) { case FBM -> SingleCubicFractalFBM(x, y, z);
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z); case Billow -> SingleCubicFractalBillow(x, y, z);
default -> SingleCellular2Edge(x, y, z); case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z);
}; };
case WhiteNoise: default -> 0;
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;
}
} }
public double GetNoise(double x, double y) { public double GetNoise(double x, double y) {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
switch(m_noiseType) { return switch(m_noiseType) {
case Value: case Value -> SingleValue(m_seed, x, y);
return SingleValue(m_seed, x, y); case ValueFractal -> switch(m_fractalType) {
case ValueFractal: case FBM -> SingleValueFractalFBM(x, y);
return switch(m_fractalType) { case Billow -> SingleValueFractalBillow(x, y);
case FBM -> SingleValueFractalFBM(x, y); case RigidMulti -> SingleValueFractalRigidMulti(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 Perlin: case FBM -> SinglePerlinFractalFBM(x, y);
return SinglePerlin(m_seed, x, y); case Billow -> SinglePerlinFractalBillow(x, y);
case PerlinFractal: case RigidMulti -> SinglePerlinFractalRigidMulti(x, y);
return switch(m_fractalType) { };
case FBM -> SinglePerlinFractalFBM(x, y); case Simplex -> SingleSimplex(m_seed, x, y);
case Billow -> SinglePerlinFractalBillow(x, y); case SimplexFractal -> switch(m_fractalType) {
case RigidMulti -> SinglePerlinFractalRigidMulti(x, y); case FBM -> SingleSimplexFractalFBM(x, y);
}; case Billow -> SingleSimplexFractalBillow(x, y);
case Simplex: case RigidMulti -> SingleSimplexFractalRigidMulti(x, y);
return SingleSimplex(m_seed, x, y); };
case SimplexFractal: case Cellular -> switch(m_cellularReturnType) {
return switch(m_fractalType) { case CellValue, NoiseLookup, Distance -> SingleCellular(x, y);
case FBM -> SingleSimplexFractalFBM(x, y); default -> SingleCellular2Edge(x, y);
case Billow -> SingleSimplexFractalBillow(x, y); };
case RigidMulti -> SingleSimplexFractalRigidMulti(x, y); case WhiteNoise -> GetWhiteNoise(x, y);
}; case Cubic -> SingleCubic(m_seed, x, y);
case Cellular: case CubicFractal -> switch(m_fractalType) {
return switch(m_cellularReturnType) { case FBM -> SingleCubicFractalFBM(x, y);
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y); case Billow -> SingleCubicFractalBillow(x, y);
default -> SingleCellular2Edge(x, y); case RigidMulti -> SingleCubicFractalRigidMulti(x, y);
}; };
case WhiteNoise: default -> 0;
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;
}
} }
private long DoubleCast2Long(double f) { private long DoubleCast2Long(double f) {