From 94814e0172b30b40f2e317db65389f43e6216856 Mon Sep 17 00:00:00 2001 From: Felix Ableitner Date: Sat, 15 Jun 2013 17:49:01 +0200 Subject: [PATCH] Added own SimplexNoise class, cache noise values. --- source/generator/Generator.cpp | 100 +++---- source/generator/Generator.h | 23 +- source/generator/SimplexNoise.cpp | 128 ++++++++ source/generator/SimplexNoise.h | 37 +++ source/generator/simplexnoise.cpp | 475 ------------------------------ source/generator/simplexnoise.h | 171 ----------- 6 files changed, 228 insertions(+), 706 deletions(-) create mode 100644 source/generator/SimplexNoise.cpp create mode 100644 source/generator/SimplexNoise.h delete mode 100644 source/generator/simplexnoise.cpp delete mode 100644 source/generator/simplexnoise.h diff --git a/source/generator/Generator.cpp b/source/generator/Generator.cpp index 5f20c52..669a97f 100644 --- a/source/generator/Generator.cpp +++ b/source/generator/Generator.cpp @@ -16,7 +16,6 @@ #include -#include "simplexnoise.h" #include "../Pathfinder.h" #include "../World.h" #include "../util/Log.h" @@ -43,11 +42,6 @@ const float Generator::LAYER_ENEMIES = 1.0f; Generator::Generator(World& world, Pathfinder& pathfinder) : mWorld(world), mPathfinder(pathfinder) { - std::mt19937 mersenne(time(nullptr)); - std::uniform_int_distribution 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.height && !(area.height & (area.height - 1))); - array noise; - array filtered; - 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); + array generatedTiles; + fill(generatedTiles, area, type::FLOOR); for (int x = area.left; x < area.left + area.width; x++) { for (int y = area.top; y < area.top + area.height; y++) { - filterWalls(noise, filtered, x, y, 2, 1, 0); - filterWalls(noise, filtered, x, y, 6, 1, 2); - filterWalls(noise, filtered, x, y, 10, 1, 4); + filterWalls(generatedTiles, x, y, 2, 1, 0); + filterWalls(generatedTiles, x, y, 6, 1, 2); + 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++) { + // Merge map that we just generated with stored map. + mTiles[x][y] = generatedTiles[x][y]; + // Actually generate physical tiles. mWorld.insert(std::shared_ptr( - 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(); - mTiles = filtered; } std::vector -Generator::getEnemySpawns(const sf::IntRect& area) const { +Generator::getEnemySpawns(const sf::IntRect& area) { auto compare = [](const sf::Vector2f& a, const sf::Vector2f& b) { return a.x < b.x || (a.x == b.x && a.y < b.y); }; std::set ret(compare); for (int x = area.left; x < area.left + area.width; x++) { 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) - < 1.0f) { + if (mCharacterNoise.getNoise(x, y) < 0.05f) { ret.insert(sf::Vector2f(thor::cwiseProduct( 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. */ 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 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. * - * @param[in] tiles Array of tile values. * @param area The area to count in. */ int -Generator::countWalls(const array& tiles, const sf::IntRect& area) { +Generator::countWalls(const sf::IntRect& area) { int count = 0; for (int x = area.left; x < area.left + area.width; x++) { 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; } /** - * Finds rectangles of specific size inside vector in and + * Finds rectangles of specific size with mTileNoise and * puts them into vector out. * - * @param[in] in Perlin noise values. - * @param[in,out] out Tiles to be placed. Does not explicitly set floor values + * @param[in,out] tiles Tiles to be placed. Does not explicitly set floor values * (keeps previous values). * @param x 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). */ 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) { // Filter in horizontal direction. - if (countWalls(in, sf::IntRect(x, y, longside, shortside)) >= + if (countWalls(sf::IntRect(x, y, longside, shortside)) >= 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. - if (countWalls(in, sf::IntRect(x, y, shortside, longside)) >= + if (countWalls(sf::IntRect(x, y, shortside, longside)) >= 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 - * into four and continues recursively. + * Inserts floor tiles into path finder, using a quadtree approach to group + * tiles where possible. * - * @param in Array of tile values. * @param area The area to generate areas for. * @param offset Offset of tiles[0][0] from World coordinate (0, 0). */ void -Generator::generateAreas(const array& in, const sf::IntRect& area, - const sf::Vector2f& offset) const { +Generator::generateAreas(const sf::IntRect& area, + const sf::Vector2f& offset) { assert(area.width > 0 && area.height > 0); - int count = countWalls(in, area); + int count = countWalls(area); if (count == 0) { mPathfinder.insertArea(sf::IntRect(area)); } @@ -244,17 +226,29 @@ Generator::generateAreas(const array& in, const sf::IntRect& area, else { int halfWidth = area.width / 2.0f; int halfHeight = area.height / 2.0f; - generateAreas(in, sf::IntRect(area.left, + generateAreas(sf::IntRect(area.left, area.top, halfWidth, halfHeight), offset); - generateAreas(in, sf::IntRect(area.left + halfWidth, + generateAreas(sf::IntRect(area.left + halfWidth, area.top, halfWidth, halfHeight), offset); - generateAreas(in, sf::IntRect(area.left, + generateAreas(sf::IntRect(area.left, 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); } } +/** + * 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. */ diff --git a/source/generator/Generator.h b/source/generator/Generator.h index 5b6fe94..59632d7 100644 --- a/source/generator/Generator.h +++ b/source/generator/Generator.h @@ -11,30 +11,35 @@ #include #include "../sprites/Tile.h" +#include "SimplexNoise.h" class World; class Pathfinder; +/** + * Procedurally generates tiles, chooses player and enemy spawn positions. + */ class Generator { public: explicit Generator(World& world, Pathfinder& pathfinder); void generateCurrentAreaIfNeeded(const sf::Vector2f& position); sf::Vector2f getPlayerSpawn() const; - std::vector getEnemySpawns(const sf::IntRect& area) const; + std::vector getEnemySpawns(const sf::IntRect& area); private: typedef Tile::Type type; typedef std::map > array; private: + void generateAreas(const sf::IntRect& area, const sf::Vector2f& offset); void generateTiles(const sf::IntRect& area); 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, - int longside, int shortside, int subtract); - static int countWalls(const array& in, const sf::IntRect& area); - void generateAreas(const array& in, const sf::IntRect& area, - const sf::Vector2f& offset) const; + + static void fill(array& tiles, const sf::IntRect& area, type value); + void filterWalls(array& tiles, int x, int y, int longside, + int shortside, int subtract); + int countWalls(const sf::IntRect& area); + static type getTileType(float value); private: static const int GENERATE_AREA_SIZE; @@ -49,6 +54,10 @@ private: array mTiles; /// Stores where tiles have already been generated. std::map > mGenerated; + /// Perlin noise used for tile generation. + SimplexNoise mTileNoise; + /// Perlin noise used for character placement. + SimplexNoise mCharacterNoise; }; #endif /* DG_GENERATOR_H_ */ diff --git a/source/generator/SimplexNoise.cpp b/source/generator/SimplexNoise.cpp new file mode 100644 index 0000000..c85ba7a --- /dev/null +++ b/source/generator/SimplexNoise.cpp @@ -0,0 +1,128 @@ +/* + * SimplexNoise.cpp + * + * Created on: 14.06.2013 + * Author: Felix + */ + +#include "SimplexNoise.h" + +#include +#include + +/** + * Initializes permutation with random values. + */ +SimplexNoise::SimplexNoise() { + std::mt19937 mersenne(time(nullptr)); + std::uniform_int_distribution 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); + } diff --git a/source/generator/SimplexNoise.h b/source/generator/SimplexNoise.h new file mode 100644 index 0000000..257371e --- /dev/null +++ b/source/generator/SimplexNoise.h @@ -0,0 +1,37 @@ +/* + * SimplexNoise.h + * + * Created on: 14.06.2013 + * Author: Felix + */ + +#ifndef DG_SIMPLEXNOISE_H_ +#define DG_SIMPLEXNOISE_H_ + +#include +#include + +/** + * 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 mPerm; + std::map > mCache; +}; + +#endif /* DG_SIMPLEXNOISE_H_ */ diff --git a/source/generator/simplexnoise.cpp b/source/generator/simplexnoise.cpp deleted file mode 100644 index 304a768..0000000 --- a/source/generator/simplexnoise.cpp +++ /dev/null @@ -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 . - * - */ - - -#include - -#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) ? 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=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; } diff --git a/source/generator/simplexnoise.h b/source/generator/simplexnoise.h deleted file mode 100644 index 7d30230..0000000 --- a/source/generator/simplexnoise.h +++ /dev/null @@ -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 . - * - */ - - -#ifndef SIMPLEX_H_ -#define SIMPLEX_H_ - -#include - -/* 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_*/