nutomic/dungeon-gunner
Archived
1
0
Fork 0
Code Issues Pull requests Releases Wiki Activity

Added own SimplexNoise class, cache noise values.

Browse source
This commit is contained in:
Felix Ableitner 2013-06-15 17:49:01 +02:00
parent 11f3800332
commit 94814e0172
6 changed files with 228 additions and 706 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

100
source/generator/Generator.cpp
View file

@ -16,7 +16,6 @@
#include <Thor/Vectors.hpp> #include <Thor/Vectors.hpp>
#include "simplexnoise.h"
#include "../Pathfinder.h" #include "../Pathfinder.h"
#include "../World.h" #include "../World.h"
#include "../util/Log.h" #include "../util/Log.h"
@ -43,11 +42,6 @@ const float Generator::LAYER_ENEMIES = 1.0f;
Generator::Generator(World& world, Pathfinder& pathfinder) : Generator::Generator(World& world, Pathfinder& pathfinder) :
mWorld(world), mWorld(world),
mPathfinder(pathfinder) { mPathfinder(pathfinder) {
std::mt19937 mersenne(time(nullptr));
std::uniform_int_distribution<int> distribution(0, 255);
for (int i = 0; i < 512; i++)
perm[i] = distribution(mersenne);
} }
/** /**
@ -113,49 +107,39 @@ Generator::generateTiles(const sf::IntRect& area) {
assert(area.width && !(area.width & (area.width - 1))); assert(area.width && !(area.width & (area.width - 1)));
assert(area.height && !(area.height & (area.height - 1))); assert(area.height && !(area.height & (area.height - 1)));
array noise; array generatedTiles;
array filtered; fill(generatedTiles, area, type::FLOOR);
for (int x = area.left - MARGIN; x < area.left + area.width + MARGIN; x++) {
for (int y = area.top - MARGIN; y < area.top + area.height + MARGIN; y++) {
noise[x][y] =
(scaled_octave_noise_3d(2, 2, 0.05f, 0.5f, -0.5f, x, y, LAYER_TILES) +
scaled_octave_noise_3d(2, 2, 0.5f, 0.15f, -0.15f, x, y, LAYER_TILES)
< -0.1f)
? type::WALL
: type::FLOOR;
}
}
fill(filtered, area, type::FLOOR);
for (int x = area.left; x < area.left + area.width; x++) { for (int x = area.left; x < area.left + area.width; x++) {
for (int y = area.top; y < area.top + area.height; y++) { for (int y = area.top; y < area.top + area.height; y++) {
filterWalls(noise, filtered, x, y, 2, 1, 0); filterWalls(generatedTiles, x, y, 2, 1, 0);
filterWalls(noise, filtered, x, y, 6, 1, 2); filterWalls(generatedTiles, x, y, 6, 1, 2);
filterWalls(noise, filtered, x, y, 10, 1, 4); filterWalls(generatedTiles, x, y, 10, 1, 4);
} }
} }
for (int x = area.left; x < area.left + area.width; x++) { for (int x = area.left; x < area.left + area.width; x++)
for (int y = area.top; y < area.top + area.height; y++) { for (int y = area.top; y < area.top + area.height; y++) {
// Merge map that we just generated with stored map.
mTiles[x][y] = generatedTiles[x][y];
// Actually generate physical tiles.
mWorld.insert(std::shared_ptr<Sprite>( mWorld.insert(std::shared_ptr<Sprite>(
new Tile(filtered.at(x).at(y), x, y))); new Tile(generatedTiles.at(x).at(y), x, y)));
} }
}
generateAreas(filtered, area, sf::Vector2f(area.left, area.top)); generateAreas(area, sf::Vector2f(area.left, area.top));
mPathfinder.generatePortals(); mPathfinder.generatePortals();
mTiles = filtered;
} }
std::vector<sf::Vector2f> std::vector<sf::Vector2f>
Generator::getEnemySpawns(const sf::IntRect& area) const { Generator::getEnemySpawns(const sf::IntRect& area) {
auto compare = [](const sf::Vector2f& a, const sf::Vector2f& b) { auto compare = [](const sf::Vector2f& a, const sf::Vector2f& b) {
return a.x < b.x || (a.x == b.x && a.y < b.y); return a.x < b.x || (a.x == b.x && a.y < b.y);
}; };
std::set<sf::Vector2f, decltype(compare)> ret(compare); std::set<sf::Vector2f, decltype(compare)> ret(compare);
for (int x = area.left; x < area.left + area.width; x++) { for (int x = area.left; x < area.left + area.width; x++) {
for (int y = area.top; y < area.top + area.height; y++) { for (int y = area.top; y < area.top + area.height; y++) {
if (scaled_octave_noise_3d(2, 2, 0.5f, 10.0f, 0, x, y, LAYER_ENEMIES) if (mCharacterNoise.getNoise(x, y) < 0.05f) {
< 1.0f) {
ret.insert(sf::Vector2f(thor::cwiseProduct( ret.insert(sf::Vector2f(thor::cwiseProduct(
findClosestFloor(sf::Vector2i(x, y)), Tile::TILE_SIZE))); findClosestFloor(sf::Vector2i(x, y)), Tile::TILE_SIZE)));
} }
@ -172,35 +156,34 @@ Generator::getEnemySpawns(const sf::IntRect& area) const {
* @param value The value to set. * @param value The value to set.
*/ */
void void
Generator::fill(array& image, const sf::IntRect& area, Tile::Type value) { Generator::fill(array& tiles, const sf::IntRect& area, Tile::Type value) {
for (int x = area.left; x < area.left + area.width; x++) { for (int x = area.left; x < area.left + area.width; x++) {
for (int y = area.top; y < area.top + area.height; y++) for (int y = area.top; y < area.top + area.height; y++)
image[x][y] = value; tiles[x][y] = value;
} }
} }
/** /**
* Counts and returns the number of walls within the area. * Counts and returns the number of walls within the area.
* *
* @param[in] tiles Array of tile values.
* @param area The area to count in. * @param area The area to count in.
*/ */
int int
Generator::countWalls(const array& tiles, const sf::IntRect& area) { Generator::countWalls(const sf::IntRect& area) {
int count = 0; int count = 0;
for (int x = area.left; x < area.left + area.width; x++) { for (int x = area.left; x < area.left + area.width; x++) {
for (int y = area.top; y < area.top + area.height; y++) for (int y = area.top; y < area.top + area.height; y++)
count += (int) (tiles.at(x).at(y) == type::WALL); count += (int) (getTileType(mCharacterNoise.getNoise(x, y)) ==
type::WALL);
} }
return count; return count;
} }
/** /**
* Finds rectangles of specific size inside vector in and * Finds rectangles of specific size with mTileNoise and
* puts them into vector out. * puts them into vector out.
* *
* @param[in] in Perlin noise values. * @param[in,out] tiles Tiles to be placed. Does not explicitly set floor values
* @param[in,out] out Tiles to be placed. Does not explicitly set floor values
* (keeps previous values). * (keeps previous values).
* @param x Position to check from (top left corner for rectangle). * @param x Position to check from (top left corner for rectangle).
* @param y Position to check from (top left corner for rectangle). * @param y Position to check from (top left corner for rectangle).
@ -210,31 +193,30 @@ Generator::countWalls(const array& tiles, const sf::IntRect& area) {
* tiles is not walls (tilecount >= longside * shortside - subtract). * tiles is not walls (tilecount >= longside * shortside - subtract).
*/ */
void void
Generator::filterWalls(const array& in, array& out, int x, int y, int longside, Generator::filterWalls(array& tiles, int x, int y, int longside,
int shortside, int subtract) { int shortside, int subtract) {
// Filter in horizontal direction. // Filter in horizontal direction.
if (countWalls(in, sf::IntRect(x, y, longside, shortside)) >= if (countWalls(sf::IntRect(x, y, longside, shortside)) >=
shortside * longside - subtract) shortside * longside - subtract)
fill(out, sf::IntRect(x, y, longside, shortside), type::WALL); fill(tiles, sf::IntRect(x, y, longside, shortside), type::WALL);
// Filter in vertical direction. // Filter in vertical direction.
if (countWalls(in, sf::IntRect(x, y, shortside, longside)) >= if (countWalls(sf::IntRect(x, y, shortside, longside)) >=
shortside * longside - subtract) shortside * longside - subtract)
fill(out, sf::IntRect(x, y, shortside, longside), type::WALL); fill(tiles, sf::IntRect(x, y, shortside, longside), type::WALL);
} }
/** /**
* Inserts tile if all values within area are the same, otherwise divides area * Inserts floor tiles into path finder, using a quadtree approach to group
* into four and continues recursively. * tiles where possible.
* *
* @param in Array of tile values.
* @param area The area to generate areas for. * @param area The area to generate areas for.
* @param offset Offset of tiles[0][0] from World coordinate (0, 0). * @param offset Offset of tiles[0][0] from World coordinate (0, 0).
*/ */
void void
Generator::generateAreas(const array& in, const sf::IntRect& area, Generator::generateAreas(const sf::IntRect& area,
const sf::Vector2f& offset) const { const sf::Vector2f& offset) {
assert(area.width > 0 && area.height > 0); assert(area.width > 0 && area.height > 0);
int count = countWalls(in, area); int count = countWalls(area);
if (count == 0) { if (count == 0) {
mPathfinder.insertArea(sf::IntRect(area)); mPathfinder.insertArea(sf::IntRect(area));
} }
@ -244,17 +226,29 @@ Generator::generateAreas(const array& in, const sf::IntRect& area,
else { else {
int halfWidth = area.width / 2.0f; int halfWidth = area.width / 2.0f;
int halfHeight = area.height / 2.0f; int halfHeight = area.height / 2.0f;
generateAreas(in, sf::IntRect(area.left, generateAreas(sf::IntRect(area.left,
area.top, halfWidth, halfHeight), offset); area.top, halfWidth, halfHeight), offset);
generateAreas(in, sf::IntRect(area.left + halfWidth, generateAreas(sf::IntRect(area.left + halfWidth,
area.top, halfWidth, halfHeight), offset); area.top, halfWidth, halfHeight), offset);
generateAreas(in, sf::IntRect(area.left, generateAreas(sf::IntRect(area.left,
area.top + halfHeight, halfWidth, halfHeight), offset); area.top + halfHeight, halfWidth, halfHeight), offset);
generateAreas(in, sf::IntRect(area.left + halfWidth, generateAreas(sf::IntRect(area.left + halfWidth,
area.top + halfHeight, halfWidth, halfHeight), offset); area.top + halfHeight, halfWidth, halfHeight), offset);
} }
} }
/**
* Defines if a perlin noise result value is converted to a wall or floor tile.
*
* @param value Perlin noise value within [-1, 1]
*/
Generator::type
Generator::getTileType(float value) {
return (value < -0.2f)
? type::WALL
: type::FLOOR;
}
/** /**
* Returns a valid position (floor) for the player to spawn at. * Returns a valid position (floor) for the player to spawn at.
*/ */

23
source/generator/Generator.h
View file

@ -11,30 +11,35 @@
#include <SFML/Graphics.hpp> #include <SFML/Graphics.hpp>
#include "../sprites/Tile.h" #include "../sprites/Tile.h"
#include "SimplexNoise.h"
class World; class World;
class Pathfinder; class Pathfinder;
/**
* Procedurally generates tiles, chooses player and enemy spawn positions.
*/
class Generator { class Generator {
public: public:
explicit Generator(World& world, Pathfinder& pathfinder); explicit Generator(World& world, Pathfinder& pathfinder);
void generateCurrentAreaIfNeeded(const sf::Vector2f& position); void generateCurrentAreaIfNeeded(const sf::Vector2f& position);
sf::Vector2f getPlayerSpawn() const; sf::Vector2f getPlayerSpawn() const;
std::vector<sf::Vector2f> getEnemySpawns(const sf::IntRect& area) const; std::vector<sf::Vector2f> getEnemySpawns(const sf::IntRect& area);
private: private:
typedef Tile::Type type; typedef Tile::Type type;
typedef std::map<int, std::map<int, type> > array; typedef std::map<int, std::map<int, type> > array;
private: private:
void generateAreas(const sf::IntRect& area, const sf::Vector2f& offset);
void generateTiles(const sf::IntRect& area); void generateTiles(const sf::IntRect& area);
sf::Vector2i findClosestFloor(const sf::Vector2i& position) const; sf::Vector2i findClosestFloor(const sf::Vector2i& position) const;
static void fill(array& in, const sf::IntRect& area, type value);
static void filterWalls(const array& in, array& out, int x, int y, static void fill(array& tiles, const sf::IntRect& area, type value);
int longside, int shortside, int subtract); void filterWalls(array& tiles, int x, int y, int longside,
static int countWalls(const array& in, const sf::IntRect& area); int shortside, int subtract);
void generateAreas(const array& in, const sf::IntRect& area, int countWalls(const sf::IntRect& area);
const sf::Vector2f& offset) const; static type getTileType(float value);
private: private:
static const int GENERATE_AREA_SIZE; static const int GENERATE_AREA_SIZE;
@ -49,6 +54,10 @@ private:
array mTiles; array mTiles;
/// Stores where tiles have already been generated. /// Stores where tiles have already been generated.
std::map<int, std::map<int, bool> > mGenerated; std::map<int, std::map<int, bool> > mGenerated;
/// Perlin noise used for tile generation.
SimplexNoise mTileNoise;
/// Perlin noise used for character placement.
SimplexNoise mCharacterNoise;
}; };
#endif /* DG_GENERATOR_H_ */ #endif /* DG_GENERATOR_H_ */

128
source/generator/SimplexNoise.cpp Normal file
View file

@ -0,0 +1,128 @@
/*
* 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);
}
/**
* 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);
}

37
source/generator/SimplexNoise.h Normal file
View file

@ -0,0 +1,37 @@
/*
* SimplexNoise.h
*
* Created on: 14.06.2013
* Author: Felix
*/
#ifndef DG_SIMPLEXNOISE_H_
#define DG_SIMPLEXNOISE_H_
#include <array>
#include <map>
/**
* Caching simplex noise generator.
*
* The actual simplex noise generator is simplexnoise1234.h/cpp
* from http://staffwww.itn.liu.se/~stegu/aqsis/aqsis-newnoise/ . See
* that implementation for more details.
*/
class SimplexNoise {
public:
SimplexNoise();
float getNoise(int x, int y);
private:
float noise(float x, float y) const;
float grad(int hash, float x, float y) const;
int fastFloor(float f) const;
private:
std::array<unsigned char, 512> mPerm;
std::map<int, std::map<int, float> > mCache;
};
#endif /* DG_SIMPLEXNOISE_H_ */

475
source/generator/simplexnoise.cpp
View file

@ -1,475 +0,0 @@
/* Copyright (c) 2007-2012 Eliot Eshelman
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#include <math.h>
#include "simplexnoise.h"
/* 2D, 3D and 4D Simplex Noise functions return 'random' values in (-1, 1).
This algorithm was originally designed by Ken Perlin, but my code has been
adapted from the implementation written by Stefan Gustavson (stegu@itn.liu.se)
Raw Simplex noise functions return the value generated by Ken's algorithm.
Scaled Raw Simplex noise functions adjust the range of values returned from the
traditional (-1, 1) to whichever bounds are passed to the function.
Multi-Octave Simplex noise functions compine multiple noise values to create a
more complex result. Each successive layer of noise is adjusted and scaled.
Scaled Multi-Octave Simplex noise functions scale the values returned from the
traditional (-1,1) range to whichever range is passed to the function.
In many cases, you may think you only need a 1D noise function, but in practice
2D is almost always better. For instance, if you're using the current frame
number as the parameter for the noise, all objects will end up with the same
noise value at each frame. By adding a second parameter on the second
dimension, you can ensure that each gets a unique noise value and they don't
all look identical.
*/
// 2D Multi-octave Simplex noise.
//
// For each octave, a higher frequency/lower amplitude function will be added to the original.
// The higher the persistence [0-1], the more of each succeeding octave will be added.
float octave_noise_2d( const float octaves, const float persistence, const float scale, const float x, const float y ) {
float total = 0;
float frequency = scale;
float amplitude = 1;
// We have to keep track of the largest possible amplitude,
// because each octave adds more, and we need a value in [-1, 1].
float maxAmplitude = 0;
for( int i=0; i < octaves; i++ ) {
total += raw_noise_2d( x * frequency, y * frequency ) * amplitude;
frequency *= 2;
maxAmplitude += amplitude;
amplitude *= persistence;
}
return total / maxAmplitude;
}
// 3D Multi-octave Simplex noise.
//
// For each octave, a higher frequency/lower amplitude function will be added to the original.
// The higher the persistence [0-1], the more of each succeeding octave will be added.
float octave_noise_3d( const float octaves, const float persistence, const float scale, const float x, const float y, const float z ) {
float total = 0;
float frequency = scale;
float amplitude = 1;
// We have to keep track of the largest possible amplitude,
// because each octave adds more, and we need a value in [-1, 1].
float maxAmplitude = 0;
for( int i=0; i < octaves; i++ ) {
total += raw_noise_3d( x * frequency, y * frequency, z * frequency ) * amplitude;
frequency *= 2;
maxAmplitude += amplitude;
amplitude *= persistence;
}
return total / maxAmplitude;
}
// 4D Multi-octave Simplex noise.
//
// For each octave, a higher frequency/lower amplitude function will be added to the original.
// The higher the persistence [0-1], the more of each succeeding octave will be added.
float octave_noise_4d( const float octaves, const float persistence, const float scale, const float x, const float y, const float z, const float w ) {
float total = 0;
float frequency = scale;
float amplitude = 1;
// We have to keep track of the largest possible amplitude,
// because each octave adds more, and we need a value in [-1, 1].
float maxAmplitude = 0;
for( int i=0; i < octaves; i++ ) {
total += raw_noise_4d( x * frequency, y * frequency, z * frequency, w * frequency ) * amplitude;
frequency *= 2;
maxAmplitude += amplitude;
amplitude *= persistence;
}
return total / maxAmplitude;
}
// 2D Scaled Multi-octave Simplex noise.
//
// Returned value will be between loBound and hiBound.
float scaled_octave_noise_2d( const float octaves, const float persistence, const float scale, const float loBound, const float hiBound, const float x, const float y ) {
return octave_noise_2d(octaves, persistence, scale, x, y) * (hiBound - loBound) / 2 + (hiBound + loBound) / 2;
}
// 3D Scaled Multi-octave Simplex noise.
//
// Returned value will be between loBound and hiBound.
float scaled_octave_noise_3d( const float octaves, const float persistence, const float scale, const float loBound, const float hiBound, const float x, const float y, const float z ) {
return octave_noise_3d(octaves, persistence, scale, x, y, z) * (hiBound - loBound) / 2 + (hiBound + loBound) / 2;
}
// 4D Scaled Multi-octave Simplex noise.
//
// Returned value will be between loBound and hiBound.
float scaled_octave_noise_4d( const float octaves, const float persistence, const float scale, const float loBound, const float hiBound, const float x, const float y, const float z, const float w ) {
return octave_noise_4d(octaves, persistence, scale, x, y, z, w) * (hiBound - loBound) / 2 + (hiBound + loBound) / 2;
}
// 2D Scaled Simplex raw noise.
//
// Returned value will be between loBound and hiBound.
float scaled_raw_noise_2d( const float loBound, const float hiBound, const float x, const float y ) {
return raw_noise_2d(x, y) * (hiBound - loBound) / 2 + (hiBound + loBound) / 2;
}
// 3D Scaled Simplex raw noise.
//
// Returned value will be between loBound and hiBound.
float scaled_raw_noise_3d( const float loBound, const float hiBound, const float x, const float y, const float z ) {
return raw_noise_3d(x, y, z) * (hiBound - loBound) / 2 + (hiBound + loBound) / 2;
}
// 4D Scaled Simplex raw noise.
//
// Returned value will be between loBound and hiBound.
float scaled_raw_noise_4d( const float loBound, const float hiBound, const float x, const float y, const float z, const float w ) {
return raw_noise_4d(x, y, z, w) * (hiBound - loBound) / 2 + (hiBound + loBound) / 2;
}
// 2D raw Simplex noise
float raw_noise_2d( const float x, const float y ) {
// Noise contributions from the three corners
float n0, n1, n2;
// Skew the input space to determine which simplex cell we're in
float F2 = 0.5 * (sqrtf(3.0) - 1.0);
// Hairy factor for 2D
float s = (x + y) * F2;
int i = fastfloor( x + s );
int j = fastfloor( y + s );
float G2 = (3.0 - sqrtf(3.0)) / 6.0;
float t = (i + j) * G2;
// Unskew the cell origin back to (x,y) space
float X0 = i-t;
float Y0 = j-t;
// The x,y distances from the cell origin
float x0 = x-X0;
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.0 + 2.0 * G2; // Offsets for last corner in (x,y) unskewed coords
float y2 = y0 - 1.0 + 2.0 * G2;
// Work out the hashed gradient indices of the three simplex corners
int ii = i & 255;
int jj = j & 255;
uint8_t gi0 = perm[ii+perm[jj]] % 12;
uint8_t gi1 = perm[ii+i1+perm[jj+j1]] % 12;
uint8_t gi2 = perm[ii+1+perm[jj+1]] % 12;
// Calculate the contribution from the three corners
float t0 = 0.5 - x0*x0-y0*y0;
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
}
float t1 = 0.5 - x1*x1-y1*y1;
if(t1<0) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
}
float t2 = 0.5 - x2*x2-y2*y2;
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);
}
// 3D raw Simplex noise
float raw_noise_3d( const float x, const float y, const float z ) {
float n0, n1, n2, n3; // Noise contributions from the four corners
// Skew the input space to determine which simplex cell we're in
float F3 = 1.0/3.0;
float s = (x+y+z)*F3; // Very nice and simple skew factor for 3D
int i = fastfloor(x+s);
int j = fastfloor(y+s);
int k = fastfloor(z+s);
float G3 = 1.0/6.0; // Very nice and simple unskew factor, too
float t = (i+j+k)*G3;
float X0 = i-t; // Unskew the cell origin back to (x,y,z) space
float Y0 = j-t;
float Z0 = k-t;
float x0 = x-X0; // The x,y,z distances from the cell origin
float y0 = y-Y0;
float z0 = z-Z0;
// For the 3D case, the simplex shape is a slightly irregular tetrahedron.
// Determine which simplex we are in.
int i1, j1, k1; // Offsets for second corner of simplex in (i,j,k) coords
int i2, j2, k2; // Offsets for third corner of simplex in (i,j,k) coords
if(x0>=y0) {
if(y0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=1; k2=0; } // X Y Z order
else if(x0>=z0) { i1=1; j1=0; k1=0; i2=1; j2=0; k2=1; } // X Z Y order
else { i1=0; j1=0; k1=1; i2=1; j2=0; k2=1; } // Z X Y order
}
else { // x0<y0
if(y0<z0) { i1=0; j1=0; k1=1; i2=0; j2=1; k2=1; } // Z Y X order
else if(x0<z0) { i1=0; j1=1; k1=0; i2=0; j2=1; k2=1; } // Y Z X order
else { i1=0; j1=1; k1=0; i2=1; j2=1; k2=0; } // Y X Z order
}
// 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.
float x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
float y1 = y0 - j1 + G3;
float z1 = z0 - k1 + G3;
float x2 = x0 - i2 + 2.0*G3; // Offsets for third corner in (x,y,z) coords
float y2 = y0 - j2 + 2.0*G3;
float z2 = z0 - k2 + 2.0*G3;
float x3 = x0 - 1.0 + 3.0*G3; // Offsets for last corner in (x,y,z) coords
float y3 = y0 - 1.0 + 3.0*G3;
float z3 = z0 - 1.0 + 3.0*G3;
// Work out the hashed gradient indices of the four simplex corners
int ii = i & 255;
int jj = j & 255;
int kk = k & 255;
uint8_t gi0 = perm[ii+perm[jj+perm[kk]]] % 12;
uint8_t gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1]]] % 12;
uint8_t gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2]]] % 12;
uint8_t gi3 = perm[ii+1+perm[jj+1+perm[kk+1]]] % 12;
// Calculate the contribution from the four corners
float t0 = 0.6 - x0*x0 - y0*y0 - z0*z0;
if(t0<0) n0 = 0.0;
else {
t0 *= t0;
n0 = t0 * t0 * dot(grad3[gi0], x0, y0, z0);
}
float t1 = 0.6 - x1*x1 - y1*y1 - z1*z1;
if(t1<0) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * dot(grad3[gi1], x1, y1, z1);
}
float t2 = 0.6 - x2*x2 - y2*y2 - z2*z2;
if(t2<0) n2 = 0.0;
else {
t2 *= t2;
n2 = t2 * t2 * dot(grad3[gi2], x2, y2, z2);
}
float t3 = 0.6 - x3*x3 - y3*y3 - z3*z3;
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);
}
// 4D raw Simplex noise
float raw_noise_4d( const float x, const float y, const float z, const float w ) {
// The skewing and unskewing factors are hairy again for the 4D case
float F4 = (sqrtf(5.0)-1.0)/4.0;
float G4 = (5.0-sqrtf(5.0))/20.0;
float n0, n1, n2, n3, n4; // Noise contributions from the five corners
// Skew the (x,y,z,w) space to determine which cell of 24 simplices we're in
float s = (x + y + z + w) * F4; // Factor for 4D skewing
int i = fastfloor(x + s);
int j = fastfloor(y + s);
int k = fastfloor(z + s);
int l = fastfloor(w + s);
float t = (i + j + k + l) * G4; // Factor for 4D unskewing
float X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
float Y0 = j - t;
float Z0 = k - t;
float W0 = l - t;
float x0 = x - X0; // The x,y,z,w distances from the cell origin
float y0 = y - Y0;
float z0 = z - Z0;
float w0 = w - W0;
// For the 4D case, the simplex is a 4D shape I won't even try to describe.
// To find out which of the 24 possible simplices we're in, we need to
// determine the magnitude ordering of x0, y0, z0 and w0.
// The method below is a good way of finding the ordering of x,y,z,w and
// then find the correct traversal order for the simplex we're in.
// First, six pair-wise comparisons are performed between each possible pair
// of the four coordinates, and the results are used to add up binary bits
// for an integer index.
int c1 = (x0 > y0) ? 32 : 0;
int c2 = (x0 > z0) ? 16 : 0;
int c3 = (y0 > z0) ? 8 : 0;
int c4 = (x0 > w0) ? 4 : 0;
int c5 = (y0 > w0) ? 2 : 0;
int c6 = (z0 > w0) ? 1 : 0;
int c = c1 + c2 + c3 + c4 + c5 + c6;
int i1, j1, k1, l1; // The integer offsets for the second simplex corner
int i2, j2, k2, l2; // The integer offsets for the third simplex corner
int i3, j3, k3, l3; // The integer offsets for the fourth simplex corner
// simplex[c] is a 4-vector with the numbers 0, 1, 2 and 3 in some order.
// Many values of c will never occur, since e.g. x>y>z>w makes x<z, y<w and x<w
// impossible. Only the 24 indices which have non-zero entries make any sense.
// We use a thresholding to set the coordinates in turn from the largest magnitude.
// The number 3 in the "simplex" array is at the position of the largest coordinate.
i1 = simplex[c][0]>=3 ? 1 : 0;
j1 = simplex[c][1]>=3 ? 1 : 0;
k1 = simplex[c][2]>=3 ? 1 : 0;
l1 = simplex[c][3]>=3 ? 1 : 0;
// The number 2 in the "simplex" array is at the second largest coordinate.
i2 = simplex[c][0]>=2 ? 1 : 0;
j2 = simplex[c][1]>=2 ? 1 : 0;
k2 = simplex[c][2]>=2 ? 1 : 0;
l2 = simplex[c][3]>=2 ? 1 : 0;
// The number 1 in the "simplex" array is at the second smallest coordinate.
i3 = simplex[c][0]>=1 ? 1 : 0;
j3 = simplex[c][1]>=1 ? 1 : 0;
k3 = simplex[c][2]>=1 ? 1 : 0;
l3 = simplex[c][3]>=1 ? 1 : 0;
// The fifth corner has all coordinate offsets = 1, so no need to look that up.
float x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
float y1 = y0 - j1 + G4;
float z1 = z0 - k1 + G4;
float w1 = w0 - l1 + G4;
float x2 = x0 - i2 + 2.0*G4; // Offsets for third corner in (x,y,z,w) coords
float y2 = y0 - j2 + 2.0*G4;
float z2 = z0 - k2 + 2.0*G4;
float w2 = w0 - l2 + 2.0*G4;
float x3 = x0 - i3 + 3.0*G4; // Offsets for fourth corner in (x,y,z,w) coords
float y3 = y0 - j3 + 3.0*G4;
float z3 = z0 - k3 + 3.0*G4;
float w3 = w0 - l3 + 3.0*G4;
float x4 = x0 - 1.0 + 4.0*G4; // Offsets for last corner in (x,y,z,w) coords
float y4 = y0 - 1.0 + 4.0*G4;
float z4 = z0 - 1.0 + 4.0*G4;
float w4 = w0 - 1.0 + 4.0*G4;
// Work out the hashed gradient indices of the five simplex corners
int ii = i & 255;
int jj = j & 255;
int kk = k & 255;
int ll = l & 255;
uint8_t gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
uint8_t gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
uint8_t gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
uint8_t gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
uint8_t gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
// Calculate the contribution from the five corners
float t0 = 0.6 - x0*x0 - y0*y0 - z0*z0 - w0*w0;
if(t0<0) n0 = 0.0;
else {
t0 *= t0;
n0 = t0 * t0 * dot(grad4[gi0], x0, y0, z0, w0);
}
float t1 = 0.6 - x1*x1 - y1*y1 - z1*z1 - w1*w1;
if(t1<0) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * dot(grad4[gi1], x1, y1, z1, w1);
}
float t2 = 0.6 - x2*x2 - y2*y2 - z2*z2 - w2*w2;
if(t2<0) n2 = 0.0;
else {
t2 *= t2;
n2 = t2 * t2 * dot(grad4[gi2], x2, y2, z2, w2);
}
float t3 = 0.6 - x3*x3 - y3*y3 - z3*z3 - w3*w3;
if(t3<0) n3 = 0.0;
else {
t3 *= t3;
n3 = t3 * t3 * dot(grad4[gi3], x3, y3, z3, w3);
}
float t4 = 0.6 - x4*x4 - y4*y4 - z4*z4 - w4*w4;
if(t4<0) n4 = 0.0;
else {
t4 *= t4;
n4 = t4 * t4 * dot(grad4[gi4], x4, y4, z4, w4);
}
// Sum up and scale the result to cover the range [-1,1]
return 27.0 * (n0 + n1 + n2 + n3 + n4);
}
int fastfloor( const float x ) { return x > 0 ? (int) x : (int) x - 1; }
float dot( const int8_t* g, const float x, const float y ) { return g[0]*x + g[1]*y; }
float dot( const int8_t* g, const float x, const float y, const float z ) { return g[0]*x + g[1]*y + g[2]*z; }
float dot( const int8_t* g, const float x, const float y, const float z, const float w ) { return g[0]*x + g[1]*y + g[2]*z + g[3]*w; }

