From b5c50d16d4767efc8b5e2d7592e49406da380d0b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Micha=C3=ABl=20Lemaire?= Date: Sun, 3 Nov 2013 15:46:39 +0100 Subject: [PATCH] Made a class of NoiseGenerator --- src/basics/Interpolation.cpp | 5 + src/basics/Interpolation.h | 23 + .../NoiseFunctionNaive.cpp} | 72 +- src/basics/NoiseFunctionNaive.h | 30 + src/basics/NoiseFunctionPerlin.cpp | 188 ++++++ src/basics/NoiseFunctionPerlin.h | 27 + .../NoiseFunctionSimplex.cpp} | 12 +- src/basics/NoiseFunctionSimplex.h | 27 + src/basics/NoiseGenerator.cpp | 597 +++++++++++++++++ src/basics/NoiseGenerator.h | 100 +++ src/basics/basics.pro | 20 +- src/basics/basics_global.h | 18 +- src/editing/baseform.h | 15 +- src/editing/dialognoise.cpp | 38 +- src/editing/dialognoise.h | 3 +- src/editing/editing.pro | 9 +- src/editing/editing_global.h | 14 + src/editing/inputnoise.cpp | 4 +- src/editing/inputnoise.h | 8 +- .../terrain/dialogbaseterrainnoise.cpp | 8 +- src/editing/terrain/dialogbaseterrainnoise.h | 10 +- src/editing/terrain/paintingbrush.cpp | 9 +- src/editing/terrain/paintingbrush.h | 7 +- .../terrain/widgetterrainbasenoisepreview.cpp | 5 +- .../terrain/widgetterrainbasenoisepreview.h | 9 +- src/rendering/Scenery.cpp | 2 +- src/rendering/Scenery.h | 6 - src/rendering/clouds/clo_definition.cpp | 81 +-- src/rendering/clouds/clo_density.cpp | 7 +- src/rendering/clouds/clo_presets.cpp | 11 +- src/rendering/clouds/public.h | 13 +- src/rendering/noise.cpp | 621 ------------------ src/rendering/noise.h | 83 --- src/rendering/noisenaive.h | 24 - src/rendering/noiseperlin.cpp | 186 ------ src/rendering/noiseperlin.h | 20 - src/rendering/noisesimplex.h | 20 - src/rendering/opencl.h | 1 - src/rendering/rendering.pro | 8 - src/rendering/rendering_global.h | 18 +- src/rendering/terrain/public.h | 13 +- src/rendering/terrain/ter_definition.cpp | 21 +- src/rendering/terrain/ter_painting.cpp | 7 +- src/rendering/terrain/ter_presets.cpp | 13 +- src/rendering/terrain/ter_preview.cpp | 4 +- src/rendering/textures/tex_definition.cpp | 40 +- src/rendering/textures/tex_presets.cpp | 6 +- src/rendering/textures/tex_tools.cpp | 12 +- src/rendering/water/public.h | 14 +- src/rendering/water/wat_definition.cpp | 22 +- src/rendering/water/wat_presets.cpp | 4 +- src/rendering/water/wat_render.cpp | 8 +- src/system/RandomGenerator.cpp | 5 + src/system/RandomGenerator.h | 24 + src/system/system.pro | 6 +- 55 files changed, 1333 insertions(+), 1225 deletions(-) create mode 100644 src/basics/Interpolation.cpp create mode 100644 src/basics/Interpolation.h rename src/{rendering/noisenaive.cpp => basics/NoiseFunctionNaive.cpp} (84%) create mode 100644 src/basics/NoiseFunctionNaive.h create mode 100644 src/basics/NoiseFunctionPerlin.cpp create mode 100644 src/basics/NoiseFunctionPerlin.h rename src/{rendering/noisesimplex.cpp => basics/NoiseFunctionSimplex.cpp} (99%) create mode 100644 src/basics/NoiseFunctionSimplex.h create mode 100644 src/basics/NoiseGenerator.cpp create mode 100644 src/basics/NoiseGenerator.h create mode 100644 src/editing/editing_global.h delete mode 100644 src/rendering/noise.cpp delete mode 100644 src/rendering/noise.h delete mode 100644 src/rendering/noisenaive.h delete mode 100644 src/rendering/noiseperlin.cpp delete mode 100644 src/rendering/noiseperlin.h delete mode 100644 src/rendering/noisesimplex.h create mode 100644 src/system/RandomGenerator.cpp create mode 100644 src/system/RandomGenerator.h diff --git a/src/basics/Interpolation.cpp b/src/basics/Interpolation.cpp new file mode 100644 index 0000000..93db00d --- /dev/null +++ b/src/basics/Interpolation.cpp @@ -0,0 +1,5 @@ +#include "Interpolation.h" + +Interpolation::Interpolation() +{ +} diff --git a/src/basics/Interpolation.h b/src/basics/Interpolation.h new file mode 100644 index 0000000..2e18243 --- /dev/null +++ b/src/basics/Interpolation.h @@ -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 diff --git a/src/rendering/noisenaive.cpp b/src/basics/NoiseFunctionNaive.cpp similarity index 84% rename from src/rendering/noisenaive.cpp rename to src/basics/NoiseFunctionNaive.cpp index 35dd0a3..6b6f8ac 100644 --- a/src/rendering/noisenaive.cpp +++ b/src/basics/NoiseFunctionNaive.cpp @@ -1,17 +1,23 @@ -#include "noisenaive.h" +#include "NoiseFunctionNaive.h" /* * Naive noise implementation, based on pseudo-random grids. */ -#include -#include -#include -#include "tools.h" +#include +#include +#include +#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) diff --git a/src/basics/NoiseFunctionNaive.h b/src/basics/NoiseFunctionNaive.h new file mode 100644 index 0000000..a60f492 --- /dev/null +++ b/src/basics/NoiseFunctionNaive.h @@ -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 diff --git a/src/basics/NoiseFunctionPerlin.cpp b/src/basics/NoiseFunctionPerlin.cpp new file mode 100644 index 0000000..bb1f664 --- /dev/null +++ b/src/basics/NoiseFunctionPerlin.cpp @@ -0,0 +1,188 @@ +#include "NoiseFunctionPerlin.h" + +/* + * Perlin noise implementation. + * + * Based on Ken Perlin implementation. + */ + +#include +#include + +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]; + } +} diff --git a/src/basics/NoiseFunctionPerlin.h b/src/basics/NoiseFunctionPerlin.h new file mode 100644 index 0000000..781a505 --- /dev/null +++ b/src/basics/NoiseFunctionPerlin.h @@ -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 diff --git a/src/rendering/noisesimplex.cpp b/src/basics/NoiseFunctionSimplex.cpp similarity index 99% rename from src/rendering/noisesimplex.cpp rename to src/basics/NoiseFunctionSimplex.cpp index cfc619d..8378377 100644 --- a/src/rendering/noisesimplex.cpp +++ b/src/basics/NoiseFunctionSimplex.cpp @@ -1,4 +1,4 @@ -#include "noisesimplex.h" +#include "NoiseFunctionSimplex.h" /* * Simplex noise implementation. @@ -6,9 +6,13 @@ * Based on Stefan Gustavson implementation. */ -#include -#include -#include +#include +#include +#include + +NoiseFunctionSimplex::NoiseFunctionSimplex() +{ +} typedef struct { diff --git a/src/basics/NoiseFunctionSimplex.h b/src/basics/NoiseFunctionSimplex.h new file mode 100644 index 0000000..abf6e04 --- /dev/null +++ b/src/basics/NoiseFunctionSimplex.h @@ -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 diff --git a/src/basics/NoiseGenerator.cpp b/src/basics/NoiseGenerator.cpp new file mode 100644 index 0000000..4f39b9e --- /dev/null +++ b/src/basics/NoiseGenerator.cpp @@ -0,0 +1,597 @@ +#include "NoiseGenerator.h" + +#include "NoiseFunctionNaive.h" +#include "NoiseFunctionPerlin.h" +#include "NoiseFunctionSimplex.h" +#include "PackStream.h" +#include "RandomGenerator.h" +#include + +#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; +} diff --git a/src/basics/NoiseGenerator.h b/src/basics/NoiseGenerator.h new file mode 100644 index 0000000..0466565 --- /dev/null +++ b/src/basics/NoiseGenerator.h @@ -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 diff --git a/src/basics/basics.pro b/src/basics/basics.pro index 9aa230e..7f36060 100644 --- a/src/basics/basics.pro +++ b/src/basics/basics.pro @@ -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 diff --git a/src/basics/basics_global.h b/src/basics/basics_global.h index 53250b6..9c05c66 100644 --- a/src/basics/basics_global.h +++ b/src/basics/basics_global.h @@ -2,17 +2,7 @@ #define BASICS_GLOBAL_H /* Shared object helpers */ -#ifdef __cplusplus -# include -#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 #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 diff --git a/src/editing/baseform.h b/src/editing/baseform.h index 1531909..fd55ba2 100644 --- a/src/editing/baseform.h +++ b/src/editing/baseform.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 diff --git a/src/editing/dialognoise.cpp b/src/editing/dialognoise.cpp index 80fe98f..b03501a 100644 --- a/src/editing/dialognoise.cpp +++ b/src/editing/dialognoise.cpp @@ -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(); } diff --git a/src/editing/dialognoise.h b/src/editing/dialognoise.h index eb9522d..bc72d4b 100644 --- a/src/editing/dialognoise.h +++ b/src/editing/dialognoise.h @@ -5,8 +5,7 @@ #include #include "basepreview.h" #include "tools.h" - -#include "rendering/noise.h" +#include "NoiseGenerator.h" class DialogNoise : public DialogWithPreview { diff --git a/src/editing/editing.pro b/src/editing/editing.pro index 08187a1..8591afd 100644 --- a/src/editing/editing.pro +++ b/src/editing/editing.pro @@ -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 diff --git a/src/editing/editing_global.h b/src/editing/editing_global.h new file mode 100644 index 0000000..da8f66e --- /dev/null +++ b/src/editing/editing_global.h @@ -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 diff --git a/src/editing/inputnoise.cpp b/src/editing/inputnoise.cpp index d2dc24d..89987f4 100644 --- a/src/editing/inputnoise.cpp +++ b/src/editing/inputnoise.cpp @@ -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); diff --git a/src/editing/inputnoise.h b/src/editing/inputnoise.h index b16be5f..e965b57 100644 --- a/src/editing/inputnoise.h +++ b/src/editing/inputnoise.h @@ -1,10 +1,16 @@ #ifndef _PAYSAGES_QT_INPUTNOISE_H_ #define _PAYSAGES_QT_INPUTNOISE_H_ +#include "editing_global.h" + #include #include "baseinput.h" -#include "rendering/noise.h" +namespace paysages { +namespace basics { + class NoiseGenerator; +} +} class InputNoise:public BaseInput { diff --git a/src/editing/terrain/dialogbaseterrainnoise.cpp b/src/editing/terrain/dialogbaseterrainnoise.cpp index 5b139c8..8cf7c20 100644 --- a/src/editing/terrain/dialogbaseterrainnoise.cpp +++ b/src/editing/terrain/dialogbaseterrainnoise.cpp @@ -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) diff --git a/src/editing/terrain/dialogbaseterrainnoise.h b/src/editing/terrain/dialogbaseterrainnoise.h index a38292c..416f1c4 100644 --- a/src/editing/terrain/dialogbaseterrainnoise.h +++ b/src/editing/terrain/dialogbaseterrainnoise.h @@ -1,11 +1,17 @@ #ifndef DIALOGBASETERRAINNOISE_H #define DIALOGBASETERRAINNOISE_H +#include "editing_global.h" #include -#include "rendering/noise.h" + +namespace paysages { +namespace basics { + class NoiseGenerator; +} +} namespace Ui { -class DialogBaseTerrainNoise; + class DialogBaseTerrainNoise; } class DialogBaseTerrainNoise : public QDialog diff --git a/src/editing/terrain/paintingbrush.cpp b/src/editing/terrain/paintingbrush.cpp index 5c70582..d846d65 100644 --- a/src/editing/terrain/paintingbrush.cpp +++ b/src/editing/terrain/paintingbrush.cpp @@ -1,6 +1,7 @@ #include "paintingbrush.h" #include +#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) diff --git a/src/editing/terrain/paintingbrush.h b/src/editing/terrain/paintingbrush.h index 249671e..815f69f 100644 --- a/src/editing/terrain/paintingbrush.h +++ b/src/editing/terrain/paintingbrush.h @@ -2,9 +2,14 @@ #define PAINTINGBRUSH_H #include -#include "rendering/noise.h" #include "rendering/terrain/public.h" +namespace paysages { +namespace basics { + class NoiseGenerator; +} +} + typedef enum { PAINTING_BRUSH_RAISE = 0, diff --git a/src/editing/terrain/widgetterrainbasenoisepreview.cpp b/src/editing/terrain/widgetterrainbasenoisepreview.cpp index 8769da6..42b2e29 100644 --- a/src/editing/terrain/widgetterrainbasenoisepreview.cpp +++ b/src/editing/terrain/widgetterrainbasenoisepreview.cpp @@ -3,6 +3,7 @@ #include #include #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); } diff --git a/src/editing/terrain/widgetterrainbasenoisepreview.h b/src/editing/terrain/widgetterrainbasenoisepreview.h index a232da8..ad565e9 100644 --- a/src/editing/terrain/widgetterrainbasenoisepreview.h +++ b/src/editing/terrain/widgetterrainbasenoisepreview.h @@ -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 diff --git a/src/rendering/Scenery.cpp b/src/rendering/Scenery.cpp index 11fd1f9..b20a542 100644 --- a/src/rendering/Scenery.cpp +++ b/src/rendering/Scenery.cpp @@ -2,7 +2,7 @@ #include -#include "rendering/noise.h" +#include "NoiseGenerator.h" #include "rendering/terrain/ter_raster.h" static Scenery* _main_scenery; diff --git a/src/rendering/Scenery.h b/src/rendering/Scenery.h index 46ed357..9a166d7 100644 --- a/src/rendering/Scenery.h +++ b/src/rendering/Scenery.h @@ -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 diff --git a/src/rendering/clouds/clo_definition.cpp b/src/rendering/clouds/clo_definition.cpp index 6e7a456..70323f6 100644 --- a/src/rendering/clouds/clo_definition.cpp +++ b/src/rendering/clouds/clo_definition.cpp @@ -2,6 +2,7 @@ #include #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); diff --git a/src/rendering/clouds/clo_density.cpp b/src/rendering/clouds/clo_density.cpp index 2daec4f..1a78119 100644 --- a/src/rendering/clouds/clo_density.cpp +++ b/src/rendering/clouds/clo_density.cpp @@ -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; } diff --git a/src/rendering/clouds/clo_presets.cpp b/src/rendering/clouds/clo_presets.cpp index 57a9a69..8ed8cc4 100644 --- a/src/rendering/clouds/clo_presets.cpp +++ b/src/rendering/clouds/clo_presets.cpp @@ -1,7 +1,8 @@ #include "private.h" -#include -#include +#include +#include +#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)); diff --git a/src/rendering/clouds/public.h b/src/rendering/clouds/public.h index b1698c8..624038d 100644 --- a/src/rendering/clouds/public.h +++ b/src/rendering/clouds/public.h @@ -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 diff --git a/src/rendering/noise.cpp b/src/rendering/noise.cpp deleted file mode 100644 index 991ae72..0000000 --- a/src/rendering/noise.cpp +++ /dev/null @@ -1,621 +0,0 @@ -#include "noise.h" - -#include -#include -#include - -#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; -} diff --git a/src/rendering/noise.h b/src/rendering/noise.h deleted file mode 100644 index 4f8d1b5..0000000 --- a/src/rendering/noise.h +++ /dev/null @@ -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 diff --git a/src/rendering/noisenaive.h b/src/rendering/noisenaive.h deleted file mode 100644 index 2239ece..0000000 --- a/src/rendering/noisenaive.h +++ /dev/null @@ -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 diff --git a/src/rendering/noiseperlin.cpp b/src/rendering/noiseperlin.cpp deleted file mode 100644 index a5585b2..0000000 --- a/src/rendering/noiseperlin.cpp +++ /dev/null @@ -1,186 +0,0 @@ -#include "noiseperlin.h" - -/* - * Perlin noise implementation. - * - * Based on Ken Perlin implementation. - */ - -#include -#include -#include -#include - -#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]; - } -} diff --git a/src/rendering/noiseperlin.h b/src/rendering/noiseperlin.h deleted file mode 100644 index 1b28315..0000000 --- a/src/rendering/noiseperlin.h +++ /dev/null @@ -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 diff --git a/src/rendering/noisesimplex.h b/src/rendering/noisesimplex.h deleted file mode 100644 index d0afabc..0000000 --- a/src/rendering/noisesimplex.h +++ /dev/null @@ -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 diff --git a/src/rendering/opencl.h b/src/rendering/opencl.h index b90a304..af32a38 100644 --- a/src/rendering/opencl.h +++ b/src/rendering/opencl.h @@ -4,7 +4,6 @@ /* OpenCL usage */ #include "rendering_global.h" -#include "noise.h" #ifdef __cplusplus extern "C" { diff --git a/src/rendering/rendering.pro b/src/rendering/rendering.pro index c105407..7059479 100644 --- a/src/rendering/rendering.pro +++ b/src/rendering/rendering.pro @@ -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 \ diff --git a/src/rendering/rendering_global.h b/src/rendering/rendering_global.h index 57c5639..d9bbe60 100644 --- a/src/rendering/rendering_global.h +++ b/src/rendering/rendering_global.h @@ -2,17 +2,7 @@ #define RENDERING_GLOBAL_H /* Shared object helpers */ -#ifdef __cplusplus -# include -#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 #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 diff --git a/src/rendering/terrain/public.h b/src/rendering/terrain/public.h index 0abd6da..e24d6fb 100644 --- a/src/rendering/terrain/public.h +++ b/src/rendering/terrain/public.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 diff --git a/src/rendering/terrain/ter_definition.cpp b/src/rendering/terrain/ter_definition.cpp index e0e90b8..f17c198 100644 --- a/src/rendering/terrain/ter_definition.cpp +++ b/src/rendering/terrain/ter_definition.cpp @@ -1,14 +1,13 @@ #include "private.h" -#include -#include #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) diff --git a/src/rendering/terrain/ter_painting.cpp b/src/rendering/terrain/ter_painting.cpp index 6a437e2..21eedb4 100644 --- a/src/rendering/terrain/ter_painting.cpp +++ b/src/rendering/terrain/ter_painting.cpp @@ -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) diff --git a/src/rendering/terrain/ter_presets.cpp b/src/rendering/terrain/ter_presets.cpp index dac81d3..9171f17 100644 --- a/src/rendering/terrain/ter_presets.cpp +++ b/src/rendering/terrain/ter_presets.cpp @@ -1,6 +1,7 @@ #include "private.h" #include +#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; diff --git a/src/rendering/terrain/ter_preview.cpp b/src/rendering/terrain/ter_preview.cpp index 742ee81..0878117 100644 --- a/src/rendering/terrain/ter_preview.cpp +++ b/src/rendering/terrain/ter_preview.cpp @@ -1,9 +1,9 @@ #include "public.h" -#include #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); diff --git a/src/rendering/textures/tex_definition.cpp b/src/rendering/textures/tex_definition.cpp index 255fe23..c1b2030 100644 --- a/src/rendering/textures/tex_definition.cpp +++ b/src/rendering/textures/tex_definition.cpp @@ -1,7 +1,7 @@ #include "private.h" -#include "Scenery.h" -#include +#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() diff --git a/src/rendering/textures/tex_presets.cpp b/src/rendering/textures/tex_presets.cpp index e8ba49a..2d07869 100644 --- a/src/rendering/textures/tex_presets.cpp +++ b/src/rendering/textures/tex_presets.cpp @@ -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); diff --git a/src/rendering/textures/tex_tools.cpp b/src/rendering/textures/tex_tools.cpp index 9aeb658..1356cb7 100644 --- a/src/rendering/textures/tex_tools.cpp +++ b/src/rendering/textures/tex_tools.cpp @@ -1,7 +1,7 @@ #include "private.h" -#include -#include +#include +#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); diff --git a/src/rendering/water/public.h b/src/rendering/water/public.h index 22d6a1a..124612f 100644 --- a/src/rendering/water/public.h +++ b/src/rendering/water/public.h @@ -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 diff --git a/src/rendering/water/wat_definition.cpp b/src/rendering/water/wat_definition.cpp index fe2df87..f055640 100644 --- a/src/rendering/water/wat_definition.cpp +++ b/src/rendering/water/wat_definition.cpp @@ -1,22 +1,22 @@ #include "private.h" -#include #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); } diff --git a/src/rendering/water/wat_presets.cpp b/src/rendering/water/wat_presets.cpp index 26839bb..4565dbb 100644 --- a/src/rendering/water/wat_presets.cpp +++ b/src/rendering/water/wat_presets.cpp @@ -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) { diff --git a/src/rendering/water/wat_render.cpp b/src/rendering/water/wat_render.cpp index b4abaa4..23c7ebc 100644 --- a/src/rendering/water/wat_render.cpp +++ b/src/rendering/water/wat_render.cpp @@ -1,9 +1,9 @@ #include "private.h" -#include -#include +#include #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; diff --git a/src/system/RandomGenerator.cpp b/src/system/RandomGenerator.cpp new file mode 100644 index 0000000..955e068 --- /dev/null +++ b/src/system/RandomGenerator.cpp @@ -0,0 +1,5 @@ +#include "RandomGenerator.h" + +RandomGenerator::RandomGenerator() +{ +} diff --git a/src/system/RandomGenerator.h b/src/system/RandomGenerator.h new file mode 100644 index 0000000..331e844 --- /dev/null +++ b/src/system/RandomGenerator.h @@ -0,0 +1,24 @@ +#ifndef RANDOMGENERATOR_H +#define RANDOMGENERATOR_H + +#include "system_global.h" +#include + +namespace paysages { +namespace system { + +class RandomGenerator +{ +public: + RandomGenerator(); + + static inline double random() + { + return ((double)rand()) / (double)RAND_MAX; + } +}; + +} +} + +#endif // RANDOMGENERATOR_H diff --git a/src/system/system.pro b/src/system/system.pro index 3806695..a23a575 100644 --- a/src/system/system.pro +++ b/src/system/system.pro @@ -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 {