dungeon-gunner/src/generator/SimplexNoise.cpp

/*
 * 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);
  }