171
source/generator/simplexnoise.h
View file

@ -1,171 +0,0 @@
/* Copyright (c) 2007-2012 Eliot Eshelman
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
#ifndef SIMPLEX_H_
#define SIMPLEX_H_
#include <stdint.h>
/* 2D, 3D and 4D Simplex Noise functions return 'random' values in (-1, 1).
This algorithm was originally designed by Ken Perlin, but my code has been
adapted from the implementation written by Stefan Gustavson (stegu@itn.liu.se)
Raw Simplex noise functions return the value generated by Ken's algorithm.
Scaled Raw Simplex noise functions adjust the range of values returned from the
traditional (-1, 1) to whichever bounds are passed to the function.
Multi-Octave Simplex noise functions compine multiple noise values to create a
more complex result. Each successive layer of noise is adjusted and scaled.
Scaled Multi-Octave Simplex noise functions scale the values returned from the
traditional (-1,1) range to whichever range is passed to the function.
In many cases, you may think you only need a 1D noise function, but in practice
2D is almost always better. For instance, if you're using the current frame
number as the parameter for the noise, all objects will end up with the same
noise value at each frame. By adding a second parameter on the second
dimension, you can ensure that each gets a unique noise value and they don't
all look identical.
*/
//from http://www.6by9.net/simplex-noise-for-c-and-python/
// Multi-octave Simplex noise
// For each octave, a higher frequency/lower amplitude function will be added to the original.
// The higher the persistence [0-1], the more of each succeeding octave will be added.
float octave_noise_2d(const float octaves,
const float persistence,
const float scale,
const float x,
const float y);
float octave_noise_3d(const float octaves,
const float persistence,
const float scale,
const float x,
const float y,
const float z);
float octave_noise_4d(const float octaves,
const float persistence,
const float scale,
const float x,
const float y,
const float z,
const float w);
// Scaled Multi-octave Simplex noise
// The result will be between the two parameters passed.
float scaled_octave_noise_2d( const float octaves,
const float persistence,
const float scale,
const float loBound,
const float hiBound,
const float x,
const float y);
float scaled_octave_noise_3d( const float octaves,
const float persistence,
const float scale,
const float loBound,
const float hiBound,
const float x,
const float y,
const float z);
float scaled_octave_noise_4d( const float octaves,
const float persistence,
const float scale,
const float loBound,
const float hiBound,
const float x,
const float y,
const float z,
const float w);
// Scaled Raw Simplex noise
// The result will be between the two parameters passed.
float scaled_raw_noise_2d( const float loBound,
const float hiBound,
const float x,
const float y);
float scaled_raw_noise_3d( const float loBound,
const float hiBound,
const float x,
const float y,
const float z);
float scaled_raw_noise_4d( const float loBound,
const float hiBound,
const float x,
const float y,
const float z,
const float w);
// Raw Simplex noise - a single noise value.
float raw_noise_2d(const float x, const float y);
float raw_noise_3d(const float x, const float y, const float z);
float raw_noise_4d(const float x, const float y, const float, const float w);
int fastfloor(const float x);
float dot(const int8_t* g, const float x, const float y);
float dot(const int8_t* g, const float x, const float y, const float z);
float dot(const int8_t* g, const float x, const float y, const float z, const float w);
// The gradients are the midpoints of the vertices of a cube.
static const int8_t grad3[12][3] = {
{1,1,0}, {-1,1,0}, {1,-1,0}, {-1,-1,0},
{1,0,1}, {-1,0,1}, {1,0,-1}, {-1,0,-1},
{0,1,1}, {0,-1,1}, {0,1,-1}, {0,-1,-1}
};
// The gradients are the midpoints of the vertices of a hypercube.
static const int8_t grad4[32][4]= {
{0,1,1,1}, {0,1,1,-1}, {0,1,-1,1}, {0,1,-1,-1},
{0,-1,1,1}, {0,-1,1,-1}, {0,-1,-1,1}, {0,-1,-1,-1},
{1,0,1,1}, {1,0,1,-1}, {1,0,-1,1}, {1,0,-1,-1},
{-1,0,1,1}, {-1,0,1,-1}, {-1,0,-1,1}, {-1,0,-1,-1},
{1,1,0,1}, {1,1,0,-1}, {1,-1,0,1}, {1,-1,0,-1},
{-1,1,0,1}, {-1,1,0,-1}, {-1,-1,0,1}, {-1,-1,0,-1},
{1,1,1,0}, {1,1,-1,0}, {1,-1,1,0}, {1,-1,-1,0},
{-1,1,1,0}, {-1,1,-1,0}, {-1,-1,1,0}, {-1,-1,-1,0}
};
// Permutation table. The same list is repeated twice.
// removed const
extern uint8_t perm[512];
// A lookup table to traverse the simplex around a given point in 4D.
static const uint8_t simplex[64][4] = {
{0,1,2,3},{0,1,3,2},{0,0,0,0},{0,2,3,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,2,3,0},
{0,2,1,3},{0,0,0,0},{0,3,1,2},{0,3,2,1},{0,0,0,0},{0,0,0,0},{0,0,0,0},{1,3,2,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{1,2,0,3},{0,0,0,0},{1,3,0,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,3,0,1},{2,3,1,0},
{1,0,2,3},{1,0,3,2},{0,0,0,0},{0,0,0,0},{0,0,0,0},{2,0,3,1},{0,0,0,0},{2,1,3,0},
{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},{0,0,0,0},
{2,0,1,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,0,1,2},{3,0,2,1},{0,0,0,0},{3,1,2,0},
{2,1,0,3},{0,0,0,0},{0,0,0,0},{0,0,0,0},{3,1,0,2},{0,0,0,0},{3,2,0,1},{3,2,1,0}
};
#endif /*SIMPLEX_H_*/