Unarelith/OpenMiner
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

[SimplexNoise] Removed. [TerrainGeneration] Now using FastNoise for land height.

Browse Source
This commit is contained in:
Quentin Bazin 2020-02-11 20:53:03 +09:00
parent a8a2440b5d
commit 7bad35ed54
4 changed files with 11 additions and 679 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

342
external/SimplexNoise.cpp vendored
View File

@ -1,342 +0,0 @@
/*
* A speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
*
* Based on example code by Stefan Gustavson (stegu@itn.liu.se).
* Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
* Better rank ordering method for 4D by Stefan Gustavson in 2012.
*
* This could be speeded up even further, but it's useful as it is.
*
* Version 2012-03-09
*
* This code was placed in the public domain by its original author,
* Stefan Gustavson. You may use it as you see fit, but
* attribution is appreciated.
*
* Original link: http://staffwww.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java
* Adapted to C++ by Unarelith
*
*/
#include <cmath>
#include "SimplexNoise.hpp"
SimplexNoise::Grad SimplexNoise::grad3[12] = {
{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}
};
SimplexNoise::Grad SimplexNoise::grad4[32] = {
{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}
};
unsigned short SimplexNoise::p[] = {151,160,137,91,90,15,
131,13,201,95,96,53,194,233,7,225,140,36,103,30,69,142,8,99,37,240,21,10,23,
190, 6,148,247,120,234,75,0,26,197,62,94,252,219,203,117,35,11,32,57,177,33,
88,237,149,56,87,174,20,125,136,171,168, 68,175,74,165,71,134,139,48,27,166,
77,146,158,231,83,111,229,122,60,211,133,230,220,105,92,41,55,46,245,40,244,
102,143,54, 65,25,63,161, 1,216,80,73,209,76,132,187,208, 89,18,169,200,196,
135,130,116,188,159,86,164,100,109,198,173,186, 3,64,52,217,226,250,124,123,
5,202,38,147,118,126,255,82,85,212,207,206,59,227,47,16,58,17,182,189,28,42,
223,183,170,213,119,248,152, 2,44,154,163, 70,221,153,101,155,167, 43,172,9,
129,22,39,253, 19,98,108,110,79,113,224,232,178,185, 112,104,218,246,97,228,
251,34,242,193,238,210,144,12,191,179,162,241, 81,51,145,235,249,14,239,107,
49,192,214, 31,181,199,106,157,184, 84,204,176,115,121,50,45,127, 4,150,254,
138,236,205,93,222,114,67,29,24,72,243,141,128,195,78,66,215,61,156,180
};
short SimplexNoise::perm[512];
short SimplexNoise::permMod12[512];
// Skewing and unskewing factors for 2, 3, and 4 dimensions
double SimplexNoise::F2 = 0.5*(std::sqrt(3.0)-1.0);
double SimplexNoise::G2 = (3.0-std::sqrt(3.0))/6.0;
double SimplexNoise::F3 = 1.0/3.0;
double SimplexNoise::G3 = 1.0/6.0;
double SimplexNoise::F4 = (std::sqrt(5.0)-1.0)/4.0;
double SimplexNoise::G4 = (5.0-std::sqrt(5.0))/20.0;
bool SimplexNoise::isInitialized = false;
// Initialization function
void SimplexNoise::init() {
for(int i=0; i<512; i++)
{
perm[i]=p[i & 255];
permMod12[i] = (short)(perm[i] % 12);
}
}
// 2D simplex noise
double SimplexNoise::noise(double xin, double yin) {
if (!isInitialized) {
init();
isInitialized = true;
}
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
int ii = i & 255;
int jj = j & 255;
int gi0 = permMod12[ii+perm[jj]];
int gi1 = permMod12[ii+i1+perm[jj+j1]];
int gi2 = permMod12[ii+1+perm[jj+1]];
// Calculate the contribution from the three corners
double 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
}
double t1 = 0.5 - x1*x1-y1*y1;
if(t1<0) n1 = 0.0;
else {
t1 *= t1;
n1 = t1 * t1 * dot(grad3[gi1], x1, y1);
}
double 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 simplex noise
double SimplexNoise::noise(double xin, double yin, double zin) {
if (!isInitialized) {
init();
isInitialized = true;
}
double n0, n1, n2, n3; // Noise contributions from the four corners
// Skew the input space to determine which simplex cell we're in
double s = (xin+yin+zin)*F3; // Very nice and simple skew factor for 3D
int i = fastfloor(xin+s);
int j = fastfloor(yin+s);
int k = fastfloor(zin+s);
double t = (i+j+k)*G3;
double X0 = i-t; // Unskew the cell origin back to (x,y,z) space
double Y0 = j-t;
double Z0 = k-t;
double x0 = xin-X0; // The x,y,z distances from the cell origin
double y0 = yin-Y0;
double z0 = zin-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.
double x1 = x0 - i1 + G3; // Offsets for second corner in (x,y,z) coords
double y1 = y0 - j1 + G3;
double z1 = z0 - k1 + G3;
double x2 = x0 - i2 + 2.0*G3; // Offsets for third corner in (x,y,z) coords
double y2 = y0 - j2 + 2.0*G3;
double z2 = z0 - k2 + 2.0*G3;
double x3 = x0 - 1.0 + 3.0*G3; // Offsets for last corner in (x,y,z) coords
double y3 = y0 - 1.0 + 3.0*G3;
double 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;
int gi0 = permMod12[ii+perm[jj+perm[kk]]];
int gi1 = permMod12[ii+i1+perm[jj+j1+perm[kk+k1]]];
int gi2 = permMod12[ii+i2+perm[jj+j2+perm[kk+k2]]];
int gi3 = permMod12[ii+1+perm[jj+1+perm[kk+1]]];
// Calculate the contribution from the four corners
double 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);
}
double 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);
}
double 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);
}
double 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 simplex noise, better simplex rank ordering method 2012-03-09
double SimplexNoise::noise(double x, double y, double z, double w) {
if (!isInitialized) {
init();
isInitialized = true;
}
double 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
double 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);
double t = (i + j + k + l) * G4; // Factor for 4D unskewing
double X0 = i - t; // Unskew the cell origin back to (x,y,z,w) space
double Y0 = j - t;
double Z0 = k - t;
double W0 = l - t;
double x0 = x - X0; // The x,y,z,w distances from the cell origin
double y0 = y - Y0;
double z0 = z - Z0;
double 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.
// Six pair-wise comparisons are performed between each possible pair
// of the four coordinates, and the results are used to rank the numbers.
int rankx = 0;
int ranky = 0;
int rankz = 0;
int rankw = 0;
if(x0 > y0) rankx++; else ranky++;
if(x0 > z0) rankx++; else rankz++;
if(x0 > w0) rankx++; else rankw++;
if(y0 > z0) ranky++; else rankz++;
if(y0 > w0) ranky++; else rankw++;
if(z0 > w0) rankz++; else rankw++;
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
// [rankx, ranky, rankz, rankw] is a 4-vector with the numbers 0, 1, 2 and 3
// in some order. We use a thresholding to set the coordinates in turn.
// Rank 3 denotes the largest coordinate.
i1 = rankx >= 3 ? 1 : 0;
j1 = ranky >= 3 ? 1 : 0;
k1 = rankz >= 3 ? 1 : 0;
l1 = rankw >= 3 ? 1 : 0;
// Rank 2 denotes the second largest coordinate.
i2 = rankx >= 2 ? 1 : 0;
j2 = ranky >= 2 ? 1 : 0;
k2 = rankz >= 2 ? 1 : 0;
l2 = rankw >= 2 ? 1 : 0;
// Rank 1 denotes the second smallest coordinate.
i3 = rankx >= 1 ? 1 : 0;
j3 = ranky >= 1 ? 1 : 0;
k3 = rankz >= 1 ? 1 : 0;
l3 = rankw >= 1 ? 1 : 0;
// The fifth corner has all coordinate offsets = 1, so no need to compute that.
double x1 = x0 - i1 + G4; // Offsets for second corner in (x,y,z,w) coords
double y1 = y0 - j1 + G4;
double z1 = z0 - k1 + G4;
double w1 = w0 - l1 + G4;
double x2 = x0 - i2 + 2.0*G4; // Offsets for third corner in (x,y,z,w) coords
double y2 = y0 - j2 + 2.0*G4;
double z2 = z0 - k2 + 2.0*G4;
double w2 = w0 - l2 + 2.0*G4;
double x3 = x0 - i3 + 3.0*G4; // Offsets for fourth corner in (x,y,z,w) coords
double y3 = y0 - j3 + 3.0*G4;
double z3 = z0 - k3 + 3.0*G4;
double w3 = w0 - l3 + 3.0*G4;
double x4 = x0 - 1.0 + 4.0*G4; // Offsets for last corner in (x,y,z,w) coords
double y4 = y0 - 1.0 + 4.0*G4;
double z4 = z0 - 1.0 + 4.0*G4;
double 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;
int gi0 = perm[ii+perm[jj+perm[kk+perm[ll]]]] % 32;
int gi1 = perm[ii+i1+perm[jj+j1+perm[kk+k1+perm[ll+l1]]]] % 32;
int gi2 = perm[ii+i2+perm[jj+j2+perm[kk+k2+perm[ll+l2]]]] % 32;
int gi3 = perm[ii+i3+perm[jj+j3+perm[kk+k3+perm[ll+l3]]]] % 32;
int gi4 = perm[ii+1+perm[jj+1+perm[kk+1+perm[ll+1]]]] % 32;
// Calculate the contribution from the five corners
double 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);
}
double 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);
}
double 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);
}
double 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);
}
double 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);
}

