Made a class of NoiseGenerator
This commit is contained in:
parent
1a69b1de1d
commit
b5c50d16d4
55 changed files with 1333 additions and 1225 deletions
5
src/basics/Interpolation.cpp
Normal file
5
src/basics/Interpolation.cpp
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
#include "Interpolation.h"
|
||||
|
||||
Interpolation::Interpolation()
|
||||
{
|
||||
}
|
||||
23
src/basics/Interpolation.h
Normal file
23
src/basics/Interpolation.h
Normal file
|
|
@ -0,0 +1,23 @@
|
|||
#ifndef INTERPOLATION_H
|
||||
#define INTERPOLATION_H
|
||||
|
||||
#include "basics_global.h"
|
||||
|
||||
namespace paysages {
|
||||
namespace basics {
|
||||
|
||||
class Interpolation
|
||||
{
|
||||
public:
|
||||
Interpolation();
|
||||
|
||||
static inline double cubic(double p[4], double x)
|
||||
{
|
||||
return p[1] + 0.5 * x * (p[2] - p[0] + x * (2.0 * p[0] - 5.0 * p[1] + 4.0 * p[2] - p[3] + x * (3.0 * (p[1] - p[2]) + p[3] - p[0])));
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif // INTERPOLATION_H
|
||||
|
|
@ -1,17 +1,23 @@
|
|||
#include "noisenaive.h"
|
||||
#include "NoiseFunctionNaive.h"
|
||||
|
||||
/*
|
||||
* Naive noise implementation, based on pseudo-random grids.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include "tools.h"
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
#include "Interpolation.h"
|
||||
#include "RandomGenerator.h"
|
||||
#include "PackStream.h"
|
||||
|
||||
static int _noise_pool_size;
|
||||
static double* _noise_pool;
|
||||
|
||||
NoiseFunctionNaive::NoiseFunctionNaive()
|
||||
{
|
||||
}
|
||||
|
||||
void noiseNaiveInit()
|
||||
{
|
||||
int i;
|
||||
|
|
@ -21,7 +27,7 @@ void noiseNaiveInit()
|
|||
|
||||
for (i = 0; i < _noise_pool_size; i++)
|
||||
{
|
||||
_noise_pool[i] = toolsRandom() - 0.5;
|
||||
_noise_pool[i] = RandomGenerator::random() - 0.5;
|
||||
}
|
||||
}
|
||||
|
||||
|
|
@ -91,7 +97,7 @@ double noiseNaiveGet1DValue(double x)
|
|||
buf_cubic_x[2] = _noise_pool[x2 % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[x3 % _noise_pool_size];
|
||||
|
||||
return toolsCubicInterpolate(buf_cubic_x, xinternal) * 0.837 + 0.5;
|
||||
return Interpolation::cubic(buf_cubic_x, xinternal) * 0.837 + 0.5;
|
||||
}
|
||||
|
||||
double noiseNaiveGet2DValue(double x, double y)
|
||||
|
|
@ -156,27 +162,27 @@ double noiseNaiveGet2DValue(double x, double y)
|
|||
buf_cubic_x[1] = _noise_pool[(y0 * size + x1) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y0 * size + x2) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y0 * size + x3) % _noise_pool_size];
|
||||
buf_cubic_y[0] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[0] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y1 * size + x0) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y1 * size + x1) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y1 * size + x2) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y1 * size + x3) % _noise_pool_size];
|
||||
buf_cubic_y[1] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[1] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y2 * size + x0) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y2 * size + x1) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y2 * size + x2) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y2 * size + x3) % _noise_pool_size];
|
||||
buf_cubic_y[2] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[2] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y3 * size + x0) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y3 * size + x1) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y3 * size + x2) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y3 * size + x3) % _noise_pool_size];
|
||||
buf_cubic_y[3] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[3] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
return toolsCubicInterpolate(buf_cubic_y, yinternal) * 0.723 + 0.5;
|
||||
return Interpolation::cubic(buf_cubic_y, yinternal) * 0.723 + 0.5;
|
||||
}
|
||||
|
||||
double noiseNaiveGet3DValue(double x, double y, double z)
|
||||
|
|
@ -266,107 +272,107 @@ double noiseNaiveGet3DValue(double x, double y, double z)
|
|||
buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y0 * size * size + x3 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_y[0] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[0] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y1 * size * size + x3 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_y[1] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[1] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y2 * size * size + x3 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_y[2] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[2] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y3 * size * size + x3 * size + z0) % _noise_pool_size];
|
||||
buf_cubic_y[3] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[3] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_z[0] = toolsCubicInterpolate(buf_cubic_y, yinternal);
|
||||
buf_cubic_z[0] = Interpolation::cubic(buf_cubic_y, yinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y0 * size * size + x3 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_y[0] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[0] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y1 * size * size + x3 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_y[1] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[1] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y2 * size * size + x3 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_y[2] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[2] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y3 * size * size + x3 * size + z1) % _noise_pool_size];
|
||||
buf_cubic_y[3] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[3] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_z[1] = toolsCubicInterpolate(buf_cubic_y, yinternal);
|
||||
buf_cubic_z[1] = Interpolation::cubic(buf_cubic_y, yinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y0 * size * size + x3 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_y[0] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[0] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y1 * size * size + x3 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_y[1] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[1] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y2 * size * size + x3 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_y[2] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[2] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y3 * size * size + x3 * size + z2) % _noise_pool_size];
|
||||
buf_cubic_y[3] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[3] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_z[2] = toolsCubicInterpolate(buf_cubic_y, yinternal);
|
||||
buf_cubic_z[2] = Interpolation::cubic(buf_cubic_y, yinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y0 * size * size + x0 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y0 * size * size + x1 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y0 * size * size + x2 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y0 * size * size + x3 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_y[0] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[0] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y1 * size * size + x0 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y1 * size * size + x1 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y1 * size * size + x2 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y1 * size * size + x3 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_y[1] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[1] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y2 * size * size + x0 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y2 * size * size + x1 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y2 * size * size + x2 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y2 * size * size + x3 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_y[2] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[2] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_x[0] = _noise_pool[(y3 * size * size + x0 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[1] = _noise_pool[(y3 * size * size + x1 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[2] = _noise_pool[(y3 * size * size + x2 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_x[3] = _noise_pool[(y3 * size * size + x3 * size + z3) % _noise_pool_size];
|
||||
buf_cubic_y[3] = toolsCubicInterpolate(buf_cubic_x, xinternal);
|
||||
buf_cubic_y[3] = Interpolation::cubic(buf_cubic_x, xinternal);
|
||||
|
||||
buf_cubic_z[3] = toolsCubicInterpolate(buf_cubic_y, yinternal);
|
||||
buf_cubic_z[3] = Interpolation::cubic(buf_cubic_y, yinternal);
|
||||
|
||||
return toolsCubicInterpolate(buf_cubic_z, zinternal) * 0.794 + 0.5;
|
||||
return Interpolation::cubic(buf_cubic_z, zinternal) * 0.794 + 0.5;
|
||||
}
|
||||
|
||||
/*double noiseNaiveGet4DValue(double x, double y, double z, double w)
|
||||
30
src/basics/NoiseFunctionNaive.h
Normal file
30
src/basics/NoiseFunctionNaive.h
Normal file
|
|
@ -0,0 +1,30 @@
|
|||
#ifndef NOISEFUNCTIONNAIVE_H
|
||||
#define NOISEFUNCTIONNAIVE_H
|
||||
|
||||
#include "basics_global.h"
|
||||
|
||||
namespace paysages {
|
||||
namespace system {
|
||||
class PackStream;
|
||||
}
|
||||
namespace basics {
|
||||
|
||||
class NoiseFunctionNaive
|
||||
{
|
||||
public:
|
||||
NoiseFunctionNaive();
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void noiseNaiveInit();
|
||||
void noiseNaiveQuit();
|
||||
void noiseNaiveSave(PackStream* stream);
|
||||
void noiseNaiveLoad(PackStream* stream);
|
||||
double noiseNaiveGet1DValue(double x);
|
||||
double noiseNaiveGet2DValue(double x, double y);
|
||||
double noiseNaiveGet3DValue(double x, double y, double z);
|
||||
/*double noiseNaiveGet4DValue(double x, double y, double z, double w);*/
|
||||
|
||||
#endif // NOISEFUNCTIONNAIVE_H
|
||||
188
src/basics/NoiseFunctionPerlin.cpp
Normal file
188
src/basics/NoiseFunctionPerlin.cpp
Normal file
|
|
@ -0,0 +1,188 @@
|
|||
#include "NoiseFunctionPerlin.h"
|
||||
|
||||
/*
|
||||
* Perlin noise implementation.
|
||||
*
|
||||
* Based on Ken Perlin implementation.
|
||||
*/
|
||||
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
|
||||
NoiseFunctionPerlin::NoiseFunctionPerlin()
|
||||
{
|
||||
}
|
||||
|
||||
#define B 0x100
|
||||
#define BM 0xff
|
||||
|
||||
#define N 0x1000
|
||||
#define NP 12 /* 2^N */
|
||||
#define NM 0xfff
|
||||
|
||||
static int p[B + B + 2];
|
||||
static double g3[B + B + 2][3];
|
||||
static double g2[B + B + 2][2];
|
||||
static double g1[B + B + 2];
|
||||
|
||||
#define s_curve(t) ( t * t * (3. - 2. * t) )
|
||||
|
||||
#define lerp(t, a, b) ( a + t * (b - a) )
|
||||
|
||||
#define setup(i,b0,b1,r0,r1)\
|
||||
t = vec[i] + N;\
|
||||
b0 = ((int)t) & BM;\
|
||||
b1 = (b0+1) & BM;\
|
||||
r0 = t - (int)t;\
|
||||
r1 = r0 - 1.;
|
||||
|
||||
double noisePerlinGet1DValue(double x)
|
||||
{
|
||||
double vec[1] = {x*2.0};
|
||||
int bx0, bx1;
|
||||
double rx0, rx1, sx, t, u, v;
|
||||
|
||||
setup(0, bx0,bx1, rx0,rx1);
|
||||
|
||||
sx = s_curve(rx0);
|
||||
|
||||
u = rx0 * g1[ p[ bx0 ] ];
|
||||
v = rx1 * g1[ p[ bx1 ] ];
|
||||
|
||||
return lerp(sx, u, v) * 1.068 + 0.5;
|
||||
}
|
||||
|
||||
double noisePerlinGet2DValue(double x, double y)
|
||||
{
|
||||
double vec[2] = {x*2.0, y*2.0};
|
||||
int bx0, bx1, by0, by1, b00, b10, b01, b11;
|
||||
double rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
|
||||
int i, j;
|
||||
|
||||
setup(0, bx0,bx1, rx0,rx1);
|
||||
setup(1, by0,by1, ry0,ry1);
|
||||
|
||||
i = p[ bx0 ];
|
||||
j = p[ bx1 ];
|
||||
|
||||
b00 = p[ i + by0 ];
|
||||
b10 = p[ j + by0 ];
|
||||
b01 = p[ i + by1 ];
|
||||
b11 = p[ j + by1 ];
|
||||
|
||||
sx = s_curve(rx0);
|
||||
sy = s_curve(ry0);
|
||||
|
||||
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
|
||||
|
||||
q = g2[ b00 ] ; u = at2(rx0,ry0);
|
||||
q = g2[ b10 ] ; v = at2(rx1,ry0);
|
||||
a = lerp(sx, u, v);
|
||||
|
||||
q = g2[ b01 ] ; u = at2(rx0,ry1);
|
||||
q = g2[ b11 ] ; v = at2(rx1,ry1);
|
||||
b = lerp(sx, u, v);
|
||||
|
||||
return lerp(sy, a, b) * 0.709 + 0.5;
|
||||
}
|
||||
|
||||
double noisePerlinGet3DValue(double x, double y, double z)
|
||||
{
|
||||
double vec[3] = {x*2.0, y*2.0, z*2.0};
|
||||
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
|
||||
double rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
|
||||
int i, j;
|
||||
|
||||
setup(0, bx0,bx1, rx0,rx1);
|
||||
setup(1, by0,by1, ry0,ry1);
|
||||
setup(2, bz0,bz1, rz0,rz1);
|
||||
|
||||
i = p[ bx0 ];
|
||||
j = p[ bx1 ];
|
||||
|
||||
b00 = p[ i + by0 ];
|
||||
b10 = p[ j + by0 ];
|
||||
b01 = p[ i + by1 ];
|
||||
b11 = p[ j + by1 ];
|
||||
|
||||
t = s_curve(rx0);
|
||||
sy = s_curve(ry0);
|
||||
sz = s_curve(rz0);
|
||||
|
||||
#define at3(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
|
||||
|
||||
q = g3[ b00 + bz0 ] ; u = at3(rx0,ry0,rz0);
|
||||
q = g3[ b10 + bz0 ] ; v = at3(rx1,ry0,rz0);
|
||||
a = lerp(t, u, v);
|
||||
|
||||
q = g3[ b01 + bz0 ] ; u = at3(rx0,ry1,rz0);
|
||||
q = g3[ b11 + bz0 ] ; v = at3(rx1,ry1,rz0);
|
||||
b = lerp(t, u, v);
|
||||
|
||||
c = lerp(sy, a, b);
|
||||
|
||||
q = g3[ b00 + bz1 ] ; u = at3(rx0,ry0,rz1);
|
||||
q = g3[ b10 + bz1 ] ; v = at3(rx1,ry0,rz1);
|
||||
a = lerp(t, u, v);
|
||||
|
||||
q = g3[ b01 + bz1 ] ; u = at3(rx0,ry1,rz1);
|
||||
q = g3[ b11 + bz1 ] ; v = at3(rx1,ry1,rz1);
|
||||
b = lerp(t, u, v);
|
||||
|
||||
d = lerp(sy, a, b);
|
||||
|
||||
return lerp(sz, c, d) * 0.661 + 0.5;
|
||||
}
|
||||
|
||||
static void _normalize2(double v[2])
|
||||
{
|
||||
double s;
|
||||
|
||||
s = sqrt(v[0] * v[0] + v[1] * v[1]);
|
||||
v[0] = v[0] / s;
|
||||
v[1] = v[1] / s;
|
||||
}
|
||||
|
||||
static void _normalize3(double v[3])
|
||||
{
|
||||
double s;
|
||||
|
||||
s = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
|
||||
v[0] = v[0] / s;
|
||||
v[1] = v[1] / s;
|
||||
v[2] = v[2] / s;
|
||||
}
|
||||
|
||||
void noisePerlinInit(void)
|
||||
{
|
||||
int i, j, k;
|
||||
|
||||
for (i = 0 ; i < B ; i++) {
|
||||
p[i] = i;
|
||||
|
||||
g1[i] = (double)((rand() % (B + B)) - B) / B;
|
||||
|
||||
for (j = 0 ; j < 2 ; j++)
|
||||
g2[i][j] = (double)((rand() % (B + B)) - B) / B;
|
||||
_normalize2(g2[i]);
|
||||
|
||||
for (j = 0 ; j < 3 ; j++)
|
||||
g3[i][j] = (double)((rand() % (B + B)) - B) / B;
|
||||
_normalize3(g3[i]);
|
||||
}
|
||||
|
||||
while (--i) {
|
||||
k = p[i];
|
||||
p[i] = p[j = rand() % B];
|
||||
p[j] = k;
|
||||
}
|
||||
|
||||
for (i = 0 ; i < B + 2 ; i++) {
|
||||
p[B + i] = p[i];
|
||||
g1[B + i] = g1[i];
|
||||
for (j = 0 ; j < 2 ; j++)
|
||||
g2[B + i][j] = g2[i][j];
|
||||
for (j = 0 ; j < 3 ; j++)
|
||||
g3[B + i][j] = g3[i][j];
|
||||
}
|
||||
}
|
||||
27
src/basics/NoiseFunctionPerlin.h
Normal file
27
src/basics/NoiseFunctionPerlin.h
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
#ifndef NOISEFUNCTIONPERLIN_H
|
||||
#define NOISEFUNCTIONPERLIN_H
|
||||
|
||||
#include "basics_global.h"
|
||||
|
||||
namespace paysages {
|
||||
namespace system {
|
||||
class PackStream;
|
||||
}
|
||||
namespace basics {
|
||||
|
||||
class NoiseFunctionPerlin
|
||||
{
|
||||
public:
|
||||
NoiseFunctionPerlin();
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void noisePerlinInit();
|
||||
double noisePerlinGet1DValue(double x);
|
||||
double noisePerlinGet2DValue(double x, double y);
|
||||
double noisePerlinGet3DValue(double x, double y, double z);
|
||||
/*double noiseSimplexGet4DValue(double x, double y, double z, double w);*/
|
||||
|
||||
#endif // NOISEFUNCTIONPERLIN_H
|
||||
|
|
@ -1,4 +1,4 @@
|
|||
#include "noisesimplex.h"
|
||||
#include "NoiseFunctionSimplex.h"
|
||||
|
||||
/*
|
||||
* Simplex noise implementation.
|
||||
|
|
@ -6,9 +6,13 @@
|
|||
* Based on Stefan Gustavson implementation.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <cstdlib>
|
||||
#include <cmath>
|
||||
#include <cstring>
|
||||
|
||||
NoiseFunctionSimplex::NoiseFunctionSimplex()
|
||||
{
|
||||
}
|
||||
|
||||
typedef struct
|
||||
{
|
||||
27
src/basics/NoiseFunctionSimplex.h
Normal file
27
src/basics/NoiseFunctionSimplex.h
Normal file
|
|
@ -0,0 +1,27 @@
|
|||
#ifndef NOISEFUNCTIONSIMPLEX_H
|
||||
#define NOISEFUNCTIONSIMPLEX_H
|
||||
|
||||
#include "basics_global.h"
|
||||
|
||||
namespace paysages {
|
||||
namespace system {
|
||||
class PackStream;
|
||||
}
|
||||
namespace basics {
|
||||
|
||||
class NoiseFunctionSimplex
|
||||
{
|
||||
public:
|
||||
NoiseFunctionSimplex();
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
void noiseSimplexInit();
|
||||
double noiseSimplexGet1DValue(double x);
|
||||
double noiseSimplexGet2DValue(double x, double y);
|
||||
double noiseSimplexGet3DValue(double x, double y, double z);
|
||||
double noiseSimplexGet4DValue(double x, double y, double z, double w);
|
||||
|
||||
#endif // NOISEFUNCTIONSIMPLEX_H
|
||||
597
src/basics/NoiseGenerator.cpp
Normal file
597
src/basics/NoiseGenerator.cpp
Normal file
|
|
@ -0,0 +1,597 @@
|
|||
#include "NoiseGenerator.h"
|
||||
|
||||
#include "NoiseFunctionNaive.h"
|
||||
#include "NoiseFunctionPerlin.h"
|
||||
#include "NoiseFunctionSimplex.h"
|
||||
#include "PackStream.h"
|
||||
#include "RandomGenerator.h"
|
||||
#include <cmath>
|
||||
|
||||
#define MAX_LEVEL_COUNT 30
|
||||
|
||||
void noiseInit()
|
||||
{
|
||||
noiseSimplexInit();
|
||||
noisePerlinInit();
|
||||
noiseNaiveInit();
|
||||
|
||||
/* Noise stats */
|
||||
/*NoiseGenerator* noise;
|
||||
int x;
|
||||
double min, max, value;
|
||||
noise = noiseCreateGenerator();
|
||||
noiseSetFunctionParams(noise, NOISE_FUNCTION_NAIVE, 0.0);
|
||||
noiseAddLevelSimple(noise, 1.0, 0.0, 1.0);
|
||||
min = 100000.0;
|
||||
max = -100000.0;
|
||||
for (x = 0; x < 1000000; x++)
|
||||
{
|
||||
value = noiseGet1DTotal(noise, toolsRandom() * 10000.0);
|
||||
value = noiseGet2DTotal(noise, toolsRandom() * 10000.0, toolsRandom() * 10000.0);
|
||||
value = noiseGet3DTotal(noise, toolsRandom() * 10000.0, toolsRandom() * 10000.0, toolsRandom() * 10000.0);
|
||||
if (value < min) min = value;
|
||||
if (value > max) max = value;
|
||||
}
|
||||
printf("%f %f\n", min, max);
|
||||
noiseDeleteGenerator(noise);*/
|
||||
}
|
||||
|
||||
void noiseQuit()
|
||||
{
|
||||
noiseNaiveQuit();
|
||||
}
|
||||
|
||||
void noiseSave(PackStream* stream)
|
||||
{
|
||||
noiseNaiveSave(stream);
|
||||
}
|
||||
|
||||
void noiseLoad(PackStream* stream)
|
||||
{
|
||||
noiseNaiveLoad(stream);
|
||||
}
|
||||
|
||||
NoiseGenerator::NoiseGenerator()
|
||||
{
|
||||
function.algorithm = NOISE_FUNCTION_SIMPLEX;
|
||||
function.ridge_factor = 0.0;
|
||||
function.curve_factor = 0.0;
|
||||
level_count = 0;
|
||||
height_offset = 0.0;
|
||||
|
||||
randomizeOffsets();
|
||||
validate();
|
||||
}
|
||||
|
||||
NoiseGenerator::~NoiseGenerator()
|
||||
{
|
||||
}
|
||||
|
||||
void NoiseGenerator::save(PackStream* stream)
|
||||
{
|
||||
int x;
|
||||
|
||||
x = (int)function.algorithm;
|
||||
stream->write(&x);
|
||||
stream->write(&function.ridge_factor);
|
||||
stream->write(&function.curve_factor);
|
||||
|
||||
stream->write(&height_offset);
|
||||
stream->write(&level_count);
|
||||
|
||||
for (x = 0; x < level_count; x++)
|
||||
{
|
||||
NoiseLevel* level = levels + x;
|
||||
|
||||
stream->write(&level->wavelength);
|
||||
stream->write(&level->amplitude);
|
||||
stream->write(&level->minvalue);
|
||||
stream->write(&level->xoffset);
|
||||
stream->write(&level->yoffset);
|
||||
stream->write(&level->zoffset);
|
||||
}
|
||||
}
|
||||
|
||||
void NoiseGenerator::load(PackStream* stream)
|
||||
{
|
||||
int x;
|
||||
|
||||
stream->read(&x);
|
||||
function.algorithm = (NoiseFunctionAlgorithm)x;
|
||||
stream->read(&function.ridge_factor);
|
||||
stream->read(&function.curve_factor);
|
||||
|
||||
stream->read(&height_offset);
|
||||
stream->read(&level_count);
|
||||
|
||||
for (x = 0; x < level_count; x++)
|
||||
{
|
||||
NoiseLevel* level = levels + x;
|
||||
|
||||
stream->read(&level->wavelength);
|
||||
stream->read(&level->amplitude);
|
||||
stream->read(&level->minvalue);
|
||||
stream->read(&level->xoffset);
|
||||
stream->read(&level->yoffset);
|
||||
stream->read(&level->zoffset);
|
||||
}
|
||||
|
||||
validate();
|
||||
}
|
||||
|
||||
void NoiseGenerator::copy(NoiseGenerator* destination)
|
||||
{
|
||||
destination->function = function;
|
||||
destination->height_offset = height_offset;
|
||||
destination->level_count = level_count;
|
||||
|
||||
memcpy(destination->levels, levels, sizeof(NoiseLevel) * destination->level_count);
|
||||
|
||||
validate();
|
||||
}
|
||||
|
||||
void NoiseGenerator::validate()
|
||||
{
|
||||
int x;
|
||||
|
||||
if (function.algorithm < 0 || function.algorithm > NOISE_FUNCTION_NAIVE)
|
||||
{
|
||||
function.algorithm = NOISE_FUNCTION_SIMPLEX;
|
||||
}
|
||||
switch (function.algorithm)
|
||||
{
|
||||
case NOISE_FUNCTION_SIMPLEX:
|
||||
_func_noise_1d = noiseSimplexGet1DValue;
|
||||
_func_noise_2d = noiseSimplexGet2DValue;
|
||||
_func_noise_3d = noiseSimplexGet3DValue;
|
||||
break;
|
||||
case NOISE_FUNCTION_PERLIN:
|
||||
_func_noise_1d = noisePerlinGet1DValue;
|
||||
_func_noise_2d = noisePerlinGet2DValue;
|
||||
_func_noise_3d = noisePerlinGet3DValue;
|
||||
break;
|
||||
case NOISE_FUNCTION_NAIVE:
|
||||
_func_noise_1d = noiseNaiveGet1DValue;
|
||||
_func_noise_2d = noiseNaiveGet2DValue;
|
||||
_func_noise_3d = noiseNaiveGet3DValue;
|
||||
break;
|
||||
}
|
||||
|
||||
if (function.ridge_factor > 0.5)
|
||||
{
|
||||
function.ridge_factor = 0.5;
|
||||
}
|
||||
if (function.ridge_factor < -0.5)
|
||||
{
|
||||
function.ridge_factor = -0.5;
|
||||
}
|
||||
if (function.curve_factor > 1.0)
|
||||
{
|
||||
function.curve_factor = 1.0;
|
||||
}
|
||||
if (function.curve_factor < -1.0)
|
||||
{
|
||||
function.curve_factor = -1.0;
|
||||
}
|
||||
|
||||
_min_value = height_offset;
|
||||
_max_value = height_offset;
|
||||
for (x = 0; x < level_count; x++)
|
||||
{
|
||||
_min_value += levels[x].minvalue;
|
||||
_max_value += levels[x].minvalue + levels[x].amplitude;
|
||||
}
|
||||
}
|
||||
|
||||
void NoiseGenerator::randomizeOffsets()
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < MAX_LEVEL_COUNT; i++)
|
||||
{
|
||||
levels[i].xoffset = RandomGenerator::random();
|
||||
levels[i].yoffset = RandomGenerator::random();
|
||||
levels[i].zoffset = RandomGenerator::random();
|
||||
}
|
||||
}
|
||||
|
||||
NoiseFunction NoiseGenerator::getFunction()
|
||||
{
|
||||
return function;
|
||||
}
|
||||
|
||||
void NoiseGenerator::setFunction(NoiseFunction* function)
|
||||
{
|
||||
this->function = *function;
|
||||
validate();
|
||||
}
|
||||
|
||||
void NoiseGenerator::setCustomFunction(double (*func1d)(double x), double (*func2d)(double x, double y), double (*func3d)(double x, double y, double z))
|
||||
{
|
||||
this->_func_noise_1d = func1d;
|
||||
this->_func_noise_2d = func2d;
|
||||
this->_func_noise_3d = func3d;
|
||||
}
|
||||
|
||||
void NoiseGenerator::setFunctionParams(NoiseFunctionAlgorithm algorithm, double ridge_factor, double curve_factor)
|
||||
{
|
||||
NoiseFunction function = {algorithm, ridge_factor, curve_factor};
|
||||
setFunction(&function);
|
||||
}
|
||||
|
||||
void NoiseGenerator::forceValue(double value)
|
||||
{
|
||||
clearLevels();
|
||||
height_offset = value;
|
||||
addLevelSimple(1.0, 0.0, 0.0); /* FIXME Should not be needed */
|
||||
}
|
||||
|
||||
void NoiseGenerator::getRange(double* minvalue, double* maxvalue)
|
||||
{
|
||||
*minvalue = _min_value;
|
||||
*maxvalue = _max_value;
|
||||
}
|
||||
|
||||
int NoiseGenerator::getLevelCount()
|
||||
{
|
||||
return level_count;
|
||||
}
|
||||
|
||||
void NoiseGenerator::clearLevels()
|
||||
{
|
||||
level_count = 0;
|
||||
validate();
|
||||
}
|
||||
|
||||
void NoiseGenerator::addLevel(NoiseLevel level, int protect_offsets)
|
||||
{
|
||||
if (level_count < MAX_LEVEL_COUNT)
|
||||
{
|
||||
NoiseLevel baselevel = levels[level_count];
|
||||
|
||||
if (protect_offsets)
|
||||
{
|
||||
level.xoffset = baselevel.xoffset;
|
||||
level.yoffset = baselevel.yoffset;
|
||||
level.zoffset = baselevel.zoffset;
|
||||
}
|
||||
|
||||
levels[level_count] = level;
|
||||
level_count++;
|
||||
validate();
|
||||
}
|
||||
}
|
||||
|
||||
void NoiseGenerator::addLevelSimple(double scaling, double minvalue, double maxvalue)
|
||||
{
|
||||
NoiseLevel level;
|
||||
|
||||
level.wavelength = scaling;
|
||||
level.minvalue = minvalue;
|
||||
level.amplitude = maxvalue - minvalue;
|
||||
|
||||
addLevel(level, 1);
|
||||
}
|
||||
|
||||
void NoiseGenerator::addLevels(int level_count, NoiseLevel start_level, double scaling_factor, double amplitude_factor, double center_factor)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < level_count; i++)
|
||||
{
|
||||
addLevel(start_level, 1);
|
||||
start_level.minvalue += start_level.amplitude * (1.0 - amplitude_factor) * center_factor;
|
||||
start_level.wavelength *= scaling_factor;
|
||||
start_level.amplitude *= amplitude_factor;
|
||||
}
|
||||
}
|
||||
|
||||
void NoiseGenerator::addLevelsSimple(int level_count, double scaling, double minvalue, double maxvalue, double center_factor)
|
||||
{
|
||||
NoiseLevel level;
|
||||
|
||||
level.wavelength = scaling;
|
||||
level.minvalue = minvalue;
|
||||
level.amplitude = maxvalue - minvalue;
|
||||
addLevels(level_count, level, 0.5, 0.5, center_factor);
|
||||
}
|
||||
|
||||
void NoiseGenerator::removeLevel(int level)
|
||||
{
|
||||
if (level >= 0 && level < level_count)
|
||||
{
|
||||
if (level_count > 1 && level < level_count - 1)
|
||||
{
|
||||
memmove(levels + level, levels + level + 1, sizeof(NoiseLevel) * (level_count - level - 1));
|
||||
}
|
||||
level_count--;
|
||||
validate();
|
||||
}
|
||||
}
|
||||
|
||||
int NoiseGenerator::getLevel(int level, NoiseLevel* params)
|
||||
{
|
||||
if (level >= 0 && level < level_count)
|
||||
{
|
||||
*params = levels[level];
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void NoiseGenerator::setLevel(int index, NoiseLevel level, int protect_offsets)
|
||||
{
|
||||
if (index >= 0 && index < level_count)
|
||||
{
|
||||
NoiseLevel baselevel = levels[index];
|
||||
|
||||
if (protect_offsets)
|
||||
{
|
||||
level.xoffset = baselevel.xoffset;
|
||||
level.yoffset = baselevel.yoffset;
|
||||
level.zoffset = baselevel.zoffset;
|
||||
}
|
||||
|
||||
levels[index] = level;
|
||||
validate();
|
||||
}
|
||||
}
|
||||
|
||||
void NoiseGenerator::setLevelSimple(int index, double scaling, double minvalue, double maxvalue)
|
||||
{
|
||||
NoiseLevel level;
|
||||
|
||||
level.wavelength = scaling;
|
||||
level.minvalue = minvalue;
|
||||
level.amplitude = maxvalue - minvalue;
|
||||
|
||||
setLevel(index, level, 1);
|
||||
}
|
||||
|
||||
void NoiseGenerator::normalizeAmplitude(double minvalue, double maxvalue, int adjust_scaling)
|
||||
{
|
||||
int level;
|
||||
double current_minvalue, current_maxvalue, current_amplitude;
|
||||
double target_amplitude, factor;
|
||||
|
||||
if (level_count == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
target_amplitude = maxvalue - minvalue;
|
||||
getRange(¤t_minvalue, ¤t_maxvalue);
|
||||
current_amplitude = current_maxvalue - current_minvalue;
|
||||
factor = target_amplitude / current_amplitude;
|
||||
|
||||
for (level = 0; level < level_count; level++)
|
||||
{
|
||||
levels[level].minvalue *= factor;
|
||||
levels[level].amplitude *= factor;
|
||||
if (adjust_scaling)
|
||||
{
|
||||
levels[level].wavelength *= factor;
|
||||
}
|
||||
}
|
||||
height_offset = minvalue + (height_offset - current_minvalue) * factor;
|
||||
validate();
|
||||
}
|
||||
|
||||
static inline double _fixValue(double value, double ridge, double curve)
|
||||
{
|
||||
if (value < 0.0)
|
||||
{
|
||||
value = 0.0;
|
||||
}
|
||||
else if (value > 1.0)
|
||||
{
|
||||
value = 1.0;
|
||||
}
|
||||
|
||||
if (curve > 0.0)
|
||||
{
|
||||
value = value * (1.0 - curve) + sqrt(value) * curve;
|
||||
}
|
||||
else if (curve < 0.0)
|
||||
{
|
||||
value = value * (1.0 - curve) + value * value * curve;
|
||||
}
|
||||
|
||||
if (ridge > 0.0)
|
||||
{
|
||||
return fabs(value - ridge) / (1.0 - ridge);
|
||||
}
|
||||
else if (ridge < 0.0)
|
||||
{
|
||||
return 1.0 - fabs(value - 1.0 - ridge) / (1.0 + ridge);
|
||||
}
|
||||
else
|
||||
{
|
||||
return value;
|
||||
}
|
||||
/*if (ridge > 0.0)
|
||||
{
|
||||
return fabs(value + 0.5 - ridge) - 0.5 + ridge;
|
||||
}
|
||||
else if (ridge < 0.0)
|
||||
{
|
||||
return -fabs(value - 0.5 - ridge) + 0.5 + ridge;
|
||||
}
|
||||
else
|
||||
{
|
||||
return value;
|
||||
}*/
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
inline double NoiseGenerator::_get1DLevelValue(NoiseLevel* level, double x)
|
||||
{
|
||||
return level->minvalue + _fixValue(_func_noise_1d(x / level->wavelength + level->xoffset), function.ridge_factor, function.curve_factor) * level->amplitude;
|
||||
}
|
||||
|
||||
double NoiseGenerator::get1DLevel(int level, double x)
|
||||
{
|
||||
if (level >= 0 && level < level_count)
|
||||
{
|
||||
return _get1DLevelValue(levels + level, x);
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
double NoiseGenerator::get1DTotal(double x)
|
||||
{
|
||||
int level;
|
||||
double result;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < level_count; level++)
|
||||
{
|
||||
result += _get1DLevelValue(levels + level, x);
|
||||
}
|
||||
return result + height_offset;
|
||||
}
|
||||
|
||||
double NoiseGenerator::get1DDetail(double x, double detail)
|
||||
{
|
||||
int level;
|
||||
double result, height, factor;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < level_count; level++)
|
||||
{
|
||||
height = levels[level].amplitude;
|
||||
factor = 1.0;
|
||||
if (height < detail * 0.25)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if (height < detail * 0.5)
|
||||
{
|
||||
factor = (detail * 0.5 - height) / 0.25;
|
||||
}
|
||||
|
||||
result += _get1DLevelValue(levels + level, x) * factor;
|
||||
}
|
||||
return result + height_offset;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
inline double NoiseGenerator::_get2DLevelValue(NoiseLevel* level, double x, double y)
|
||||
{
|
||||
return level->minvalue + _fixValue(_func_noise_2d(x / level->wavelength + level->xoffset, y / level->wavelength + level->yoffset), function.ridge_factor, function.curve_factor) * level->amplitude;
|
||||
}
|
||||
|
||||
double NoiseGenerator::get2DLevel(int level, double x, double y)
|
||||
{
|
||||
if (level >= 0 && level < level_count)
|
||||
{
|
||||
return _get2DLevelValue(levels + level, x, y);
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
double NoiseGenerator::get2DTotal(double x, double y)
|
||||
{
|
||||
int level;
|
||||
double result;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < level_count; level++)
|
||||
{
|
||||
result += _get2DLevelValue(levels + level, x, y);
|
||||
}
|
||||
return result + height_offset;
|
||||
}
|
||||
|
||||
double NoiseGenerator::get2DDetail(double x, double y, double detail)
|
||||
{
|
||||
int level;
|
||||
double result, height, factor;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < level_count; level++)
|
||||
{
|
||||
height = levels[level].amplitude;
|
||||
factor = 1.0;
|
||||
if (height < detail * 0.25)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if (height < detail * 0.5)
|
||||
{
|
||||
factor = (detail * 0.5 - height) / 0.25;
|
||||
}
|
||||
|
||||
result += _get2DLevelValue(levels + level, x, y) * factor;
|
||||
}
|
||||
return result + height_offset;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
inline double NoiseGenerator::_get3DLevelValue(NoiseLevel* level, double x, double y, double z)
|
||||
{
|
||||
return level->minvalue + _fixValue(_func_noise_3d(x / level->wavelength + level->xoffset, y / level->wavelength + level->yoffset, z / level->wavelength + level->zoffset), function.ridge_factor, function.curve_factor) * level->amplitude;
|
||||
}
|
||||
|
||||
double NoiseGenerator::get3DLevel(int level, double x, double y, double z)
|
||||
{
|
||||
if (level >= 0 && level < level_count)
|
||||
{
|
||||
return _get3DLevelValue(levels + level, x, y, z);
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
double NoiseGenerator::get3DTotal(double x, double y, double z)
|
||||
{
|
||||
int level;
|
||||
double result;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < level_count; level++)
|
||||
{
|
||||
result += _get3DLevelValue(levels + level, x, y, z);
|
||||
}
|
||||
return result + height_offset;
|
||||
}
|
||||
|
||||
double NoiseGenerator::get3DDetail(double x, double y, double z, double detail)
|
||||
{
|
||||
int level;
|
||||
double result, height, factor;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < level_count; level++)
|
||||
{
|
||||
height = levels[level].amplitude;
|
||||
factor = 1.0;
|
||||
if (height < detail * 0.25)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if (height < detail * 0.5)
|
||||
{
|
||||
factor = (detail * 0.5 - height) / 0.25;
|
||||
}
|
||||
|
||||
result += _get3DLevelValue(levels + level, x, y, z) * factor;
|
||||
}
|
||||
return result + height_offset;
|
||||
}
|
||||
100
src/basics/NoiseGenerator.h
Normal file
100
src/basics/NoiseGenerator.h
Normal file
|
|
@ -0,0 +1,100 @@
|
|||
#ifndef NOISEGENERATOR_H
|
||||
#define NOISEGENERATOR_H
|
||||
|
||||
#include "basics_global.h"
|
||||
|
||||
#define MAX_LEVEL_COUNT 30
|
||||
|
||||
typedef enum
|
||||
{
|
||||
NOISE_FUNCTION_SIMPLEX,
|
||||
NOISE_FUNCTION_PERLIN,
|
||||
NOISE_FUNCTION_NAIVE
|
||||
} NoiseFunctionAlgorithm;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
NoiseFunctionAlgorithm algorithm;
|
||||
double ridge_factor; /* -0.5;0.5 */
|
||||
double curve_factor; /* -1.0;1.0 */
|
||||
} NoiseFunction;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
double wavelength;
|
||||
double amplitude;
|
||||
double minvalue;
|
||||
double xoffset;
|
||||
double yoffset;
|
||||
double zoffset;
|
||||
} NoiseLevel;
|
||||
|
||||
namespace paysages {
|
||||
namespace system {class PackStream;}
|
||||
namespace basics {
|
||||
|
||||
class BASICSSHARED_EXPORT NoiseGenerator
|
||||
{
|
||||
public:
|
||||
NoiseGenerator();
|
||||
virtual ~NoiseGenerator();
|
||||
|
||||
virtual void save(PackStream* stream);
|
||||
virtual void load(PackStream* stream);
|
||||
virtual void copy(NoiseGenerator* destination);
|
||||
virtual void validate();
|
||||
|
||||
void randomizeOffsets();
|
||||
NoiseFunction getFunction();
|
||||
void setCustomFunction(double (*func1d)(double x), double (*func2d)(double x, double y), double (*func3d)(double x, double y, double z));
|
||||
void setFunction(NoiseFunction* function);
|
||||
void setFunctionParams(NoiseFunctionAlgorithm algorithm, double ridge_factor, double curve_factor);
|
||||
void forceValue(double value);
|
||||
void getRange(double* minvalue, double* maxvalue);
|
||||
int getLevelCount();
|
||||
void clearLevels();
|
||||
void addLevel(NoiseLevel level, int protect_offsets);
|
||||
void addLevelSimple(double scaling, double minvalue, double maxvalue);
|
||||
void addLevels(int level_count, NoiseLevel start_level, double scaling_factor, double amplitude_factor, double center_factor);
|
||||
void addLevelsSimple(int level_count, double scaling, double minvalue, double maxvalue, double center_factor);
|
||||
void removeLevel(int level);
|
||||
int getLevel(int level, NoiseLevel* params);
|
||||
void setLevel(int index, NoiseLevel level, int protect_offsets);
|
||||
void setLevelSimple(int index, double scaling, double minvalue, double maxvalue);
|
||||
void normalizeAmplitude(double minvalue, double maxvalue, int adjust_scaling);
|
||||
double get1DLevel(int level, double x);
|
||||
double get1DTotal(double x);
|
||||
double get1DDetail(double x, double detail);
|
||||
double get2DLevel(int level, double x, double y);
|
||||
double get2DTotal(double x, double y);
|
||||
double get2DDetail(double x, double y, double detail);
|
||||
double get3DLevel(int level, double x, double y, double z);
|
||||
double get3DTotal(double x, double y, double z);
|
||||
double get3DDetail(double x, double y, double z, double detail);
|
||||
|
||||
private:
|
||||
double _get1DLevelValue(NoiseLevel* level, double x);
|
||||
double _get2DLevelValue(NoiseLevel* level, double x, double y);
|
||||
double _get3DLevelValue(NoiseLevel* level, double x, double y, double z);
|
||||
|
||||
NoiseFunction function;
|
||||
double height_offset;
|
||||
int level_count;
|
||||
NoiseLevel levels[MAX_LEVEL_COUNT];
|
||||
|
||||
double _min_value;
|
||||
double _max_value;
|
||||
double (*_func_noise_1d)(double x);
|
||||
double (*_func_noise_2d)(double x, double y);
|
||||
double (*_func_noise_3d)(double x, double y, double z);
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
BASICSSHARED_EXPORT void noiseInit();
|
||||
BASICSSHARED_EXPORT void noiseQuit();
|
||||
BASICSSHARED_EXPORT void noiseSave(PackStream* stream);
|
||||
BASICSSHARED_EXPORT void noiseLoad(PackStream* stream);
|
||||
|
||||
#endif // NOISEGENERATOR_H
|
||||
|
|
@ -12,11 +12,21 @@ TEMPLATE = lib
|
|||
DEFINES += BASICS_LIBRARY
|
||||
|
||||
SOURCES += \
|
||||
ColorRGB.cpp
|
||||
ColorRGB.cpp \
|
||||
NoiseGenerator.cpp \
|
||||
NoiseFunctionNaive.cpp \
|
||||
NoiseFunctionPerlin.cpp \
|
||||
NoiseFunctionSimplex.cpp \
|
||||
Interpolation.cpp
|
||||
|
||||
HEADERS +=\
|
||||
basics_global.h \
|
||||
ColorRGB.h
|
||||
ColorRGB.h \
|
||||
NoiseGenerator.h \
|
||||
NoiseFunctionNaive.h \
|
||||
NoiseFunctionPerlin.h \
|
||||
NoiseFunctionSimplex.h \
|
||||
Interpolation.h
|
||||
|
||||
unix:!symbian {
|
||||
maemo5 {
|
||||
|
|
@ -26,3 +36,9 @@ unix:!symbian {
|
|||
}
|
||||
INSTALLS += target
|
||||
}
|
||||
|
||||
win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../system/release/ -lpaysages_system
|
||||
else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../system/debug/ -lpaysages_system
|
||||
else:unix: LIBS += -L$$OUT_PWD/../system/ -lpaysages_system
|
||||
INCLUDEPATH += $$PWD/../system
|
||||
DEPENDPATH += $$PWD/../system
|
||||
|
|
|
|||
|
|
@ -2,17 +2,7 @@
|
|||
#define BASICS_GLOBAL_H
|
||||
|
||||
/* Shared object helpers */
|
||||
#ifdef __cplusplus
|
||||
# include <QtCore/qglobal.h>
|
||||
#else
|
||||
# if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
|
||||
# define Q_DECL_EXPORT __declspec(dllexport)
|
||||
# define Q_DECL_IMPORT __declspec(dllimport)
|
||||
# else
|
||||
# define Q_DECL_EXPORT
|
||||
# define Q_DECL_IMPORT
|
||||
# endif
|
||||
#endif
|
||||
#include <QtCore/qglobal.h>
|
||||
#if defined(DEFINITION_LIBRARY)
|
||||
# define BASICSSHARED_EXPORT Q_DECL_EXPORT
|
||||
#else
|
||||
|
|
@ -20,14 +10,12 @@
|
|||
#endif
|
||||
|
||||
/* Namespace using */
|
||||
#ifdef __cplusplus
|
||||
namespace paysages
|
||||
{
|
||||
namespace system {}
|
||||
namespace basics {}
|
||||
}
|
||||
using namespace paysages::system;
|
||||
#endif
|
||||
|
||||
/* Global imports */
|
||||
using namespace paysages::basics;
|
||||
|
||||
#endif // BASICS_GLOBAL_H
|
||||
|
|
|
|||
|
|
@ -9,14 +9,23 @@
|
|||
#include "rendering/shared/types.h"
|
||||
#include "rendering/tools/curve.h"
|
||||
#include "rendering/tools/color.h"
|
||||
#include "PackStream.h"
|
||||
#include "rendering/tools/lighting.h"
|
||||
#include "rendering/noise.h"
|
||||
#include "Layers.h"
|
||||
|
||||
class QPushButton;
|
||||
class QComboBox;
|
||||
|
||||
namespace paysages {
|
||||
namespace system {
|
||||
class PackStream;
|
||||
}
|
||||
namespace basics {
|
||||
class NoiseGenerator;
|
||||
}
|
||||
namespace definition {
|
||||
class Layers;
|
||||
}
|
||||
}
|
||||
|
||||
class BaseForm : public QWidget
|
||||
{
|
||||
Q_OBJECT
|
||||
|
|
|
|||
|
|
@ -19,7 +19,7 @@ public:
|
|||
PreviewLevel(QWidget* parent, NoiseGenerator* noise): BasePreview(parent)
|
||||
{
|
||||
_noise_original = noise;
|
||||
_noise_preview = noiseCreateGenerator();
|
||||
_noise_preview = new NoiseGenerator();
|
||||
_level = -1;
|
||||
|
||||
configScaling(0.15, 6.0, 0.09, 6.0);
|
||||
|
|
@ -33,11 +33,11 @@ public:
|
|||
protected:
|
||||
void updateData()
|
||||
{
|
||||
noiseCopy(_noise_original, _noise_preview);
|
||||
_noise_original->copy(_noise_preview);
|
||||
}
|
||||
Color getColor(double x, double y)
|
||||
{
|
||||
if ((_level >= 0) && (-y > noiseGet1DLevel(_noise_preview, _level, x)))
|
||||
if ((_level >= 0) && (-y > _noise_preview->get1DLevel(_level, x)))
|
||||
{
|
||||
return COLOR_WHITE;
|
||||
}
|
||||
|
|
@ -58,18 +58,18 @@ public:
|
|||
PreviewTotal(QWidget* parent, NoiseGenerator* noise): BasePreview(parent)
|
||||
{
|
||||
_noise_original = noise;
|
||||
_noise_preview = noiseCreateGenerator();
|
||||
_noise_preview = new NoiseGenerator();
|
||||
|
||||
configScaling(0.15, 6.0, 0.09, 6.0);
|
||||
}
|
||||
protected:
|
||||
void updateData()
|
||||
{
|
||||
noiseCopy(_noise_original, _noise_preview);
|
||||
_noise_original->copy(_noise_preview);
|
||||
}
|
||||
Color getColor(double x, double y)
|
||||
{
|
||||
if (-y > noiseGet1DTotal(_noise_preview, x))
|
||||
if (-y > _noise_preview->get1DTotal(x))
|
||||
{
|
||||
return COLOR_WHITE;
|
||||
}
|
||||
|
|
@ -95,7 +95,7 @@ DialogNoise::DialogNoise(QWidget *parent, NoiseGenerator* value):
|
|||
QLabel* label;
|
||||
|
||||
_base = value;
|
||||
_current = noiseCreateGenerator();
|
||||
_current = new NoiseGenerator();
|
||||
|
||||
setLayout(new QHBoxLayout());
|
||||
|
||||
|
|
@ -208,7 +208,7 @@ DialogNoise::~DialogNoise()
|
|||
delete previewLevel;
|
||||
delete previewTotal;
|
||||
|
||||
noiseDeleteGenerator(_current);
|
||||
delete _current;
|
||||
}
|
||||
|
||||
bool DialogNoise::getNoise(QWidget* parent, NoiseGenerator* noise)
|
||||
|
|
@ -230,13 +230,13 @@ void DialogNoise::closeEvent(QCloseEvent*)
|
|||
|
||||
void DialogNoise::accept()
|
||||
{
|
||||
noiseCopy(_current, _base);
|
||||
_current->copy(_base);
|
||||
QDialog::accept();
|
||||
}
|
||||
|
||||
void DialogNoise::revert()
|
||||
{
|
||||
noiseCopy(_base, _current);
|
||||
_base->copy(_current);
|
||||
|
||||
revertToCurrent();
|
||||
}
|
||||
|
|
@ -250,7 +250,7 @@ void DialogNoise::revertToCurrent()
|
|||
selected = levels->currentRow();
|
||||
|
||||
levels->clear();
|
||||
n = noiseGetLevelCount(_current);
|
||||
n = _current->getLevelCount();
|
||||
for (i = 0; i < n; i++)
|
||||
{
|
||||
levels->addItem(QString(tr("Component %1")).arg(i + 1));
|
||||
|
|
@ -269,7 +269,7 @@ void DialogNoise::revertToCurrent()
|
|||
levels->setCurrentRow(selected);
|
||||
}
|
||||
|
||||
function = noiseGetFunction(_current);
|
||||
function = _current->getFunction();
|
||||
function_algo->setCurrentIndex((int)function.algorithm);
|
||||
function_ridge->setValue(round(function.ridge_factor * 20.0));
|
||||
|
||||
|
|
@ -284,7 +284,7 @@ void DialogNoise::addLevel()
|
|||
level.amplitude = 0.1;
|
||||
level.wavelength = 0.1;
|
||||
|
||||
noiseAddLevel(_current, level, 1);
|
||||
_current->addLevel(level, 1);
|
||||
|
||||
revertToCurrent();
|
||||
|
||||
|
|
@ -297,7 +297,7 @@ void DialogNoise::removeLevel()
|
|||
|
||||
row = levels->currentRow();
|
||||
|
||||
noiseRemoveLevel(_current, _current_level);
|
||||
_current->removeLevel(_current_level);
|
||||
|
||||
revertToCurrent();
|
||||
|
||||
|
|
@ -315,8 +315,8 @@ void DialogNoise::functionChanged()
|
|||
function.algorithm = (NoiseFunctionAlgorithm)function_algo->currentIndex();
|
||||
function.ridge_factor = (double)function_ridge->value() * 0.05;
|
||||
|
||||
noiseSetFunction(_current, &function);
|
||||
noiseValidate(_current);
|
||||
_current->setFunction(&function);
|
||||
_current->validate();
|
||||
|
||||
previewLevel->redraw();
|
||||
previewTotal->redraw();
|
||||
|
|
@ -324,7 +324,7 @@ void DialogNoise::functionChanged()
|
|||
|
||||
void DialogNoise::levelChanged(int row)
|
||||
{
|
||||
if (noiseGetLevel(_current, row, &_current_level_params))
|
||||
if (_current->getLevel(row, &_current_level_params))
|
||||
{
|
||||
_current_level = row;
|
||||
((PreviewLevel*)previewLevel)->setLevel(row);
|
||||
|
|
@ -338,7 +338,7 @@ void DialogNoise::levelChanged(int row)
|
|||
void DialogNoise::heightChanged(int value)
|
||||
{
|
||||
_current_level_params.amplitude = ((double)value) / 1000.0;
|
||||
noiseSetLevel(_current, _current_level, _current_level_params, 1);
|
||||
_current->setLevel(_current_level, _current_level_params, 1);
|
||||
previewLevel->redraw();
|
||||
previewTotal->redraw();
|
||||
}
|
||||
|
|
@ -346,7 +346,7 @@ void DialogNoise::heightChanged(int value)
|
|||
void DialogNoise::scalingChanged(int value)
|
||||
{
|
||||
_current_level_params.wavelength = ((double)value) / 1000.0;
|
||||
noiseSetLevel(_current, _current_level, _current_level_params, 1);
|
||||
_current->setLevel(_current_level, _current_level_params, 1);
|
||||
previewLevel->redraw();
|
||||
previewTotal->redraw();
|
||||
}
|
||||
|
|
|
|||
|
|
@ -5,8 +5,7 @@
|
|||
#include <QComboBox>
|
||||
#include "basepreview.h"
|
||||
#include "tools.h"
|
||||
|
||||
#include "rendering/noise.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
class DialogNoise : public DialogWithPreview
|
||||
{
|
||||
|
|
|
|||
|
|
@ -68,7 +68,8 @@ HEADERS += \
|
|||
textures/PreviewLayerCoverage.h \
|
||||
textures/PreviewLayerLook.h \
|
||||
textures/PreviewCumul.h \
|
||||
textures/DialogTexturesLayer.h
|
||||
textures/DialogTexturesLayer.h \
|
||||
editing_global.h
|
||||
|
||||
SOURCES += \
|
||||
terrain/widgetheightmap.cpp \
|
||||
|
|
@ -150,6 +151,12 @@ else:unix: LIBS += -L$$OUT_PWD/../system/ -lpaysages_system
|
|||
INCLUDEPATH += $$PWD/../system
|
||||
DEPENDPATH += $$PWD/../system
|
||||
|
||||
win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../basics/release/ -lpaysages_basics
|
||||
else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../basics/debug/ -lpaysages_basics
|
||||
else:unix: LIBS += -L$$OUT_PWD/../basics/ -lpaysages_basics
|
||||
INCLUDEPATH += $$PWD/../basics
|
||||
DEPENDPATH += $$PWD/../basics
|
||||
|
||||
win32:CONFIG(release, debug|release): LIBS += -L$$OUT_PWD/../exploring/release/ -lpaysages_exploring
|
||||
else:win32:CONFIG(debug, debug|release): LIBS += -L$$OUT_PWD/../exploring/debug/ -lpaysages_exploring
|
||||
else:unix: LIBS += -L$$OUT_PWD/../exploring/ -lpaysages_exploring
|
||||
|
|
|
|||
14
src/editing/editing_global.h
Normal file
14
src/editing/editing_global.h
Normal file
|
|
@ -0,0 +1,14 @@
|
|||
#ifndef EDITING_GLOBAL_H
|
||||
#define EDITING_GLOBAL_H
|
||||
|
||||
namespace paysages
|
||||
{
|
||||
namespace system {}
|
||||
namespace basics {}
|
||||
namespace definition {}
|
||||
}
|
||||
using namespace paysages::system;
|
||||
using namespace paysages::basics;
|
||||
using namespace paysages::definition;
|
||||
|
||||
#endif // EDITING_GLOBAL_H
|
||||
|
|
@ -29,12 +29,12 @@ public:
|
|||
double value, factor;
|
||||
double minvalue, maxvalue;
|
||||
|
||||
noiseGetRange(noise, &minvalue, &maxvalue);
|
||||
noise->getRange(&minvalue, &maxvalue);
|
||||
|
||||
for (int x = 0; x < width; x++)
|
||||
{
|
||||
factor = ((double)(height / 2)) / maxvalue;
|
||||
value = -noiseGet1DTotal(noise, ((double)x) / factor) * factor;
|
||||
value = -noise->get1DTotal(((double)x) / factor) * factor;
|
||||
painter.setPen(Qt::white);
|
||||
painter.drawLine(x, 0, x, height / 2 + value);
|
||||
painter.setPen(Qt::black);
|
||||
|
|
|
|||
|
|
@ -1,10 +1,16 @@
|
|||
#ifndef _PAYSAGES_QT_INPUTNOISE_H_
|
||||
#define _PAYSAGES_QT_INPUTNOISE_H_
|
||||
|
||||
#include "editing_global.h"
|
||||
|
||||
#include <QWidget>
|
||||
#include "baseinput.h"
|
||||
|
||||
#include "rendering/noise.h"
|
||||
namespace paysages {
|
||||
namespace basics {
|
||||
class NoiseGenerator;
|
||||
}
|
||||
}
|
||||
|
||||
class InputNoise:public BaseInput
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,6 +1,8 @@
|
|||
#include "dialogbaseterrainnoise.h"
|
||||
#include "ui_dialogbaseterrainnoise.h"
|
||||
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
DialogBaseTerrainNoise::DialogBaseTerrainNoise(QWidget *parent) :
|
||||
QDialog(parent),
|
||||
ui(new Ui::DialogBaseTerrainNoise)
|
||||
|
|
@ -8,19 +10,19 @@ DialogBaseTerrainNoise::DialogBaseTerrainNoise(QWidget *parent) :
|
|||
ui->setupUi(this);
|
||||
|
||||
_original = 0;
|
||||
_modified = noiseCreateGenerator();
|
||||
_modified = new NoiseGenerator();
|
||||
}
|
||||
|
||||
DialogBaseTerrainNoise::~DialogBaseTerrainNoise()
|
||||
{
|
||||
delete ui;
|
||||
noiseDeleteGenerator(_modified);
|
||||
delete _modified;
|
||||
}
|
||||
|
||||
void DialogBaseTerrainNoise::setNoise(NoiseGenerator* noise)
|
||||
{
|
||||
_original = noise;
|
||||
noiseCopy(noise, _modified);
|
||||
noise->copy(_modified);
|
||||
}
|
||||
|
||||
int DialogBaseTerrainNoise::editNoise(QWidget* parent, NoiseGenerator* noise)
|
||||
|
|
|
|||
|
|
@ -1,11 +1,17 @@
|
|||
#ifndef DIALOGBASETERRAINNOISE_H
|
||||
#define DIALOGBASETERRAINNOISE_H
|
||||
|
||||
#include "editing_global.h"
|
||||
#include <QDialog>
|
||||
#include "rendering/noise.h"
|
||||
|
||||
namespace paysages {
|
||||
namespace basics {
|
||||
class NoiseGenerator;
|
||||
}
|
||||
}
|
||||
|
||||
namespace Ui {
|
||||
class DialogBaseTerrainNoise;
|
||||
class DialogBaseTerrainNoise;
|
||||
}
|
||||
|
||||
class DialogBaseTerrainNoise : public QDialog
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#include "paintingbrush.h"
|
||||
|
||||
#include <cmath>
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
PaintingBrush::PaintingBrush()
|
||||
{
|
||||
|
|
@ -9,13 +10,13 @@ PaintingBrush::PaintingBrush()
|
|||
_smoothing = 0.0;
|
||||
_strength = 0.0;
|
||||
_height = 0.0;
|
||||
_noise = noiseCreateGenerator();
|
||||
noiseAddLevelsSimple(_noise, 10, 1.0, -0.5, 0.5, 0.5);
|
||||
_noise = new NoiseGenerator();
|
||||
_noise->addLevelsSimple(10, 1.0, -0.5, 0.5, 0.5);
|
||||
}
|
||||
|
||||
PaintingBrush::~PaintingBrush()
|
||||
{
|
||||
noiseDeleteGenerator(_noise);
|
||||
delete _noise;
|
||||
}
|
||||
|
||||
void PaintingBrush::setMode(PaintingBrushMode mode)
|
||||
|
|
@ -56,7 +57,7 @@ void PaintingBrush::setStrength(QAbstractSlider* slider)
|
|||
|
||||
void PaintingBrush::randomizeNoise()
|
||||
{
|
||||
noiseRandomizeOffsets(_noise);
|
||||
_noise->randomizeOffsets();
|
||||
}
|
||||
|
||||
double PaintingBrush::getInfluence(double relative_x, double relative_z)
|
||||
|
|
|
|||
|
|
@ -2,9 +2,14 @@
|
|||
#define PAINTINGBRUSH_H
|
||||
|
||||
#include <QAbstractSlider>
|
||||
#include "rendering/noise.h"
|
||||
#include "rendering/terrain/public.h"
|
||||
|
||||
namespace paysages {
|
||||
namespace basics {
|
||||
class NoiseGenerator;
|
||||
}
|
||||
}
|
||||
|
||||
typedef enum
|
||||
{
|
||||
PAINTING_BRUSH_RAISE = 0,
|
||||
|
|
|
|||
|
|
@ -3,6 +3,7 @@
|
|||
#include <QPainter>
|
||||
#include <QPaintEvent>
|
||||
#include "tools.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
WidgetTerrainBaseNoisePreview::WidgetTerrainBaseNoisePreview(QWidget* parent) :
|
||||
DrawingWidget(parent)
|
||||
|
|
@ -30,12 +31,12 @@ void WidgetTerrainBaseNoisePreview::doDrawing(QPainter* painter)
|
|||
double value, factor;
|
||||
double minvalue, maxvalue;
|
||||
|
||||
noiseGetRange(_noise, &minvalue, &maxvalue);
|
||||
_noise->getRange(&minvalue, &maxvalue);
|
||||
factor = ((double)height) / (maxvalue - minvalue);
|
||||
|
||||
for (int x = boundaries.left(); x <= boundaries.right(); x++)
|
||||
{
|
||||
value = noiseGet1DTotal(_noise, 100.0 * ((double)x) / factor);
|
||||
value = _noise->get1DTotal(100.0 * ((double)x) / factor);
|
||||
|
||||
painter->drawLine(x, height - 1 - (value - minvalue) * factor, x, height - 1);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,12 +1,17 @@
|
|||
#ifndef _PAYSAGES_EDITING_TERRAIN_WIDGETTERRAINBASENOISEPREVIEW_H_
|
||||
#define _PAYSAGES_EDITING_TERRAIN_WIDGETTERRAINBASENOISEPREVIEW_H_
|
||||
|
||||
#include "editing_global.h"
|
||||
#include "editing/common/DrawingWidget.h"
|
||||
|
||||
#include "rendering/noise.h"
|
||||
|
||||
class QPainter;
|
||||
|
||||
namespace paysages {
|
||||
namespace basics {
|
||||
class NoiseGenerator;
|
||||
}
|
||||
}
|
||||
|
||||
class WidgetTerrainBaseNoisePreview : public DrawingWidget
|
||||
{
|
||||
Q_OBJECT
|
||||
|
|
|
|||
|
|
@ -2,7 +2,7 @@
|
|||
|
||||
#include <ctime>
|
||||
|
||||
#include "rendering/noise.h"
|
||||
#include "NoiseGenerator.h"
|
||||
#include "rendering/terrain/ter_raster.h"
|
||||
|
||||
static Scenery* _main_scenery;
|
||||
|
|
|
|||
|
|
@ -25,9 +25,6 @@
|
|||
//class PackStream;
|
||||
//class Renderer;
|
||||
|
||||
namespace paysages {
|
||||
namespace rendering {
|
||||
|
||||
/**
|
||||
* @brief Global scenery management
|
||||
*
|
||||
|
|
@ -79,9 +76,6 @@ private:
|
|||
WaterDefinition* water;
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
|
|
|
|||
|
|
@ -2,6 +2,7 @@
|
|||
|
||||
#include <stdlib.h>
|
||||
#include "PackStream.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
/******************** Global definition ********************/
|
||||
static void _validateDefinition(CloudsDefinition* definition)
|
||||
|
|
@ -62,23 +63,23 @@ void cloudsLayerValidateDefinition(CloudsLayerDefinition* definition)
|
|||
}
|
||||
|
||||
curveClear(definition->_coverage_by_altitude);
|
||||
noiseClearLevels(definition->_shape_noise);
|
||||
noiseClearLevels(definition->_edge_noise);
|
||||
noiseClearLevels(definition->_coverage_noise);
|
||||
definition->_shape_noise->clearLevels();
|
||||
definition->_edge_noise->clearLevels();
|
||||
definition->_coverage_noise->clearLevels();
|
||||
|
||||
noiseAddLevelsSimple(definition->_coverage_noise, 2, 10.0, 0.0, 1.0, 0.0);
|
||||
noiseAddLevelsSimple(definition->_coverage_noise, 2, 1.0, 0.0, 1.0, 0.0);
|
||||
noiseSetFunctionParams(definition->_coverage_noise, NOISE_FUNCTION_NAIVE, 0.0, 0.0);
|
||||
definition->_coverage_noise->addLevelsSimple(2, 10.0, 0.0, 1.0, 0.0);
|
||||
definition->_coverage_noise->addLevelsSimple(2, 1.0, 0.0, 1.0, 0.0);
|
||||
definition->_coverage_noise->setFunctionParams(NOISE_FUNCTION_NAIVE, 0.0, 0.0);
|
||||
switch (definition->type)
|
||||
{
|
||||
case CLOUDS_TYPE_CIRRUS:
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.0, 0.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.5, 1.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 1.0, 0.0);
|
||||
noiseAddLevelsSimple(definition->_shape_noise, 3, 1.0, 0.0, 1.0, 0.5);
|
||||
noiseSetFunctionParams(definition->_shape_noise, NOISE_FUNCTION_SIMPLEX, 0.0, 0.0);
|
||||
noiseAddLevelsSimple(definition->_edge_noise, 4, 1.0, -0.5, 0.5, 0.5);
|
||||
noiseSetFunctionParams(definition->_edge_noise, NOISE_FUNCTION_SIMPLEX, -0.2, 0.0);
|
||||
definition->_shape_noise->addLevelsSimple(3, 1.0, 0.0, 1.0, 0.5);
|
||||
definition->_shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.0, 0.0);
|
||||
definition->_edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
|
||||
definition->_edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.2, 0.0);
|
||||
break;
|
||||
case CLOUDS_TYPE_CUMULUS:
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.0, 0.0);
|
||||
|
|
@ -86,38 +87,38 @@ void cloudsLayerValidateDefinition(CloudsLayerDefinition* definition)
|
|||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.4, 0.8);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.7, 1.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 1.0, 0.0);
|
||||
noiseAddLevelsSimple(definition->_shape_noise, 7, 1.0, 0.0, 1.0, 0.5);
|
||||
noiseSetFunctionParams(definition->_shape_noise, NOISE_FUNCTION_SIMPLEX, 0.4, 0.0);
|
||||
noiseAddLevelsSimple(definition->_edge_noise, 4, 1.0, -0.5, 0.5, 0.5);
|
||||
noiseSetFunctionParams(definition->_edge_noise, NOISE_FUNCTION_SIMPLEX, 0.8, 0.0);
|
||||
definition->_shape_noise->addLevelsSimple(7, 1.0, 0.0, 1.0, 0.5);
|
||||
definition->_shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.4, 0.0);
|
||||
definition->_edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
|
||||
definition->_edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.8, 0.0);
|
||||
break;
|
||||
case CLOUDS_TYPE_STRATOCUMULUS:
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.0, 0.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.2, 1.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.5, 1.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 1.0, 0.0);
|
||||
noiseAddLevelsSimple(definition->_shape_noise, 4, 1.0, 0.0, 1.0, 0.5);
|
||||
noiseSetFunctionParams(definition->_shape_noise, NOISE_FUNCTION_SIMPLEX, 0.3, 0.0);
|
||||
noiseAddLevelsSimple(definition->_edge_noise, 6, 1.0, -0.5, 0.5, 0.5);
|
||||
noiseSetFunctionParams(definition->_edge_noise, NOISE_FUNCTION_SIMPLEX, 0.5, 0.0);
|
||||
definition->_shape_noise->addLevelsSimple(4, 1.0, 0.0, 1.0, 0.5);
|
||||
definition->_shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.3, 0.0);
|
||||
definition->_edge_noise->addLevelsSimple(6, 1.0, -0.5, 0.5, 0.5);
|
||||
definition->_edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.5, 0.0);
|
||||
break;
|
||||
case CLOUDS_TYPE_STRATUS:
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.0, 0.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.2, 1.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 0.8, 1.0);
|
||||
curveQuickAddPoint(definition->_coverage_by_altitude, 1.0, 0.0);
|
||||
noiseAddLevelsSimple(definition->_shape_noise, 3, 1.0, 0.0, 1.0, 0.5);
|
||||
noiseSetFunctionParams(definition->_shape_noise, NOISE_FUNCTION_SIMPLEX, -0.3, 0.0);
|
||||
noiseAddLevelsSimple(definition->_edge_noise, 4, 1.0, -0.5, 0.5, 0.5);
|
||||
noiseSetFunctionParams(definition->_edge_noise, NOISE_FUNCTION_SIMPLEX, -0.5, 0.0);
|
||||
definition->_shape_noise->addLevelsSimple(3, 1.0, 0.0, 1.0, 0.5);
|
||||
definition->_shape_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.3, 0.0);
|
||||
definition->_edge_noise->addLevelsSimple(4, 1.0, -0.5, 0.5, 0.5);
|
||||
definition->_edge_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -0.5, 0.0);
|
||||
break;
|
||||
default:
|
||||
break;
|
||||
}
|
||||
|
||||
noiseNormalizeAmplitude(definition->_coverage_noise, -1.0, 3.0, 0);
|
||||
noiseNormalizeAmplitude(definition->_shape_noise, -0.5, 0.5, 0);
|
||||
noiseNormalizeAmplitude(definition->_edge_noise, -0.5, 0.5, 0);
|
||||
definition->_coverage_noise->normalizeAmplitude(-1.0, 3.0, 0);
|
||||
definition->_shape_noise->normalizeAmplitude(-0.5, 0.5, 0);
|
||||
definition->_edge_noise->normalizeAmplitude(-0.5, 0.5, 0);
|
||||
|
||||
materialValidate(&definition->material);
|
||||
}
|
||||
|
|
@ -128,9 +129,9 @@ CloudsLayerDefinition* cloudsLayerCreateDefinition()
|
|||
|
||||
result = new CloudsLayerDefinition;
|
||||
result->_coverage_by_altitude = curveCreate();
|
||||
result->_coverage_noise = noiseCreateGenerator();
|
||||
result->_shape_noise = noiseCreateGenerator();
|
||||
result->_edge_noise = noiseCreateGenerator();
|
||||
result->_coverage_noise = new NoiseGenerator();
|
||||
result->_shape_noise = new NoiseGenerator();
|
||||
result->_edge_noise = new NoiseGenerator();
|
||||
|
||||
cloudsLayerAutoPreset(result, CLOUDS_LAYER_PRESET_CIRRUS);
|
||||
|
||||
|
|
@ -140,9 +141,9 @@ CloudsLayerDefinition* cloudsLayerCreateDefinition()
|
|||
void cloudsLayerDeleteDefinition(CloudsLayerDefinition* definition)
|
||||
{
|
||||
curveDelete(definition->_coverage_by_altitude);
|
||||
noiseDeleteGenerator(definition->_coverage_noise);
|
||||
noiseDeleteGenerator(definition->_shape_noise);
|
||||
noiseDeleteGenerator(definition->_edge_noise);
|
||||
delete definition->_coverage_noise;
|
||||
delete definition->_shape_noise;
|
||||
delete definition->_edge_noise;
|
||||
delete definition;
|
||||
}
|
||||
|
||||
|
|
@ -157,13 +158,13 @@ void cloudsLayerCopyDefinition(CloudsLayerDefinition* source, CloudsLayerDefinit
|
|||
curveCopy(source->_coverage_by_altitude, destination->_coverage_by_altitude);
|
||||
|
||||
destination->_coverage_noise = temp._coverage_noise;
|
||||
noiseCopy(source->_coverage_noise, destination->_coverage_noise);
|
||||
source->_coverage_noise->copy(destination->_coverage_noise);
|
||||
|
||||
destination->_shape_noise = temp._shape_noise;
|
||||
noiseCopy(source->_shape_noise, destination->_shape_noise);
|
||||
source->_shape_noise->copy(destination->_shape_noise);
|
||||
|
||||
destination->_edge_noise = temp._edge_noise;
|
||||
noiseCopy(source->_edge_noise, destination->_edge_noise);
|
||||
source->_edge_noise->copy(destination->_edge_noise);
|
||||
}
|
||||
|
||||
void _cloudsLayerSave(PackStream* stream, CloudsLayerDefinition* layer)
|
||||
|
|
@ -174,9 +175,9 @@ void _cloudsLayerSave(PackStream* stream, CloudsLayerDefinition* layer)
|
|||
stream->write(&layer->lower_altitude);
|
||||
stream->write(&layer->thickness);
|
||||
curveSave(stream, layer->_coverage_by_altitude);
|
||||
noiseSaveGenerator(stream, layer->_coverage_noise);
|
||||
noiseSaveGenerator(stream, layer->_shape_noise);
|
||||
noiseSaveGenerator(stream, layer->_edge_noise);
|
||||
layer->_coverage_noise->save(stream);
|
||||
layer->_shape_noise->save(stream);
|
||||
layer->_edge_noise->save(stream);
|
||||
materialSave(stream, &layer->material);
|
||||
stream->write(&layer->hardness);
|
||||
stream->write(&layer->transparencydepth);
|
||||
|
|
@ -197,9 +198,9 @@ void _cloudsLayerLoad(PackStream* stream, CloudsLayerDefinition* layer)
|
|||
stream->read(&layer->lower_altitude);
|
||||
stream->read(&layer->thickness);
|
||||
curveLoad(stream, layer->_coverage_by_altitude);
|
||||
noiseLoadGenerator(stream, layer->_coverage_noise);
|
||||
noiseLoadGenerator(stream, layer->_shape_noise);
|
||||
noiseLoadGenerator(stream, layer->_edge_noise);
|
||||
layer->_coverage_noise->load(stream);
|
||||
layer->_shape_noise->load(stream);
|
||||
layer->_edge_noise->load(stream);
|
||||
materialLoad(stream, &layer->material);
|
||||
stream->read(&layer->hardness);
|
||||
stream->read(&layer->transparencydepth);
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#include "clo_density.h"
|
||||
|
||||
#include "../tools.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
double cloudsGetLayerCoverage(CloudsLayerDefinition* layer, Vector3 location)
|
||||
{
|
||||
|
|
@ -10,7 +11,7 @@ double cloudsGetLayerCoverage(CloudsLayerDefinition* layer, Vector3 location)
|
|||
}
|
||||
else
|
||||
{
|
||||
double coverage = 0.5 + noiseGet2DTotal(layer->_coverage_noise, location.x / layer->shape_scaling, location.z / layer->shape_scaling);
|
||||
double coverage = 0.5 + layer->_coverage_noise->get2DTotal(location.x / layer->shape_scaling, location.z / layer->shape_scaling);
|
||||
coverage -= (1.0 - layer->base_coverage);
|
||||
|
||||
coverage *= curveGetValue(layer->_coverage_by_altitude, (location.y - layer->lower_altitude) / layer->thickness);
|
||||
|
|
@ -42,7 +43,7 @@ double cloudsGetLayerDensity(CloudsLayerDefinition* layer, Vector3 location, dou
|
|||
}
|
||||
else
|
||||
{
|
||||
double density = noiseGet3DTotal(layer->_shape_noise, location.x / layer->shape_scaling, location.y / layer->shape_scaling, location.z / layer->shape_scaling);
|
||||
double density = layer->_shape_noise->get3DTotal(location.x / layer->shape_scaling, location.y / layer->shape_scaling, location.z / layer->shape_scaling);
|
||||
density -= (0.5 - coverage);
|
||||
return (density <= 0.0) ? 0.0 : density;
|
||||
}
|
||||
|
|
@ -60,7 +61,7 @@ double cloudsGetEdgeDensity(CloudsLayerDefinition* layer, Vector3 location, doub
|
|||
}
|
||||
else
|
||||
{
|
||||
double density = noiseGet3DTotal(layer->_edge_noise, location.x / layer->edge_scaling, location.y / layer->edge_scaling, location.z / layer->edge_scaling);
|
||||
double density = layer->_edge_noise->get3DTotal(location.x / layer->edge_scaling, location.y / layer->edge_scaling, location.z / layer->edge_scaling);
|
||||
density -= (0.5 - layer_density);
|
||||
return (density <= 0.0) ? 0.0 : density;
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,7 +1,8 @@
|
|||
#include "private.h"
|
||||
|
||||
#include <math.h>
|
||||
#include <stdlib.h>
|
||||
#include <cmath>
|
||||
#include <cstdlib>
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
/*
|
||||
* Clouds presets.
|
||||
|
|
@ -22,9 +23,9 @@ void cloudsAutoPreset(CloudsDefinition* definition, CloudsPreset preset)
|
|||
|
||||
void cloudsLayerAutoPreset(CloudsLayerDefinition* definition, CloudsLayerPreset preset)
|
||||
{
|
||||
noiseRandomizeOffsets(definition->_coverage_noise);
|
||||
noiseRandomizeOffsets(definition->_edge_noise);
|
||||
noiseRandomizeOffsets(definition->_shape_noise);
|
||||
definition->_coverage_noise->randomizeOffsets();
|
||||
definition->_edge_noise->randomizeOffsets();
|
||||
definition->_shape_noise->randomizeOffsets();
|
||||
|
||||
definition->material.base = colorToHSL(colorFromValues(0.7, 0.7, 0.7, 1.0));
|
||||
|
||||
|
|
|
|||
|
|
@ -6,12 +6,13 @@
|
|||
#include "../tools/lighting.h"
|
||||
#include "../tools/curve.h"
|
||||
#include "../tools/euclid.h"
|
||||
#include "../noise.h"
|
||||
#include "Layers.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
namespace paysages {
|
||||
namespace basics {
|
||||
class NoiseGenerator;
|
||||
}
|
||||
}
|
||||
|
||||
typedef enum
|
||||
{
|
||||
|
|
@ -82,8 +83,4 @@ RENDERINGSHARED_EXPORT LayerType cloudsGetLayerType();
|
|||
RENDERINGSHARED_EXPORT void cloudsAutoPreset(CloudsDefinition* definition, CloudsPreset preset);
|
||||
RENDERINGSHARED_EXPORT void cloudsLayerAutoPreset(CloudsLayerDefinition* definition, CloudsLayerPreset preset);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,621 +0,0 @@
|
|||
#include "noise.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
|
||||
#include "tools.h"
|
||||
#include "noisesimplex.h"
|
||||
#include "noisenaive.h"
|
||||
#include "noiseperlin.h"
|
||||
#include "opencl.h"
|
||||
|
||||
#define MAX_LEVEL_COUNT 30
|
||||
|
||||
struct NoiseGenerator
|
||||
{
|
||||
NoiseFunction function;
|
||||
double height_offset;
|
||||
int level_count;
|
||||
NoiseLevel levels[MAX_LEVEL_COUNT];
|
||||
|
||||
double _min_value;
|
||||
double _max_value;
|
||||
double (*_func_noise_1d)(double x);
|
||||
double (*_func_noise_2d)(double x, double y);
|
||||
double (*_func_noise_3d)(double x, double y, double z);
|
||||
};
|
||||
|
||||
void noiseInit()
|
||||
{
|
||||
noiseSimplexInit();
|
||||
noisePerlinInit();
|
||||
noiseNaiveInit();
|
||||
|
||||
/* Noise stats */
|
||||
/*NoiseGenerator* noise;
|
||||
int x;
|
||||
double min, max, value;
|
||||
noise = noiseCreateGenerator();
|
||||
noiseSetFunctionParams(noise, NOISE_FUNCTION_NAIVE, 0.0);
|
||||
noiseAddLevelSimple(noise, 1.0, 0.0, 1.0);
|
||||
min = 100000.0;
|
||||
max = -100000.0;
|
||||
for (x = 0; x < 1000000; x++)
|
||||
{
|
||||
value = noiseGet1DTotal(noise, toolsRandom() * 10000.0);
|
||||
value = noiseGet2DTotal(noise, toolsRandom() * 10000.0, toolsRandom() * 10000.0);
|
||||
value = noiseGet3DTotal(noise, toolsRandom() * 10000.0, toolsRandom() * 10000.0, toolsRandom() * 10000.0);
|
||||
if (value < min) min = value;
|
||||
if (value > max) max = value;
|
||||
}
|
||||
printf("%f %f\n", min, max);
|
||||
noiseDeleteGenerator(noise);*/
|
||||
}
|
||||
|
||||
void noiseQuit()
|
||||
{
|
||||
noiseNaiveQuit();
|
||||
}
|
||||
|
||||
void noiseSave(PackStream* stream)
|
||||
{
|
||||
noiseNaiveSave(stream);
|
||||
}
|
||||
|
||||
void noiseLoad(PackStream* stream)
|
||||
{
|
||||
noiseNaiveLoad(stream);
|
||||
}
|
||||
|
||||
NoiseGenerator* noiseCreateGenerator()
|
||||
{
|
||||
NoiseGenerator* result;
|
||||
|
||||
/* initialize */
|
||||
result = new NoiseGenerator;
|
||||
result->function.algorithm = NOISE_FUNCTION_SIMPLEX;
|
||||
result->function.ridge_factor = 0.0;
|
||||
result->function.curve_factor = 0.0;
|
||||
result->level_count = 0;
|
||||
result->height_offset = 0.0;
|
||||
|
||||
noiseRandomizeOffsets(result);
|
||||
noiseValidate(result);
|
||||
|
||||
return result;
|
||||
}
|
||||
|
||||
void noiseDeleteGenerator(NoiseGenerator* generator)
|
||||
{
|
||||
delete generator;
|
||||
}
|
||||
|
||||
void noiseSaveGenerator(PackStream* stream, NoiseGenerator* generator)
|
||||
{
|
||||
int x;
|
||||
|
||||
x = (int)generator->function.algorithm;
|
||||
stream->write(&x);
|
||||
stream->write(&generator->function.ridge_factor);
|
||||
stream->write(&generator->function.curve_factor);
|
||||
|
||||
stream->write(&generator->height_offset);
|
||||
stream->write(&generator->level_count);
|
||||
|
||||
for (x = 0; x < generator->level_count; x++)
|
||||
{
|
||||
NoiseLevel* level = generator->levels + x;
|
||||
|
||||
stream->write(&level->wavelength);
|
||||
stream->write(&level->amplitude);
|
||||
stream->write(&level->minvalue);
|
||||
stream->write(&level->xoffset);
|
||||
stream->write(&level->yoffset);
|
||||
stream->write(&level->zoffset);
|
||||
}
|
||||
}
|
||||
|
||||
void noiseLoadGenerator(PackStream* stream, NoiseGenerator* generator)
|
||||
{
|
||||
int x;
|
||||
|
||||
stream->read(&x);
|
||||
generator->function.algorithm = (NoiseFunctionAlgorithm)x;
|
||||
stream->read(&generator->function.ridge_factor);
|
||||
stream->read(&generator->function.curve_factor);
|
||||
|
||||
stream->read(&generator->height_offset);
|
||||
stream->read(&generator->level_count);
|
||||
|
||||
for (x = 0; x < generator->level_count; x++)
|
||||
{
|
||||
NoiseLevel* level = generator->levels + x;
|
||||
|
||||
stream->read(&level->wavelength);
|
||||
stream->read(&level->amplitude);
|
||||
stream->read(&level->minvalue);
|
||||
stream->read(&level->xoffset);
|
||||
stream->read(&level->yoffset);
|
||||
stream->read(&level->zoffset);
|
||||
}
|
||||
|
||||
noiseValidate(generator);
|
||||
}
|
||||
|
||||
void noiseCopy(NoiseGenerator* source, NoiseGenerator* destination)
|
||||
{
|
||||
destination->function = source->function;
|
||||
destination->height_offset = source->height_offset;
|
||||
destination->level_count = source->level_count;
|
||||
|
||||
memcpy(destination->levels, source->levels, sizeof(NoiseLevel) * destination->level_count);
|
||||
|
||||
noiseValidate(destination);
|
||||
}
|
||||
|
||||
void noiseValidate(NoiseGenerator* generator)
|
||||
{
|
||||
int x;
|
||||
|
||||
if (generator->function.algorithm < 0 || generator->function.algorithm > NOISE_FUNCTION_NAIVE)
|
||||
{
|
||||
generator->function.algorithm = NOISE_FUNCTION_SIMPLEX;
|
||||
}
|
||||
switch (generator->function.algorithm)
|
||||
{
|
||||
case NOISE_FUNCTION_SIMPLEX:
|
||||
generator->_func_noise_1d = noiseSimplexGet1DValue;
|
||||
generator->_func_noise_2d = noiseSimplexGet2DValue;
|
||||
generator->_func_noise_3d = noiseSimplexGet3DValue;
|
||||
break;
|
||||
case NOISE_FUNCTION_PERLIN:
|
||||
generator->_func_noise_1d = noisePerlinGet1DValue;
|
||||
generator->_func_noise_2d = noisePerlinGet2DValue;
|
||||
generator->_func_noise_3d = noisePerlinGet3DValue;
|
||||
break;
|
||||
case NOISE_FUNCTION_NAIVE:
|
||||
generator->_func_noise_1d = noiseNaiveGet1DValue;
|
||||
generator->_func_noise_2d = noiseNaiveGet2DValue;
|
||||
generator->_func_noise_3d = noiseNaiveGet3DValue;
|
||||
break;
|
||||
}
|
||||
|
||||
if (generator->function.ridge_factor > 0.5)
|
||||
{
|
||||
generator->function.ridge_factor = 0.5;
|
||||
}
|
||||
if (generator->function.ridge_factor < -0.5)
|
||||
{
|
||||
generator->function.ridge_factor = -0.5;
|
||||
}
|
||||
if (generator->function.curve_factor > 1.0)
|
||||
{
|
||||
generator->function.curve_factor = 1.0;
|
||||
}
|
||||
if (generator->function.curve_factor < -1.0)
|
||||
{
|
||||
generator->function.curve_factor = -1.0;
|
||||
}
|
||||
|
||||
generator->_min_value = generator->height_offset;
|
||||
generator->_max_value = generator->height_offset;
|
||||
for (x = 0; x < generator->level_count; x++)
|
||||
{
|
||||
generator->_min_value += generator->levels[x].minvalue;
|
||||
generator->_max_value += generator->levels[x].minvalue + generator->levels[x].amplitude;
|
||||
}
|
||||
}
|
||||
|
||||
void noiseRandomizeOffsets(NoiseGenerator* generator)
|
||||
{
|
||||
int i;
|
||||
for (i = 0; i < MAX_LEVEL_COUNT; i++)
|
||||
{
|
||||
generator->levels[i].xoffset = toolsRandom();
|
||||
generator->levels[i].yoffset = toolsRandom();
|
||||
generator->levels[i].zoffset = toolsRandom();
|
||||
}
|
||||
}
|
||||
|
||||
NoiseFunction noiseGetFunction(NoiseGenerator* generator)
|
||||
{
|
||||
return generator->function;
|
||||
}
|
||||
|
||||
void noiseSetFunction(NoiseGenerator* generator, NoiseFunction* function)
|
||||
{
|
||||
generator->function = *function;
|
||||
noiseValidate(generator);
|
||||
}
|
||||
|
||||
void noiseSetCustomFunction(NoiseGenerator* generator, double (*func1d)(double x), double (*func2d)(double x, double y), double (*func3d)(double x, double y, double z))
|
||||
{
|
||||
generator->_func_noise_1d = func1d;
|
||||
generator->_func_noise_2d = func2d;
|
||||
generator->_func_noise_3d = func3d;
|
||||
}
|
||||
|
||||
void noiseSetFunctionParams(NoiseGenerator* generator, NoiseFunctionAlgorithm algorithm, double ridge_factor, double curve_factor)
|
||||
{
|
||||
NoiseFunction function = {algorithm, ridge_factor, curve_factor};
|
||||
noiseSetFunction(generator, &function);
|
||||
}
|
||||
|
||||
void noiseForceValue(NoiseGenerator* generator, double value)
|
||||
{
|
||||
noiseClearLevels(generator);
|
||||
generator->height_offset = value;
|
||||
noiseAddLevelSimple(generator, 1.0, 0.0, 0.0); /* FIXME Should not be needed */
|
||||
}
|
||||
|
||||
void noiseGetRange(NoiseGenerator* generator, double* minvalue, double* maxvalue)
|
||||
{
|
||||
*minvalue = generator->_min_value;
|
||||
*maxvalue = generator->_max_value;
|
||||
}
|
||||
|
||||
int noiseGetLevelCount(NoiseGenerator* generator)
|
||||
{
|
||||
return generator->level_count;
|
||||
}
|
||||
|
||||
void noiseClearLevels(NoiseGenerator* generator)
|
||||
{
|
||||
generator->level_count = 0;
|
||||
noiseValidate(generator);
|
||||
}
|
||||
|
||||
void noiseAddLevel(NoiseGenerator* generator, NoiseLevel level, int protect_offsets)
|
||||
{
|
||||
if (generator->level_count < MAX_LEVEL_COUNT)
|
||||
{
|
||||
NoiseLevel baselevel = generator->levels[generator->level_count];
|
||||
|
||||
if (protect_offsets)
|
||||
{
|
||||
level.xoffset = baselevel.xoffset;
|
||||
level.yoffset = baselevel.yoffset;
|
||||
level.zoffset = baselevel.zoffset;
|
||||
}
|
||||
|
||||
generator->levels[generator->level_count] = level;
|
||||
generator->level_count++;
|
||||
noiseValidate(generator);
|
||||
}
|
||||
}
|
||||
|
||||
void noiseAddLevelSimple(NoiseGenerator* generator, double scaling, double minvalue, double maxvalue)
|
||||
{
|
||||
NoiseLevel level;
|
||||
|
||||
level.wavelength = scaling;
|
||||
level.minvalue = minvalue;
|
||||
level.amplitude = maxvalue - minvalue;
|
||||
|
||||
noiseAddLevel(generator, level, 1);
|
||||
}
|
||||
|
||||
void noiseAddLevels(NoiseGenerator* generator, int level_count, NoiseLevel start_level, double scaling_factor, double amplitude_factor, double center_factor)
|
||||
{
|
||||
int i;
|
||||
|
||||
for (i = 0; i < level_count; i++)
|
||||
{
|
||||
noiseAddLevel(generator, start_level, 1);
|
||||
start_level.minvalue += start_level.amplitude * (1.0 - amplitude_factor) * center_factor;
|
||||
start_level.wavelength *= scaling_factor;
|
||||
start_level.amplitude *= amplitude_factor;
|
||||
}
|
||||
}
|
||||
|
||||
void noiseAddLevelsSimple(NoiseGenerator* generator, int level_count, double scaling, double minvalue, double maxvalue, double center_factor)
|
||||
{
|
||||
NoiseLevel level;
|
||||
|
||||
level.wavelength = scaling;
|
||||
level.minvalue = minvalue;
|
||||
level.amplitude = maxvalue - minvalue;
|
||||
noiseAddLevels(generator, level_count, level, 0.5, 0.5, center_factor);
|
||||
}
|
||||
|
||||
void noiseRemoveLevel(NoiseGenerator* generator, int level)
|
||||
{
|
||||
if (level >= 0 && level < generator->level_count)
|
||||
{
|
||||
if (generator->level_count > 1 && level < generator->level_count - 1)
|
||||
{
|
||||
memmove(generator->levels + level, generator->levels + level + 1, sizeof(NoiseLevel) * (generator->level_count - level - 1));
|
||||
}
|
||||
generator->level_count--;
|
||||
noiseValidate(generator);
|
||||
}
|
||||
}
|
||||
|
||||
int noiseGetLevel(NoiseGenerator* generator, int level, NoiseLevel* params)
|
||||
{
|
||||
if (level >= 0 && level < generator->level_count)
|
||||
{
|
||||
*params = generator->levels[level];
|
||||
return 1;
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
void noiseSetLevel(NoiseGenerator* generator, int index, NoiseLevel level, int protect_offsets)
|
||||
{
|
||||
if (index >= 0 && index < generator->level_count)
|
||||
{
|
||||
NoiseLevel baselevel = generator->levels[index];
|
||||
|
||||
if (protect_offsets)
|
||||
{
|
||||
level.xoffset = baselevel.xoffset;
|
||||
level.yoffset = baselevel.yoffset;
|
||||
level.zoffset = baselevel.zoffset;
|
||||
}
|
||||
|
||||
generator->levels[index] = level;
|
||||
noiseValidate(generator);
|
||||
}
|
||||
}
|
||||
|
||||
void noiseSetLevelSimple(NoiseGenerator* generator, int index, double scaling, double minvalue, double maxvalue)
|
||||
{
|
||||
NoiseLevel level;
|
||||
|
||||
level.wavelength = scaling;
|
||||
level.minvalue = minvalue;
|
||||
level.amplitude = maxvalue - minvalue;
|
||||
|
||||
noiseSetLevel(generator, index, level, 1);
|
||||
}
|
||||
|
||||
void noiseNormalizeAmplitude(NoiseGenerator* generator, double minvalue, double maxvalue, int adjust_scaling)
|
||||
{
|
||||
int level;
|
||||
double current_minvalue, current_maxvalue, current_amplitude;
|
||||
double target_amplitude, factor;
|
||||
|
||||
if (generator->level_count == 0)
|
||||
{
|
||||
return;
|
||||
}
|
||||
|
||||
target_amplitude = maxvalue - minvalue;
|
||||
noiseGetRange(generator, ¤t_minvalue, ¤t_maxvalue);
|
||||
current_amplitude = current_maxvalue - current_minvalue;
|
||||
factor = target_amplitude / current_amplitude;
|
||||
|
||||
for (level = 0; level < generator->level_count; level++)
|
||||
{
|
||||
generator->levels[level].minvalue *= factor;
|
||||
generator->levels[level].amplitude *= factor;
|
||||
if (adjust_scaling)
|
||||
{
|
||||
generator->levels[level].wavelength *= factor;
|
||||
}
|
||||
}
|
||||
generator->height_offset = minvalue + (generator->height_offset - current_minvalue) * factor;
|
||||
noiseValidate(generator);
|
||||
}
|
||||
|
||||
static inline double _fixValue(double value, double ridge, double curve)
|
||||
{
|
||||
if (value < 0.0)
|
||||
{
|
||||
value = 0.0;
|
||||
}
|
||||
else if (value > 1.0)
|
||||
{
|
||||
value = 1.0;
|
||||
}
|
||||
|
||||
if (curve > 0.0)
|
||||
{
|
||||
value = value * (1.0 - curve) + sqrt(value) * curve;
|
||||
}
|
||||
else if (curve < 0.0)
|
||||
{
|
||||
value = value * (1.0 - curve) + value * value * curve;
|
||||
}
|
||||
|
||||
if (ridge > 0.0)
|
||||
{
|
||||
return fabs(value - ridge) / (1.0 - ridge);
|
||||
}
|
||||
else if (ridge < 0.0)
|
||||
{
|
||||
return 1.0 - fabs(value - 1.0 - ridge) / (1.0 + ridge);
|
||||
}
|
||||
else
|
||||
{
|
||||
return value;
|
||||
}
|
||||
/*if (ridge > 0.0)
|
||||
{
|
||||
return fabs(value + 0.5 - ridge) - 0.5 + ridge;
|
||||
}
|
||||
else if (ridge < 0.0)
|
||||
{
|
||||
return -fabs(value - 0.5 - ridge) + 0.5 + ridge;
|
||||
}
|
||||
else
|
||||
{
|
||||
return value;
|
||||
}*/
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static inline double _get1DLevelValue(NoiseGenerator* generator, NoiseLevel* level, double x)
|
||||
{
|
||||
return level->minvalue + _fixValue(generator->_func_noise_1d(x / level->wavelength + level->xoffset), generator->function.ridge_factor, generator->function.curve_factor) * level->amplitude;
|
||||
}
|
||||
|
||||
double noiseGet1DLevel(NoiseGenerator* generator, int level, double x)
|
||||
{
|
||||
if (level >= 0 && level < generator->level_count)
|
||||
{
|
||||
return _get1DLevelValue(generator, generator->levels + level, x);
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
double noiseGet1DTotal(NoiseGenerator* generator, double x)
|
||||
{
|
||||
int level;
|
||||
double result;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < generator->level_count; level++)
|
||||
{
|
||||
result += _get1DLevelValue(generator, generator->levels + level, x);
|
||||
}
|
||||
return result + generator->height_offset;
|
||||
}
|
||||
|
||||
double noiseGet1DDetail(NoiseGenerator* generator, double x, double detail)
|
||||
{
|
||||
int level;
|
||||
double result, height, factor;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < generator->level_count; level++)
|
||||
{
|
||||
height = generator->levels[level].amplitude;
|
||||
factor = 1.0;
|
||||
if (height < detail * 0.25)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if (height < detail * 0.5)
|
||||
{
|
||||
factor = (detail * 0.5 - height) / 0.25;
|
||||
}
|
||||
|
||||
result += _get1DLevelValue(generator, generator->levels + level, x) * factor;
|
||||
}
|
||||
return result + generator->height_offset;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static inline double _get2DLevelValue(NoiseGenerator* generator, NoiseLevel* level, double x, double y)
|
||||
{
|
||||
return level->minvalue + _fixValue(generator->_func_noise_2d(x / level->wavelength + level->xoffset, y / level->wavelength + level->yoffset), generator->function.ridge_factor, generator->function.curve_factor) * level->amplitude;
|
||||
}
|
||||
|
||||
double noiseGet2DLevel(NoiseGenerator* generator, int level, double x, double y)
|
||||
{
|
||||
if (level >= 0 && level < generator->level_count)
|
||||
{
|
||||
return _get2DLevelValue(generator, generator->levels + level, x, y);
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
double noiseGet2DTotal(NoiseGenerator* generator, double x, double y)
|
||||
{
|
||||
int level;
|
||||
double result;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < generator->level_count; level++)
|
||||
{
|
||||
result += _get2DLevelValue(generator, generator->levels + level, x, y);
|
||||
}
|
||||
return result + generator->height_offset;
|
||||
}
|
||||
|
||||
double noiseGet2DDetail(NoiseGenerator* generator, double x, double y, double detail)
|
||||
{
|
||||
int level;
|
||||
double result, height, factor;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < generator->level_count; level++)
|
||||
{
|
||||
height = generator->levels[level].amplitude;
|
||||
factor = 1.0;
|
||||
if (height < detail * 0.25)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if (height < detail * 0.5)
|
||||
{
|
||||
factor = (detail * 0.5 - height) / 0.25;
|
||||
}
|
||||
|
||||
result += _get2DLevelValue(generator, generator->levels + level, x, y) * factor;
|
||||
}
|
||||
return result + generator->height_offset;
|
||||
}
|
||||
|
||||
|
||||
|
||||
|
||||
static inline double _get3DLevelValue(NoiseGenerator* generator, NoiseLevel* level, double x, double y, double z)
|
||||
{
|
||||
return level->minvalue + _fixValue(generator->_func_noise_3d(x / level->wavelength + level->xoffset, y / level->wavelength + level->yoffset, z / level->wavelength + level->zoffset), generator->function.ridge_factor, generator->function.curve_factor) * level->amplitude;
|
||||
}
|
||||
|
||||
double noiseGet3DLevel(NoiseGenerator* generator, int level, double x, double y, double z)
|
||||
{
|
||||
if (level >= 0 && level < generator->level_count)
|
||||
{
|
||||
return _get3DLevelValue(generator, generator->levels + level, x, y, z);
|
||||
}
|
||||
else
|
||||
{
|
||||
return 0.0;
|
||||
}
|
||||
}
|
||||
|
||||
double noiseGet3DTotal(NoiseGenerator* generator, double x, double y, double z)
|
||||
{
|
||||
int level;
|
||||
double result;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < generator->level_count; level++)
|
||||
{
|
||||
result += _get3DLevelValue(generator, generator->levels + level, x, y, z);
|
||||
}
|
||||
return result + generator->height_offset;
|
||||
}
|
||||
|
||||
double noiseGet3DDetail(NoiseGenerator* generator, double x, double y, double z, double detail)
|
||||
{
|
||||
int level;
|
||||
double result, height, factor;
|
||||
|
||||
result = 0.0;
|
||||
for (level = 0; level < generator->level_count; level++)
|
||||
{
|
||||
height = generator->levels[level].amplitude;
|
||||
factor = 1.0;
|
||||
if (height < detail * 0.25)
|
||||
{
|
||||
break;
|
||||
}
|
||||
else if (height < detail * 0.5)
|
||||
{
|
||||
factor = (detail * 0.5 - height) / 0.25;
|
||||
}
|
||||
|
||||
result += _get3DLevelValue(generator, generator->levels + level, x, y, z) * factor;
|
||||
}
|
||||
return result + generator->height_offset;
|
||||
}
|
||||
|
|
@ -1,83 +0,0 @@
|
|||
#ifndef _PAYSAGES_NOISE_H_
|
||||
#define _PAYSAGES_NOISE_H_
|
||||
|
||||
#include "rendering_global.h"
|
||||
|
||||
namespace paysages {
|
||||
namespace system {class PackStream;}
|
||||
}
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
typedef enum
|
||||
{
|
||||
NOISE_FUNCTION_SIMPLEX,
|
||||
NOISE_FUNCTION_PERLIN,
|
||||
NOISE_FUNCTION_NAIVE
|
||||
} NoiseFunctionAlgorithm;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
NoiseFunctionAlgorithm algorithm;
|
||||
double ridge_factor; /* -0.5;0.5 */
|
||||
double curve_factor; /* -1.0;1.0 */
|
||||
} NoiseFunction;
|
||||
|
||||
typedef struct
|
||||
{
|
||||
double wavelength;
|
||||
double amplitude;
|
||||
double minvalue;
|
||||
double xoffset;
|
||||
double yoffset;
|
||||
double zoffset;
|
||||
} NoiseLevel;
|
||||
|
||||
typedef struct NoiseGenerator NoiseGenerator;
|
||||
|
||||
RENDERINGSHARED_EXPORT void noiseInit();
|
||||
RENDERINGSHARED_EXPORT void noiseQuit();
|
||||
RENDERINGSHARED_EXPORT void noiseSave(PackStream* stream);
|
||||
RENDERINGSHARED_EXPORT void noiseLoad(PackStream* stream);
|
||||
|
||||
RENDERINGSHARED_EXPORT NoiseGenerator* noiseCreateGenerator();
|
||||
RENDERINGSHARED_EXPORT void noiseDeleteGenerator(NoiseGenerator* generator);
|
||||
RENDERINGSHARED_EXPORT void noiseSaveGenerator(PackStream* stream, NoiseGenerator* generator);
|
||||
RENDERINGSHARED_EXPORT void noiseLoadGenerator(PackStream* stream, NoiseGenerator* generator);
|
||||
RENDERINGSHARED_EXPORT void noiseCopy(NoiseGenerator* source, NoiseGenerator* destination);
|
||||
RENDERINGSHARED_EXPORT void noiseValidate(NoiseGenerator* generator);
|
||||
RENDERINGSHARED_EXPORT void noiseRandomizeOffsets(NoiseGenerator* generator);
|
||||
RENDERINGSHARED_EXPORT NoiseFunction noiseGetFunction(NoiseGenerator* generator);
|
||||
RENDERINGSHARED_EXPORT void noiseSetCustomFunction(NoiseGenerator* generator, double (*func1d)(double x), double (*func2d)(double x, double y), double (*func3d)(double x, double y, double z));
|
||||
RENDERINGSHARED_EXPORT void noiseSetFunction(NoiseGenerator* generator, NoiseFunction* function);
|
||||
RENDERINGSHARED_EXPORT void noiseSetFunctionParams(NoiseGenerator* generator, NoiseFunctionAlgorithm algorithm, double ridge_factor, double curve_factor);
|
||||
RENDERINGSHARED_EXPORT void noiseForceValue(NoiseGenerator* generator, double value);
|
||||
RENDERINGSHARED_EXPORT void noiseGetRange(NoiseGenerator* generator, double* minvalue, double* maxvalue);
|
||||
RENDERINGSHARED_EXPORT int noiseGetLevelCount(NoiseGenerator* generator);
|
||||
RENDERINGSHARED_EXPORT void noiseClearLevels(NoiseGenerator* generator);
|
||||
RENDERINGSHARED_EXPORT void noiseAddLevel(NoiseGenerator* generator, NoiseLevel level, int protect_offsets);
|
||||
RENDERINGSHARED_EXPORT void noiseAddLevelSimple(NoiseGenerator* generator, double scaling, double minvalue, double maxvalue);
|
||||
RENDERINGSHARED_EXPORT void noiseAddLevels(NoiseGenerator* generator, int level_count, NoiseLevel start_level, double scaling_factor, double amplitude_factor, double center_factor);
|
||||
RENDERINGSHARED_EXPORT void noiseAddLevelsSimple(NoiseGenerator* generator, int level_count, double scaling, double minvalue, double maxvalue, double center_factor);
|
||||
RENDERINGSHARED_EXPORT void noiseRemoveLevel(NoiseGenerator* generator, int level);
|
||||
RENDERINGSHARED_EXPORT int noiseGetLevel(NoiseGenerator* generator, int level, NoiseLevel* params);
|
||||
RENDERINGSHARED_EXPORT void noiseSetLevel(NoiseGenerator* generator, int index, NoiseLevel level, int protect_offsets);
|
||||
RENDERINGSHARED_EXPORT void noiseSetLevelSimple(NoiseGenerator* generator, int index, double scaling, double minvalue, double maxvalue);
|
||||
RENDERINGSHARED_EXPORT void noiseNormalizeAmplitude(NoiseGenerator* generator, double minvalue, double maxvalue, int adjust_scaling);
|
||||
RENDERINGSHARED_EXPORT double noiseGet1DLevel(NoiseGenerator* generator, int level, double x);
|
||||
RENDERINGSHARED_EXPORT double noiseGet1DTotal(NoiseGenerator* generator, double x);
|
||||
RENDERINGSHARED_EXPORT double noiseGet1DDetail(NoiseGenerator* generator, double x, double detail);
|
||||
RENDERINGSHARED_EXPORT double noiseGet2DLevel(NoiseGenerator* generator, int level, double x, double y);
|
||||
RENDERINGSHARED_EXPORT double noiseGet2DTotal(NoiseGenerator* generator, double x, double y);
|
||||
RENDERINGSHARED_EXPORT double noiseGet2DDetail(NoiseGenerator* generator, double x, double y, double detail);
|
||||
RENDERINGSHARED_EXPORT double noiseGet3DLevel(NoiseGenerator* generator, int level, double x, double y, double z);
|
||||
RENDERINGSHARED_EXPORT double noiseGet3DTotal(NoiseGenerator* generator, double x, double y, double z);
|
||||
RENDERINGSHARED_EXPORT double noiseGet3DDetail(NoiseGenerator* generator, double x, double y, double z, double detail);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -1,24 +0,0 @@
|
|||
#ifndef _PAYSAGES_NOISENAIVE_H_
|
||||
#define _PAYSAGES_NOISENAIVE_H_
|
||||
|
||||
#include "rendering_global.h"
|
||||
#include "PackStream.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
RENDERINGSHARED_EXPORT void noiseNaiveInit();
|
||||
RENDERINGSHARED_EXPORT void noiseNaiveQuit();
|
||||
RENDERINGSHARED_EXPORT void noiseNaiveSave(PackStream* stream);
|
||||
RENDERINGSHARED_EXPORT void noiseNaiveLoad(PackStream* stream);
|
||||
RENDERINGSHARED_EXPORT double noiseNaiveGet1DValue(double x);
|
||||
RENDERINGSHARED_EXPORT double noiseNaiveGet2DValue(double x, double y);
|
||||
RENDERINGSHARED_EXPORT double noiseNaiveGet3DValue(double x, double y, double z);
|
||||
/*double noiseNaiveGet4DValue(double x, double y, double z, double w);*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -1,186 +0,0 @@
|
|||
#include "noiseperlin.h"
|
||||
|
||||
/*
|
||||
* Perlin noise implementation.
|
||||
*
|
||||
* Based on Ken Perlin implementation.
|
||||
*/
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <string.h>
|
||||
#include <stdio.h>
|
||||
|
||||
#define B 0x100
|
||||
#define BM 0xff
|
||||
|
||||
#define N 0x1000
|
||||
#define NP 12 /* 2^N */
|
||||
#define NM 0xfff
|
||||
|
||||
static int p[B + B + 2];
|
||||
static double g3[B + B + 2][3];
|
||||
static double g2[B + B + 2][2];
|
||||
static double g1[B + B + 2];
|
||||
|
||||
#define s_curve(t) ( t * t * (3. - 2. * t) )
|
||||
|
||||
#define lerp(t, a, b) ( a + t * (b - a) )
|
||||
|
||||
#define setup(i,b0,b1,r0,r1)\
|
||||
t = vec[i] + N;\
|
||||
b0 = ((int)t) & BM;\
|
||||
b1 = (b0+1) & BM;\
|
||||
r0 = t - (int)t;\
|
||||
r1 = r0 - 1.;
|
||||
|
||||
double noisePerlinGet1DValue(double x)
|
||||
{
|
||||
double vec[1] = {x*2.0};
|
||||
int bx0, bx1;
|
||||
double rx0, rx1, sx, t, u, v;
|
||||
|
||||
setup(0, bx0,bx1, rx0,rx1);
|
||||
|
||||
sx = s_curve(rx0);
|
||||
|
||||
u = rx0 * g1[ p[ bx0 ] ];
|
||||
v = rx1 * g1[ p[ bx1 ] ];
|
||||
|
||||
return lerp(sx, u, v) * 1.068 + 0.5;
|
||||
}
|
||||
|
||||
double noisePerlinGet2DValue(double x, double y)
|
||||
{
|
||||
double vec[2] = {x*2.0, y*2.0};
|
||||
int bx0, bx1, by0, by1, b00, b10, b01, b11;
|
||||
double rx0, rx1, ry0, ry1, *q, sx, sy, a, b, t, u, v;
|
||||
int i, j;
|
||||
|
||||
setup(0, bx0,bx1, rx0,rx1);
|
||||
setup(1, by0,by1, ry0,ry1);
|
||||
|
||||
i = p[ bx0 ];
|
||||
j = p[ bx1 ];
|
||||
|
||||
b00 = p[ i + by0 ];
|
||||
b10 = p[ j + by0 ];
|
||||
b01 = p[ i + by1 ];
|
||||
b11 = p[ j + by1 ];
|
||||
|
||||
sx = s_curve(rx0);
|
||||
sy = s_curve(ry0);
|
||||
|
||||
#define at2(rx,ry) ( rx * q[0] + ry * q[1] )
|
||||
|
||||
q = g2[ b00 ] ; u = at2(rx0,ry0);
|
||||
q = g2[ b10 ] ; v = at2(rx1,ry0);
|
||||
a = lerp(sx, u, v);
|
||||
|
||||
q = g2[ b01 ] ; u = at2(rx0,ry1);
|
||||
q = g2[ b11 ] ; v = at2(rx1,ry1);
|
||||
b = lerp(sx, u, v);
|
||||
|
||||
return lerp(sy, a, b) * 0.709 + 0.5;
|
||||
}
|
||||
|
||||
double noisePerlinGet3DValue(double x, double y, double z)
|
||||
{
|
||||
double vec[3] = {x*2.0, y*2.0, z*2.0};
|
||||
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
|
||||
double rx0, rx1, ry0, ry1, rz0, rz1, *q, sy, sz, a, b, c, d, t, u, v;
|
||||
int i, j;
|
||||
|
||||
setup(0, bx0,bx1, rx0,rx1);
|
||||
setup(1, by0,by1, ry0,ry1);
|
||||
setup(2, bz0,bz1, rz0,rz1);
|
||||
|
||||
i = p[ bx0 ];
|
||||
j = p[ bx1 ];
|
||||
|
||||
b00 = p[ i + by0 ];
|
||||
b10 = p[ j + by0 ];
|
||||
b01 = p[ i + by1 ];
|
||||
b11 = p[ j + by1 ];
|
||||
|
||||
t = s_curve(rx0);
|
||||
sy = s_curve(ry0);
|
||||
sz = s_curve(rz0);
|
||||
|
||||
#define at3(rx,ry,rz) ( rx * q[0] + ry * q[1] + rz * q[2] )
|
||||
|
||||
q = g3[ b00 + bz0 ] ; u = at3(rx0,ry0,rz0);
|
||||
q = g3[ b10 + bz0 ] ; v = at3(rx1,ry0,rz0);
|
||||
a = lerp(t, u, v);
|
||||
|
||||
q = g3[ b01 + bz0 ] ; u = at3(rx0,ry1,rz0);
|
||||
q = g3[ b11 + bz0 ] ; v = at3(rx1,ry1,rz0);
|
||||
b = lerp(t, u, v);
|
||||
|
||||
c = lerp(sy, a, b);
|
||||
|
||||
q = g3[ b00 + bz1 ] ; u = at3(rx0,ry0,rz1);
|
||||
q = g3[ b10 + bz1 ] ; v = at3(rx1,ry0,rz1);
|
||||
a = lerp(t, u, v);
|
||||
|
||||
q = g3[ b01 + bz1 ] ; u = at3(rx0,ry1,rz1);
|
||||
q = g3[ b11 + bz1 ] ; v = at3(rx1,ry1,rz1);
|
||||
b = lerp(t, u, v);
|
||||
|
||||
d = lerp(sy, a, b);
|
||||
|
||||
return lerp(sz, c, d) * 0.661 + 0.5;
|
||||
}
|
||||
|
||||
static void _normalize2(double v[2])
|
||||
{
|
||||
double s;
|
||||
|
||||
s = sqrt(v[0] * v[0] + v[1] * v[1]);
|
||||
v[0] = v[0] / s;
|
||||
v[1] = v[1] / s;
|
||||
}
|
||||
|
||||
static void _normalize3(double v[3])
|
||||
{
|
||||
double s;
|
||||
|
||||
s = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
|
||||
v[0] = v[0] / s;
|
||||
v[1] = v[1] / s;
|
||||
v[2] = v[2] / s;
|
||||
}
|
||||
|
||||
void noisePerlinInit(void)
|
||||
{
|
||||
int i, j, k;
|
||||
|
||||
for (i = 0 ; i < B ; i++) {
|
||||
p[i] = i;
|
||||
|
||||
g1[i] = (double)((rand() % (B + B)) - B) / B;
|
||||
|
||||
for (j = 0 ; j < 2 ; j++)
|
||||
g2[i][j] = (double)((rand() % (B + B)) - B) / B;
|
||||
_normalize2(g2[i]);
|
||||
|
||||
for (j = 0 ; j < 3 ; j++)
|
||||
g3[i][j] = (double)((rand() % (B + B)) - B) / B;
|
||||
_normalize3(g3[i]);
|
||||
}
|
||||
|
||||
while (--i) {
|
||||
k = p[i];
|
||||
p[i] = p[j = rand() % B];
|
||||
p[j] = k;
|
||||
}
|
||||
|
||||
for (i = 0 ; i < B + 2 ; i++) {
|
||||
p[B + i] = p[i];
|
||||
g1[B + i] = g1[i];
|
||||
for (j = 0 ; j < 2 ; j++)
|
||||
g2[B + i][j] = g2[i][j];
|
||||
for (j = 0 ; j < 3 ; j++)
|
||||
g3[B + i][j] = g3[i][j];
|
||||
}
|
||||
}
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
#ifndef _PAYSAGES_NOISEPERLIN_H_
|
||||
#define _PAYSAGES_NOISEPERLIN_H_
|
||||
|
||||
#include "rendering_global.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
RENDERINGSHARED_EXPORT void noisePerlinInit();
|
||||
RENDERINGSHARED_EXPORT double noisePerlinGet1DValue(double x);
|
||||
RENDERINGSHARED_EXPORT double noisePerlinGet2DValue(double x, double y);
|
||||
RENDERINGSHARED_EXPORT double noisePerlinGet3DValue(double x, double y, double z);
|
||||
/*double noiseSimplexGet4DValue(double x, double y, double z, double w);*/
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -1,20 +0,0 @@
|
|||
#ifndef _PAYSAGES_NOISESIMPLEX_H_
|
||||
#define _PAYSAGES_NOISESIMPLEX_H_
|
||||
|
||||
#include "rendering_global.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
|
||||
RENDERINGSHARED_EXPORT void noiseSimplexInit();
|
||||
RENDERINGSHARED_EXPORT double noiseSimplexGet1DValue(double x);
|
||||
RENDERINGSHARED_EXPORT double noiseSimplexGet2DValue(double x, double y);
|
||||
RENDERINGSHARED_EXPORT double noiseSimplexGet3DValue(double x, double y, double z);
|
||||
RENDERINGSHARED_EXPORT double noiseSimplexGet4DValue(double x, double y, double z, double w);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
@ -4,7 +4,6 @@
|
|||
/* OpenCL usage */
|
||||
|
||||
#include "rendering_global.h"
|
||||
#include "noise.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
|
|
|
|||
|
|
@ -14,10 +14,6 @@ SOURCES += main.cpp \
|
|||
renderer.cpp \
|
||||
render.cpp \
|
||||
opencl.cpp \
|
||||
noisesimplex.cpp \
|
||||
noiseperlin.cpp \
|
||||
noisenaive.cpp \
|
||||
noise.cpp \
|
||||
geoarea.cpp \
|
||||
camera.cpp \
|
||||
atmosphere/atm_render.cpp \
|
||||
|
|
@ -68,10 +64,6 @@ HEADERS += \
|
|||
renderer.h \
|
||||
render.h \
|
||||
opencl.h \
|
||||
noisesimplex.h \
|
||||
noiseperlin.h \
|
||||
noisenaive.h \
|
||||
noise.h \
|
||||
main.h \
|
||||
geoarea.h \
|
||||
camera.h \
|
||||
|
|
|
|||
|
|
@ -2,17 +2,7 @@
|
|||
#define RENDERING_GLOBAL_H
|
||||
|
||||
/* Shared object helpers */
|
||||
#ifdef __cplusplus
|
||||
# include <QtCore/qglobal.h>
|
||||
#else
|
||||
# if defined(WIN32) || defined(_WIN32) || defined(__WIN32__) || defined(__NT__)
|
||||
# define Q_DECL_EXPORT __declspec(dllexport)
|
||||
# define Q_DECL_IMPORT __declspec(dllimport)
|
||||
# else
|
||||
# define Q_DECL_EXPORT
|
||||
# define Q_DECL_IMPORT
|
||||
# endif
|
||||
#endif
|
||||
#include <QtCore/qglobal.h>
|
||||
#if defined(RENDERING_LIBRARY)
|
||||
# define RENDERINGSHARED_EXPORT Q_DECL_EXPORT
|
||||
#else
|
||||
|
|
@ -20,20 +10,14 @@
|
|||
#endif
|
||||
|
||||
/* Namespace using */
|
||||
#ifdef __cplusplus
|
||||
namespace paysages
|
||||
{
|
||||
namespace system {}
|
||||
namespace basics {}
|
||||
namespace definition {}
|
||||
namespace rendering {}
|
||||
}
|
||||
using namespace paysages::system;
|
||||
using namespace paysages::basics;
|
||||
using namespace paysages::definition;
|
||||
using namespace paysages::rendering;
|
||||
#endif
|
||||
|
||||
/* Global import */
|
||||
|
||||
#endif // RENDERING_GLOBAL_H
|
||||
|
|
|
|||
|
|
@ -6,11 +6,12 @@
|
|||
#include "../shared/types.h"
|
||||
#include "../tools/color.h"
|
||||
#include "../tools/euclid.h"
|
||||
#include "../noise.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
namespace paysages {
|
||||
namespace basics {
|
||||
class NoiseGenerator;
|
||||
}
|
||||
}
|
||||
|
||||
typedef enum
|
||||
{
|
||||
|
|
@ -91,8 +92,4 @@ RENDERINGSHARED_EXPORT void terrainBrushReset(TerrainHeightMap* heightmap, Terra
|
|||
RENDERINGSHARED_EXPORT void terrainBrushFlatten(TerrainHeightMap* heightmap, TerrainBrush* brush, double height, double force);
|
||||
RENDERINGSHARED_EXPORT void terrainEndBrushStroke(TerrainHeightMap* heightmap);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,14 +1,13 @@
|
|||
#include "private.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include "../tools.h"
|
||||
#include "../renderer.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
/******************** Definition ********************/
|
||||
static void _validateDefinition(TerrainDefinition* definition)
|
||||
{
|
||||
noiseValidate(definition->_height_noise);
|
||||
definition->_height_noise->validate();
|
||||
|
||||
if (definition->height < 1.0)
|
||||
{
|
||||
|
|
@ -16,7 +15,7 @@ static void _validateDefinition(TerrainDefinition* definition)
|
|||
}
|
||||
|
||||
/* Get minimal and maximal height */
|
||||
noiseGetRange(definition->_height_noise, &definition->_min_height, &definition->_max_height);
|
||||
definition->_height_noise->getRange(&definition->_min_height, &definition->_max_height);
|
||||
definition->_min_height *= definition->height * definition->scaling;
|
||||
definition->_max_height *= definition->height * definition->scaling;
|
||||
|
||||
|
|
@ -35,7 +34,7 @@ static TerrainDefinition* _createDefinition()
|
|||
|
||||
definition->water_height = -0.3;
|
||||
|
||||
definition->_height_noise = noiseCreateGenerator();
|
||||
definition->_height_noise = new NoiseGenerator();
|
||||
|
||||
terrainAutoPreset(definition, TERRAIN_PRESET_STANDARD);
|
||||
|
||||
|
|
@ -45,7 +44,7 @@ static TerrainDefinition* _createDefinition()
|
|||
static void _deleteDefinition(TerrainDefinition* definition)
|
||||
{
|
||||
terrainHeightmapDelete(definition->height_map);
|
||||
noiseDeleteGenerator(definition->_height_noise);
|
||||
delete definition->_height_noise;
|
||||
delete definition;
|
||||
}
|
||||
|
||||
|
|
@ -59,7 +58,7 @@ static void _copyDefinition(TerrainDefinition* source, TerrainDefinition* destin
|
|||
|
||||
destination->water_height = source->water_height;
|
||||
|
||||
noiseCopy(source->_height_noise, destination->_height_noise);
|
||||
source->_height_noise->copy(destination->_height_noise);
|
||||
|
||||
_validateDefinition(destination);
|
||||
}
|
||||
|
|
@ -71,7 +70,7 @@ static void _saveDefinition(PackStream* stream, TerrainDefinition* definition)
|
|||
stream->write(&definition->shadow_smoothing);
|
||||
terrainHeightmapSave(stream, definition->height_map);
|
||||
stream->write(&definition->water_height);
|
||||
noiseSaveGenerator(stream, definition->_height_noise);
|
||||
definition->_height_noise->save(stream);
|
||||
}
|
||||
|
||||
static void _loadDefinition(PackStream* stream, TerrainDefinition* definition)
|
||||
|
|
@ -81,7 +80,7 @@ static void _loadDefinition(PackStream* stream, TerrainDefinition* definition)
|
|||
stream->read(&definition->shadow_smoothing);
|
||||
terrainHeightmapLoad(stream, definition->height_map);
|
||||
stream->read(&definition->water_height);
|
||||
noiseLoadGenerator(stream, definition->_height_noise);
|
||||
definition->_height_noise->load(stream);
|
||||
|
||||
_validateDefinition(definition);
|
||||
}
|
||||
|
|
@ -102,7 +101,7 @@ double terrainGetGridHeight(TerrainDefinition* definition, int x, int z, int wit
|
|||
|
||||
if (!with_painting || !terrainHeightmapGetGridHeight(definition->height_map, x, z, &height))
|
||||
{
|
||||
height = noiseGet2DTotal(definition->_height_noise, (double)x, (double)z);
|
||||
height = definition->_height_noise->get2DTotal((double)x, (double)z);
|
||||
}
|
||||
|
||||
return height;
|
||||
|
|
@ -116,7 +115,7 @@ double terrainGetInterpolatedHeight(TerrainDefinition* definition, double x, dou
|
|||
|
||||
if (!with_painting || !terrainHeightmapGetInterpolatedHeight(definition->height_map, x, z, &height))
|
||||
{
|
||||
height = noiseGet2DTotal(definition->_height_noise, x, z);
|
||||
height = definition->_height_noise->get2DTotal(x, z);
|
||||
}
|
||||
|
||||
if (scaled)
|
||||
|
|
|
|||
|
|
@ -12,6 +12,7 @@
|
|||
#include "../tools.h"
|
||||
#include "../tools/array.h"
|
||||
#include "PackStream.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
typedef struct
|
||||
{
|
||||
|
|
@ -556,11 +557,11 @@ void terrainBrushSmooth(TerrainHeightMap* heightmap, TerrainBrush* brush, double
|
|||
_applyBrush(heightmap, brush, value, NULL, _applyBrushSmooth);
|
||||
}
|
||||
|
||||
static double _applyBrushAddNoise(TerrainHeightMap* heightmap, TerrainBrush* brush, double x, double z, double basevalue, double influence, double force, void* data)
|
||||
static double _applyBrushAddNoise(TerrainHeightMap*, TerrainBrush* brush, double x, double z, double basevalue, double influence, double force, void* data)
|
||||
{
|
||||
UNUSED(heightmap);
|
||||
NoiseGenerator* noise = (NoiseGenerator*)data;
|
||||
|
||||
return basevalue + noiseGet2DTotal((NoiseGenerator*)data, x / brush->total_radius, z / brush->total_radius) * influence * force * brush->total_radius;
|
||||
return basevalue + noise->get2DTotal(x / brush->total_radius, z / brush->total_radius) * influence * force * brush->total_radius;
|
||||
}
|
||||
|
||||
void terrainBrushAddNoise(TerrainHeightMap* heightmap, TerrainBrush* brush, NoiseGenerator* generator, double value)
|
||||
|
|
|
|||
|
|
@ -1,6 +1,7 @@
|
|||
#include "private.h"
|
||||
|
||||
#include <math.h>
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
/*
|
||||
* Terrain presets.
|
||||
|
|
@ -12,12 +13,12 @@ void terrainAutoPreset(TerrainDefinition* definition, TerrainPreset preset)
|
|||
switch (preset)
|
||||
{
|
||||
case TERRAIN_PRESET_STANDARD:
|
||||
noiseRandomizeOffsets(definition->_height_noise);
|
||||
noiseClearLevels(definition->_height_noise);
|
||||
noiseAddLevelSimple(definition->_height_noise, pow(2.0, resolution + 1), -1.0, 1.0);
|
||||
noiseAddLevelsSimple(definition->_height_noise, resolution - 2, pow(2.0, resolution - 1), -0.7, 0.7, 0.5);
|
||||
noiseNormalizeAmplitude(definition->_height_noise, -1.0, 1.0, 0);
|
||||
noiseSetFunctionParams(definition->_height_noise, NOISE_FUNCTION_SIMPLEX, 0.0, 0.0);
|
||||
definition->_height_noise->randomizeOffsets();
|
||||
definition->_height_noise->clearLevels();
|
||||
definition->_height_noise->addLevelSimple(pow(2.0, resolution + 1), -1.0, 1.0);
|
||||
definition->_height_noise->addLevelsSimple(resolution - 2, pow(2.0, resolution - 1), -0.7, 0.7, 0.5);
|
||||
definition->_height_noise->normalizeAmplitude(-1.0, 1.0, 0);
|
||||
definition->_height_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, 0.0, 0.0);
|
||||
definition->scaling = 1.0;
|
||||
definition->height = 30.0;
|
||||
definition->shadow_smoothing = 0.03;
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#include "public.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "../tools.h"
|
||||
#include "../tools/lighting.h"
|
||||
#include "../renderer.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
/*
|
||||
* Terrain previews.
|
||||
|
|
@ -67,7 +67,7 @@ Renderer* terrainCreatePreviewRenderer()
|
|||
layer->material.reflection = 0.05;
|
||||
layer->material.shininess = 2.0;
|
||||
TexturesDefinitionClass.validate(textures);
|
||||
noiseClearLevels(layer->_detail_noise);
|
||||
layer->_detail_noise->clearLevels();
|
||||
|
||||
TexturesRendererClass.bind(result, textures);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#include "private.h"
|
||||
#include "Scenery.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "Scenery.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
/******************** Global definition ********************/
|
||||
static void _validateDefinition(TexturesDefinition* definition)
|
||||
|
|
@ -57,15 +57,15 @@ static void _layerValidateDefinition(TexturesLayerDefinition* definition)
|
|||
definition->displacement_scaling = 0.000001;
|
||||
}
|
||||
|
||||
noiseClearLevels(definition->_displacement_noise);
|
||||
noiseAddLevelsSimple(definition->_displacement_noise, 9, 1.0, -1.0, 1.0, 0.0);
|
||||
noiseNormalizeAmplitude(definition->_displacement_noise, -1.0, 1.0, 0);
|
||||
noiseValidate(definition->_displacement_noise);
|
||||
definition->_displacement_noise->clearLevels();
|
||||
definition->_displacement_noise->addLevelsSimple(9, 1.0, -1.0, 1.0, 0.0);
|
||||
definition->_displacement_noise->normalizeAmplitude(-1.0, 1.0, 0);
|
||||
definition->_displacement_noise->validate();
|
||||
|
||||
noiseClearLevels(definition->_detail_noise);
|
||||
noiseAddLevelsSimple(definition->_detail_noise, 7, 0.01, -1.0, 1.0, 0.0);
|
||||
noiseNormalizeAmplitude(definition->_detail_noise, -0.008, 0.008, 0);
|
||||
noiseValidate(definition->_detail_noise);
|
||||
definition->_detail_noise->clearLevels();
|
||||
definition->_detail_noise->addLevelsSimple(7, 0.01, -1.0, 1.0, 0.0);
|
||||
definition->_detail_noise->normalizeAmplitude(-0.008, 0.008, 0);
|
||||
definition->_detail_noise->validate();
|
||||
|
||||
materialValidate(&definition->material);
|
||||
|
||||
|
|
@ -85,8 +85,8 @@ static TexturesLayerDefinition* _layerCreateDefinition()
|
|||
result = new TexturesLayerDefinition;
|
||||
|
||||
result->terrain_zone = zoneCreate();
|
||||
result->_displacement_noise = noiseCreateGenerator();
|
||||
result->_detail_noise = noiseCreateGenerator();
|
||||
result->_displacement_noise = new NoiseGenerator();
|
||||
result->_detail_noise = new NoiseGenerator();
|
||||
|
||||
texturesLayerAutoPreset(result, TEXTURES_LAYER_PRESET_ROCK);
|
||||
|
||||
|
|
@ -98,8 +98,8 @@ static TexturesLayerDefinition* _layerCreateDefinition()
|
|||
static void _layerDeleteDefinition(TexturesLayerDefinition* definition)
|
||||
{
|
||||
zoneDelete(definition->terrain_zone);
|
||||
noiseDeleteGenerator(definition->_displacement_noise);
|
||||
noiseDeleteGenerator(definition->_detail_noise);
|
||||
delete definition->_displacement_noise;
|
||||
delete definition->_detail_noise;
|
||||
delete definition;
|
||||
}
|
||||
|
||||
|
|
@ -111,8 +111,8 @@ static void _layerCopyDefinition(TexturesLayerDefinition* source, TexturesLayerD
|
|||
destination->displacement_offset = source->displacement_offset;
|
||||
destination->material = source->material;
|
||||
|
||||
noiseCopy(source->_displacement_noise, destination->_displacement_noise);
|
||||
noiseCopy(source->_detail_noise, destination->_detail_noise);
|
||||
source->_displacement_noise->copy(destination->_displacement_noise);
|
||||
source->_detail_noise->copy(destination->_detail_noise);
|
||||
}
|
||||
|
||||
static void _layerSave(PackStream* stream, TexturesLayerDefinition* layer)
|
||||
|
|
@ -123,8 +123,8 @@ static void _layerSave(PackStream* stream, TexturesLayerDefinition* layer)
|
|||
stream->write(&layer->displacement_offset);
|
||||
materialSave(stream, &layer->material);
|
||||
|
||||
noiseSaveGenerator(stream, layer->_displacement_noise);
|
||||
noiseSaveGenerator(stream, layer->_detail_noise);
|
||||
layer->_displacement_noise->save(stream);
|
||||
layer->_detail_noise->save(stream);
|
||||
}
|
||||
|
||||
static void _layerLoad(PackStream* stream, TexturesLayerDefinition* layer)
|
||||
|
|
@ -135,8 +135,8 @@ static void _layerLoad(PackStream* stream, TexturesLayerDefinition* layer)
|
|||
stream->read(&layer->displacement_offset);
|
||||
materialLoad(stream, &layer->material);
|
||||
|
||||
noiseLoadGenerator(stream, layer->_displacement_noise);
|
||||
noiseLoadGenerator(stream, layer->_detail_noise);
|
||||
layer->_displacement_noise->load(stream);
|
||||
layer->_detail_noise->load(stream);
|
||||
}
|
||||
|
||||
LayerType texturesGetLayerType()
|
||||
|
|
|
|||
|
|
@ -1,5 +1,7 @@
|
|||
#include "private.h"
|
||||
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
void texturesAutoPreset(TexturesDefinition* definition, TexturesPreset preset)
|
||||
{
|
||||
TexturesLayerDefinition* layer;
|
||||
|
|
@ -55,8 +57,8 @@ void texturesAutoPreset(TexturesDefinition* definition, TexturesPreset preset)
|
|||
|
||||
void texturesLayerAutoPreset(TexturesLayerDefinition* definition, TexturesLayerPreset preset)
|
||||
{
|
||||
noiseRandomizeOffsets(definition->_displacement_noise);
|
||||
noiseRandomizeOffsets(definition->_detail_noise);
|
||||
definition->_displacement_noise->randomizeOffsets();
|
||||
definition->_detail_noise->randomizeOffsets();
|
||||
|
||||
zoneClear(definition->terrain_zone);
|
||||
|
||||
|
|
|
|||
|
|
@ -1,7 +1,7 @@
|
|||
#include "private.h"
|
||||
|
||||
#include <assert.h>
|
||||
#include <math.h>
|
||||
#include <cmath>
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
/*
|
||||
* Get the base presence factor of a layer, not accounting for other layers.
|
||||
|
|
@ -16,11 +16,9 @@ double texturesGetLayerBasePresence(TexturesLayerDefinition* layer, TerrainResul
|
|||
*/
|
||||
double texturesGetTriplanarNoise(NoiseGenerator* noise, Vector3 location, Vector3 normal)
|
||||
{
|
||||
/*assert(v3Norm(normal) == 1.0);*/
|
||||
|
||||
double noiseXY = noiseGet2DTotal(noise, location.x, location.y);
|
||||
double noiseXZ = noiseGet2DTotal(noise, location.x, location.z);
|
||||
double noiseYZ = noiseGet2DTotal(noise, location.y, location.z);
|
||||
double noiseXY = noise->get2DTotal(location.x, location.y);
|
||||
double noiseXZ = noise->get2DTotal(location.x, location.z);
|
||||
double noiseYZ = noise->get2DTotal(location.y, location.z);
|
||||
|
||||
double mXY = fabs(normal.z);
|
||||
double mXZ = fabs(normal.y);
|
||||
|
|
|
|||
|
|
@ -6,12 +6,12 @@
|
|||
#include "../tools/lighting.h"
|
||||
#include "../tools/curve.h"
|
||||
#include "../tools/euclid.h"
|
||||
#include "../noise.h"
|
||||
#include "Layers.h"
|
||||
|
||||
#ifdef __cplusplus
|
||||
extern "C" {
|
||||
#endif
|
||||
namespace paysages {
|
||||
namespace basics {
|
||||
class NoiseGenerator;
|
||||
}
|
||||
}
|
||||
|
||||
typedef enum
|
||||
{
|
||||
|
|
@ -75,8 +75,4 @@ RENDERINGSHARED_EXPORT Color waterGetPreviewCoverage(Renderer* renderer, double
|
|||
RENDERINGSHARED_EXPORT Renderer* waterCreatePreviewColorRenderer();
|
||||
RENDERINGSHARED_EXPORT Color waterGetPreviewColor(Renderer* renderer, double x, double y, double scaling);
|
||||
|
||||
#ifdef __cplusplus
|
||||
}
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
|
|
|||
|
|
@ -1,22 +1,22 @@
|
|||
#include "private.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include "PackStream.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
static void _validateDefinition(WaterDefinition* definition)
|
||||
{
|
||||
double scaling = definition->scaling * 0.3;
|
||||
noiseClearLevels(definition->_waves_noise);
|
||||
definition->_waves_noise->clearLevels();
|
||||
if (definition->waves_height > 0.0)
|
||||
{
|
||||
noiseAddLevelsSimple(definition->_waves_noise, 2, scaling, -definition->waves_height * scaling * 0.015, definition->waves_height * scaling * 0.015, 0.5);
|
||||
definition->_waves_noise->addLevelsSimple(2, scaling, -definition->waves_height * scaling * 0.015, definition->waves_height * scaling * 0.015, 0.5);
|
||||
}
|
||||
if (definition->detail_height > 0.0)
|
||||
{
|
||||
noiseAddLevelsSimple(definition->_waves_noise, 3, scaling * 0.1, -definition->detail_height * scaling * 0.015, definition->detail_height * scaling * 0.015, 0.5);
|
||||
definition->_waves_noise->addLevelsSimple(3, scaling * 0.1, -definition->detail_height * scaling * 0.015, definition->detail_height * scaling * 0.015, 0.5);
|
||||
}
|
||||
noiseSetFunctionParams(definition->_waves_noise, NOISE_FUNCTION_SIMPLEX, -definition->turbulence, 0.0);
|
||||
noiseValidate(definition->_waves_noise);
|
||||
definition->_waves_noise->setFunctionParams(NOISE_FUNCTION_SIMPLEX, -definition->turbulence, 0.0);
|
||||
definition->_waves_noise->validate();
|
||||
|
||||
materialValidate(&definition->material);
|
||||
materialValidate(&definition->foam_material);
|
||||
|
|
@ -26,7 +26,7 @@ static WaterDefinition* _createDefinition()
|
|||
{
|
||||
WaterDefinition* definition = new WaterDefinition;
|
||||
|
||||
definition->_waves_noise = noiseCreateGenerator();
|
||||
definition->_waves_noise = new NoiseGenerator();
|
||||
|
||||
waterAutoPreset(definition, WATER_PRESET_LAKE);
|
||||
|
||||
|
|
@ -35,7 +35,7 @@ static WaterDefinition* _createDefinition()
|
|||
|
||||
static void _deleteDefinition(WaterDefinition* definition)
|
||||
{
|
||||
noiseDeleteGenerator(definition->_waves_noise);
|
||||
delete definition->_waves_noise;
|
||||
delete definition;
|
||||
}
|
||||
|
||||
|
|
@ -46,7 +46,7 @@ static void _copyDefinition(WaterDefinition* source, WaterDefinition* destinatio
|
|||
noise = destination->_waves_noise;
|
||||
*destination = *source;
|
||||
destination->_waves_noise = noise;
|
||||
noiseCopy(source->_waves_noise, destination->_waves_noise);
|
||||
source->_waves_noise->copy(destination->_waves_noise);
|
||||
}
|
||||
|
||||
static void _saveDefinition(PackStream* stream, WaterDefinition* definition)
|
||||
|
|
@ -66,7 +66,7 @@ static void _saveDefinition(PackStream* stream, WaterDefinition* definition)
|
|||
stream->write(&definition->foam_coverage);
|
||||
materialSave(stream, &definition->foam_material);
|
||||
|
||||
noiseSaveGenerator(stream, definition->_waves_noise);
|
||||
definition->_waves_noise->save(stream);
|
||||
}
|
||||
|
||||
static void _loadDefinition(PackStream* stream, WaterDefinition* definition)
|
||||
|
|
@ -86,7 +86,7 @@ static void _loadDefinition(PackStream* stream, WaterDefinition* definition)
|
|||
stream->read(&definition->foam_coverage);
|
||||
materialLoad(stream, &definition->foam_material);
|
||||
|
||||
noiseLoadGenerator(stream, definition->_waves_noise);
|
||||
definition->_waves_noise->load(stream);
|
||||
|
||||
_validateDefinition(definition);
|
||||
}
|
||||
|
|
|
|||
|
|
@ -1,8 +1,10 @@
|
|||
#include "private.h"
|
||||
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
void waterAutoPreset(WaterDefinition* definition, WaterPreset preset)
|
||||
{
|
||||
noiseRandomizeOffsets(definition->_waves_noise);
|
||||
definition->_waves_noise->randomizeOffsets();
|
||||
|
||||
if (preset == WATER_PRESET_LAKE)
|
||||
{
|
||||
|
|
|
|||
|
|
@ -1,9 +1,9 @@
|
|||
#include "private.h"
|
||||
|
||||
#include <stdlib.h>
|
||||
#include <math.h>
|
||||
#include <cmath>
|
||||
#include "../tools.h"
|
||||
#include "../renderer.h"
|
||||
#include "NoiseGenerator.h"
|
||||
|
||||
static HeightInfo _FAKE_HEIGHT_INFO = {0.0, 0.0, 0.0};
|
||||
|
||||
|
|
@ -44,7 +44,7 @@ static WaterResult _fakeGetResult(Renderer* renderer, double x, double z)
|
|||
/******************** Helpers ********************/
|
||||
static inline double _getHeight(WaterDefinition* definition, double base_height, double x, double z)
|
||||
{
|
||||
return base_height + noiseGet2DTotal(definition->_waves_noise, x, z);
|
||||
return base_height + definition->_waves_noise->get2DTotal(x, z);
|
||||
}
|
||||
|
||||
static inline Vector3 _getNormal(WaterDefinition* definition, double base_height, Vector3 base, double detail)
|
||||
|
|
@ -205,7 +205,7 @@ static HeightInfo _realGetHeightInfo(Renderer* renderer)
|
|||
double noise_minvalue, noise_maxvalue;
|
||||
|
||||
info.base_height = renderer->terrain->getWaterHeight(renderer);
|
||||
noiseGetRange(definition->_waves_noise, &noise_minvalue, &noise_maxvalue);
|
||||
definition->_waves_noise->getRange(&noise_minvalue, &noise_maxvalue);
|
||||
info.min_height = info.base_height + noise_minvalue;
|
||||
info.max_height = info.base_height + noise_maxvalue;
|
||||
|
||||
|
|
|
|||
5
src/system/RandomGenerator.cpp
Normal file
5
src/system/RandomGenerator.cpp
Normal file
|
|
@ -0,0 +1,5 @@
|
|||
#include "RandomGenerator.h"
|
||||
|
||||
RandomGenerator::RandomGenerator()
|
||||
{
|
||||
}
|
||||
24
src/system/RandomGenerator.h
Normal file
24
src/system/RandomGenerator.h
Normal file
|
|
@ -0,0 +1,24 @@
|
|||
#ifndef RANDOMGENERATOR_H
|
||||
#define RANDOMGENERATOR_H
|
||||
|
||||
#include "system_global.h"
|
||||
#include <cstdlib>
|
||||
|
||||
namespace paysages {
|
||||
namespace system {
|
||||
|
||||
class RandomGenerator
|
||||
{
|
||||
public:
|
||||
RandomGenerator();
|
||||
|
||||
static inline double random()
|
||||
{
|
||||
return ((double)rand()) / (double)RAND_MAX;
|
||||
}
|
||||
};
|
||||
|
||||
}
|
||||
}
|
||||
|
||||
#endif // RANDOMGENERATOR_H
|
||||
|
|
@ -17,7 +17,8 @@ SOURCES += \
|
|||
Thread.cpp \
|
||||
Mutex.cpp \
|
||||
System.cpp \
|
||||
PackStream.cpp
|
||||
PackStream.cpp \
|
||||
RandomGenerator.cpp
|
||||
|
||||
HEADERS += \
|
||||
system_global.h \
|
||||
|
|
@ -25,7 +26,8 @@ HEADERS += \
|
|||
Thread.h \
|
||||
Mutex.h \
|
||||
System.h \
|
||||
PackStream.h
|
||||
PackStream.h \
|
||||
RandomGenerator.h
|
||||
|
||||
unix:!symbian {
|
||||
maemo5 {
|
||||
|
|
|
|||
Loading…
Reference in a new issue