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

Revert "Switch!"

Browse Source 
This reverts commit 47fa31515d958036d5e98636d123de72655ccadc.
This commit is contained in:
cyberpwn 2022-01-13 07:16:45 -05:00
parent e586d0aecf
commit d468d0ca28
8 changed files with 478 additions and 329 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,8 +481,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;
} case 1:
case 1 -> {
var8 = var6; var8 = var6;
var9 = var2; var9 = var2;
var10 = var5; var10 = var5;
@ -490,8 +489,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;
} case 2:
case 2 -> {
var8 = var5; var8 = var5;
var9 = var2; var9 = var2;
var10 = var7; var10 = var7;
@ -499,8 +497,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;
} case 3:
case 3 -> {
var8 = var5; var8 = var5;
var9 = var6; var9 = var6;
var10 = var2; var10 = var2;
@ -508,8 +505,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;
} case 4:
case 4 -> {
var8 = var7; var8 = var7;
var9 = var5; var9 = var5;
var10 = var2; var10 = var2;
@ -517,8 +513,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;
} case 5:
case 5 -> {
var8 = var2; var8 = var2;
var9 = var5; var9 = var5;
var10 = var6; var10 = var6;
@ -526,7 +521,6 @@ 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,13 +157,18 @@ 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) {
return switch(saturationType) { switch(saturationType) {
case RANDOM -> randomWithin(new Range(0, 100)); case RANDOM:
case MONOCHROME -> 0; return randomWithin(new Range(0, 100));
case HIGH -> randomWithin(new Range(75, 100)); case MONOCHROME:
case MEDIUM -> randomWithin(new Range(55, 75)); return 0;
case LOW -> randomWithin(new Range(35, 55)); case HIGH:
}; 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) {
@ -177,9 +182,15 @@ public class RandomColor {
if(luminosity != null) { if(luminosity != null) {
switch(luminosity) { switch(luminosity) {
case LIGHT -> min = 55; case LIGHT:
case BRIGHT -> min = max - 10; min = 55;
case DARK -> max = 55; break;
case BRIGHT:
min = max - 10;
break;
case DARK:
max = 55;
break;
} }
} }
@ -204,12 +215,19 @@ public class RandomColor {
if(luminosity != null) { if(luminosity != null) {
switch(luminosity) { switch(luminosity) {
case DARK -> max = min + 20;
case LIGHT -> min = (max + min) / 2; case DARK:
case RANDOM -> { max = min + 20;
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,15 +203,19 @@ 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) {
return switch(indexRight - indexLeft) { switch(indexRight - indexLeft) {
case 0 -> arcLengthRecursive(indexLeft, remainderLeft, remainderRight); case 0:
case 1 -> return arcLengthRecursive(indexLeft, remainderLeft, remainderRight);
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
arcLengthRecursive(indexLeft, remainderLeft, 1.0) return arcLengthRecursive(indexLeft, remainderLeft, 1.0)
+ arcLengthRecursive(indexRight, 0.0, remainderRight); + arcLengthRecursive(indexRight, 0.0, remainderRight);
default -> arcLengthRecursive(indexLeft, remainderLeft, indexRight - 1, 1.0)
+ arcLengthRecursive(indexRight, 0.0, remainderRight); default:
}; 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,37 +467,38 @@ 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 -> 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); int var11 = clamp((int) (var8 * 255.0F), 0, 255);

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

@ -266,71 +266,85 @@ public class VectorMath {
KList<BlockFace> faces = new KList<>(); KList<BlockFace> faces = new KList<>();
switch(f) { switch(f) {
case DOWN -> faces.add(BlockFace.DOWN); case DOWN:
case EAST -> faces.add(BlockFace.EAST); faces.add(BlockFace.DOWN);
case EAST_NORTH_EAST -> { break;
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 -> faces.add(BlockFace.NORTH); case NORTH:
case NORTH_EAST -> { faces.add(BlockFace.NORTH);
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 -> faces.add(BlockFace.SELF); case SELF:
case SOUTH -> faces.add(BlockFace.SOUTH); faces.add(BlockFace.SELF);
case SOUTH_EAST -> { break;
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 -> faces.add(BlockFace.UP); case UP:
case WEST -> faces.add(BlockFace.WEST); faces.add(BlockFace.UP);
case WEST_NORTH_WEST -> { break;
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,8 +481,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;
} case 1:
case 1 -> {
var8 = var6; var8 = var6;
var9 = var2; var9 = var2;
var10 = var5; var10 = var5;
@ -490,8 +489,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;
} case 2:
case 2 -> {
var8 = var5; var8 = var5;
var9 = var2; var9 = var2;
var10 = var7; var10 = var7;
@ -499,8 +497,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;
} case 3:
case 3 -> {
var8 = var5; var8 = var5;
var9 = var6; var9 = var6;
var10 = var2; var10 = var2;
@ -508,8 +505,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;
} case 4:
case 4 -> {
var8 = var7; var8 = var7;
var9 = var5; var9 = var5;
var10 = var2; var10 = var2;
@ -517,8 +513,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;
} case 5:
case 5 -> {
var8 = var2; var8 = var2;
var9 = var5; var9 = var5;
var10 = var6; var10 = var6;
@ -526,7 +521,6 @@ 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;
} // W,X,Y break; // W,X,Y
case 2 -> { case 2:
a = zd; a = zd;
b = wd; b = wd;
c = xd; c = xd;
} // Z,W,X break; // Z,W,X
case 3 -> { case 3:
a = yd; a = yd;
b = zd; b = zd;
c = wd; c = wd;
} // Y,Z,W break; // 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,46 +332,66 @@ 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:
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleValueFractalFBM(x, y, z); case FBM:
case Billow -> SingleValueFractalBillow(x, y, z); return SingleValueFractalFBM(x, y, z);
case RigidMulti -> SingleValueFractalRigidMulti(x, y, z); case Billow:
default -> 0; return SingleValueFractalBillow(x, y, z);
}; 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:
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SinglePerlinFractalFBM(x, y, z); case FBM:
case Billow -> SinglePerlinFractalBillow(x, y, z); return SinglePerlinFractalFBM(x, y, z);
case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z); case Billow:
default -> 0; return SinglePerlinFractalBillow(x, y, z);
}; 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:
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleSimplexFractalFBM(x, y, z); case FBM:
case Billow -> SingleSimplexFractalBillow(x, y, z); return SingleSimplexFractalFBM(x, y, z);
case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z); case Billow:
default -> 0; return SingleSimplexFractalBillow(x, y, z);
}; case RigidMulti:
return SingleSimplexFractalRigidMulti(x, y, z);
default:
return 0;
}
case Cellular: case Cellular:
return switch(m_cellularReturnType) { switch(m_cellularReturnType) {
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z); case CellValue:
default -> SingleCellular2Edge(x, y, z); case NoiseLookup:
}; 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:
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleCubicFractalFBM(x, y, z); case FBM:
case Billow -> SingleCubicFractalBillow(x, y, z); return SingleCubicFractalFBM(x, y, z);
case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z); case Billow:
default -> 0; return SingleCubicFractalBillow(x, y, z);
}; case RigidMulti:
return SingleCubicFractalRigidMulti(x, y, z);
default:
return 0;
}
default: default:
return 0; return 0;
} }
@ -385,46 +405,66 @@ public class FastNoise {
case Value: case Value:
return SingleValue(m_seed, x, y); return SingleValue(m_seed, x, y);
case ValueFractal: case ValueFractal:
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleValueFractalFBM(x, y); case FBM:
case Billow -> SingleValueFractalBillow(x, y); return SingleValueFractalFBM(x, y);
case RigidMulti -> SingleValueFractalRigidMulti(x, y); case Billow:
default -> 0; return SingleValueFractalBillow(x, y);
}; 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:
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SinglePerlinFractalFBM(x, y); case FBM:
case Billow -> SinglePerlinFractalBillow(x, y); return SinglePerlinFractalFBM(x, y);
case RigidMulti -> SinglePerlinFractalRigidMulti(x, y); case Billow:
default -> 0; return SinglePerlinFractalBillow(x, y);
}; 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:
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleSimplexFractalFBM(x, y); case FBM:
case Billow -> SingleSimplexFractalBillow(x, y); return SingleSimplexFractalFBM(x, y);
case RigidMulti -> SingleSimplexFractalRigidMulti(x, y); case Billow:
default -> 0; return SingleSimplexFractalBillow(x, y);
}; case RigidMulti:
return SingleSimplexFractalRigidMulti(x, y);
default:
return 0;
}
case Cellular: case Cellular:
return switch(m_cellularReturnType) { switch(m_cellularReturnType) {
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y); case CellValue:
default -> SingleCellular2Edge(x, y); case NoiseLookup:
}; 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:
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleCubicFractalFBM(x, y); case FBM:
case Billow -> SingleCubicFractalBillow(x, y); return SingleCubicFractalFBM(x, y);
case RigidMulti -> SingleCubicFractalRigidMulti(x, y); case Billow:
default -> 0; return SingleCubicFractalBillow(x, y);
}; case RigidMulti:
return SingleCubicFractalRigidMulti(x, y);
default:
return 0;
}
default: default:
return 0; return 0;
} }
@ -478,12 +518,16 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleValueFractalFBM(x, y, z); case FBM:
case Billow -> SingleValueFractalBillow(x, y, z); return SingleValueFractalFBM(x, y, z);
case RigidMulti -> SingleValueFractalRigidMulti(x, y, z); case Billow:
default -> 0; return SingleValueFractalBillow(x, y, z);
}; 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) {
@ -551,21 +595,22 @@ public class FastNoise {
float xs, ys, zs; float xs, ys, zs;
switch(m_interp) { switch(m_interp) {
case Linear -> { default:
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);
@ -583,12 +628,16 @@ public class FastNoise {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleValueFractalFBM(x, y); case FBM:
case Billow -> SingleValueFractalBillow(x, y); return SingleValueFractalFBM(x, y);
case RigidMulti -> SingleValueFractalRigidMulti(x, y); case Billow:
default -> 0; return SingleValueFractalBillow(x, y);
}; case RigidMulti:
return SingleValueFractalRigidMulti(x, y);
default:
return 0;
}
} }
private float SingleValueFractalFBM(float x, float y) { private float SingleValueFractalFBM(float x, float y) {
@ -650,18 +699,19 @@ public class FastNoise {
float xs, ys; float xs, ys;
switch(m_interp) { switch(m_interp) {
case Linear -> { default:
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);
@ -676,12 +726,16 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SinglePerlinFractalFBM(x, y, z); case FBM:
case Billow -> SinglePerlinFractalBillow(x, y, z); return SinglePerlinFractalFBM(x, y, z);
case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z); case Billow:
default -> 0; return SinglePerlinFractalBillow(x, y, z);
}; 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) {
@ -749,21 +803,22 @@ public class FastNoise {
float xs, ys, zs; float xs, ys, zs;
switch(m_interp) { switch(m_interp) {
case Linear -> { default:
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;
@ -788,12 +843,16 @@ public class FastNoise {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SinglePerlinFractalFBM(x, y); case FBM:
case Billow -> SinglePerlinFractalBillow(x, y); return SinglePerlinFractalFBM(x, y);
case RigidMulti -> SinglePerlinFractalRigidMulti(x, y); case Billow:
default -> 0; return SinglePerlinFractalBillow(x, y);
}; case RigidMulti:
return SinglePerlinFractalRigidMulti(x, y);
default:
return 0;
}
} }
private float SinglePerlinFractalFBM(float x, float y) { private float SinglePerlinFractalFBM(float x, float y) {
@ -856,18 +915,19 @@ public class FastNoise {
float xs, ys; float xs, ys;
switch(m_interp) { switch(m_interp) {
case Linear -> { default:
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;
@ -887,12 +947,16 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleSimplexFractalFBM(x, y, z); case FBM:
case Billow -> SingleSimplexFractalBillow(x, y, z); return SingleSimplexFractalFBM(x, y, z);
case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z); case Billow:
default -> 0; return SingleSimplexFractalBillow(x, y, z);
}; 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) {
@ -1066,12 +1130,16 @@ public class FastNoise {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleSimplexFractalFBM(x, y); case FBM:
case Billow -> SingleSimplexFractalBillow(x, y); return SingleSimplexFractalFBM(x, y);
case RigidMulti -> SingleSimplexFractalRigidMulti(x, y); case Billow:
default -> 0; return SingleSimplexFractalBillow(x, y);
}; case RigidMulti:
return SingleSimplexFractalRigidMulti(x, y);
default:
return 0;
}
} }
private float SingleSimplexFractalFBM(float x, float y) { private float SingleSimplexFractalFBM(float x, float y) {
@ -1285,12 +1353,16 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleCubicFractalFBM(x, y, z); case FBM:
case Billow -> SingleCubicFractalBillow(x, y, z); return SingleCubicFractalFBM(x, y, z);
case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z); case Billow:
default -> 0; return SingleCubicFractalBillow(x, y, z);
}; 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) {
@ -1377,12 +1449,16 @@ public class FastNoise {
x *= m_frequency; x *= m_frequency;
y *= m_frequency; y *= m_frequency;
return switch(m_fractalType) { switch(m_fractalType) {
case FBM -> SingleCubicFractalFBM(x, y); case FBM:
case Billow -> SingleCubicFractalBillow(x, y); return SingleCubicFractalFBM(x, y);
case RigidMulti -> SingleCubicFractalRigidMulti(x, y); case Billow:
default -> 0; return SingleCubicFractalBillow(x, y);
}; case RigidMulti:
return SingleCubicFractalRigidMulti(x, y);
default:
return 0;
}
} }
private float SingleCubicFractalFBM(float x, float y) { private float SingleCubicFractalFBM(float x, float y) {
@ -1466,10 +1542,14 @@ public class FastNoise {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
return switch(m_cellularReturnType) { switch(m_cellularReturnType) {
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z); case CellValue:
default -> SingleCellular2Edge(x, y, z); case NoiseLookup:
}; 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) {
@ -1631,34 +1711,48 @@ public class FastNoise {
break; break;
} }
return switch(m_cellularReturnType) { switch(m_cellularReturnType) {
case Distance2 -> distance2 - 1; case Distance2:
case Distance2Add -> distance2 + distance - 1; return distance2 - 1;
case Distance2Sub -> distance2 - distance - 1; case Distance2Add:
case Distance2Mul -> distance2 * distance - 1; return distance2 + distance - 1;
case Distance2Div -> distance / distance2 - 1; case Distance2Sub:
default -> 0; return distance2 - distance - 1;
}; 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;
return switch(m_cellularReturnType) { switch(m_cellularReturnType) {
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, sourceNoise, iscale); case CellValue:
default -> SingleCellular2Edge(x, y); case NoiseLookup:
}; 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;
return switch(m_cellularReturnType) { switch(m_cellularReturnType) {
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y); case CellValue:
default -> SingleCellular2Edge(x, y); case NoiseLookup:
}; 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) {
@ -1877,14 +1971,20 @@ public class FastNoise {
break; break;
} }
return switch(m_cellularReturnType) { switch(m_cellularReturnType) {
case Distance2 -> distance2 - 1; case Distance2:
case Distance2Add -> distance2 + distance - 1; return distance2 - 1;
case Distance2Sub -> distance2 - distance - 1; case Distance2Add:
case Distance2Mul -> distance2 * distance - 1; return distance2 + distance - 1;
case Distance2Div -> distance / distance2 - 1; case Distance2Sub:
default -> 0; return distance2 - distance - 1;
}; 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) {
@ -1919,21 +2019,22 @@ public class FastNoise {
float xs, ys, zs; float xs, ys, zs;
switch(m_interp) { switch(m_interp) {
case Linear -> { default:
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];
@ -2002,18 +2103,19 @@ public class FastNoise {
float xs, ys; float xs, ys;
switch(m_interp) { switch(m_interp) {
case Linear -> { default:
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,76 +325,98 @@ public class FastNoiseDouble {
y *= m_frequency; y *= m_frequency;
z *= m_frequency; z *= m_frequency;
return switch(m_noiseType) { switch(m_noiseType) {
case Value -> SingleValue(m_seed, x, y, z); case Value:
case ValueFractal -> switch(m_fractalType) { return SingleValue(m_seed, x, y, z);
case FBM -> SingleValueFractalFBM(x, y, z); case ValueFractal:
case Billow -> SingleValueFractalBillow(x, y, z); return switch(m_fractalType) {
case RigidMulti -> SingleValueFractalRigidMulti(x, y, z); case FBM -> SingleValueFractalFBM(x, y, z);
}; case Billow -> SingleValueFractalBillow(x, y, z);
case Perlin -> SinglePerlin(m_seed, x, y, z); case RigidMulti -> SingleValueFractalRigidMulti(x, y, z);
case PerlinFractal -> switch(m_fractalType) { };
case FBM -> SinglePerlinFractalFBM(x, y, z); case Perlin:
case Billow -> SinglePerlinFractalBillow(x, y, z); return SinglePerlin(m_seed, x, y, z);
case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z); case PerlinFractal:
}; return switch(m_fractalType) {
case Simplex -> SingleSimplex(m_seed, x, y, z); case FBM -> SinglePerlinFractalFBM(x, y, z);
case SimplexFractal -> switch(m_fractalType) { case Billow -> SinglePerlinFractalBillow(x, y, z);
case FBM -> SingleSimplexFractalFBM(x, y, z); case RigidMulti -> SinglePerlinFractalRigidMulti(x, y, z);
case Billow -> SingleSimplexFractalBillow(x, y, z); };
case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z); case Simplex:
}; return SingleSimplex(m_seed, x, y, z);
case Cellular -> switch(m_cellularReturnType) { case SimplexFractal:
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z); return switch(m_fractalType) {
default -> SingleCellular2Edge(x, y, z); case FBM -> SingleSimplexFractalFBM(x, y, z);
}; case Billow -> SingleSimplexFractalBillow(x, y, z);
case WhiteNoise -> GetWhiteNoise(x, y, z); case RigidMulti -> SingleSimplexFractalRigidMulti(x, y, z);
case Cubic -> SingleCubic(m_seed, x, y, z); };
case CubicFractal -> switch(m_fractalType) { case Cellular:
case FBM -> SingleCubicFractalFBM(x, y, z); return switch(m_cellularReturnType) {
case Billow -> SingleCubicFractalBillow(x, y, z); case CellValue, NoiseLookup, Distance -> SingleCellular(x, y, z);
case RigidMulti -> SingleCubicFractalRigidMulti(x, y, z); default -> SingleCellular2Edge(x, y, z);
}; };
default -> 0; 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;
}
} }
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;
return switch(m_noiseType) { switch(m_noiseType) {
case Value -> SingleValue(m_seed, x, y); case Value:
case ValueFractal -> switch(m_fractalType) { return SingleValue(m_seed, x, y);
case FBM -> SingleValueFractalFBM(x, y); case ValueFractal:
case Billow -> SingleValueFractalBillow(x, y); return switch(m_fractalType) {
case RigidMulti -> SingleValueFractalRigidMulti(x, y); case FBM -> SingleValueFractalFBM(x, y);
}; case Billow -> SingleValueFractalBillow(x, y);
case Perlin -> SinglePerlin(m_seed, x, y); case RigidMulti -> SingleValueFractalRigidMulti(x, y);
case PerlinFractal -> switch(m_fractalType) { };
case FBM -> SinglePerlinFractalFBM(x, y); case Perlin:
case Billow -> SinglePerlinFractalBillow(x, y); return SinglePerlin(m_seed, x, y);
case RigidMulti -> SinglePerlinFractalRigidMulti(x, y); case PerlinFractal:
}; return switch(m_fractalType) {
case Simplex -> SingleSimplex(m_seed, x, y); case FBM -> SinglePerlinFractalFBM(x, y);
case SimplexFractal -> switch(m_fractalType) { case Billow -> SinglePerlinFractalBillow(x, y);
case FBM -> SingleSimplexFractalFBM(x, y); case RigidMulti -> SinglePerlinFractalRigidMulti(x, y);
case Billow -> SingleSimplexFractalBillow(x, y); };
case RigidMulti -> SingleSimplexFractalRigidMulti(x, y); case Simplex:
}; return SingleSimplex(m_seed, x, y);
case Cellular -> switch(m_cellularReturnType) { case SimplexFractal:
case CellValue, NoiseLookup, Distance -> SingleCellular(x, y); return switch(m_fractalType) {
default -> SingleCellular2Edge(x, y); case FBM -> SingleSimplexFractalFBM(x, y);
}; case Billow -> SingleSimplexFractalBillow(x, y);
case WhiteNoise -> GetWhiteNoise(x, y); case RigidMulti -> SingleSimplexFractalRigidMulti(x, y);
case Cubic -> SingleCubic(m_seed, x, y); };
case CubicFractal -> switch(m_fractalType) { case Cellular:
case FBM -> SingleCubicFractalFBM(x, y); return switch(m_cellularReturnType) {
case Billow -> SingleCubicFractalBillow(x, y); case CellValue, NoiseLookup, Distance -> SingleCellular(x, y);
case RigidMulti -> SingleCubicFractalRigidMulti(x, y); default -> SingleCellular2Edge(x, y);
}; };
default -> 0; 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;
}
} }
private long DoubleCast2Long(double f) { private long DoubleCast2Long(double f) {