87
external/SimplexNoise.hpp vendored
View File

@ -1,87 +0,0 @@
/*
* A speed-improved simplex noise algorithm for 2D, 3D and 4D in Java.
*
* Based on example code by Stefan Gustavson (stegu@itn.liu.se).
* Optimisations by Peter Eastman (peastman@drizzle.stanford.edu).
* Better rank ordering method for 4D by Stefan Gustavson in 2012.
*
* This could be speeded up even further, but it's useful as it is.
*
* Version 2012-03-09
*
* This code was placed in the public domain by its original author,
* Stefan Gustavson. You may use it as you see fit, but
* attribution is appreciated.
*
* Original link: http://staffwww.itn.liu.se/~stegu/simplexnoise/SimplexNoise.java
* Adapted to C++ by Unarelith
*
*/
#ifndef SIMPLEXNOISE_HPP_
#define SIMPLEXNOISE_HPP_
class SimplexNoise {
public:
// 2D simplex noise
static double noise(double xin, double yin);
// 3D simplex noise
static double noise(double xin, double yin, double zin);
// 4D simplex noise
static double noise(double xin, double yin, double zin, double win);
private:
// Inner class to speed upp gradient computations
// (In Java, array access is a lot slower than member access)
// FIXME: Is C++ different on that topic?
struct Grad {
Grad(double _x, double _y, double _z) : x(_x), y(_y), z(_z) {}
Grad(double _x, double _y, double _z, double _w) : x(_x), y(_y), z(_z), w(_w) {}
double x = 0;
double y = 0;
double z = 0;
double w = 0;
};
// This method is a *lot* faster than using (int)Math.floor(x)
static int fastfloor(double x) {
int xi = (int)x;
return x<xi ? xi-1 : xi;
}
static double dot(Grad g, double x, double y) {
return g.x*x + g.y*y;
}
static double dot(Grad g, double x, double y, double z) {
return g.x*x + g.y*y + g.z*z;
}
static double dot(Grad g, double x, double y, double z, double w) {
return g.x*x + g.y*y + g.z*z + g.w*w;
}
// Initialization function
static void init();
static Grad grad3[12];
static Grad grad4[32];
static unsigned short p[];
static short perm[512];
static short permMod12[512];
static double F2;
static double G2;
static double F3;
static double G3;
static double F4;
static double G4;
static bool isInitialized;
};
#endif // SIMPLEXNOISE_HPP_

