133 lines
3.6 KiB
C++
133 lines
3.6 KiB
C++
/*
|
|
* SimplexNoise.cpp
|
|
*
|
|
* Created on: 14.06.2013
|
|
* Author: Felix
|
|
*/
|
|
|
|
#include "SimplexNoise.h"
|
|
|
|
#include <algorithm>
|
|
#include <time.h>
|
|
|
|
/**
|
|
* Initializes permutation with random values.
|
|
*/
|
|
SimplexNoise::SimplexNoise() {
|
|
std::mt19937 mersenne(time(nullptr));
|
|
std::uniform_int_distribution<int> distribution(0, 255);
|
|
|
|
for (int i = 0; i < 512; i++)
|
|
mPerm[i] = distribution(mersenne);
|
|
}
|
|
|
|
/**
|
|
* Returns a noise value from cache, or generates if it was requested for
|
|
* the first time.
|
|
*
|
|
* @return Value within [-1, 1]
|
|
*/
|
|
float
|
|
SimplexNoise::getNoise(int x, int y) {
|
|
if (mCache.count(x) == 0 ||
|
|
mCache.at(x).count(y) == 0)
|
|
mCache[x][y] = noise(x, y);
|
|
return mCache.at(x).at(y);
|
|
}
|
|
|
|
float
|
|
SimplexNoise::getNoise(const Vector2i& v) {
|
|
return getNoise(v.x, v.y);
|
|
}
|
|
|
|
/**
|
|
* Floor implementation that is faster than std implementation by
|
|
* ignoring some checks and does not consider some border conditions.
|
|
*/
|
|
int
|
|
SimplexNoise::fastFloor(float f) const {
|
|
return (f>0)
|
|
? f
|
|
: ((int) f) - 1;
|
|
}
|
|
|
|
/**
|
|
* Helper function for noise generation.
|
|
*/
|
|
float
|
|
SimplexNoise::grad(int hash, float x, float y) const {
|
|
int h = hash & 7; // Convert low 3 bits of hash code
|
|
float u = h<4 ? x : y; // into 8 simple gradient directions,
|
|
float v = h<4 ? y : x; // and compute the dot product with (x,y).
|
|
return ((h&1)? -u : u) + ((h&2)? -2.0f*v : 2.0f*v);
|
|
}
|
|
|
|
/**
|
|
* Generates actual noise.
|
|
*/
|
|
float
|
|
SimplexNoise::noise(float x, float y) const {
|
|
|
|
#define F2 0.366025403 // F2 = 0.5*(sqrt(3.0)-1.0)
|
|
#define G2 0.211324865 // G2 = (3.0-Math.sqrt(3.0))/6.0
|
|
|
|
float n0, n1, n2; // Noise contributions from the three corners
|
|
|
|
// Skew the input space to determine which simplex cell we're in
|
|
float s = (x+y)*F2; // Hairy factor for 2D
|
|
float xs = x + s;
|
|
float ys = y + s;
|
|
int i = fastFloor(xs);
|
|
int j = fastFloor(ys);
|
|
|
|
float t = (float)(i+j)*G2;
|
|
float X0 = i-t; // Unskew the cell origin back to (x,y) space
|
|
float Y0 = j-t;
|
|
float x0 = x-X0; // The x,y distances from the cell origin
|
|
float y0 = y-Y0;
|
|
|
|
// For the 2D case, the simplex shape is an equilateral triangle.
|
|
// Determine which simplex we are in.
|
|
int i1, j1; // Offsets for second (middle) corner of simplex in (i,j) coords
|
|
if(x0>y0) {i1=1; j1=0;} // lower triangle, XY order: (0,0)->(1,0)->(1,1)
|
|
else {i1=0; j1=1;} // upper triangle, YX order: (0,0)->(0,1)->(1,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
|
|
|
|
float x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
|
|
float y1 = y0 - j1 + G2;
|
|
float x2 = x0 - 1.0f + 2.0f * G2; // Offsets for last corner in (x,y) unskewed coords
|
|
float y2 = y0 - 1.0f + 2.0f * G2;
|
|
|
|
// Wrap the integer indices at 256, to avoid indexing perm[] out of bounds
|
|
int ii = i & 0xff;
|
|
int jj = j & 0xff;
|
|
|
|
// Calculate the contribution from the three corners
|
|
float t0 = 0.5f - x0*x0-y0*y0;
|
|
if(t0 < 0.0f) n0 = 0.0f;
|
|
else {
|
|
t0 *= t0;
|
|
n0 = t0 * t0 * grad(mPerm[ii+mPerm[jj]], x0, y0);
|
|
}
|
|
|
|
float t1 = 0.5f - x1*x1-y1*y1;
|
|
if(t1 < 0.0f) n1 = 0.0f;
|
|
else {
|
|
t1 *= t1;
|
|
n1 = t1 * t1 * grad(mPerm[ii+i1+mPerm[jj+j1]], x1, y1);
|
|
}
|
|
|
|
float t2 = 0.5f - x2*x2-y2*y2;
|
|
if(t2 < 0.0f) n2 = 0.0f;
|
|
else {
|
|
t2 *= t2;
|
|
n2 = t2 * t2 * grad(mPerm[ii+1+mPerm[jj+1]], 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 40.0f * (n0 + n1 + n2);
|
|
}
|