- * Default: 1337 - */ - public void setSeed(int seed) { - mSeed = seed; - } - - /** - * Sets frequency for all noise types - *
- * Default: 0.01 - */ - public void setFrequency(double frequency) { - mFrequency = frequency; - } - - /** - * Sets noise algorithm used for GetNoise(...) - *
- * Default: OpenSimplex2Sampler - */ - public void setNoiseType(NoiseType noiseType) { - mNoiseType = noiseType; - UpdateTransformType3D(); - } - - private void UpdateTransformType3D() { - switch(mRotationType3D) { - case ImproveXYPlanes: - mTransformType3D = TransformType3D.ImproveXYPlanes; - break; - case ImproveXZPlanes: - mTransformType3D = TransformType3D.ImproveXZPlanes; - break; - default: - switch(mNoiseType) { - case OpenSimplex2: - case OpenSimplex2S: - mTransformType3D = TransformType3D.DefaultOpenSimplex2; - break; - default: - mTransformType3D = TransformType3D.None; - break; - } - break; - } - } - - /** - * Sets domain rotation type for 3D Noise and 3D DomainWarp. - * Can aid in reducing directional artifacts when sampling a 2D plane in 3D - *
- * Default: None - */ - public void setRotationType3D(RotationType3D rotationType3D) { - mRotationType3D = rotationType3D; - UpdateTransformType3D(); - updateWarpTransformType3D(); - } - - private void updateWarpTransformType3D() { - switch(mRotationType3D) { - case ImproveXYPlanes: - mWarpTransformType3D = TransformType3D.ImproveXYPlanes; - break; - case ImproveXZPlanes: - mWarpTransformType3D = TransformType3D.ImproveXZPlanes; - break; - default: - switch(mDomainWarpType) { - case OpenSimplex2: - case OpenSimplex2Reduced: - mWarpTransformType3D = TransformType3D.DefaultOpenSimplex2; - break; - default: - mWarpTransformType3D = TransformType3D.None; - break; - } - break; - } - } - - /** - * Sets method for combining octaves in all fractal noise types - *
- * Default: None - * Note: FractalType.DomainWarp... only affects DomainWarp(...) - */ - public void setFractalType(FractalType fractalType) { - mFractalType = fractalType; - } - - /** - * Sets octave count for all fractal noise types - *
- * Default: 3 - */ - public void setFractalOctaves(int octaves) { - mOctaves = octaves; - calculateFractalBounding(); - } - - private void calculateFractalBounding() { - double gain = fastAbs(mGain); - double amp = gain; - double ampFractal = 1.0; - for(int i = 1; i < mOctaves; i++) { - ampFractal += amp; - amp *= gain; - } - mFractalBounding = 1 / ampFractal; - } - - /** - * Sets octave lacunarity for all fractal noise types - *
- * Default: 2.0 - */ - public void setFractalLacunarity(double lacunarity) { - mLacunarity = lacunarity; - } - - /** - * Sets octave gain for all fractal noise types - *
- * Default: 0.5 - */ - public void setFractalGain(double gain) { - mGain = gain; - calculateFractalBounding(); - } - - /** - * Sets octave weighting for all none DomainWarp fratal types - *
- * Default: 0.0 - * Note: Keep between 0...1 to maintain -1...1 output bounding - */ - public void setFractalWeightedStrength(double weightedStrength) { - mWeightedStrength = weightedStrength; - } - - /** - * Sets strength of the fractal ping pong effect - *
- * Default: 2.0 - */ - public void setFractalPingPongStrength(double pingPongStrength) { - mPingPongStrength = pingPongStrength; - } - - /** - * Sets distance function used in cellular noise calculations - *
- * Default: Distance - */ - public void setCellularDistanceFunction(CellularDistanceFunction cellularDistanceFunction) { - mCellularDistanceFunction = cellularDistanceFunction; - } - - /** - * Sets return type from cellular noise calculations - *
- * Default: EuclideanSq - */ - public void setCellularReturnType(CellularReturnType cellularReturnType) { - mCellularReturnType = cellularReturnType; - } - - /** - * Sets the maximum distance a cellular point can move from it's grid position - *
- * Default: 1.0 - * Note: Setting this higher than 1 will cause artifacts - */ - public void setCellularJitter(double cellularJitter) { - mCellularJitterModifier = cellularJitter; - } - - /** - * Sets the warp algorithm when using DomainWarp(...) - *
- * Default: OpenSimplex2Sampler - */ - public void setDomainWarpType(DomainWarpType domainWarpType) { - mDomainWarpType = domainWarpType; - updateWarpTransformType3D(); - } - - /** - * Sets the maximum warp distance from original position when using DomainWarp(...) - *
- * Default: 1.0 - */ - public void setDomainWarpAmp(double domainWarpAmp) { - mDomainWarpAmp = domainWarpAmp; - } - - /** - * 2D noise at given position using current settings - *
- * Noise output bounded between -1...1 - */ - @Override - public double getNoise(double x, double y) { - return getNoiseSeeded(mSeed, x, y); - } - - /** - * 3D noise at given position using current settings - *
- * Noise output bounded between -1...1 - */ - @Override - public double getNoise(double x, double y, double z) { - return getNoiseSeeded(mSeed, x, y, z); - } - - @Override - public double getNoiseSeeded(int seed, double x, double y) { - x *= mFrequency; - y *= mFrequency; - - switch(mNoiseType) { - case OpenSimplex2: - case OpenSimplex2S: { - - final double SQRT3 = 1.7320508075688772935274463415059; - final double F2 = 0.5f * (SQRT3 - 1); - - double t = (x + y) * F2; - x += t; - y += t; - } - break; - default: - break; - } - - switch(mFractalType) { - default: - return getNoiseRaw(seed, x, y); - case FBm: - return genFractalFBm(seed, x, y); - case Ridged: - return genFractalRidged(seed, x, y); - case PingPong: - return genFractalPingPong(seed, x, y); - } - } - - @Override - public double getNoiseSeeded(int seed, double x, double y, double z) { - x *= mFrequency; - y *= mFrequency; - z *= mFrequency; - - switch(mTransformType3D) { - case ImproveXYPlanes: { - - double xy = x + y; - - double s2 = xy * -0.211324865405187D; - - z *= 0.577350269189626; - x += s2 - z; - y = y + s2 - z; - - z += xy * 0.577350269189626; - } - break; - case ImproveXZPlanes: { - - double xz = x + z; - - double s2 = xz * -0.211324865405187D; - - y *= 0.577350269189626; - x += s2 - y; - z += s2 - y; - - y += xz * 0.577350269189626; - } - break; - case DefaultOpenSimplex2: { - - final double R3 = 2.0 / 3.0; - - double r = (x + y + z) * R3; // Rotation, not skew - x = r - x; - y = r - y; - z = r - z; - } - break; - default: - break; - } - - switch(mFractalType) { - default: - return getNoiseRaw(seed, x, y, z); - case FBm: - return genFractalFBm(seed, x, y, z); - case Ridged: - return genFractalRidged(seed, x, y, z); - case PingPong: - return genFractalPingPong(seed, x, y, z); - } - } - - public double getNoiseRaw(int seed, double x, double y) { - switch(mNoiseType) { - case OpenSimplex2: - return singleSimplex(seed, x, y); - case OpenSimplex2S: - return singleOpenSimplex2S(seed, x, y); - case Cellular: - return singleCellular(seed, x, y); - case Perlin: - return singlePerlin(seed, x, y); - case ValueCubic: - return singleValueCubic(seed, x, y); - case Value: - return singleValue(seed, x, y); - case WhiteNoise: - return singleWhiteNoise(seed, x, y); - default: - return 0; - } - } - - public double getNoiseRaw(int seed, double x, double y, double z) { - switch(mNoiseType) { - case OpenSimplex2: - return singleOpenSimplex2(seed, x, y, z); - case OpenSimplex2S: - return singleOpenSimplex2S(seed, x, y, z); - case Cellular: - return singleCellular(seed, x, y, z); - case Perlin: - return singlePerlin(seed, x, y, z); - case ValueCubic: - return singleValueCubic(seed, x, y, z); - case Value: - return singleValue(seed, x, y, z); - case WhiteNoise: - return singleWhiteNoise(seed, x, y, z); - default: - return 0; - } - } - - /** - * 2D warps the input position using current domain warp settings - *
- * Example usage with GetNoise
- * DomainWarp(coord)
- * noise = GetNoise(x, y)
- */
- public void domainWarp(Vector2 coord) {
- switch(mFractalType) {
- default:
- domainWarpSingle(mSeed, coord);
- break;
- case DomainWarpProgressive:
- domainWarpFractalProgressive(mSeed, coord);
- break;
- case DomainWarpIndependent:
- domainWarpFractalIndependent(mSeed, coord);
- break;
- }
- }
-
- /**
- * 3D warps the input position using current domain warp settings
- *
- * Example usage with GetNoise
- * DomainWarp(coord)
- * noise = GetNoise(x, y, z)
- */
- public void domainWarp(Vector3 coord) {
- switch(mFractalType) {
- default:
- domainWarpSingle(mSeed, coord);
- break;
- case DomainWarpProgressive:
- domainWarpFractalProgressive(mSeed, coord);
- break;
- case DomainWarpIndependent:
- domainWarpFractalIndependent(mSeed, coord);
- break;
- }
- }
-
- private double genFractalFBm(int seed, double x, double y) {
- double sum = 0;
- double amp = mFractalBounding;
-
- for(int i = 0; i < mOctaves; i++) {
- double noise = getNoiseRaw(seed++, x, y);
- sum += noise * amp;
- amp *= lerp(1.0, fastMin(noise + 1, 2) * 0.5, mWeightedStrength);
-
- x *= mLacunarity;
- y *= mLacunarity;
- amp *= mGain;
- }
-
- return sum;
- }
-
- private double genFractalFBm(int seed, double x, double y, double z) {
- double sum = 0;
- double amp = mFractalBounding;
-
- for(int i = 0; i < mOctaves; i++) {
- double noise = getNoiseRaw(seed++, x, y, z);
- sum += noise * amp;
- amp *= lerp(1.0, (noise + 1) * 0.5, mWeightedStrength);
-
- x *= mLacunarity;
- y *= mLacunarity;
- z *= mLacunarity;
- amp *= mGain;
- }
-
- return sum;
- }
-
- private double genFractalRidged(int seed, double x, double y) {
- double sum = 0;
- double amp = mFractalBounding;
-
- for(int i = 0; i < mOctaves; i++) {
- double noise = fastAbs(getNoiseRaw(seed++, x, y));
- sum += (noise * -2 + 1) * amp;
- amp *= lerp(1.0, 1 - noise, mWeightedStrength);
-
- x *= mLacunarity;
- y *= mLacunarity;
- amp *= mGain;
- }
-
- return sum;
- }
-
- // Generic noise gen
- private double genFractalRidged(int seed, double x, double y, double z) {
- double sum = 0;
- double amp = mFractalBounding;
-
- for(int i = 0; i < mOctaves; i++) {
- double noise = fastAbs(getNoiseRaw(seed++, x, y, z));
- sum += (noise * -2 + 1) * amp;
- amp *= lerp(1.0, 1 - noise, mWeightedStrength);
-
- x *= mLacunarity;
- y *= mLacunarity;
- z *= mLacunarity;
- amp *= mGain;
- }
-
- return sum;
- }
-
- private double genFractalPingPong(int seed, double x, double y) {
- double sum = 0;
- double amp = mFractalBounding;
-
- for(int i = 0; i < mOctaves; i++) {
- double noise = pingPong((getNoiseRaw(seed++, x, y) + 1) * mPingPongStrength);
- sum += (noise - 0.5) * 2 * amp;
- amp *= lerp(1.0, noise, mWeightedStrength);
-
- x *= mLacunarity;
- y *= mLacunarity;
- amp *= mGain;
- }
-
- return sum;
- }
-
- // Noise Coordinate Transforms (frequency, and possible skew or rotation)
- private double genFractalPingPong(int seed, double x, double y, double z) {
- double sum = 0;
- double amp = mFractalBounding;
-
- for(int i = 0; i < mOctaves; i++) {
- double noise = pingPong((getNoiseRaw(seed++, x, y, z) + 1) * mPingPongStrength);
- sum += (noise - 0.5) * 2 * amp;
- amp *= lerp(1.0, noise, mWeightedStrength);
-
- x *= mLacunarity;
- y *= mLacunarity;
- z *= mLacunarity;
- amp *= mGain;
- }
-
- return sum;
- }
-
- private double singleSimplex(int seed, double x, double y) {
- // 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex.
- final double SQRT3 = 1.7320508075688772935274463415059;
- final double G2 = (3 - SQRT3) / 6;
-
- /*
- * --- Skew moved to switch statements before fractal evaluation ---
- * final FNLdouble F2 = 0.5f * (SQRT3 - 1);
- * FNLdouble s = (x + y) * F2;
- * x += s; y += s;
- */
-
- int i = fastFloor(x);
- int j = fastFloor(y);
- double xi = x - i;
- double yi = y - j;
-
- double t = (xi + yi) * G2;
- double x0 = xi - t;
- double y0 = yi - t;
-
- i *= PRIME_X;
- j *= PRIME_Y;
-
- double n0, n1, n2;
-
- double a = 0.5 - x0 * x0 - y0 * y0;
- if(a <= 0) n0 = 0;
- else {
- n0 = (a * a) * (a * a) * gradCoord(seed, i, j, x0, y0);
- }
-
- double c = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
- if(c <= 0) n2 = 0;
- else {
- double x2 = x0 + (2 * G2 - 1);
- double y2 = y0 + (2 * G2 - 1);
- n2 = (c * c) * (c * c) * gradCoord(seed, i + PRIME_X, j + PRIME_Y, x2, y2);
- }
-
- if(y0 > x0) {
- double x1 = x0 + G2;
- double y1 = y0 + (G2 - 1);
- double b = 0.5 - x1 * x1 - y1 * y1;
- if(b <= 0) n1 = 0;
- else {
- n1 = (b * b) * (b * b) * gradCoord(seed, i, j + PRIME_Y, x1, y1);
- }
- } else {
- double x1 = x0 + (G2 - 1);
- double y1 = y0 + G2;
- double b = 0.5 - x1 * x1 - y1 * y1;
- if(b <= 0) n1 = 0;
- else {
- n1 = (b * b) * (b * b) * gradCoord(seed, i + PRIME_X, j, x1, y1);
- }
- }
-
- return (n0 + n1 + n2) * 99.83685446303647f;
- }
-
- // Fractal FBm
- private double singleOpenSimplex2(int seed, double x, double y, double z) {
- // 3D OpenSimplex2Sampler case uses two offset rotated cube grids.
- /*
- * --- Rotation moved to switch statements before fractal evaluation ---
- * final FNLdouble R3 = (FNLdouble)(2.0 / 3.0);
- * FNLdouble r = (x + y + z) * R3; // Rotation, not skew
- * x = r - x; y = r - y; z = r - z;
- */
-
- int i = fastRound(x);
- int j = fastRound(y);
- int k = fastRound(z);
- double x0 = x - i;
- double y0 = y - j;
- double z0 = z - k;
-
- int xNSign = (int) (-1.0 - x0) | 1;
- int yNSign = (int) (-1.0 - y0) | 1;
- int zNSign = (int) (-1.0 - z0) | 1;
-
- double ax0 = xNSign * -x0;
- double ay0 = yNSign * -y0;
- double az0 = zNSign * -z0;
-
- i *= PRIME_X;
- j *= PRIME_Y;
- k *= PRIME_Z;
-
- double value = 0;
- double a = (0.6f - x0 * x0) - (y0 * y0 + z0 * z0);
-
- for(int l = 0; ; l++) {
- if(a > 0) {
- value += (a * a) * (a * a) * gradCoord(seed, i, j, k, x0, y0, z0);
- }
-
- if(ax0 >= ay0 && ax0 >= az0) {
- double b = a + ax0 + ax0;
- if(b > 1) {
- b -= 1;
- value += (b * b) * (b * b) * gradCoord(seed, i - xNSign * PRIME_X, j, k, x0 + xNSign, y0, z0);
- }
- } else if(ay0 > ax0 && ay0 >= az0) {
- double b = a + ay0 + ay0;
- if(b > 1) {
- b -= 1;
- value += (b * b) * (b * b) * gradCoord(seed, i, j - yNSign * PRIME_Y, k, x0, y0 + yNSign, z0);
- }
- } else {
- double b = a + az0 + az0;
- if(b > 1) {
- b -= 1;
- value += (b * b) * (b * b) * gradCoord(seed, i, j, k - zNSign * PRIME_Z, x0, y0, z0 + zNSign);
- }
- }
-
- if(l == 1) break;
-
- ax0 = 0.5 - ax0;
- ay0 = 0.5 - ay0;
- az0 = 0.5 - az0;
-
- x0 = xNSign * ax0;
- y0 = yNSign * ay0;
- z0 = zNSign * az0;
-
- a += (0.75 - ax0) - (ay0 + az0);
-
- i += (xNSign >> 1) & PRIME_X;
- j += (yNSign >> 1) & PRIME_Y;
- k += (zNSign >> 1) & PRIME_Z;
-
- xNSign = -xNSign;
- yNSign = -yNSign;
- zNSign = -zNSign;
-
- seed = ~seed;
- }
-
- return value * 32.69428253173828125;
- }
-
- @SuppressWarnings("NumericOverflow")
- private double singleOpenSimplex2S(int seed, double x, double y) {
- // 2D OpenSimplex2S case is a modified 2D simplex noise.
-
- final double SQRT3 = 1.7320508075688772935274463415059;
- final double G2 = (3 - SQRT3) / 6;
-
- /*
- * --- Skew moved to TransformNoiseCoordinate method ---
- * final FNLdouble F2 = 0.5f * (SQRT3 - 1);
- * FNLdouble s = (x + y) * F2;
- * x += s; y += s;
- */
-
- int i = fastFloor(x);
- int j = fastFloor(y);
- double xi = x - i;
- double yi = y - j;
-
- i *= PRIME_X;
- j *= PRIME_Y;
- int i1 = i + PRIME_X;
- int j1 = j + PRIME_Y;
-
- double t = (xi + yi) * G2;
- double x0 = xi - t;
- double y0 = yi - t;
-
- double a0 = (2.0 / 3.0) - x0 * x0 - y0 * y0;
- double value = (a0 * a0) * (a0 * a0) * gradCoord(seed, i, j, x0, y0);
-
- double a1 = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a0);
- double x1 = x0 - (1 - 2 * G2);
- double y1 = y0 - (1 - 2 * G2);
- value += (a1 * a1) * (a1 * a1) * gradCoord(seed, i1, j1, x1, y1);
-
- // Nested conditionals were faster than compact bit logic/arithmetic.
- double xmyi = xi - yi;
- if(t > G2) {
- if(xi + xmyi > 1) {
- double x2 = x0 + (3 * G2 - 2);
- double y2 = y0 + (3 * G2 - 1);
- double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
- if(a2 > 0) {
- value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i + (PRIME_X << 1), j + PRIME_Y, x2, y2);
- }
- } else {
- double x2 = x0 + G2;
- double y2 = y0 + (G2 - 1);
- double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
- if(a2 > 0) {
- value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i, j + PRIME_Y, x2, y2);
- }
- }
-
- if(yi - xmyi > 1) {
- double x3 = x0 + (3 * G2 - 1);
- double y3 = y0 + (3 * G2 - 2);
- double a3 = (2.0 / 3.0) - x3 * x3 - y3 * y3;
- if(a3 > 0) {
- value += (a3 * a3) * (a3 * a3) * gradCoord(seed, i + PRIME_X, j + (PRIME_Y << 1), x3, y3);
- }
- } else {
- double x3 = x0 + (G2 - 1);
- double y3 = y0 + G2;
- double a3 = (2.0 / 3.0) - x3 * x3 - y3 * y3;
- if(a3 > 0) {
- value += (a3 * a3) * (a3 * a3) * gradCoord(seed, i + PRIME_X, j, x3, y3);
- }
- }
- } else {
- if(xi + xmyi < 0) {
- double x2 = x0 + (1 - G2);
- double y2 = y0 - G2;
- double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
- if(a2 > 0) {
- value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i - PRIME_X, j, x2, y2);
- }
- } else {
- double x2 = x0 + (G2 - 1);
- double y2 = y0 + G2;
- double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
- if(a2 > 0) {
- value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i + PRIME_X, j, x2, y2);
- }
- }
-
- if(yi < xmyi) {
- double x2 = x0 - G2;
- double y2 = y0 - (G2 - 1);
- double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
- if(a2 > 0) {
- value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i, j - PRIME_Y, x2, y2);
- }
- } else {
- double x2 = x0 + G2;
- double y2 = y0 + (G2 - 1);
- double a2 = (2.0 / 3.0) - x2 * x2 - y2 * y2;
- if(a2 > 0) {
- value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i, j + PRIME_Y, x2, y2);
- }
- }
- }
-
- return value * 18.24196194486065;
- }
-
- // Fractal Ridged
- @SuppressWarnings("NumericOverflow")
- private double singleOpenSimplex2S(int seed, double x, double y, double z) {
- // 3D OpenSimplex2S case uses two offset rotated cube grids.
- /*
- * --- Rotation moved to TransformNoiseCoordinate method ---
- * final FNLdouble R3 = (FNLdouble)(2.0 / 3.0);
- * FNLdouble r = (x + y + z) * R3; // Rotation, not skew
- * x = r - x; y = r - y; z = r - z;
- */
-
- int i = fastFloor(x);
- int j = fastFloor(y);
- int k = fastFloor(z);
- double xi = x - i;
- double yi = y - j;
- double zi = z - k;
-
- i *= PRIME_X;
- j *= PRIME_Y;
- k *= PRIME_Z;
- int seed2 = seed + 1293373;
-
- int xNMask = (int) (-0.5 - xi);
- int yNMask = (int) (-0.5 - yi);
- int zNMask = (int) (-0.5 - zi);
-
- double x0 = xi + xNMask;
- double y0 = yi + yNMask;
- double z0 = zi + zNMask;
- double a0 = 0.75 - x0 * x0 - y0 * y0 - z0 * z0;
- double value = (a0 * a0) * (a0 * a0) * gradCoord(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0, y0,
- z0);
-
- double x1 = xi - 0.5;
- double y1 = yi - 0.5;
- double z1 = zi - 0.5;
- double a1 = 0.75 - x1 * x1 - y1 * y1 - z1 * z1;
- value += (a1 * a1) * (a1 * a1) * gradCoord(seed2, i + PRIME_X, j + PRIME_Y, k + PRIME_Z, x1, y1, z1);
-
- double xAFlipMask0 = ((xNMask | 1) << 1) * x1;
- double yAFlipMask0 = ((yNMask | 1) << 1) * y1;
- double zAFlipMask0 = ((zNMask | 1) << 1) * z1;
- double xAFlipMask1 = (-2 - (xNMask << 2)) * x1 - 1.0;
- double yAFlipMask1 = (-2 - (yNMask << 2)) * y1 - 1.0;
- double zAFlipMask1 = (-2 - (zNMask << 2)) * z1 - 1.0;
-
- boolean skip5 = false;
- double a2 = xAFlipMask0 + a0;
- if(a2 > 0) {
- double x2 = x0 - (xNMask | 1);
- value += (a2 * a2) * (a2 * a2) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x2, y0,
- z0);
- } else {
- double a3 = yAFlipMask0 + zAFlipMask0 + a0;
- if(a3 > 0) {
- double y3 = y0 - (yNMask | 1);
- double z3 = z0 - (zNMask | 1);
- value += (a3 * a3) * (a3 * a3) * gradCoord(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x0,
- y3, z3);
- }
-
- double a4 = xAFlipMask1 + a1;
- if(a4 > 0) {
- double x4 = (xNMask | 1) + x1;
- value += (a4 * a4) * (a4 * a4) * gradCoord(seed2, i + (xNMask & (PRIME_X << 1)), j + PRIME_Y, k + PRIME_Z, x4, y1, z1);
- skip5 = true;
- }
- }
-
- boolean skip9 = false;
- double a6 = yAFlipMask0 + a0;
- if(a6 > 0) {
- double y6 = y0 - (yNMask | 1);
- value += (a6 * a6) * (a6 * a6) * gradCoord(seed, i + (xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), x0, y6,
- z0);
- } else {
- double a7 = xAFlipMask0 + zAFlipMask0 + a0;
- if(a7 > 0) {
- double x7 = x0 - (xNMask | 1);
- double z7 = z0 - (zNMask | 1);
- value += (a7 * a7) * (a7 * a7) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x7,
- y0, z7);
- }
-
- double a8 = yAFlipMask1 + a1;
- if(a8 > 0) {
- double y8 = (yNMask | 1) + y1;
- value += (a8 * a8) * (a8 * a8) * gradCoord(seed2, i + PRIME_X, j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z, x1, y8, z1);
- skip9 = true;
- }
- }
-
- boolean skipD = false;
- double aA = zAFlipMask0 + a0;
- if(aA > 0) {
- double zA = z0 - (zNMask | 1);
- value += (aA * aA) * (aA * aA) * gradCoord(seed, i + (xNMask & PRIME_X), j + (yNMask & PRIME_Y), k + (~zNMask & PRIME_Z), x0, y0,
- zA);
- } else {
- double aB = xAFlipMask0 + yAFlipMask0 + a0;
- if(aB > 0) {
- double xB = x0 - (xNMask | 1);
- double yB = y0 - (yNMask | 1);
- value += (aB * aB) * (aB * aB) * gradCoord(seed, i + (~xNMask & PRIME_X), j + (~yNMask & PRIME_Y), k + (zNMask & PRIME_Z), xB,
- yB, z0);
- }
-
- double aC = zAFlipMask1 + a1;
- if(aC > 0) {
- double zC = (zNMask | 1) + z1;
- value += (aC * aC) * (aC * aC) * gradCoord(seed2, i + PRIME_X, j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)), x1, y1, zC);
- skipD = true;
- }
- }
-
- if(!skip5) {
- double a5 = yAFlipMask1 + zAFlipMask1 + a1;
- if(a5 > 0) {
- double y5 = (yNMask | 1) + y1;
- double z5 = (zNMask | 1) + z1;
- value += (a5 * a5) * (a5 * a5) * gradCoord(seed2, i + PRIME_X, j + (yNMask & (PRIME_Y << 1)), k + (zNMask & (PRIME_Z << 1)),
- x1, y5, z5);
- }
- }
-
- if(!skip9) {
- double a9 = xAFlipMask1 + zAFlipMask1 + a1;
- if(a9 > 0) {
- double x9 = (xNMask | 1) + x1;
- double z9 = (zNMask | 1) + z1;
- value += (a9 * a9) * (a9 * a9) * gradCoord(seed2, i + (xNMask & (PRIME_X << 1)), j + PRIME_Y, k + (zNMask & (PRIME_Z << 1)), x9,
- y1, z9);
- }
- }
-
- if(!skipD) {
- double aD = xAFlipMask1 + yAFlipMask1 + a1;
- if(aD > 0) {
- double xD = (xNMask | 1) + x1;
- double yD = (yNMask | 1) + y1;
- value += (aD * aD) * (aD * aD) * gradCoord(seed2, i + (xNMask & (PRIME_X << 1)), j + (yNMask & (PRIME_Y << 1)), k + PRIME_Z,
- xD, yD, z1);
- }
- }
-
- return value * 9.046026385208288;
- }
-
- private double singleCellular(int seed, double x, double y) {
- int xr = fastRound(x);
- int yr = fastRound(y);
-
- double distance0 = Double.MAX_VALUE;
- double distance1 = Double.MAX_VALUE;
- double distance2 = Double.MAX_VALUE;
-
- int closestHash = 0;
-
- double cellularJitter = 0.43701595 * mCellularJitterModifier;
-
- int xPrimed = (xr - 1) * PRIME_X;
- int yPrimedBase = (yr - 1) * PRIME_Y;
-
- Vector2 center = new Vector2(x, y);
-
- switch(mCellularDistanceFunction) {
- default:
- case Euclidean:
- case EuclideanSq:
- for(int xi = xr - 1; xi <= xr + 1; xi++) {
- int yPrimed = yPrimedBase;
-
- for(int yi = yr - 1; yi <= yr + 1; yi++) {
- int hash = hash(seed, xPrimed, yPrimed);
- int idx = hash & (255 << 1);
-
- double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter;
- double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
-
- double newDistance = vecX * vecX + vecY * vecY;
-
- distance1 = fastMax(fastMin(distance1, newDistance), distance0);
- if(newDistance < distance0) {
- distance0 = newDistance;
- closestHash = hash;
- center.setX((xi + RAND_VECS_2D[idx] * cellularJitter) / mFrequency);
- center.setZ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / mFrequency);
- } else if(newDistance < distance1) {
- distance2 = distance1;
- distance1 = newDistance;
- } else if(newDistance < distance2) {
- distance2 = newDistance;
- }
- yPrimed += PRIME_Y;
- }
- xPrimed += PRIME_X;
- }
- break;
- case Manhattan:
- for(int xi = xr - 1; xi <= xr + 1; xi++) {
- int yPrimed = yPrimedBase;
-
- for(int yi = yr - 1; yi <= yr + 1; yi++) {
- int hash = hash(seed, xPrimed, yPrimed);
- int idx = hash & (255 << 1);
-
- double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter;
- double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
-
- double newDistance = fastAbs(vecX) + fastAbs(vecY);
-
- distance1 = fastMax(fastMin(distance1, newDistance), distance0);
- if(newDistance < distance0) {
- distance0 = newDistance;
- closestHash = hash;
- center.setX((xi + RAND_VECS_2D[idx] * cellularJitter) / mFrequency);
- center.setZ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / mFrequency);
- } else if(newDistance < distance1) {
- distance2 = distance1;
- distance1 = newDistance;
- } else if(newDistance < distance2) {
- distance2 = newDistance;
- }
- yPrimed += PRIME_Y;
- }
- xPrimed += PRIME_X;
- }
- break;
- case Hybrid:
- for(int xi = xr - 1; xi <= xr + 1; xi++) {
- int yPrimed = yPrimedBase;
-
- for(int yi = yr - 1; yi <= yr + 1; yi++) {
- int hash = hash(seed, xPrimed, yPrimed);
- int idx = hash & (255 << 1);
-
- double vecX = (xi - x) + RAND_VECS_2D[idx] * cellularJitter;
- double vecY = (yi - y) + RAND_VECS_2D[idx | 1] * cellularJitter;
-
- double newDistance = (fastAbs(vecX) + fastAbs(vecY)) + (vecX * vecX + vecY * vecY);
-
- distance1 = fastMax(fastMin(distance1, newDistance), distance0);
- if(newDistance < distance0) {
- distance0 = newDistance;
- closestHash = hash;
- center.setX((xi + RAND_VECS_2D[idx] * cellularJitter) / mFrequency);
- center.setZ((yi + RAND_VECS_2D[idx | 1] * cellularJitter) / mFrequency);
- } else if(newDistance < distance1) {
- distance2 = distance1;
- distance1 = newDistance;
- } else if(newDistance < distance2) {
- distance2 = newDistance;
- }
- yPrimed += PRIME_Y;
- }
- xPrimed += PRIME_X;
- }
- break;
- }
-
- if(mCellularDistanceFunction == CellularDistanceFunction.Euclidean && mCellularReturnType != CellularReturnType.CellValue) {
- distance0 = fastSqrt(distance0);
- if(mCellularReturnType != CellularReturnType.CellValue) {
- distance1 = fastSqrt(distance1);
- }
- }
-
- switch(mCellularReturnType) {
- case CellValue:
- return closestHash * (1 / 2147483648.0);
- case Distance:
- return distance0 - 1;
- case Distance2:
- return distance1 - 1;
- case Distance2Add:
- return (distance1 + distance0) * 0.5 - 1;
- case Distance2Sub:
- return distance1 - distance0 - 1;
- case Distance2Mul:
- return distance1 * distance0 * 0.5 - 1;
- case Distance2Div:
- return distance0 / distance1 - 1;
- case NoiseLookup:
- return cellularNoiseLookup.getNoise(center.getX(), center.getZ());
- case Distance3:
- return distance2 - 1;
- case Distance3Add:
- return (distance2 + distance0) * 0.5 - 1;
- case Distance3Sub:
- return distance2 - distance0 - 1;
- case Distance3Mul:
- return distance2 * distance0 - 1;
- case Distance3Div:
- return distance0 / distance2 - 1;
- default:
- return 0;
- }
- }
-
- // Fractal pingPong
- private double singleCellular(int seed, double x, double y, double z) {
- int xr = fastRound(x);
- int yr = fastRound(y);
- int zr = fastRound(z);
-
- double distance0 = Double.MAX_VALUE;
- double distance1 = Double.MAX_VALUE;
- double distance2 = Double.MAX_VALUE;
- int closestHash = 0;
-
- double cellularJitter = 0.39614353 * mCellularJitterModifier;
-
- int xPrimed = (xr - 1) * PRIME_X;
- int yPrimedBase = (yr - 1) * PRIME_Y;
- int zPrimedBase = (zr - 1) * PRIME_Z;
-
- Vector3 center = new Vector3(x, y, z);
-
- switch(mCellularDistanceFunction) {
- case Euclidean:
- case EuclideanSq:
- for(int xi = xr - 1; xi <= xr + 1; xi++) {
- int yPrimed = yPrimedBase;
-
- for(int yi = yr - 1; yi <= yr + 1; yi++) {
- int zPrimed = zPrimedBase;
-
- for(int zi = zr - 1; zi <= zr + 1; zi++) {
- int hash = hash(seed, xPrimed, yPrimed, zPrimed);
- int idx = hash & (255 << 2);
-
- double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter;
- double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
- double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
-
- double newDistance = vecX * vecX + vecY * vecY + vecZ * vecZ;
-
- if(newDistance < distance0) {
- distance0 = newDistance;
- closestHash = hash;
- center.setX((xi + RAND_VECS_3D[idx] * cellularJitter) / mFrequency);
- center.setY((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / mFrequency);
- center.setZ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / mFrequency);
- } else if(newDistance < distance1) {
- distance2 = distance1;
- distance1 = newDistance;
- } else if(newDistance < distance2) {
- distance2 = newDistance;
- }
- zPrimed += PRIME_Z;
- }
- yPrimed += PRIME_Y;
- }
- xPrimed += PRIME_X;
- }
- break;
- case Manhattan:
- for(int xi = xr - 1; xi <= xr + 1; xi++) {
- int yPrimed = yPrimedBase;
-
- for(int yi = yr - 1; yi <= yr + 1; yi++) {
- int zPrimed = zPrimedBase;
-
- for(int zi = zr - 1; zi <= zr + 1; zi++) {
- int hash = hash(seed, xPrimed, yPrimed, zPrimed);
- int idx = hash & (255 << 2);
-
- double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter;
- double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
- double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
-
- double newDistance = fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ);
-
- if(newDistance < distance0) {
- distance0 = newDistance;
- closestHash = hash;
- center.setX((xi + RAND_VECS_3D[idx] * cellularJitter) / mFrequency);
- center.setY((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / mFrequency);
- center.setZ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / mFrequency);
- } else if(newDistance < distance1) {
- distance2 = distance1;
- distance1 = newDistance;
- } else if(newDistance < distance2) {
- distance2 = newDistance;
- }
- zPrimed += PRIME_Z;
- }
- yPrimed += PRIME_Y;
- }
- xPrimed += PRIME_X;
- }
- break;
- case Hybrid:
- for(int xi = xr - 1; xi <= xr + 1; xi++) {
- int yPrimed = yPrimedBase;
-
- for(int yi = yr - 1; yi <= yr + 1; yi++) {
- int zPrimed = zPrimedBase;
-
- for(int zi = zr - 1; zi <= zr + 1; zi++) {
- int hash = hash(seed, xPrimed, yPrimed, zPrimed);
- int idx = hash & (255 << 2);
-
- double vecX = (xi - x) + RAND_VECS_3D[idx] * cellularJitter;
- double vecY = (yi - y) + RAND_VECS_3D[idx | 1] * cellularJitter;
- double vecZ = (zi - z) + RAND_VECS_3D[idx | 2] * cellularJitter;
-
- double newDistance = (fastAbs(vecX) + fastAbs(vecY) + fastAbs(vecZ)) +
- (vecX * vecX + vecY * vecY + vecZ * vecZ);
-
- distance1 = fastMax(fastMin(distance1, newDistance), distance0);
- if(newDistance < distance0) {
- distance0 = newDistance;
- closestHash = hash;
- center.setX((xi + RAND_VECS_3D[idx] * cellularJitter) / mFrequency);
- center.setY((yi + RAND_VECS_3D[idx | 1] * cellularJitter) / mFrequency);
- center.setZ((zi + RAND_VECS_3D[idx | 2] * cellularJitter) / mFrequency);
- } else if(newDistance < distance1) {
- distance2 = distance1;
- distance1 = newDistance;
- } else if(newDistance < distance2) {
- distance2 = newDistance;
- }
- zPrimed += PRIME_Z;
- }
- yPrimed += PRIME_Y;
- }
- xPrimed += PRIME_X;
- }
- break;
- default:
- break;
- }
-
- if(mCellularDistanceFunction == CellularDistanceFunction.Euclidean && mCellularReturnType != CellularReturnType.CellValue) {
- distance0 = fastSqrt(distance0);
- if(mCellularReturnType != CellularReturnType.CellValue) {
- distance1 = fastSqrt(distance1);
- }
- }
-
- switch(mCellularReturnType) {
- case CellValue:
- return closestHash * (1 / 2147483648.0);
- case Distance:
- return distance0 - 1;
- case Distance2:
- return distance1 - 1;
- case Distance2Add:
- return (distance1 + distance0) * 0.5 - 1;
- case Distance2Sub:
- return distance1 - distance0 - 1;
- case Distance2Mul:
- return distance1 * distance0 * 0.5 - 1;
- case Distance2Div:
- return distance0 / distance1 - 1;
- case NoiseLookup:
- return cellularNoiseLookup.getNoise(center.getX(), center.getY(), center.getZ());
- case Distance3:
- return distance2 - 1;
- case Distance3Add:
- return (distance2 + distance0) * 0.5 - 1;
- case Distance3Sub:
- return distance2 - distance0 - 1;
- case Distance3Mul:
- return distance2 * distance0 - 1;
- case Distance3Div:
- return distance0 / distance2 - 1;
- default:
- return 0;
- }
- }
-
- private double singlePerlin(int seed, double x, double y) {
- int x0 = fastFloor(x);
- int y0 = fastFloor(y);
-
- double xd0 = x - x0;
- double yd0 = y - y0;
- double xd1 = xd0 - 1;
- double yd1 = yd0 - 1;
-
- double xs = interpQuintic(xd0);
- double ys = interpQuintic(yd0);
-
- x0 *= PRIME_X;
- y0 *= PRIME_Y;
- int x1 = x0 + PRIME_X;
- int y1 = y0 + PRIME_Y;
-
- double xf0 = lerp(gradCoord(seed, x0, y0, xd0, yd0), gradCoord(seed, x1, y0, xd1, yd0), xs);
- double xf1 = lerp(gradCoord(seed, x0, y1, xd0, yd1), gradCoord(seed, x1, y1, xd1, yd1), xs);
-
- return lerp(xf0, xf1, ys) * 1.4247691104677813;
- }
-
- private long murmur64(long h) {
- h ^= h >>> 33;
- h *= 0xff51afd7ed558ccdL;
- h ^= h >>> 33;
- h *= 0xc4ceb9fe1a85ec53L;
- h ^= h >>> 33;
- return h;
- }
-
- private double singleWhiteNoise(int seed, double x, double y, double z) {
- long hashX = murmur64(Double.doubleToRawLongBits(x) ^ seed);
- long hashZ = murmur64(Double.doubleToRawLongBits(y) ^ seed);
- long hash = (((hashX ^ (hashX >>> 32)) + ((hashZ ^ (hashZ >>> 32)) << 32)) ^ seed) + Double.doubleToRawLongBits(z);
- long base = ((murmur64(hash)) & 0x000fffffffffffffL)
- + POSITIVE_POW1; // Sign and exponent
- return (Double.longBitsToDouble(base) - 1.5) * 2;
- }
-
- private double singleWhiteNoise(int seed, double x, double y) {
- long hashX = murmur64(Double.doubleToRawLongBits(x) ^ seed);
- long hashZ = murmur64(Double.doubleToRawLongBits(y) ^ seed);
- long hash = ((hashX ^ (hashX >>> 32)) + ((hashZ ^ (hashZ >>> 32)) << 32)) ^ seed;
- long base = (murmur64(hash) & 0x000fffffffffffffL)
- + POSITIVE_POW1; // Sign and exponent
- return (Double.longBitsToDouble(base) - 1.5) * 2;
- }
-
- // Simplex/OpenSimplex2Sampler Noise
- private double singlePerlin(int seed, double x, double y, double z) {
- int x0 = fastFloor(x);
- int y0 = fastFloor(y);
- int z0 = fastFloor(z);
-
- double xd0 = x - x0;
- double yd0 = y - y0;
- double zd0 = z - z0;
- double xd1 = xd0 - 1;
- double yd1 = yd0 - 1;
- double zd1 = zd0 - 1;
-
- double xs = interpQuintic(xd0);
- double ys = interpQuintic(yd0);
- double zs = interpQuintic(zd0);
-
- x0 *= PRIME_X;
- y0 *= PRIME_Y;
- z0 *= PRIME_Z;
- int x1 = x0 + PRIME_X;
- int y1 = y0 + PRIME_Y;
- int z1 = z0 + PRIME_Z;
-
- double xf00 = lerp(gradCoord(seed, x0, y0, z0, xd0, yd0, zd0), gradCoord(seed, x1, y0, z0, xd1, yd0, zd0), xs);
- double xf10 = lerp(gradCoord(seed, x0, y1, z0, xd0, yd1, zd0), gradCoord(seed, x1, y1, z0, xd1, yd1, zd0), xs);
- double xf01 = lerp(gradCoord(seed, x0, y0, z1, xd0, yd0, zd1), gradCoord(seed, x1, y0, z1, xd1, yd0, zd1), xs);
- double xf11 = lerp(gradCoord(seed, x0, y1, z1, xd0, yd1, zd1), gradCoord(seed, x1, y1, z1, xd1, yd1, zd1), xs);
-
- double yf0 = lerp(xf00, xf10, ys);
- double yf1 = lerp(xf01, xf11, ys);
-
- return lerp(yf0, yf1, zs) * 0.964921414852142333984375;
- }
-
- private double singleValueCubic(int seed, double x, double y) {
- int x1 = fastFloor(x);
- int y1 = fastFloor(y);
-
- double xs = x - x1;
- double ys = y - y1;
-
- x1 *= PRIME_X;
- y1 *= PRIME_Y;
- int x0 = x1 - PRIME_X;
- int y0 = y1 - PRIME_Y;
- int x2 = x1 + PRIME_X;
- int y2 = y1 + PRIME_Y;
- int x3 = x1 + (PRIME_X << 1);
- int y3 = y1 + (PRIME_Y << 1);
-
- return cubicLerp(
- cubicLerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), valCoord(seed, x2, y0), valCoord(seed, x3, y0),
- xs),
- cubicLerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), valCoord(seed, x2, y1), valCoord(seed, x3, y1),
- xs),
- cubicLerp(valCoord(seed, x0, y2), valCoord(seed, x1, y2), valCoord(seed, x2, y2), valCoord(seed, x3, y2),
- xs),
- cubicLerp(valCoord(seed, x0, y3), valCoord(seed, x1, y3), valCoord(seed, x2, y3), valCoord(seed, x3, y3),
- xs),
- ys) * (1 / (1.5 * 1.5));
- }
-
- // OpenSimplex2S Noise
- private double singleValueCubic(int seed, double x, double y, double z) {
- int x1 = fastFloor(x);
- int y1 = fastFloor(y);
- int z1 = fastFloor(z);
-
- double xs = x - x1;
- double ys = y - y1;
- double zs = z - z1;
-
- x1 *= PRIME_X;
- y1 *= PRIME_Y;
- z1 *= PRIME_Z;
-
- int x0 = x1 - PRIME_X;
- int y0 = y1 - PRIME_Y;
- int z0 = z1 - PRIME_Z;
- int x2 = x1 + PRIME_X;
- int y2 = y1 + PRIME_Y;
- int z2 = z1 + PRIME_Z;
- int x3 = x1 + (PRIME_X << 1);
- int y3 = y1 + (PRIME_Y << 1);
- int z3 = z1 + (PRIME_Z << 1);
-
- return cubicLerp(
- cubicLerp(
- cubicLerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), valCoord(seed, x2, y0, z0),
- valCoord(seed, x3, y0, z0), xs),
- cubicLerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), valCoord(seed, x2, y1, z0),
- valCoord(seed, x3, y1, z0), xs),
- cubicLerp(valCoord(seed, x0, y2, z0), valCoord(seed, x1, y2, z0), valCoord(seed, x2, y2, z0),
- valCoord(seed, x3, y2, z0), xs),
- cubicLerp(valCoord(seed, x0, y3, z0), valCoord(seed, x1, y3, z0), valCoord(seed, x2, y3, z0),
- valCoord(seed, x3, y3, z0), xs),
- ys),
- cubicLerp(
- cubicLerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), valCoord(seed, x2, y0, z1),
- valCoord(seed, x3, y0, z1), xs),
- cubicLerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), valCoord(seed, x2, y1, z1),
- valCoord(seed, x3, y1, z1), xs),
- cubicLerp(valCoord(seed, x0, y2, z1), valCoord(seed, x1, y2, z1), valCoord(seed, x2, y2, z1),
- valCoord(seed, x3, y2, z1), xs),
- cubicLerp(valCoord(seed, x0, y3, z1), valCoord(seed, x1, y3, z1), valCoord(seed, x2, y3, z1),
- valCoord(seed, x3, y3, z1), xs),
- ys),
- cubicLerp(
- cubicLerp(valCoord(seed, x0, y0, z2), valCoord(seed, x1, y0, z2), valCoord(seed, x2, y0, z2),
- valCoord(seed, x3, y0, z2), xs),
- cubicLerp(valCoord(seed, x0, y1, z2), valCoord(seed, x1, y1, z2), valCoord(seed, x2, y1, z2),
- valCoord(seed, x3, y1, z2), xs),
- cubicLerp(valCoord(seed, x0, y2, z2), valCoord(seed, x1, y2, z2), valCoord(seed, x2, y2, z2),
- valCoord(seed, x3, y2, z2), xs),
- cubicLerp(valCoord(seed, x0, y3, z2), valCoord(seed, x1, y3, z2), valCoord(seed, x2, y3, z2),
- valCoord(seed, x3, y3, z2), xs),
- ys),
- cubicLerp(
- cubicLerp(valCoord(seed, x0, y0, z3), valCoord(seed, x1, y0, z3), valCoord(seed, x2, y0, z3),
- valCoord(seed, x3, y0, z3), xs),
- cubicLerp(valCoord(seed, x0, y1, z3), valCoord(seed, x1, y1, z3), valCoord(seed, x2, y1, z3),
- valCoord(seed, x3, y1, z3), xs),
- cubicLerp(valCoord(seed, x0, y2, z3), valCoord(seed, x1, y2, z3), valCoord(seed, x2, y2, z3),
- valCoord(seed, x3, y2, z3), xs),
- cubicLerp(valCoord(seed, x0, y3, z3), valCoord(seed, x1, y3, z3), valCoord(seed, x2, y3, z3),
- valCoord(seed, x3, y3, z3), xs),
- ys),
- zs) * (1 / (1.5 * 1.5 * 1.5));
- }
-
- private double singleValue(int seed, double x, double y) {
- int x0 = fastFloor(x);
- int y0 = fastFloor(y);
-
- double xs = interpHermite(x - x0);
- double ys = interpHermite(y - y0);
-
- x0 *= PRIME_X;
- y0 *= PRIME_Y;
- int x1 = x0 + PRIME_X;
- int y1 = y0 + PRIME_Y;
-
- double xf0 = lerp(valCoord(seed, x0, y0), valCoord(seed, x1, y0), xs);
- double xf1 = lerp(valCoord(seed, x0, y1), valCoord(seed, x1, y1), xs);
-
- return lerp(xf0, xf1, ys);
- }
-
- // Cellular Noise
- private double singleValue(int seed, double x, double y, double z) {
- int x0 = fastFloor(x);
- int y0 = fastFloor(y);
- int z0 = fastFloor(z);
-
- double xs = interpHermite(x - x0);
- double ys = interpHermite(y - y0);
- double zs = interpHermite(z - z0);
-
- x0 *= PRIME_X;
- y0 *= PRIME_Y;
- z0 *= PRIME_Z;
- int x1 = x0 + PRIME_X;
- int y1 = y0 + PRIME_Y;
- int z1 = z0 + PRIME_Z;
-
- double xf00 = lerp(valCoord(seed, x0, y0, z0), valCoord(seed, x1, y0, z0), xs);
- double xf10 = lerp(valCoord(seed, x0, y1, z0), valCoord(seed, x1, y1, z0), xs);
- double xf01 = lerp(valCoord(seed, x0, y0, z1), valCoord(seed, x1, y0, z1), xs);
- double xf11 = lerp(valCoord(seed, x0, y1, z1), valCoord(seed, x1, y1, z1), xs);
-
- double yf0 = lerp(xf00, xf10, ys);
- double yf1 = lerp(xf01, xf11, ys);
-
- return lerp(yf0, yf1, zs);
- }
-
- private void doSingleDomainWarp(int seed, double amp, double freq, double x, double y, Vector2 coord) {
- switch(mDomainWarpType) {
- case OpenSimplex2:
- singleDomainWarpSimplexGradient(seed, amp * 38.283687591552734375, freq, x, y, coord, false);
- break;
- case OpenSimplex2Reduced:
- singleDomainWarpSimplexGradient(seed, amp * 16.0, freq, x, y, coord, true);
- break;
- case BasicGrid:
- singleDomainWarpBasicGrid(seed, amp, freq, x, y, coord);
- break;
- case Function:
- singleFunctionDomainWarp(seed, amp, x, y, freq, coord);
- break;
- }
- }
-
- // Perlin Noise
- private void doSingleDomainWarp(int seed, double amp, double freq, double x, double y,
- double z,
- Vector3 coord) {
- switch(mDomainWarpType) {
- case OpenSimplex2:
- singleDomainWarpOpenSimplex2Gradient(seed, amp * 32.69428253173828125, freq, x, y, z, coord, false);
- break;
- case OpenSimplex2Reduced:
- singleDomainWarpOpenSimplex2Gradient(seed, amp * 7.71604938271605, freq, x, y, z, coord, true);
- break;
- case BasicGrid:
- singleDomainWarpBasicGrid(seed, amp, freq, x, y, z, coord);
- break;
- case Function:
- singleFunctionDomainWarp(seed, amp, x, y, z, freq, coord);
- break;
- }
- }
-
- private void singleFunctionDomainWarp(int seed, double amp, double x, double y, double freq, Vector2 coord) {
- coord.add(domainWarpFunction.getNoiseSeeded(seed + 1, x, y) * amp,
- domainWarpFunction.getNoiseSeeded(seed + 2, x, y) * amp);
- }
-
- private void singleFunctionDomainWarp(int seed, double amp, double x, double y, double z, double freq, Vector3 coord) {
- coord.add(domainWarpFunction.getNoiseSeeded(seed + 1, x, y, z) * amp,
- domainWarpFunction.getNoiseSeeded(seed + 3, x, y, z) * amp,
- domainWarpFunction.getNoiseSeeded(seed + 2, x, y, z) * amp);
- }
-
- private void domainWarpSingle(int seed, Vector2 coord) {
- double amp = mDomainWarpAmp * mFractalBounding;
- double freq = mFrequency;
-
-
- double xs = coord.getX();
-
- double ys = coord.getZ();
- switch(mDomainWarpType) {
- case OpenSimplex2:
- case OpenSimplex2Reduced: {
-
- final double SQRT3 = 1.7320508075688772935274463415059;
- final double F2 = 0.5 * (SQRT3 - 1);
-
- double t = (xs + ys) * F2;
- xs += t;
- ys += t;
- }
- break;
- default:
- break;
- }
-
- doSingleDomainWarp(seed, amp, freq, xs, ys, coord);
- }
-
- // Value Cubic Noise
- private void domainWarpSingle(int seed, Vector3 coord) {
- double amp = mDomainWarpAmp * mFractalBounding;
- double freq = mFrequency;
-
-
- double xs = coord.getX();
-
- double ys = coord.getY();
-
- double zs = coord.getZ();
- switch(mWarpTransformType3D) {
- case ImproveXYPlanes: {
-
- double xy = xs + ys;
-
- double s2 = xy * -0.211324865405187D;
-
- zs *= 0.577350269189626;
- xs += s2 - zs;
- ys = ys + s2 - zs;
-
- zs += xy * 0.577350269189626;
- }
- break;
- case ImproveXZPlanes: {
-
- double xz = xs + zs;
-
- double s2 = xz * -0.211324865405187D;
-
- ys *= 0.577350269189626;
- xs += s2 - ys;
- zs += s2 - ys;
-
- ys += xz * 0.577350269189626;
- }
- break;
- case DefaultOpenSimplex2: {
-
- final double R3 = 2.0 / 3.0;
-
- double r = (xs + ys + zs) * R3; // Rotation, not skew
- xs = r - xs;
- ys = r - ys;
- zs = r - zs;
- }
- break;
- default:
- break;
- }
-
- doSingleDomainWarp(seed, amp, freq, xs, ys, zs, coord);
- }
-
- private void domainWarpFractalProgressive(int seed, Vector2 coord) {
- double amp = mDomainWarpAmp * mFractalBounding;
- double freq = mFrequency;
-
- for(int i = 0; i < mOctaves; i++) {
-
- double xs = coord.getX();
-
- double ys = coord.getZ();
- switch(mDomainWarpType) {
- case OpenSimplex2:
- case OpenSimplex2Reduced: {
-
- final double SQRT3 = 1.7320508075688772935274463415059;
- final double F2 = 0.5 * (SQRT3 - 1);
-
- double t = (xs + ys) * F2;
- xs += t;
- ys += t;
- }
- break;
- default:
- break;
- }
-
- doSingleDomainWarp(seed, amp, freq, xs, ys, coord);
-
- seed++;
- amp *= mGain;
- freq *= mLacunarity;
- }
- }
-
- // Value Noise
- private void domainWarpFractalProgressive(int seed, Vector3 coord) {
- double amp = mDomainWarpAmp * mFractalBounding;
- double freq = mFrequency;
-
- for(int i = 0; i < mOctaves; i++) {
-
- double xs = coord.getX();
-
- double ys = coord.getY();
-
- double zs = coord.getZ();
- switch(mWarpTransformType3D) {
- case ImproveXYPlanes: {
-
- double xy = xs + ys;
-
- double s2 = xy * -0.211324865405187D;
-
- zs *= 0.577350269189626;
- xs += s2 - zs;
- ys = ys + s2 - zs;
-
- zs += xy * 0.577350269189626;
- }
- break;
- case ImproveXZPlanes: {
-
- double xz = xs + zs;
-
- double s2 = xz * -0.211324865405187D;
-
- ys *= 0.577350269189626;
- xs += s2 - ys;
- zs += s2 - ys;
-
- ys += xz * 0.577350269189626;
- }
- break;
- case DefaultOpenSimplex2: {
-
- final double R3 = 2.0 / 3.0;
-
- double r = (xs + ys + zs) * R3; // Rotation, not skew
- xs = r - xs;
- ys = r - ys;
- zs = r - zs;
- }
- break;
- default:
- break;
- }
-
- doSingleDomainWarp(seed, amp, freq, xs, ys, zs, coord);
-
- seed++;
- amp *= mGain;
- freq *= mLacunarity;
- }
- }
-
- // Domain Warp Fractal Independant
- private void domainWarpFractalIndependent(int seed, Vector2 coord) {
-
- double xs = coord.getX();
-
- double ys = coord.getZ();
- switch(mDomainWarpType) {
- case OpenSimplex2:
- case OpenSimplex2Reduced: {
-
- final double SQRT3 = 1.7320508075688772935274463415059;
- final double F2 = 0.5 * (SQRT3 - 1);
-
- double t = (xs + ys) * F2;
- xs += t;
- ys += t;
- }
- break;
- default:
- break;
- }
-
- double amp = mDomainWarpAmp * mFractalBounding;
- double freq = mFrequency;
-
- for(int i = 0; i < mOctaves; i++) {
- doSingleDomainWarp(seed, amp, freq, xs, ys, coord);
-
- seed++;
- amp *= mGain;
- freq *= mLacunarity;
- }
- }
-
- // Domain Warp
- private void domainWarpFractalIndependent(int seed, Vector3 coord) {
-
- double xs = coord.getX();
-
- double ys = coord.getY();
-
- double zs = coord.getZ();
- switch(mWarpTransformType3D) {
- case ImproveXYPlanes: {
-
- double xy = xs + ys;
-
- double s2 = xy * -0.211324865405187D;
-
- zs *= 0.577350269189626;
- xs += s2 - zs;
- ys = ys + s2 - zs;
-
- zs += xy * 0.577350269189626;
- }
- break;
- case ImproveXZPlanes: {
-
- double xz = xs + zs;
-
- double s2 = xz * -0.211324865405187D;
-
- ys *= 0.577350269189626;
- xs += s2 - ys;
- zs += s2 - ys;
-
- ys += xz * 0.577350269189626;
- }
- break;
- case DefaultOpenSimplex2: {
-
- final double R3 = 2.0 / 3.0;
-
- double r = (xs + ys + zs) * R3; // Rotation, not skew
- xs = r - xs;
- ys = r - ys;
- zs = r - zs;
- }
- break;
- default:
- break;
- }
-
- double amp = mDomainWarpAmp * mFractalBounding;
- double freq = mFrequency;
-
- for(int i = 0; i < mOctaves; i++) {
- doSingleDomainWarp(seed, amp, freq, xs, ys, zs, coord);
-
- seed++;
- amp *= mGain;
- freq *= mLacunarity;
- }
- }
-
- private void singleDomainWarpBasicGrid(int seed, double warpAmp, double frequency, double x, double y,
- Vector2 coord) {
-
- double xf = x * frequency;
-
- double yf = y * frequency;
-
- int x0 = fastFloor(xf);
- int y0 = fastFloor(yf);
-
- double xs = interpHermite(xf - x0);
- double ys = interpHermite(yf - y0);
-
- x0 *= PRIME_X;
- y0 *= PRIME_Y;
- int x1 = x0 + PRIME_X;
- int y1 = y0 + PRIME_Y;
-
- int hash0 = hash(seed, x0, y0) & (255 << 1);
- int hash1 = hash(seed, x1, y0) & (255 << 1);
-
- double lx0x = lerp(RAND_VECS_2D[hash0], RAND_VECS_2D[hash1], xs);
- double ly0x = lerp(RAND_VECS_2D[hash0 | 1], RAND_VECS_2D[hash1 | 1], xs);
-
- hash0 = hash(seed, x0, y1) & (255 << 1);
- hash1 = hash(seed, x1, y1) & (255 << 1);
-
- double lx1x = lerp(RAND_VECS_2D[hash0], RAND_VECS_2D[hash1], xs);
- double ly1x = lerp(RAND_VECS_2D[hash0 | 1], RAND_VECS_2D[hash1 | 1], xs);
-
- coord.add(lerp(lx0x, lx1x, ys) * warpAmp,
- lerp(ly0x, ly1x, ys) * warpAmp);
- }
-
- // Domain Warp Single Wrapper
- private void singleDomainWarpBasicGrid(int seed, double warpAmp, double frequency, double x,
- double y, double z, Vector3 coord) {
-
- double xf = x * frequency;
-
- double yf = y * frequency;
-
- double zf = z * frequency;
-
- int x0 = fastFloor(xf);
- int y0 = fastFloor(yf);
- int z0 = fastFloor(zf);
-
- double xs = interpHermite(xf - x0);
- double ys = interpHermite(yf - y0);
- double zs = interpHermite(zf - z0);
-
- x0 *= PRIME_X;
- y0 *= PRIME_Y;
- z0 *= PRIME_Z;
- int x1 = x0 + PRIME_X;
- int y1 = y0 + PRIME_Y;
- int z1 = z0 + PRIME_Z;
-
- int hash0 = hash(seed, x0, y0, z0) & (255 << 2);
- int hash1 = hash(seed, x1, y0, z0) & (255 << 2);
-
- double lx0x = lerp(RAND_VECS_3D[hash0], RAND_VECS_3D[hash1], xs);
- double ly0x = lerp(RAND_VECS_3D[hash0 | 1], RAND_VECS_3D[hash1 | 1], xs);
- double lz0x = lerp(RAND_VECS_3D[hash0 | 2], RAND_VECS_3D[hash1 | 2], xs);
-
- hash0 = hash(seed, x0, y1, z0) & (255 << 2);
- hash1 = hash(seed, x1, y1, z0) & (255 << 2);
-
- double lx1x = lerp(RAND_VECS_3D[hash0], RAND_VECS_3D[hash1], xs);
- double ly1x = lerp(RAND_VECS_3D[hash0 | 1], RAND_VECS_3D[hash1 | 1], xs);
- double lz1x = lerp(RAND_VECS_3D[hash0 | 2], RAND_VECS_3D[hash1 | 2], xs);
-
- double lx0y = lerp(lx0x, lx1x, ys);
- double ly0y = lerp(ly0x, ly1x, ys);
- double lz0y = lerp(lz0x, lz1x, ys);
-
- hash0 = hash(seed, x0, y0, z1) & (255 << 2);
- hash1 = hash(seed, x1, y0, z1) & (255 << 2);
-
- lx0x = lerp(RAND_VECS_3D[hash0], RAND_VECS_3D[hash1], xs);
- ly0x = lerp(RAND_VECS_3D[hash0 | 1], RAND_VECS_3D[hash1 | 1], xs);
- lz0x = lerp(RAND_VECS_3D[hash0 | 2], RAND_VECS_3D[hash1 | 2], xs);
-
- hash0 = hash(seed, x0, y1, z1) & (255 << 2);
- hash1 = hash(seed, x1, y1, z1) & (255 << 2);
-
- lx1x = lerp(RAND_VECS_3D[hash0], RAND_VECS_3D[hash1], xs);
- ly1x = lerp(RAND_VECS_3D[hash0 | 1], RAND_VECS_3D[hash1 | 1], xs);
- lz1x = lerp(RAND_VECS_3D[hash0 | 2], RAND_VECS_3D[hash1 | 2], xs);
-
- coord.add(lerp(lx0y, lerp(lx0x, lx1x, ys), zs) * warpAmp,
- lerp(ly0y, lerp(ly0x, ly1x, ys), zs) * warpAmp,
- lerp(lz0y, lerp(lz0x, lz1x, ys), zs) * warpAmp);
- }
-
- // Domain Warp Simplex/OpenSimplex2Sampler
- private void singleDomainWarpSimplexGradient(int seed, double warpAmp, double frequency, double x, double y,
- Vector2 coord, boolean outGradOnly) {
- final double SQRT3 = 1.7320508075688772935274463415059;
- final double G2 = (3 - SQRT3) / 6;
-
- x *= frequency;
- y *= frequency;
-
- /*
- * --- Skew moved to switch statements before fractal evaluation ---
- * final FNLdouble F2 = 0.5f * (SQRT3 - 1);
- * FNLdouble s = (x + y) * F2;
- * x += s; y += s;
- */
-
- int i = fastFloor(x);
- int j = fastFloor(y);
- double xi = x - i;
- double yi = y - j;
-
- double t = (xi + yi) * G2;
- double x0 = xi - t;
- double y0 = yi - t;
-
- i *= PRIME_X;
- j *= PRIME_Y;
-
- double vx, vy;
- vx = vy = 0;
-
- double a = 0.5 - x0 * x0 - y0 * y0;
- if(a > 0) {
- double aaaa = (a * a) * (a * a);
- double xo, yo;
- if(outGradOnly) {
- int hash = hash(seed, i, j) & (255 << 1);
- xo = RAND_VECS_2D[hash];
- yo = RAND_VECS_2D[hash | 1];
- } else {
- int hash = hash(seed, i, j);
- int index1 = hash & (127 << 1);
- int index2 = (hash >> 7) & (255 << 1);
- double xg = GRADIENTS_2_D[index1];
- double yg = GRADIENTS_2_D[index1 | 1];
- double value = x0 * xg + y0 * yg;
- double xgo = RAND_VECS_2D[index2];
- double ygo = RAND_VECS_2D[index2 | 1];
- xo = value * xgo;
- yo = value * ygo;
- }
- vx += aaaa * xo;
- vy += aaaa * yo;
- }
-
- double c = 2 * (1 - 2 * G2) * (1 / G2 - 2) * t + ((-2 * (1 - 2 * G2) * (1 - 2 * G2)) + a);
- if(c > 0) {
- double x2 = x0 + (2 * G2 - 1);
- double y2 = y0 + (2 * G2 - 1);
- double cccc = (c * c) * (c * c);
- double xo, yo;
- if(outGradOnly) {
- int hash = hash(seed, i + PRIME_X, j + PRIME_Y) & (255 << 1);
- xo = RAND_VECS_2D[hash];
- yo = RAND_VECS_2D[hash | 1];
- } else {
- int hash = hash(seed, i + PRIME_X, j + PRIME_Y);
- int index1 = hash & (127 << 1);
- int index2 = (hash >> 7) & (255 << 1);
- double xg = GRADIENTS_2_D[index1];
- double yg = GRADIENTS_2_D[index1 | 1];
- double value = x2 * xg + y2 * yg;
- double xgo = RAND_VECS_2D[index2];
- double ygo = RAND_VECS_2D[index2 | 1];
- xo = value * xgo;
- yo = value * ygo;
- }
- vx += cccc * xo;
- vy += cccc * yo;
- }
-
- if(y0 > x0) {
- double x1 = x0 + G2;
- double y1 = y0 + (G2 - 1);
- double b = 0.5 - x1 * x1 - y1 * y1;
- if(b > 0) {
- double bbbb = (b * b) * (b * b);
- double xo, yo;
- if(outGradOnly) {
- int hash = hash(seed, i, j + PRIME_Y) & (255 << 1);
- xo = RAND_VECS_2D[hash];
- yo = RAND_VECS_2D[hash | 1];
- } else {
- int hash = hash(seed, i, j + PRIME_Y);
- int index1 = hash & (127 << 1);
- int index2 = (hash >> 7) & (255 << 1);
- double xg = GRADIENTS_2_D[index1];
- double yg = GRADIENTS_2_D[index1 | 1];
- double value = x1 * xg + y1 * yg;
- double xgo = RAND_VECS_2D[index2];
- double ygo = RAND_VECS_2D[index2 | 1];
- xo = value * xgo;
- yo = value * ygo;
- }
- vx += bbbb * xo;
- vy += bbbb * yo;
- }
- } else {
- double x1 = x0 + (G2 - 1);
- double y1 = y0 + G2;
- double b = 0.5 - x1 * x1 - y1 * y1;
- if(b > 0) {
- double bbbb = (b * b) * (b * b);
- double xo, yo;
- if(outGradOnly) {
- int hash = hash(seed, i + PRIME_X, j) & (255 << 1);
- xo = RAND_VECS_2D[hash];
- yo = RAND_VECS_2D[hash | 1];
- } else {
- int hash = hash(seed, i + PRIME_X, j);
- int index1 = hash & (127 << 1);
- int index2 = (hash >> 7) & (255 << 1);
- double xg = GRADIENTS_2_D[index1];
- double yg = GRADIENTS_2_D[index1 | 1];
- double value = x1 * xg + y1 * yg;
- double xgo = RAND_VECS_2D[index2];
- double ygo = RAND_VECS_2D[index2 | 1];
- xo = value * xgo;
- yo = value * ygo;
- }
- vx += bbbb * xo;
- vy += bbbb * yo;
- }
- }
-
- coord.add(vx * warpAmp,
- vy * warpAmp);
- }
-
- // Domain Warp Fractal Progressive
- private void singleDomainWarpOpenSimplex2Gradient(int seed, double warpAmp, double frequency, double x,
- double y, double z, Vector3 coord, boolean outGradOnly) {
- x *= frequency;
- y *= frequency;
- z *= frequency;
-
- /*
- * --- Rotation moved to switch statements before fractal evaluation ---
- * final FNLdouble R3 = (FNLdouble)(2.0 / 3.0);
- * FNLdouble r = (x + y + z) * R3; // Rotation, not skew
- * x = r - x; y = r - y; z = r - z;
- */
-
- int i = fastRound(x);
- int j = fastRound(y);
- int k = fastRound(z);
- double x0 = x - i;
- double y0 = y - j;
- double z0 = z - k;
-
- int xNSign = (int) (-x0 - 1.0) | 1;
- int yNSign = (int) (-y0 - 1.0) | 1;
- int zNSign = (int) (-z0 - 1.0) | 1;
-
- double ax0 = xNSign * -x0;
- double ay0 = yNSign * -y0;
- double az0 = zNSign * -z0;
-
- i *= PRIME_X;
- j *= PRIME_Y;
- k *= PRIME_Z;
-
- double vx, vy, vz;
- vx = vy = vz = 0;
-
- double a = (0.6 - x0 * x0) - (y0 * y0 + z0 * z0);
- for(int l = 0; ; l++) {
- if(a > 0) {
- double aaaa = (a * a) * (a * a);
- double xo, yo, zo;
- if(outGradOnly) {
- int hash = hash(seed, i, j, k) & (255 << 2);
- xo = RAND_VECS_3D[hash];
- yo = RAND_VECS_3D[hash | 1];
- zo = RAND_VECS_3D[hash | 2];
- } else {
- int hash = hash(seed, i, j, k);
- int index1 = hash & (63 << 2);
- int index2 = (hash >> 6) & (255 << 2);
- double xg = GRADIENTS_3D[index1];
- double yg = GRADIENTS_3D[index1 | 1];
- double zg = GRADIENTS_3D[index1 | 2];
- double value = x0 * xg + y0 * yg + z0 * zg;
- double xgo = RAND_VECS_3D[index2];
- double ygo = RAND_VECS_3D[index2 | 1];
- double zgo = RAND_VECS_3D[index2 | 2];
- xo = value * xgo;
- yo = value * ygo;
- zo = value * zgo;
- }
- vx += aaaa * xo;
- vy += aaaa * yo;
- vz += aaaa * zo;
- }
-
- double b = a;
- int i1 = i;
- int j1 = j;
- int k1 = k;
- double x1 = x0;
- double y1 = y0;
- double z1 = z0;
-
- if(ax0 >= ay0 && ax0 >= az0) {
- x1 += xNSign;
- b = b + ax0 + ax0;
- i1 -= xNSign * PRIME_X;
- } else if(ay0 > ax0 && ay0 >= az0) {
- y1 += yNSign;
- b = b + ay0 + ay0;
- j1 -= yNSign * PRIME_Y;
- } else {
- z1 += zNSign;
- b = b + az0 + az0;
- k1 -= zNSign * PRIME_Z;
- }
-
- if(b > 1) {
- b -= 1;
- double bbbb = (b * b) * (b * b);
- double xo, yo, zo;
- if(outGradOnly) {
- int hash = hash(seed, i1, j1, k1) & (255 << 2);
- xo = RAND_VECS_3D[hash];
- yo = RAND_VECS_3D[hash | 1];
- zo = RAND_VECS_3D[hash | 2];
- } else {
- int hash = hash(seed, i1, j1, k1);
- int index1 = hash & (63 << 2);
- int index2 = (hash >> 6) & (255 << 2);
- double xg = GRADIENTS_3D[index1];
- double yg = GRADIENTS_3D[index1 | 1];
- double zg = GRADIENTS_3D[index1 | 2];
- double value = x1 * xg + y1 * yg + z1 * zg;
- double xgo = RAND_VECS_3D[index2];
- double ygo = RAND_VECS_3D[index2 | 1];
- double zgo = RAND_VECS_3D[index2 | 2];
- xo = value * xgo;
- yo = value * ygo;
- zo = value * zgo;
- }
- vx += bbbb * xo;
- vy += bbbb * yo;
- vz += bbbb * zo;
- }
-
- if(l == 1) break;
-
- ax0 = 0.5 - ax0;
- ay0 = 0.5 - ay0;
- az0 = 0.5 - az0;
-
- x0 = xNSign * ax0;
- y0 = yNSign * ay0;
- z0 = zNSign * az0;
-
- a += (0.75 - ax0) - (ay0 + az0);
-
- i += (xNSign >> 1) & PRIME_X;
- j += (yNSign >> 1) & PRIME_Y;
- k += (zNSign >> 1) & PRIME_Z;
-
- xNSign = -xNSign;
- yNSign = -yNSign;
- zNSign = -zNSign;
-
- seed += 1293373;
- }
-
- coord.add(vx * warpAmp,
- vy * warpAmp,
- vz * warpAmp);
- }
-
- public enum NoiseType {
- OpenSimplex2,
- OpenSimplex2S,
- Cellular,
- Perlin,
- ValueCubic,
- Value,
- WhiteNoise,
- Constant
- }
-
-
- public enum RotationType3D {
- None,
- ImproveXYPlanes,
- ImproveXZPlanes
- }
-
-
- public enum FractalType {
- None,
- FBm,
- Ridged,
- PingPong,
- DomainWarpProgressive,
- DomainWarpIndependent
- }
-
- // Domain Warp Basic Grid
-
-
- public enum CellularDistanceFunction {
- Euclidean,
- EuclideanSq,
- Manhattan,
- Hybrid
- }
-
-
- public enum CellularReturnType {
- CellValue,
- Distance,
- Distance2,
- Distance2Add,
- Distance2Sub,
- Distance2Mul,
- Distance2Div,
- NoiseLookup,
- Distance3,
- Distance3Add,
- Distance3Sub,
- Distance3Mul,
- Distance3Div
- }
-
-
- public enum DomainWarpType {
- OpenSimplex2,
- OpenSimplex2Reduced,
- BasicGrid,
- Function
- }
-
-
- private enum TransformType3D {
- None,
- ImproveXYPlanes,
- ImproveXZPlanes,
- DefaultOpenSimplex2
- }
-}
\ No newline at end of file
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java
index a44a47cd1..d0b2b3b7a 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/CellularSampler.java
@@ -187,7 +187,12 @@ public class CellularSampler extends NoiseFunction {
private ReturnType returnType = ReturnType.Distance;
private double jitterModifier = 1.0;
- private NoiseSampler noiseLookup = new OpenSimplex2Sampler();
+ private NoiseSampler noiseLookup;
+
+ public CellularSampler(int seed) {
+ super(seed);
+ noiseLookup = new OpenSimplex2Sampler(seed);
+ }
public void setDistanceFunction(DistanceFunction distanceFunction) {
this.distanceFunction = distanceFunction;
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ConstantSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/ConstantSampler.java
similarity index 53%
rename from common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ConstantSampler.java
rename to common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/ConstantSampler.java
index 0def98ac1..4ad942076 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/ConstantSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/ConstantSampler.java
@@ -1,27 +1,16 @@
-package com.dfsek.terra.api.math.noise.samplers;
-
-import com.dfsek.terra.api.math.noise.NoiseSampler;
+package com.dfsek.terra.api.math.noise.samplers.noise;
/**
* Sampler implementation that returns a constant.
*/
-public class ConstantSampler implements NoiseSampler {
+public class ConstantSampler extends NoiseFunction {
private final double constant;
public ConstantSampler(double constant) {
+ super(0);
this.constant = constant;
}
- @Override
- public double getNoise(double x, double y) {
- return constant;
- }
-
- @Override
- public double getNoise(double x, double y, double z) {
- return constant;
- }
-
@Override
public double getNoiseSeeded(int seed, double x, double y) {
return constant;
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/NoiseFunction.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/NoiseFunction.java
index d1fabbe91..9aff174b6 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/NoiseFunction.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/NoiseFunction.java
@@ -3,6 +3,7 @@ package com.dfsek.terra.api.math.noise.samplers.noise;
import com.dfsek.terra.api.math.noise.NoiseSampler;
import net.jafama.FastMath;
+@SuppressWarnings("ManualMinMaxCalculation")
public abstract class NoiseFunction implements NoiseSampler {
// Hashing
protected static final int PRIME_X = 501125321;
@@ -13,6 +14,10 @@ public abstract class NoiseFunction implements NoiseSampler {
protected double frequency = 0.02d;
protected int seed = 2403;
+ public NoiseFunction(int seed) {
+ this.seed = seed;
+ }
+
protected static int fastFloor(double f) {
return f >= 0 ? (int) f : (int) f - 1;
}
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/WhiteNoiseSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/WhiteNoiseSampler.java
index 2fe8ed992..1f01e423e 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/WhiteNoiseSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/WhiteNoiseSampler.java
@@ -3,6 +3,10 @@ package com.dfsek.terra.api.math.noise.samplers.noise;
public class WhiteNoiseSampler extends NoiseFunction {
private static final long POSITIVE_POW1 = 0b01111111111L << 52; // Bits that when applied to the exponent/sign section of a double, produce a positive number with a power of 1.
+ public WhiteNoiseSampler(int seed) {
+ super(seed);
+ }
+
@Override
public double getNoiseSeeded(int seed, double x, double y) {
long hashX = Double.doubleToRawLongBits(x) ^ seed;
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/BrownianMotionSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/BrownianMotionSampler.java
index 4a138c7dd..cb3a6f5f4 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/BrownianMotionSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/BrownianMotionSampler.java
@@ -3,8 +3,8 @@ package com.dfsek.terra.api.math.noise.samplers.noise.fractal;
import com.dfsek.terra.api.math.noise.NoiseSampler;
public class BrownianMotionSampler extends FractalNoiseFunction {
- public BrownianMotionSampler(NoiseSampler input) {
- super(input);
+ public BrownianMotionSampler(int seed, NoiseSampler input) {
+ super(seed, input);
}
@Override
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/FractalNoiseFunction.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/FractalNoiseFunction.java
index da5798d2f..39def1cea 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/FractalNoiseFunction.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/FractalNoiseFunction.java
@@ -11,7 +11,8 @@ public abstract class FractalNoiseFunction extends NoiseFunction {
protected double lacunarity = 2.0d;
protected double weightedStrength = 0.0d;
- public FractalNoiseFunction(NoiseSampler input) {
+ public FractalNoiseFunction(int seed, NoiseSampler input) {
+ super(seed);
this.input = input;
}
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/PingPongSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/PingPongSampler.java
index de30a20e3..baee4b89d 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/PingPongSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/PingPongSampler.java
@@ -5,10 +5,11 @@ import com.dfsek.terra.api.math.noise.NoiseSampler;
public class PingPongSampler extends FractalNoiseFunction {
private double pingPongStrength = 2.0;
- public PingPongSampler(NoiseSampler input) {
- super(input);
+ public PingPongSampler(int seed, NoiseSampler input) {
+ super(seed, input);
}
+
private static double pingPong(double t) {
t -= (int) (t * 0.5f) << 1;
return t < 1 ? t : 2 - t;
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/RidgedFractalSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/RidgedFractalSampler.java
index e1be7f698..59421c777 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/RidgedFractalSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/fractal/RidgedFractalSampler.java
@@ -3,8 +3,9 @@ package com.dfsek.terra.api.math.noise.samplers.noise.fractal;
import com.dfsek.terra.api.math.noise.NoiseSampler;
public class RidgedFractalSampler extends FractalNoiseFunction {
- public RidgedFractalSampler(NoiseSampler input) {
- super(input);
+
+ public RidgedFractalSampler(int seed, NoiseSampler input) {
+ super(seed, input);
}
@Override
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2SSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2SSampler.java
index 0e24c0cff..88506d3b4 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2SSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2SSampler.java
@@ -1,6 +1,10 @@
package com.dfsek.terra.api.math.noise.samplers.noise.simplex;
public class OpenSimplex2SSampler extends SimplexStyleSampler {
+ public OpenSimplex2SSampler(int seed) {
+ super(seed);
+ }
+
@Override
@SuppressWarnings("NumericOverflow")
public double getNoiseSeeded(int seed, double x, double y) {
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2Sampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2Sampler.java
index ad94ab9dd..9517a33ef 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2Sampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/OpenSimplex2Sampler.java
@@ -3,6 +3,10 @@ package com.dfsek.terra.api.math.noise.samplers.noise.simplex;
public class OpenSimplex2Sampler extends SimplexStyleSampler {
private static final double SQRT3 = 1.7320508075688772935274463415059;
+ public OpenSimplex2Sampler(int seed) {
+ super(seed);
+ }
+
@Override
public double getNoiseSeeded(int seed, double x, double y) {
// 2D OpenSimplex2 case uses the same algorithm as ordinary Simplex.
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/PerlinSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/PerlinSampler.java
index e10ca5778..f10ed7ce6 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/PerlinSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/PerlinSampler.java
@@ -1,6 +1,10 @@
package com.dfsek.terra.api.math.noise.samplers.noise.simplex;
public class PerlinSampler extends SimplexStyleSampler {
+ public PerlinSampler(int seed) {
+ super(seed);
+ }
+
@Override
public double getNoiseSeeded(int seed, double x, double y) {
int x0 = fastFloor(x);
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/SimplexStyleSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/SimplexStyleSampler.java
index c45f2960e..b27aed62f 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/SimplexStyleSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/simplex/SimplexStyleSampler.java
@@ -68,6 +68,10 @@ public abstract class SimplexStyleSampler extends NoiseFunction {
1, 1, 0, 0, 0, -1, 1, 0, -1, 1, 0, 0, 0, -1, -1, 0
};
+ public SimplexStyleSampler(int seed) {
+ super(seed);
+ }
+
protected static double gradCoord(int seed, int xPrimed, int yPrimed, double xd, double yd) {
int hash = hash(seed, xPrimed, yPrimed);
hash ^= hash >> 15;
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueCubicSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueCubicSampler.java
index ef8bdb033..624522b5f 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueCubicSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueCubicSampler.java
@@ -1,6 +1,10 @@
package com.dfsek.terra.api.math.noise.samplers.noise.value;
public class ValueCubicSampler extends ValueStyleNoise {
+ public ValueCubicSampler(int seed) {
+ super(seed);
+ }
+
@Override
public double getNoiseSeeded(int seed, double x, double y) {
int x1 = fastFloor(x);
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueSampler.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueSampler.java
index 48d778c7c..f6df641c2 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueSampler.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueSampler.java
@@ -1,6 +1,10 @@
package com.dfsek.terra.api.math.noise.samplers.noise.value;
public class ValueSampler extends ValueStyleNoise {
+ public ValueSampler(int seed) {
+ super(seed);
+ }
+
@Override
public double getNoiseSeeded(int seed, double x, double y) {
int x0 = fastFloor(x);
diff --git a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueStyleNoise.java b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueStyleNoise.java
index f828d0cba..246d77538 100644
--- a/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueStyleNoise.java
+++ b/common/src/main/java/com/dfsek/terra/api/math/noise/samplers/noise/value/ValueStyleNoise.java
@@ -3,6 +3,10 @@ package com.dfsek.terra.api.math.noise.samplers.noise.value;
import com.dfsek.terra.api.math.noise.samplers.noise.NoiseFunction;
public abstract class ValueStyleNoise extends NoiseFunction {
+ public ValueStyleNoise(int seed) {
+ super(seed);
+ }
+
protected static double valCoord(int seed, int xPrimed, int yPrimed) {
int hash = hash(seed, xPrimed, yPrimed);
diff --git a/common/src/main/java/com/dfsek/terra/config/GenericLoaders.java b/common/src/main/java/com/dfsek/terra/config/GenericLoaders.java
index 7d966680e..52cdf965c 100644
--- a/common/src/main/java/com/dfsek/terra/config/GenericLoaders.java
+++ b/common/src/main/java/com/dfsek/terra/config/GenericLoaders.java
@@ -6,8 +6,8 @@ import com.dfsek.terra.api.core.TerraPlugin;
import com.dfsek.terra.api.math.GridSpawn;
import com.dfsek.terra.api.math.ProbabilityCollection;
import com.dfsek.terra.api.math.Range;
-import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
import com.dfsek.terra.api.math.noise.samplers.ImageSampler;
+import com.dfsek.terra.api.math.noise.samplers.noise.CellularSampler;
import com.dfsek.terra.api.util.seeded.SourceSeeded;
import com.dfsek.terra.api.util.seeded.StageSeeded;
import com.dfsek.terra.api.world.palette.holder.PaletteHolder;
@@ -37,7 +37,6 @@ import com.dfsek.terra.config.loaders.config.biome.templates.stage.mutator.Repla
import com.dfsek.terra.config.loaders.config.biome.templates.stage.mutator.SmoothMutatorTemplate;
import com.dfsek.terra.config.loaders.config.function.FunctionTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.DomainWarpTemplate;
-import com.dfsek.terra.config.loaders.config.sampler.templates.FastNoiseTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.ImageSamplerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.ClampNormalizerTemplate;
import com.dfsek.terra.config.loaders.config.sampler.templates.normalizer.LinearNormalizerTemplate;
@@ -75,7 +74,6 @@ public class GenericLoaders implements LoaderRegistrar {
.registerLoader(TreeLayer.class, new TreeLayerLoader())
.registerLoader(MaterialSet.class, new MaterialSetLoader())
.registerLoader(OreHolder.class, new OreHolderLoader())
- .registerLoader(FastNoiseTemplate.class, FastNoiseTemplate::new)
.registerLoader(ImageSamplerTemplate.class, ImageSamplerTemplate::new)
.registerLoader(DomainWarpTemplate.class, DomainWarpTemplate::new)
.registerLoader(LinearNormalizerTemplate.class, LinearNormalizerTemplate::new)
@@ -98,12 +96,8 @@ public class GenericLoaders implements LoaderRegistrar {
.registerLoader(ImageBiomeProvider.Align.class, (t, object, cf) -> ImageBiomeProvider.Align.valueOf((String) object))
.registerLoader(ExpanderStage.Type.class, (t, object, cf) -> ExpanderStage.Type.valueOf((String) object))
.registerLoader(MutatorStage.Type.class, (t, object, cf) -> MutatorStage.Type.valueOf((String) object))
- .registerLoader(FastNoiseLite.NoiseType.class, (t, object, cf) -> FastNoiseLite.NoiseType.valueOf((String) object))
- .registerLoader(FastNoiseLite.FractalType.class, (t, object, cf) -> FastNoiseLite.FractalType.valueOf((String) object))
- .registerLoader(FastNoiseLite.DomainWarpType.class, (t, object, cf) -> FastNoiseLite.DomainWarpType.valueOf((String) object))
- .registerLoader(FastNoiseLite.RotationType3D.class, (t, object, cf) -> FastNoiseLite.RotationType3D.valueOf((String) object))
- .registerLoader(FastNoiseLite.CellularReturnType.class, (t, object, cf) -> FastNoiseLite.CellularReturnType.valueOf((String) object))
- .registerLoader(FastNoiseLite.CellularDistanceFunction.class, (t, object, cf) -> FastNoiseLite.CellularDistanceFunction.valueOf((String) object))
+ .registerLoader(CellularSampler.ReturnType.class, (t, object, cf) -> CellularSampler.ReturnType.valueOf((String) object))
+ .registerLoader(CellularSampler.DistanceFunction.class, (t, object, cf) -> CellularSampler.DistanceFunction.valueOf((String) object))
.registerLoader(TerraFlora.Search.class, (t, o, l) -> TerraFlora.Search.valueOf(o.toString()));
}
}
diff --git a/common/src/main/java/com/dfsek/terra/config/builder/GeneratorBuilder.java b/common/src/main/java/com/dfsek/terra/config/builder/GeneratorBuilder.java
index d64e9ef0c..798e91245 100644
--- a/common/src/main/java/com/dfsek/terra/config/builder/GeneratorBuilder.java
+++ b/common/src/main/java/com/dfsek/terra/config/builder/GeneratorBuilder.java
@@ -3,8 +3,8 @@ package com.dfsek.terra.config.builder;
import com.dfsek.paralithic.eval.parser.Scope;
import com.dfsek.paralithic.eval.tokenizer.ParseException;
import com.dfsek.terra.api.math.noise.NoiseSampler;
-import com.dfsek.terra.api.math.noise.samplers.ConstantSampler;
import com.dfsek.terra.api.math.noise.samplers.ExpressionSampler;
+import com.dfsek.terra.api.math.noise.samplers.noise.ConstantSampler;
import com.dfsek.terra.api.util.seeded.NoiseSeeded;
import com.dfsek.terra.api.world.palette.holder.PaletteHolder;
import com.dfsek.terra.config.loaders.config.function.FunctionTemplate;
diff --git a/common/src/main/java/com/dfsek/terra/config/factories/FloraFactory.java b/common/src/main/java/com/dfsek/terra/config/factories/FloraFactory.java
index 49e88a2a5..4d4cae0b1 100644
--- a/common/src/main/java/com/dfsek/terra/config/factories/FloraFactory.java
+++ b/common/src/main/java/com/dfsek/terra/config/factories/FloraFactory.java
@@ -1,7 +1,7 @@
package com.dfsek.terra.config.factories;
import com.dfsek.terra.api.core.TerraPlugin;
-import com.dfsek.terra.api.math.noise.samplers.FastNoiseLite;
+import com.dfsek.terra.api.math.noise.samplers.noise.WhiteNoiseSampler;
import com.dfsek.terra.api.platform.block.BlockData;
import com.dfsek.terra.api.world.flora.Flora;
import com.dfsek.terra.api.world.palette.NoisePalette;
@@ -13,9 +13,7 @@ import com.dfsek.terra.world.population.items.flora.TerraFlora;
public class FloraFactory implements TerraFactory