198 lines
6.6 KiB
C++
198 lines
6.6 KiB
C++
// Copyright © 2008-2021 Pioneer Developers. See AUTHORS.txt for details
|
|
// Licensed under the terms of the GPL v3. See licenses/GPL-3.txt
|
|
|
|
#ifndef _TERRAINNOISE_H
|
|
#define _TERRAINNOISE_H
|
|
|
|
#include "perlin.h"
|
|
#include "../libs.h"
|
|
|
|
namespace TerrainNoise {
|
|
|
|
// octavenoise functions return range [0,1] if persistence = 0.5
|
|
inline double octavenoise(const fracdef_t &def, const double persistence, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / def.lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = def.frequency;
|
|
for (int i = 0; i < def.octaves; i++) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= def.lacunarity;
|
|
}
|
|
return (n + 1.0) * 0.5;
|
|
}
|
|
|
|
inline double river_octavenoise(const fracdef_t &def, const double persistence, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / def.lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = def.frequency;
|
|
for (int i = 0; i < def.octaves; i++) {
|
|
n += amplitude * fabs(noise(frequency * p));
|
|
amplitude *= persistence;
|
|
frequency *= def.lacunarity;
|
|
}
|
|
return fabs(n);
|
|
}
|
|
|
|
inline double ridged_octavenoise(const fracdef_t &def, const double persistence, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / def.lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = def.frequency;
|
|
for (int i = 0; i < def.octaves; i++) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= def.lacunarity;
|
|
}
|
|
n = 1.0 - fabs(n);
|
|
n *= n;
|
|
return n;
|
|
}
|
|
|
|
inline double billow_octavenoise(const fracdef_t &def, const double persistence, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / def.lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = def.frequency;
|
|
for (int i = 0; i < def.octaves; i++) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= def.lacunarity;
|
|
}
|
|
return (2.0 * fabs(n) - 1.0) + 1.0;
|
|
}
|
|
|
|
inline double voronoiscam_octavenoise(const fracdef_t &def, const double persistence, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / def.lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = def.frequency;
|
|
for (int i = 0; i < def.octaves; i++) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= def.lacunarity;
|
|
}
|
|
return sqrt(10.0 * fabs(n));
|
|
}
|
|
|
|
inline double dunes_octavenoise(const fracdef_t &def, const double persistence, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / def.lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = def.frequency;
|
|
for (int i = 0; i < 3; i++) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= def.lacunarity;
|
|
}
|
|
return 1.0 - fabs(n);
|
|
}
|
|
|
|
// XXX merge these with their fracdef versions
|
|
inline double octavenoise(int octaves, const double persistence, const double lacunarity, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = 1.0;
|
|
while (octaves--) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= lacunarity;
|
|
}
|
|
return (n + 1.0) * 0.5;
|
|
}
|
|
|
|
inline double river_octavenoise(int octaves, const double persistence, const double lacunarity, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = 1.0;
|
|
while (octaves--) {
|
|
n += amplitude * fabs(noise(frequency * p));
|
|
amplitude *= persistence;
|
|
frequency *= lacunarity;
|
|
}
|
|
return n;
|
|
}
|
|
|
|
inline double ridged_octavenoise(int octaves, const double persistence, const double lacunarity, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = 1.0;
|
|
while (octaves--) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= lacunarity;
|
|
}
|
|
n = 1.0 - fabs(n);
|
|
n *= n;
|
|
return n;
|
|
}
|
|
|
|
inline double billow_octavenoise(int octaves, const double persistence, const double lacunarity, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = 1.0;
|
|
while (octaves--) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= lacunarity;
|
|
}
|
|
return (2.0 * fabs(n) - 1.0) + 1.0;
|
|
}
|
|
|
|
inline double voronoiscam_octavenoise(int octaves, const double persistence, const double lacunarity, const vector3d &p)
|
|
{
|
|
//assert(persistence <= (1.0 / lacunarity));
|
|
double n = 0;
|
|
double amplitude = persistence;
|
|
double frequency = 1.0;
|
|
while (octaves--) {
|
|
n += amplitude * noise(frequency * p);
|
|
amplitude *= persistence;
|
|
frequency *= lacunarity;
|
|
}
|
|
return sqrt(10.0 * fabs(n));
|
|
}
|
|
|
|
// not really a noise function but no better place for it
|
|
inline vector3d interpolate_color(const double n, const vector3d &start, const vector3d &end)
|
|
{
|
|
const double nClamped = Clamp(n, 0.0, 1.0);
|
|
return start * (1.0 - nClamped) + end * nClamped;
|
|
}
|
|
|
|
} // namespace TerrainNoise
|
|
|
|
// common colours for earthlike worlds
|
|
// XXX better way to do this?
|
|
|
|
#define terrain_colournoise_rock octavenoise(GetFracDef(0), 0.65, p)
|
|
#define terrain_colournoise_rock2 octavenoise(GetFracDef(1), 0.6, p) * 0.6 * ridged_octavenoise(GetFracDef(0), 0.55, p)
|
|
// #define terrain_colournoise_rock3 0.5*ridged_octavenoise(GetFracDef(0), 0.5, p)*voronoiscam_octavenoise(GetFracDef(0), 0.5, p)*ridged_octavenoise(GetFracDef(1), 0.5, p)
|
|
// #define terrain_colournoise_rock4 0.5*ridged_octavenoise(GetFracDef(1), 0.5, p)*octavenoise(GetFracDef(1), 0.5, p)*octavenoise(GetFracDef(5), 0.5, p)
|
|
#define terrain_colournoise_mud 0.1 * voronoiscam_octavenoise(GetFracDef(1), 0.5, p) * octavenoise(GetFracDef(1), 0.5, p) * GetFracDef(5).amplitude
|
|
#define terrain_colournoise_sand ridged_octavenoise(GetFracDef(0), 0.4, p) * dunes_octavenoise(GetFracDef(2), 0.4, p) + 0.1 * dunes_octavenoise(GetFracDef(1), 0.5, p)
|
|
#define terrain_colournoise_sand2 dunes_octavenoise(GetFracDef(0), 0.6, p) * octavenoise(GetFracDef(4), 0.6, p)
|
|
// #define terrain_colournoise_sand3 dunes_octavenoise(GetFracDef(2), 0.6, p)*dunes_octavenoise(GetFracDef(6), 0.6, p)
|
|
#define terrain_colournoise_grass billow_octavenoise(GetFracDef(1), 0.8, p)
|
|
#define terrain_colournoise_grass2 billow_octavenoise(GetFracDef(3), 0.6, p) * voronoiscam_octavenoise(GetFracDef(4), 0.6, p) * river_octavenoise(GetFracDef(5), 0.6, p)
|
|
#define terrain_colournoise_forest octavenoise(GetFracDef(1), 0.65, p) * voronoiscam_octavenoise(GetFracDef(2), 0.65, p)
|
|
#define terrain_colournoise_water dunes_octavenoise(GetFracDef(6), 0.6, p)
|
|
|
|
#endif
|