7
server/include/world/TerrainGenerator.hpp
View File

@ -38,18 +38,11 @@ class TerrainGenerator {
void setBlocksFromLuaTable(const sol::table &table);
private:
void lightTestGeneration(ServerChunk &chunk) const;
void basicGeneration(ServerChunk &chunk) const;
void testCraftGeneration(ServerChunk &chunk) const;
void simplexGeneration(ServerChunk &chunk) const;
void fastNoiseGeneration(ServerChunk &chunk) const;
static float noise2d(float x, float y, int octaves, float persistence);
static float noise3d_abs(float x, float y, float z, int octaves, float persistence);
static float newNoise2d(float x, float y, int octaves, float persistence);
static float newNoise3d_abs(float x, float y, float z, int octaves, float persistence);
u16 m_dirtBlockID = 0;
u16 m_grassBlockID = 0;
u16 m_stoneBlockID = 0;

254
server/source/world/TerrainGenerator.cpp
View File

@ -28,18 +28,12 @@
#include <glm/gtc/noise.hpp>
#include "FastNoise.hpp"
#include "SimplexNoise.hpp"
TerrainGenerator::TerrainGenerator() {
srand(1337);
}
void TerrainGenerator::generate(ServerChunk &chunk) const {
// lightTestGeneration(chunk);
// basicGeneration(chunk);
testCraftGeneration(chunk);
// simplexGeneration(chunk);
// fastNoiseGeneration(chunk);
fastNoiseGeneration(chunk);
}
void TerrainGenerator::setBlocksFromLuaTable(const sol::table &table) {
@ -53,66 +47,22 @@ void TerrainGenerator::setBlocksFromLuaTable(const sol::table &table) {
m_sandBlockID = Registry::getInstance().getBlockFromStringID(table["sand"].get<std::string>()).id();
}
void TerrainGenerator::lightTestGeneration(ServerChunk &chunk) const {
for(u8 y = 0 ; y < CHUNK_HEIGHT ; y++) {
for(u8 z = 0 ; z < CHUNK_DEPTH ; z++) {
for(u8 x = 0 ; x < CHUNK_WIDTH ; x++) {
if (y == 4)
chunk.setBlockRaw(x, y, z, m_stoneBlockID);
else if (y == 10 && (z > 4 || chunk.z() != 0))
chunk.setBlockRaw(x, y, z, m_stoneBlockID);
}
}
}
void TerrainGenerator::fastNoiseGeneration(ServerChunk &chunk) const {
FastNoise noise;
noise.SetNoiseType(FastNoise::NoiseType::SimplexFractal);
noise.SetFrequency(1 / 256.0f);
noise.SetFractalOctaves(4);
if (chunk.y() == 0) {
for(u8 z = 0 ; z < CHUNK_DEPTH ; z++) {
for(u8 x = 0 ; x < CHUNK_WIDTH ; x++) {
chunk.lightmap().addSunlight(x, 31, z, 15);
}
}
}
// Chunk *topChunk = chunk.getSurroundingChunk(Chunk::Top);
// if (topChunk) {
// for(u8 z = 0 ; z < CHUNK_DEPTH ; z++) {
// for(u8 x = 0 ; x < CHUNK_WIDTH ; x++) {
// int sunlightLevel = topChunk->lightmap().getSunlight(x, 0, z);
// if (sunlightLevel) {
// chunk.lightmap().addSunlight(x, CHUNK_HEIGHT - 1, z, sunlightLevel);
// }
// }
// }
// }
}
void TerrainGenerator::basicGeneration(ServerChunk &chunk) const {
for(u8 z = 0 ; z < CHUNK_DEPTH ; z++) {
for(u8 x = 0 ; x < CHUNK_WIDTH ; x++) {
float n = noise2d((x + chunk.x() * CHUNK_WIDTH) / 256.0, (z + chunk.z() * CHUNK_DEPTH) / 256.0, 5, 0.5) * 4;
float h = 10 + n * 2;
for(u8 y = 0 ; y < CHUNK_HEIGHT ; y++) {
if(y + chunk.y() * CHUNK_HEIGHT < h) {
chunk.setBlockRaw(x, y, z, 1);
}
else if (y == CHUNK_HEIGHT - 1) {
chunk.lightmap().addSunlight(x, y, z, 15);
}
}
}
}
}
void TerrainGenerator::testCraftGeneration(ServerChunk &chunk) const {
srand(chunk.x() + chunk.y() + chunk.z() + 1337);
Chunk *topChunk = chunk.getSurroundingChunk(Chunk::Top);
for(int z = 0 ; z < CHUNK_DEPTH ; z++) {
for(int x = 0 ; x < CHUNK_WIDTH ; x++) {
// Land height
float n = noise2d((x + chunk.x() * CHUNK_WIDTH) / 256.0, (z + chunk.z() * CHUNK_DEPTH) / 256.0, 4, 0.5) * 4;
float h = 10 + n * 2;
float n = noise.GetNoise(x + chunk.x() * CHUNK_WIDTH, z + chunk.z() * CHUNK_DEPTH);
float h = 10 + n * 20;
// float n = noise2d((x + chunk.x() * CHUNK_WIDTH) / 256.0, (z + chunk.z() * CHUNK_DEPTH) / 256.0, 4, 0.5) * 4;
// float h = 10 + n * 2;
// Land blocks
for(int y = 0 ; y < CHUNK_HEIGHT ; y++) {
@ -151,20 +101,6 @@ void TerrainGenerator::testCraftGeneration(ServerChunk &chunk) const {
}
}
else {
// // Random value used to determine land type
// float r = noise3d_abs((x + chunk.x() * CHUNK_WIDTH) / 256.0, (y + chunk.y() * CHUNK_HEIGHT) / 256.0 + 16, (z + chunk.z() * CHUNK_DEPTH) / 256.0, 5, 0.5) * 4;
//
// // Sand layer
// if(n * 4 + r * 5 < 4) {
// chunk.setBlockRaw(x, y, z, m_sandBlockID);
// }
// // Dirt layer, but use grass blocks for the top
// else if(n + r * 5 < 6 * 8 && n * 10 + r * 5 > 30) {
// chunk.setBlockRaw(x, y, z, (h < SEALEVEL - 5 || y + chunk.y() * CHUNK_HEIGHT < h - 1) ? m_dirtBlockID : m_grassBlockID);
// }
// else {
// chunk.setBlockRaw(x, y, z, m_stoneBlockID);
// }
if (y + chunk.y() * CHUNK_HEIGHT >= h - 1 && y + chunk.y() * CHUNK_HEIGHT > SEALEVEL - 1)
chunk.setBlockRaw(x, y, z, m_grassBlockID);
else if (y + chunk.y() * CHUNK_HEIGHT <= SEALEVEL - 1 && h < SEALEVEL && y + chunk.y() * CHUNK_HEIGHT > h - 3)
@ -197,146 +133,6 @@ void TerrainGenerator::testCraftGeneration(ServerChunk &chunk) const {
}
}
void TerrainGenerator::simplexGeneration(ServerChunk &chunk) const {
srand(1337);
Chunk *topChunk = chunk.getSurroundingChunk(Chunk::Top);
for(int z = 0 ; z < CHUNK_DEPTH ; z++) {
for(int x = 0 ; x < CHUNK_WIDTH ; x++) {
// Land height
float n = newNoise2d((x + chunk.x() * CHUNK_WIDTH) / 256.0, (z + chunk.z() * CHUNK_DEPTH) / 256.0, 4, 0.5) * 4;
float h = 10 + n * 2;
// Land blocks
for(int y = 0 ; y < CHUNK_HEIGHT ; y++) {
// Are we above "ground" level?
if(y + chunk.y() * CHUNK_HEIGHT > h) {
// If we are not yet up to sea level, fill with water blocks
if(y + chunk.y() * CHUNK_HEIGHT < SEALEVEL) {
chunk.setBlockRaw(x, y, z, m_waterBlockID);
}
// Otherwise we are in the air, so try to make a tree
else if(chunk.getBlock(x, y - 1, z) == m_grassBlockID && (rand() % 256) == 0 && n < 4) {
// Trunk
h = (rand() & 0x3) + 3;
for(int i = 0 ; i < h ; i++) {
chunk.setBlockRaw(x, y + i, z, m_logBlockID);
}
// Leaves
for(int ix = -3 ; ix <= 3 ; ix++) {
for(int iy = -3 ; iy <= 3 ; iy++) {
for(int iz = -3 ; iz <= 3 ; iz++) {
if(ix * ix + iy * iy + iz * iz < 8 + (rand() & 1) && !chunk.getBlock(x + ix, y + h + iy, z + iz)) {
chunk.setBlockRaw(x + ix, y + h + iy, z + iz, m_leavesBlockID);
}
}
}
}
}
// Or a flower
else if(chunk.getBlock(x, y - 1, z) == m_grassBlockID && (rand() & 0xff) == 0) {
chunk.setBlockRaw(x, y, z, m_flowerBlockID);
}
// If we are on the top block of the chunk, add sunlight
else if (y == CHUNK_HEIGHT - 1) {
chunk.lightmap().addSunlight(x, y, z, 15);
}
}
else {
if (y + chunk.y() * CHUNK_HEIGHT >= h - 1 && y + chunk.y() * CHUNK_HEIGHT > SEALEVEL - 1)
chunk.setBlockRaw(x, y, z, m_grassBlockID);
else if (y + chunk.y() * CHUNK_HEIGHT <= SEALEVEL - 1 && h < SEALEVEL && y + chunk.y() * CHUNK_HEIGHT > h - 3)
chunk.setBlockRaw(x, y, z, m_sandBlockID);
else if (y + chunk.y() * CHUNK_HEIGHT > h - 3)
chunk.setBlockRaw(x, y, z, m_dirtBlockID);
else
chunk.setBlockRaw(x, y, z, m_stoneBlockID);
}
if (topChunk && topChunk->isInitialized()) {
int sunlightLevel = topChunk->lightmap().getSunlight(x, 0, z);
if (sunlightLevel) {
chunk.lightmap().addSunlight(x, CHUNK_HEIGHT - 1, z, sunlightLevel);
}
}
}
}
}
}
void TerrainGenerator::fastNoiseGeneration(ServerChunk &chunk) const {
FastNoise noise;
noise.SetNoiseType(FastNoise::NoiseType::SimplexFractal);
noise.SetFrequency(1);
noise.SetFractalOctaves(4);
srand(1337);
Chunk *topChunk = chunk.getSurroundingChunk(Chunk::Top);
for(int z = 0 ; z < CHUNK_DEPTH ; z++) {
for(int x = 0 ; x < CHUNK_WIDTH ; x++) {
// Land height
float d = 256.0f;
float n = noise.GetNoise((x + chunk.x() * CHUNK_WIDTH) / d, (z + chunk.z() * CHUNK_DEPTH) / d);
float h = 10 + n * 20;
// Land blocks
for(int y = 0 ; y < CHUNK_HEIGHT ; y++) {
// Are we above "ground" level?
if(y + chunk.y() * CHUNK_HEIGHT > h) {
// If we are not yet up to sea level, fill with water blocks
if(y + chunk.y() * CHUNK_HEIGHT < SEALEVEL) {
chunk.setBlockRaw(x, y, z, m_waterBlockID);
}
// Otherwise we are in the air, so try to make a tree
else if(chunk.getBlock(x, y - 1, z) == m_grassBlockID && (rand() % 256) == 0 && n < 1) {
// Trunk
h = (rand() & 0x3) + 3;
for(int i = 0 ; i < h ; i++) {
chunk.setBlockRaw(x, y + i, z, m_logBlockID);
}
// Leaves
for(int ix = -3 ; ix <= 3 ; ix++) {
for(int iy = -3 ; iy <= 3 ; iy++) {
for(int iz = -3 ; iz <= 3 ; iz++) {
if(ix * ix + iy * iy + iz * iz < 8 + (rand() & 1) && !chunk.getBlock(x + ix, y + h + iy, z + iz)) {
chunk.setBlockRaw(x + ix, y + h + iy, z + iz, m_leavesBlockID);
}
}
}
}
}
// Or a flower
else if(chunk.getBlock(x, y - 1, z) == m_grassBlockID && (rand() & 0xff) == 0) {
chunk.setBlockRaw(x, y, z, m_flowerBlockID);
}
// If we are on the top block of the chunk, add sunlight
else if (y == CHUNK_HEIGHT - 1) {
chunk.lightmap().addSunlight(x, y, z, 15);
}
}
else {
if (y + chunk.y() * CHUNK_HEIGHT >= h - 1 && y + chunk.y() * CHUNK_HEIGHT > SEALEVEL - 1)
chunk.setBlockRaw(x, y, z, m_grassBlockID);
else if (y + chunk.y() * CHUNK_HEIGHT <= SEALEVEL - 1 && h < SEALEVEL && y + chunk.y() * CHUNK_HEIGHT > h - 3)
chunk.setBlockRaw(x, y, z, m_sandBlockID);
else if (y + chunk.y() * CHUNK_HEIGHT > h - 3)
chunk.setBlockRaw(x, y, z, m_dirtBlockID);
else
chunk.setBlockRaw(x, y, z, m_stoneBlockID);
}
if (topChunk && topChunk->isInitialized()) {
int sunlightLevel = topChunk->lightmap().getSunlight(x, 0, z);
if (sunlightLevel) {
chunk.lightmap().addSunlight(x, CHUNK_HEIGHT - 1, z, sunlightLevel);
}
}
}
}
}
}
float TerrainGenerator::noise2d(float x, float y, int octaves, float persistence) {
float sum = 0;
float strength = 1.0;
@ -365,31 +161,3 @@ float TerrainGenerator::noise3d_abs(float x, float y, float z, int octaves, floa
return sum;
}
float TerrainGenerator::newNoise2d(float x, float y, int octaves, float persistence) {
float sum = 0;
float strength = 1.0;
float scale = 1.0;
for(int i = 0 ; i < octaves ; i++) {
sum += strength * SimplexNoise::noise(x * scale, y * scale);
scale *= 2.0;
strength *= persistence;
}
return sum;
}
float TerrainGenerator::newNoise3d_abs(float x, float y, float z, int octaves, float persistence) {
float sum = 0;
float strength = 1.0;
float scale = 1.0;
for(int i = 0 ; i < octaves ; i++) {
sum += strength * fabs(SimplexNoise::noise(x * scale, y * scale, z * scale));
scale *= 2.0;
strength *= persistence;
}
return sum;
}