Class SimplexIslands

Source/Utils/SimplexIslands.hpp:42–283

};

class SimplexIslands {  // Simplex noise in 2D, 3D and 4D
		// Inner class to speed upp gradient computations
	// (In Java, array access is a lot slower than member access)
public:
	std::vector<Grad> grad3;
	std::vector<Grad> grad4;

	static short pbak[];
	static short p[];

	// To remove the need for index wrapping, double the permutation table length
	short perm[512];
	short permMod12[512];
	
	double F2;
	double G2;
	double F3;
	double G3;
	double F4;
	double G4;

	SimplexIslands();

	// This method is a *lot* faster than using (int)Math.floor(x)
	static inline int32_t fastfloor(double fp) {
		int32_t i = static_cast<int32_t>(fp);
		return (fp < i) ? (i - 1) : (i);
	}

	double dot(Grad g, double x, double y) {
		return g.x*x + g.y*y;
	}

	// 2D simplex noise
	double noise(double xin, double yin) {
		double n0, n1, n2; // Noise contributions from the three corners
		// Skew the input space to determine which simplex cell we're in
		double s = (xin + yin)*F2; // Hairy factor for 2D
		int i = fastfloor(xin + s);
		int j = fastfloor(yin + s);
		double t = (i + j)*G2;
		double X0 = i - t; // Unskew the cell origin back to (x,y) space
		double Y0 = j - t;
		double x0 = xin - X0; // The x,y distances from the cell origin
		double y0 = yin - 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
		double x1 = x0 - i1 + G2; // Offsets for middle corner in (x,y) unskewed coords
		double y1 = y0 - j1 + G2;
		double x2 = x0 - 1.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
		double y2 = y0 - 1.0 + 2.0 * G2;
		// Work out the hashed gradient indices of the three simplex corners