mirror of
https://github.com/VolmitSoftware/Iris.git
synced 2025-07-19 02:36:59 +00:00
Noise
This commit is contained in:
Dan Macbook
parent
887d355dea
commit
a4d1b5b972
@ -11,7 +11,6 @@ import javax.swing.JPanel;
|
||||
|
||||
import com.volmit.iris.noise.CNG;
|
||||
import com.volmit.iris.object.NoiseStyle;
|
||||
import com.volmit.iris.util.Form;
|
||||
import com.volmit.iris.util.GroupedExecutor;
|
||||
import com.volmit.iris.util.M;
|
||||
import com.volmit.iris.util.PrecisionStopwatch;
|
||||
@ -23,7 +22,7 @@ public class NoiseView extends JPanel {
|
||||
private static final long serialVersionUID = 2094606939770332040L;
|
||||
|
||||
RollingSequence r = new RollingSequence(256);
|
||||
CNG cng = NoiseStyle.CELLULAR_IRIS_DOUBLE.create(new RNG(RNG.r.nextLong())).scale(0.25);
|
||||
CNG cng = NoiseStyle.PERLIN_IRIS.create(new RNG(RNG.r.nextLong())).scale(0.25);
|
||||
GroupedExecutor gx = new GroupedExecutor(Runtime.getRuntime().availableProcessors(), Thread.MAX_PRIORITY,
|
||||
"Iris Renderer");
|
||||
ReentrantLock l = new ReentrantLock();
|
||||
@ -87,7 +86,6 @@ public class NoiseView extends JPanel {
|
||||
|
||||
p.end();
|
||||
r.put(p.getMilliseconds());
|
||||
System.out.println("Accuracy: " + accuracy + " MS: " + Form.duration(r.getAverage(), 2));
|
||||
|
||||
EventQueue.invokeLater(() -> {
|
||||
repaint();
|
||||
|
||||
31
src/main/java/com/volmit/iris/noise/FractalCubicNoise.java
Normal file
31
src/main/java/com/volmit/iris/noise/FractalCubicNoise.java
Normal file
@ -0,0 +1,31 @@
|
||||
package com.volmit.iris.noise;
|
||||
|
||||
import com.volmit.iris.noise.FastNoise.FractalType;
|
||||
|
||||
public class FractalCubicNoise implements NoiseGenerator {
|
||||
private final FastNoise n;
|
||||
|
||||
public FractalCubicNoise(long seed) {
|
||||
this.n = new FastNoise((int) seed);
|
||||
n.SetFractalType(FractalType.Billow);
|
||||
}
|
||||
|
||||
private double f(double n) {
|
||||
return (n / 2D) + 0.5D;
|
||||
}
|
||||
|
||||
@Override
|
||||
public double noise(double x) {
|
||||
return f(n.GetCubicFractal((float) x, 0));
|
||||
}
|
||||
|
||||
@Override
|
||||
public double noise(double x, double z) {
|
||||
return f(n.GetCubicFractal((float) x, (float) z));
|
||||
}
|
||||
|
||||
@Override
|
||||
public double noise(double x, double y, double z) {
|
||||
return f(n.GetCubicFractal((float) x, (float) y, (float) z));
|
||||
}
|
||||
}
|
||||
@ -3,12 +3,14 @@ package com.volmit.iris.noise;
|
||||
public enum NoiseType {
|
||||
WHITE(seed -> new WhiteNoise(seed)),
|
||||
SIMPLEX(seed -> new SimplexNoise(seed)),
|
||||
PERLIN(seed -> new PerlinNoise(seed)),
|
||||
FRACTAL_BILLOW_SIMPLEX(seed -> new FractalBillowSimplexNoise(seed)),
|
||||
FRACTAL_FBM_SIMPLEX(seed -> new FractalFBMSimplexNoise(seed)),
|
||||
FRACTAL_RIGID_MULTI_SIMPLEX(seed -> new FractalRigidMultiSimplexNoise(seed)),
|
||||
CELLULAR(seed -> new CellularNoise(seed)),
|
||||
GLOB(seed -> new GlobNoise(seed)),
|
||||
CUBIC(seed -> new CubicNoise(seed)),
|
||||
FRACTAL_CUBIC(seed -> new FractalCubicNoise(seed)),
|
||||
CELLULAR_HEIGHT(seed -> new CellHeightNoise(seed)),
|
||||
VASCULAR(seed -> new VascularNoise(seed));
|
||||
|
||||
|
||||
@ -1,175 +1,77 @@
|
||||
package com.volmit.iris.noise;
|
||||
|
||||
import java.util.Random;
|
||||
import com.volmit.iris.util.RNG;
|
||||
|
||||
public class PerlinNoise extends BasePerlinNoiseGenerator
|
||||
{
|
||||
public class PerlinNoise implements NoiseGenerator, OctaveNoise {
|
||||
private final FastNoise n;
|
||||
private int octaves;
|
||||
|
||||
/**
|
||||
* Creates an instance using the given PRNG.
|
||||
*
|
||||
* @param rand
|
||||
* the PRNG used to generate the seed permutation
|
||||
*/
|
||||
public PerlinNoise(Random rand)
|
||||
{
|
||||
offsetX = rand.nextDouble() * 256;
|
||||
offsetY = rand.nextDouble() * 256;
|
||||
offsetZ = rand.nextDouble() * 256;
|
||||
// The only reason why I'm re-implementing the constructor code is that I've
|
||||
// read
|
||||
// on at least 3 different sources that the permutation table should initially
|
||||
// be
|
||||
// populated with indices.
|
||||
// "The permutation table is his answer to the issue of random numbers.
|
||||
// First take an array of decent length, usually 256 values. Fill it
|
||||
// sequentially with each
|
||||
// number in that range: so index 1 gets 1, index 8 gets 8, index 251 gets 251,
|
||||
// etc...
|
||||
// Then randomly shuffle the values so you have a table of 256 random values,
|
||||
// but only
|
||||
// contains the values between 0 and 255."
|
||||
// source: https://code.google.com/p/fractalterraingeneration/wiki/Perlin_Noise
|
||||
for(int i = 0; i < 256; i++)
|
||||
{
|
||||
perm[i] = i;
|
||||
}
|
||||
for(int i = 0; i < 256; i++)
|
||||
{
|
||||
int pos = rand.nextInt(256 - i) + i;
|
||||
int old = perm[i];
|
||||
perm[i] = perm[pos];
|
||||
perm[pos] = old;
|
||||
perm[i + 256] = perm[i];
|
||||
}
|
||||
public PerlinNoise(long seed) {
|
||||
this.n = new FastNoise(new RNG(seed).imax());
|
||||
n.SetNoiseType(FastNoise.NoiseType.Perlin);
|
||||
octaves = 1;
|
||||
}
|
||||
|
||||
public static int floor(double x)
|
||||
{
|
||||
int floored = (int) x;
|
||||
return x < floored ? floored - 1 : floored;
|
||||
public double f(double v) {
|
||||
return (v / 2D) + 0.5D;
|
||||
}
|
||||
|
||||
/**
|
||||
* Generates a rectangular section of this generator's noise.
|
||||
*
|
||||
* @param noise
|
||||
* the output of the previous noise layer
|
||||
* @param x
|
||||
* the X offset
|
||||
* @param y
|
||||
* the Y offset
|
||||
* @param z
|
||||
* the Z offset
|
||||
* @param sizeX
|
||||
* the size on the X axis
|
||||
* @param sizeY
|
||||
* the size on the Y axis
|
||||
* @param sizeZ
|
||||
* the size on the Z axis
|
||||
* @param scaleX
|
||||
* the X scale parameter
|
||||
* @param scaleY
|
||||
* the Y scale parameter
|
||||
* @param scaleZ
|
||||
* the Z scale parameter
|
||||
* @param amplitude
|
||||
* the amplitude parameter
|
||||
* @return {@code noise} with this layer of noise added
|
||||
*/
|
||||
public double[] getNoise(double[] noise, double x, double y, double z, int sizeX, int sizeY, int sizeZ, double scaleX, double scaleY, double scaleZ, double amplitude)
|
||||
{
|
||||
if(sizeY == 1)
|
||||
{
|
||||
return get2dNoise(noise, x, z, sizeX, sizeZ, scaleX, scaleZ, amplitude);
|
||||
@Override
|
||||
public double noise(double x) {
|
||||
if (octaves <= 1) {
|
||||
return f(n.GetPerlin((float) x, 0f));
|
||||
}
|
||||
else
|
||||
{
|
||||
return get3dNoise(noise, x, y, z, sizeX, sizeY, sizeZ, scaleX, scaleY, scaleZ, amplitude);
|
||||
|
||||
double f = 1;
|
||||
double m = 0;
|
||||
double v = 0;
|
||||
|
||||
for (int i = 0; i < octaves; i++) {
|
||||
v += n.GetPerlin((float) (x * (f == 1 ? f++ : (f *= 2))), 0f) * f;
|
||||
m += f;
|
||||
}
|
||||
|
||||
return f(v / m);
|
||||
}
|
||||
|
||||
protected double[] get2dNoise(double[] noise, double x, double z, int sizeX, int sizeZ, double scaleX, double scaleZ, double amplitude)
|
||||
{
|
||||
int index = 0;
|
||||
for(int i = 0; i < sizeX; i++)
|
||||
{
|
||||
double dx = x + offsetX + i * scaleX;
|
||||
int floorX = floor(dx);
|
||||
int ix = floorX & 255;
|
||||
dx -= floorX;
|
||||
double fx = fade(dx);
|
||||
for(int j = 0; j < sizeZ; j++)
|
||||
{
|
||||
double dz = z + offsetZ + j * scaleZ;
|
||||
int floorZ = floor(dz);
|
||||
int iz = floorZ & 255;
|
||||
dz -= floorZ;
|
||||
double fz = fade(dz);
|
||||
// Hash coordinates of the square corners
|
||||
int a = perm[ix];
|
||||
int aa = perm[a] + iz;
|
||||
int b = perm[ix + 1];
|
||||
int ba = perm[b] + iz;
|
||||
double x1 = lerp(fx, grad(perm[aa], dx, 0, dz), grad(perm[ba], dx - 1, 0, dz));
|
||||
double x2 = lerp(fx, grad(perm[aa + 1], dx, 0, dz - 1), grad(perm[ba + 1], dx - 1, 0, dz - 1));
|
||||
noise[index++] += lerp(fz, x1, x2) * amplitude;
|
||||
}
|
||||
@Override
|
||||
public double noise(double x, double z) {
|
||||
if (octaves <= 1) {
|
||||
return f(n.GetPerlin((float) x, (float) z));
|
||||
}
|
||||
return noise;
|
||||
double f = 1;
|
||||
double m = 0;
|
||||
double v = 0;
|
||||
|
||||
for (int i = 0; i < octaves; i++) {
|
||||
f = f == 1 ? f + 1 : f * 2;
|
||||
v += n.GetPerlin((float) (x * f), (float) (z * f)) * f;
|
||||
m += f;
|
||||
}
|
||||
|
||||
return f(v / m);
|
||||
}
|
||||
|
||||
protected double[] get3dNoise(double[] noise, double x, double y, double z, int sizeX, int sizeY, int sizeZ, double scaleX, double scaleY, double scaleZ, double amplitude)
|
||||
{
|
||||
int n = -1;
|
||||
double x1 = 0;
|
||||
double x2 = 0;
|
||||
double x3 = 0;
|
||||
double x4 = 0;
|
||||
int index = 0;
|
||||
for(int i = 0; i < sizeX; i++)
|
||||
{
|
||||
double dx = x + offsetX + i * scaleX;
|
||||
int floorX = floor(dx);
|
||||
int ix = floorX & 255;
|
||||
dx -= floorX;
|
||||
double fx = fade(dx);
|
||||
for(int j = 0; j < sizeZ; j++)
|
||||
{
|
||||
double dz = z + offsetZ + j * scaleZ;
|
||||
int floorZ = floor(dz);
|
||||
int iz = floorZ & 255;
|
||||
dz -= floorZ;
|
||||
double fz = fade(dz);
|
||||
for(int k = 0; k < sizeY; k++)
|
||||
{
|
||||
double dy = y + offsetY + k * scaleY;
|
||||
int floorY = floor(dy);
|
||||
int iy = floorY & 255;
|
||||
dy -= floorY;
|
||||
double fy = fade(dy);
|
||||
if(k == 0 || iy != n)
|
||||
{
|
||||
n = iy;
|
||||
// Hash coordinates of the cube corners
|
||||
int a = perm[ix] + iy;
|
||||
int aa = perm[a] + iz;
|
||||
int ab = perm[a + 1] + iz;
|
||||
int b = perm[ix + 1] + iy;
|
||||
int ba = perm[b] + iz;
|
||||
int bb = perm[b + 1] + iz;
|
||||
x1 = lerp(fx, grad(perm[aa], dx, dy, dz), grad(perm[ba], dx - 1, dy, dz));
|
||||
x2 = lerp(fx, grad(perm[ab], dx, dy - 1, dz), grad(perm[bb], dx - 1, dy - 1, dz));
|
||||
x3 = lerp(fx, grad(perm[aa + 1], dx, dy, dz - 1), grad(perm[ba + 1], dx - 1, dy, dz - 1));
|
||||
x4 = lerp(fx, grad(perm[ab + 1], dx, dy - 1, dz - 1), grad(perm[bb + 1], dx - 1, dy - 1, dz - 1));
|
||||
}
|
||||
double y1 = lerp(fy, x1, x2);
|
||||
double y2 = lerp(fy, x3, x4);
|
||||
|
||||
noise[index++] += lerp(fz, y1, y2) * amplitude;
|
||||
}
|
||||
}
|
||||
@Override
|
||||
public double noise(double x, double y, double z) {
|
||||
if (octaves <= 1) {
|
||||
return f(n.GetPerlin((float) x, (float) y, (float) z));
|
||||
}
|
||||
return noise;
|
||||
double f = 1;
|
||||
double m = 0;
|
||||
double v = 0;
|
||||
|
||||
for (int i = 0; i < octaves; i++) {
|
||||
f = f == 1 ? f + 1 : f * 2;
|
||||
v += n.GetPerlin((float) (x * f), (float) (y * f), (float) (z * f)) * f;
|
||||
m += f;
|
||||
}
|
||||
|
||||
return f(v / m);
|
||||
}
|
||||
}
|
||||
|
||||
@Override
|
||||
public void setOctaves(int o) {
|
||||
octaves = o;
|
||||
}
|
||||
}
|
||||
|
||||
@ -1,377 +0,0 @@
|
||||
package com.volmit.iris.noise;
|
||||
|
||||
import java.util.Random;
|
||||
|
||||
/**
|
||||
* A speed-improved simplex noise algorithm.
|
||||
*
|
||||
* <p>
|
||||
* Based on example code by Stefan Gustavson (stegu@itn.liu.se). Optimisations
|
||||
* by Peter Eastman (peastman@drizzle.stanford.edu). Better rank ordering method
|
||||
* by Stefan Gustavson in 2012.
|
||||
*
|
||||
* <p>
|
||||
* This could be sped up even further, but it's useful as is.
|
||||
*/
|
||||
public class SNG extends PerlinNoise
|
||||
{
|
||||
|
||||
protected static final double SQRT_3 = 1.7320508075688772; // Math.sqrt(3)
|
||||
protected static final double F2 = 0.5 * (SQRT_3 - 1);
|
||||
protected static final double G2 = (3 - SQRT_3) / 6;
|
||||
protected static final double G22 = G2 * 2.0 - 1;
|
||||
protected static final double F3 = 1.0 / 3.0;
|
||||
protected static final double G3 = 1.0 / 6.0;
|
||||
protected static final double G32 = G3 * 2.0;
|
||||
protected static final double G33 = G3 * 3.0 - 1.0;
|
||||
private static Grad[] grad3 = {new Grad(1, 1, 0), new Grad(-1, 1, 0), new Grad(1, -1, 0), new Grad(-1, -1, 0), new Grad(1, 0, 1), new Grad(-1, 0, 1), new Grad(1, 0, -1), new Grad(-1, 0, -1), new Grad(0, 1, 1), new Grad(0, -1, 1), new Grad(0, 1, -1), new Grad(0, -1, -1)};
|
||||
protected final int[] permMod12 = new int[512];
|
||||
|
||||
/**
|
||||
* Creates a simplex noise generator.
|
||||
*
|
||||
* @param rand
|
||||
* the PRNG to use
|
||||
*/
|
||||
public SNG(Random rand)
|
||||
{
|
||||
super(rand);
|
||||
for(int i = 0; i < 512; i++)
|
||||
{
|
||||
permMod12[i] = perm[i] % 12;
|
||||
}
|
||||
}
|
||||
|
||||
public static int floor(double x)
|
||||
{
|
||||
return x > 0 ? (int) x : (int) x - 1;
|
||||
}
|
||||
|
||||
protected static double dot(Grad g, double x, double y)
|
||||
{
|
||||
return g.x * x + g.y * y;
|
||||
}
|
||||
|
||||
protected static double dot(Grad g, double x, double y, double z)
|
||||
{
|
||||
return g.x * x + g.y * y + g.z * z;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected double[] get2dNoise(double[] noise, double x, double z, int sizeX, int sizeY, double scaleX, double scaleY, double amplitude)
|
||||
{
|
||||
int index = 0;
|
||||
for(int i = 0; i < sizeY; i++)
|
||||
{
|
||||
double zin = offsetY + (z + i) * scaleY;
|
||||
for(int j = 0; j < sizeX; j++)
|
||||
{
|
||||
double xin = offsetX + (x + j) * scaleX;
|
||||
noise[index++] += simplex2D(xin, zin) * amplitude;
|
||||
}
|
||||
}
|
||||
return noise;
|
||||
}
|
||||
|
||||
@Override
|
||||
protected double[] get3dNoise(double[] noise, double x, double y, double z, int sizeX, int sizeY, int sizeZ, double scaleX, double scaleY, double scaleZ, double amplitude)
|
||||
{
|
||||
int index = 0;
|
||||
for(int i = 0; i < sizeZ; i++)
|
||||
{
|
||||
double zin = offsetZ + (z + i) * scaleZ;
|
||||
for(int j = 0; j < sizeX; j++)
|
||||
{
|
||||
double xin = offsetX + (x + j) * scaleX;
|
||||
for(int k = 0; k < sizeY; k++)
|
||||
{
|
||||
double yin = offsetY + (y + k) * scaleY;
|
||||
noise[index++] += simplex3D(xin, yin, zin) * amplitude;
|
||||
}
|
||||
}
|
||||
}
|
||||
return noise;
|
||||
}
|
||||
|
||||
@Override
|
||||
public double noise(double xin, double yin)
|
||||
{
|
||||
xin += offsetX;
|
||||
yin += offsetY;
|
||||
return simplex2D(xin, yin);
|
||||
}
|
||||
|
||||
@Override
|
||||
public double noise(double xin, double yin, double zin)
|
||||
{
|
||||
xin += offsetX;
|
||||
yin += offsetY;
|
||||
zin += offsetZ;
|
||||
return simplex3D(xin, yin, zin);
|
||||
}
|
||||
|
||||
private double simplex2D(double xin, double yin)
|
||||
{
|
||||
// Skew the input space to determine which simplex cell we're in
|
||||
double s = (xin + yin) * F2; // Hairy factor for 2D
|
||||
int i = floor(xin + s);
|
||||
int j = floor(yin + s);
|
||||
double t = (i + j) * G2;
|
||||
double dx0 = i - t; // Unskew the cell origin back to (x,y) space
|
||||
double dy0 = j - t;
|
||||
double x0 = xin - dx0; // The x,y distances from the cell origin
|
||||
double y0 = yin - dy0;
|
||||
|
||||
// For the 2D case, the simplex shape is an equilateral triangle.
|
||||
|
||||
// Determine which simplex we are in.
|
||||
int i1; // Offsets for second (middle) corner of simplex in (i,j) coords
|
||||
int j1;
|
||||
if(x0 > y0)
|
||||
{
|
||||
i1 = 1; // lower triangle, XY order: (0,0)->(1,0)->(1,1)
|
||||
j1 = 0;
|
||||
}
|
||||
else
|
||||
{
|
||||
i1 = 0; // upper triangle, YX order: (0,0)->(0,1)->(1,1)
|
||||
j1 = 1;
|
||||
}
|
||||
|
||||
// A step of (1,0) in (i,j) means a step of (1-c,-c) in (x,y), and
|
||||
// a step of (0,1) in (i,j) means a step of (-c,1-c) in (x,y), where
|
||||
// c = (3-sqrt(3))/6
|
||||
|
||||
double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
|
||||
double y1 = y0 - j1 + G2;
|
||||
double x2 = x0 + G22; // Offsets for last corner in (x,y) unskewed coords
|
||||
double y2 = y0 + G22;
|
||||
|
||||
// Work out the hashed gradient indices of the three simplex corners
|
||||
int ii = i & 255;
|
||||
int jj = j & 255;
|
||||
int gi0 = permMod12[ii + perm[jj]];
|
||||
int gi1 = permMod12[ii + i1 + perm[jj + j1]];
|
||||
int gi2 = permMod12[ii + 1 + perm[jj + 1]];
|
||||
|
||||
// Calculate the contribution from the three corners
|
||||
double t0 = 0.5 - x0 * x0 - y0 * y0;
|
||||
double n0;
|
||||
if(t0 < 0)
|
||||
{
|
||||
n0 = 0.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t0 *= t0;
|
||||
n0 = t0 * t0 * dot(grad3[gi0], x0, y0); // (x,y) of grad3 used for 2D gradient
|
||||
}
|
||||
|
||||
double t1 = 0.5 - x1 * x1 - y1 * y1;
|
||||
double n1;
|
||||
if(t1 < 0)
|
||||
{
|
||||
n1 = 0.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t1 *= t1;
|
||||
n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
|
||||
}
|
||||
|
||||
double t2 = 0.5 - x2 * x2 - y2 * y2;
|
||||
double n2;
|
||||
if(t2 < 0)
|
||||
{
|
||||
n2 = 0.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t2 *= t2;
|
||||
n2 = t2 * t2 * dot(grad3[gi2], x2, y2);
|
||||
}
|
||||
|
||||
// Add contributions from each corner to get the final noise value.
|
||||
// The result is scaled to return values in the interval [-1,1].
|
||||
return 70.0 * (n0 + n1 + n2);
|
||||
}
|
||||
|
||||
private double simplex3D(double xin, double yin, double zin)
|
||||
{
|
||||
// Skew the input space to determine which simplex cell we're in
|
||||
double s = (xin + yin + zin) * F3; // Very nice and simple skew factor for 3D
|
||||
int i = floor(xin + s);
|
||||
int j = floor(yin + s);
|
||||
int k = floor(zin + s);
|
||||
double t = (i + j + k) * G3;
|
||||
double dx0 = i - t; // Unskew the cell origin back to (x,y,z) space
|
||||
double dy0 = j - t;
|
||||
double dz0 = k - t;
|
||||
|
||||
// For the 3D case, the simplex shape is a slightly irregular tetrahedron.
|
||||
|
||||
int i1; // Offsets for second corner of simplex in (i,j,k) coords
|
||||
int j1;
|
||||
int k1;
|
||||
int i2; // Offsets for third corner of simplex in (i,j,k) coords
|
||||
int j2;
|
||||
int k2;
|
||||
|
||||
double x0 = xin - dx0; // The x,y,z distances from the cell origin
|
||||
double y0 = yin - dy0;
|
||||
double z0 = zin - dz0;
|
||||
// Determine which simplex we are in
|
||||
if(x0 >= y0)
|
||||
{
|
||||
if(y0 >= z0)
|
||||
{
|
||||
i1 = 1; // X Y Z order
|
||||
j1 = 0;
|
||||
k1 = 0;
|
||||
i2 = 1;
|
||||
j2 = 1;
|
||||
k2 = 0;
|
||||
}
|
||||
else if(x0 >= z0)
|
||||
{
|
||||
i1 = 1; // X Z Y order
|
||||
j1 = 0;
|
||||
k1 = 0;
|
||||
i2 = 1;
|
||||
j2 = 0;
|
||||
k2 = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
i1 = 0; // Z X Y order
|
||||
j1 = 0;
|
||||
k1 = 1;
|
||||
i2 = 1;
|
||||
j2 = 0;
|
||||
k2 = 1;
|
||||
}
|
||||
}
|
||||
else
|
||||
{ // x0<y0
|
||||
if(y0 < z0)
|
||||
{
|
||||
i1 = 0; // Z Y X order
|
||||
j1 = 0;
|
||||
k1 = 1;
|
||||
i2 = 0;
|
||||
j2 = 1;
|
||||
k2 = 1;
|
||||
}
|
||||
else if(x0 < z0)
|
||||
{
|
||||
i1 = 0; // Y Z X order
|
||||
j1 = 1;
|
||||
k1 = 0;
|
||||
i2 = 0;
|
||||
j2 = 1;
|
||||
k2 = 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
i1 = 0; // Y X Z order
|
||||
j1 = 1;
|
||||
k1 = 0;
|
||||
i2 = 1;
|
||||
j2 = 1;
|
||||
k2 = 0;
|
||||
}
|
||||
}
|
||||
|
||||
// A step of (1,0,0) in (i,j,k) means a step of (1-c,-c,-c) in (x,y,z),
|
||||
// a step of (0,1,0) in (i,j,k) means a step of (-c,1-c,-c) in (x,y,z), and
|
||||
// a step of (0,0,1) in (i,j,k) means a step of (-c,-c,1-c) in (x,y,z), where
|
||||
// c = 1/6.
|
||||
double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
|
||||
double y1 = y0 - j1 + G3;
|
||||
double z1 = z0 - k1 + G3;
|
||||
double x2 = x0 - i2 + G32; // Offsets for third corner in (x,y,z) coords
|
||||
double y2 = y0 - j2 + G32;
|
||||
double z2 = z0 - k2 + G32;
|
||||
|
||||
// Work out the hashed gradient indices of the four simplex corners
|
||||
int ii = i & 255;
|
||||
int jj = j & 255;
|
||||
int kk = k & 255;
|
||||
int gi0 = permMod12[ii + perm[jj + perm[kk]]];
|
||||
int gi1 = permMod12[ii + i1 + perm[jj + j1 + perm[kk + k1]]];
|
||||
int gi2 = permMod12[ii + i2 + perm[jj + j2 + perm[kk + k2]]];
|
||||
int gi3 = permMod12[ii + 1 + perm[jj + 1 + perm[kk + 1]]];
|
||||
|
||||
// Calculate the contribution from the four corners
|
||||
double t0 = 0.5 - x0 * x0 - y0 * y0 - z0 * z0;
|
||||
double n0; // Noise contributions from the four corners
|
||||
if(t0 < 0)
|
||||
{
|
||||
n0 = 0.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t0 *= t0;
|
||||
n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
|
||||
}
|
||||
|
||||
double t1 = 0.5 - x1 * x1 - y1 * y1 - z1 * z1;
|
||||
double n1;
|
||||
if(t1 < 0)
|
||||
{
|
||||
n1 = 0.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t1 *= t1;
|
||||
n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
|
||||
}
|
||||
|
||||
double t2 = 0.5 - x2 * x2 - y2 * y2 - z2 * z2;
|
||||
double n2;
|
||||
if(t2 < 0)
|
||||
{
|
||||
n2 = 0.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t2 *= t2;
|
||||
n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
|
||||
}
|
||||
|
||||
double x3 = x0 + G33; // Offsets for last corner in (x,y,z) coords
|
||||
double y3 = y0 + G33;
|
||||
double z3 = z0 + G33;
|
||||
double t3 = 0.5 - x3 * x3 - y3 * y3 - z3 * z3;
|
||||
double n3;
|
||||
if(t3 < 0)
|
||||
{
|
||||
n3 = 0.0;
|
||||
}
|
||||
else
|
||||
{
|
||||
t3 *= t3;
|
||||
n3 = t3 * t3 * dot(grad3[gi3], x3, y3, z3);
|
||||
}
|
||||
|
||||
// Add contributions from each corner to get the final noise value.
|
||||
// The result is scaled to stay just inside [-1,1]
|
||||
return 32.0 * (n0 + n1 + n2 + n3);
|
||||
}
|
||||
|
||||
// Inner class to speed up gradient computations
|
||||
// (array access is a lot slower than member access)
|
||||
private static class Grad
|
||||
{
|
||||
public double x;
|
||||
public double y;
|
||||
public double z;
|
||||
|
||||
Grad(double x, double y, double z)
|
||||
{
|
||||
this.x = x;
|
||||
this.y = y;
|
||||
this.z = z;
|
||||
}
|
||||
}
|
||||
}
|
||||
@ -8,6 +8,7 @@ public class SimplexNoise implements NoiseGenerator, OctaveNoise {
|
||||
|
||||
public SimplexNoise(long seed) {
|
||||
this.n = new FastNoise(new RNG(seed).imax());
|
||||
n.SetNoiseType(FastNoise.NoiseType.Simplex);
|
||||
octaves = 1;
|
||||
}
|
||||
|
||||
|
||||
@ -1,17 +0,0 @@
|
||||
package com.volmit.iris.noise;
|
||||
|
||||
public class Test {
|
||||
|
||||
public static void main(String[] args) {
|
||||
NoiseGenerator t = null;
|
||||
|
||||
for (NoiseType i : NoiseType.values()) {
|
||||
System.out.println("Test: " + i.name());
|
||||
t = i.create(0);
|
||||
for (int j = 0; j < 100; j++) {
|
||||
System.out.println(t.noise(j * 1));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
}
|
||||
@ -42,6 +42,26 @@ public enum NoiseStyle {
|
||||
@DontObfuscate
|
||||
SIMPLEX(rng -> new CNG(rng, 1D, 1).scale(1)),
|
||||
|
||||
@Desc("Perlin. Like simplex but more natural")
|
||||
@DontObfuscate
|
||||
PERLIN(rng -> new CNG(rng, NoiseType.PERLIN, 1D, 1).scale(1.47)),
|
||||
|
||||
@Desc("Perlin. Like simplex but more natural")
|
||||
@DontObfuscate
|
||||
PERLIN_IRIS(rng -> CNG.signature(rng, NoiseType.PERLIN).scale(1.47)),
|
||||
|
||||
@Desc("Perlin. Like simplex but more natural")
|
||||
@DontObfuscate
|
||||
PERLIN_IRIS_HALF(rng -> CNG.signatureHalf(rng, NoiseType.PERLIN).scale(1.47)),
|
||||
|
||||
@Desc("Perlin. Like simplex but more natural")
|
||||
@DontObfuscate
|
||||
PERLIN_IRIS_DOUBLE(rng -> CNG.signatureDouble(rng, NoiseType.PERLIN).scale(1.47)),
|
||||
|
||||
@Desc("Perlin. Like simplex but more natural")
|
||||
@DontObfuscate
|
||||
PERLIN_IRIS_THICK(rng -> CNG.signatureThick(rng, NoiseType.PERLIN).scale(1.47)),
|
||||
|
||||
@Desc("Billow Fractal Simplex Noise. Single octave.")
|
||||
@DontObfuscate
|
||||
FRACTAL_BILLOW_SIMPLEX(rng -> new CNG(rng, NoiseType.FRACTAL_BILLOW_SIMPLEX, 1D, 1)),
|
||||
@ -244,23 +264,55 @@ public enum NoiseStyle {
|
||||
|
||||
@Desc("Cubic Noise")
|
||||
@DontObfuscate
|
||||
LAVALAMP(rng -> new CNG(rng, NoiseType.CUBIC, 1D, 1).scale(256)),
|
||||
CUBIC(rng -> new CNG(rng, NoiseType.CUBIC, 1D, 1).scale(256)),
|
||||
|
||||
@Desc("Fractal Cubic Noise")
|
||||
@DontObfuscate
|
||||
FRACTAL_CUBIC(rng -> new CNG(rng, NoiseType.FRACTAL_CUBIC, 1D, 1).scale(2)),
|
||||
|
||||
@Desc("Fractal Cubic Noise With Iris Swirls")
|
||||
@DontObfuscate
|
||||
FRACTAL_CUBIC_IRIS(rng -> CNG.signature(rng, NoiseType.FRACTAL_CUBIC).scale(2)),
|
||||
|
||||
@Desc("Fractal Cubic Noise With Iris Swirls")
|
||||
@DontObfuscate
|
||||
FRACTAL_CUBIC_IRIS_THICK(rng -> CNG.signatureThick(rng, NoiseType.FRACTAL_CUBIC).scale(2)),
|
||||
|
||||
@Desc("Fractal Cubic Noise With Iris Swirls")
|
||||
@DontObfuscate
|
||||
FRACTAL_CUBIC_IRIS_HALF(rng -> CNG.signatureHalf(rng, NoiseType.FRACTAL_CUBIC).scale(2)),
|
||||
|
||||
@Desc("Fractal Cubic Noise With Iris Swirls")
|
||||
@DontObfuscate
|
||||
FRACTAL_CUBIC_IRIS_DOUBLE(rng -> CNG.signatureDouble(rng, NoiseType.FRACTAL_CUBIC).scale(2)),
|
||||
|
||||
@Desc("Fractal Cubic Noise, 2 Octaves")
|
||||
@DontObfuscate
|
||||
BIOCTAVE_FRACTAL_CUBIC(rng -> new CNG(rng, NoiseType.FRACTAL_CUBIC, 1D, 2).scale(2)),
|
||||
|
||||
@Desc("Fractal Cubic Noise, 3 Octaves")
|
||||
@DontObfuscate
|
||||
TRIOCTAVE_FRACTAL_CUBIC(rng -> new CNG(rng, NoiseType.FRACTAL_CUBIC, 1D, 3).scale(1.5)),
|
||||
|
||||
@Desc("Fractal Cubic Noise, 4 Octaves")
|
||||
@DontObfuscate
|
||||
QUADOCTAVE_FRACTAL_CUBIC(rng -> new CNG(rng, NoiseType.FRACTAL_CUBIC, 1D, 4).scale(1)),
|
||||
|
||||
@Desc("Cubic Noise")
|
||||
@DontObfuscate
|
||||
LAVALAMP_IRIS(rng -> CNG.signature(rng, NoiseType.CUBIC).scale(256)),
|
||||
CUBIC_IRIS(rng -> CNG.signature(rng, NoiseType.CUBIC).scale(256)),
|
||||
|
||||
@Desc("Cubic Noise")
|
||||
@DontObfuscate
|
||||
LAVALAMP_IRIS_HALF(rng -> CNG.signatureHalf(rng, NoiseType.CUBIC).scale(256)),
|
||||
CUBIC_IRIS_HALF(rng -> CNG.signatureHalf(rng, NoiseType.CUBIC).scale(256)),
|
||||
|
||||
@Desc("Cubic Noise")
|
||||
@DontObfuscate
|
||||
LAVALAMP_IRIS_DOUBLE(rng -> CNG.signatureDouble(rng, NoiseType.CUBIC).scale(256)),
|
||||
CUBIC_IRIS_DOUBLE(rng -> CNG.signatureDouble(rng, NoiseType.CUBIC).scale(256)),
|
||||
|
||||
@Desc("Cubic Noise")
|
||||
@DontObfuscate
|
||||
LAVALAMP_IRIS_THICK(rng -> CNG.signatureThick(rng, NoiseType.CUBIC).scale(256)),
|
||||
CUBIC_IRIS_THICK(rng -> CNG.signatureThick(rng, NoiseType.CUBIC).scale(256)),
|
||||
|
||||
@Desc("Cellular noise creates the same noise level for cells, changes noise level on cell borders.")
|
||||
@DontObfuscate
|
||||
|
||||
Loading…
x
Reference in New Issue
Block a user