719 lines
16 KiB
C++
719 lines
16 KiB
C++
#ifndef STAR_PERLIN_HPP
|
|
#define STAR_PERLIN_HPP
|
|
|
|
#include "StarJson.hpp"
|
|
#include "StarBiMap.hpp"
|
|
#include "StarInterpolation.hpp"
|
|
#include "StarRandom.hpp"
|
|
|
|
namespace Star {
|
|
|
|
STAR_EXCEPTION(PerlinException, StarException);
|
|
|
|
enum class PerlinType {
|
|
Uninitialized,
|
|
Perlin,
|
|
Billow,
|
|
RidgedMulti
|
|
};
|
|
extern EnumMap<PerlinType> const PerlinTypeNames;
|
|
|
|
int const PerlinSampleSize = 512;
|
|
|
|
template <typename Float>
|
|
class Perlin {
|
|
public:
|
|
// Default constructed perlin noise is uninitialized and cannot be queried.
|
|
Perlin();
|
|
|
|
Perlin(unsigned octaves, Float freq, Float amp, Float bias, Float alpha, Float beta, uint64_t seed);
|
|
Perlin(PerlinType type, unsigned octaves, Float freq, Float amp, Float bias, Float alpha, Float beta, uint64_t seed);
|
|
Perlin(Json const& config, uint64_t seed);
|
|
explicit Perlin(Json const& json);
|
|
|
|
Perlin(Perlin const& perlin);
|
|
Perlin(Perlin&& perlin);
|
|
|
|
Perlin& operator=(Perlin const& perlin);
|
|
Perlin& operator=(Perlin&& perlin);
|
|
|
|
Float get(Float x) const;
|
|
Float get(Float x, Float y) const;
|
|
Float get(Float x, Float y, Float z) const;
|
|
|
|
PerlinType type() const;
|
|
|
|
unsigned octaves() const;
|
|
Float frequency() const;
|
|
Float amplitude() const;
|
|
Float bias() const;
|
|
Float alpha() const;
|
|
Float beta() const;
|
|
|
|
Json toJson() const;
|
|
|
|
private:
|
|
static Float s_curve(Float t);
|
|
static void setup(Float v, int& b0, int& b1, Float& r0, Float& r1);
|
|
|
|
static Float at2(Float* q, Float rx, Float ry);
|
|
static Float at3(Float* q, Float rx, Float ry, Float rz);
|
|
|
|
Float noise1(Float arg) const;
|
|
Float noise2(Float vec[2]) const;
|
|
Float noise3(Float vec[3]) const;
|
|
|
|
void normalize2(Float v[2]) const;
|
|
void normalize3(Float v[3]) const;
|
|
|
|
void init(uint64_t seed);
|
|
|
|
Float perlin(Float x) const;
|
|
Float perlin(Float x, Float y) const;
|
|
Float perlin(Float x, Float y, Float z) const;
|
|
|
|
Float ridgedMulti(Float x) const;
|
|
Float ridgedMulti(Float x, Float y) const;
|
|
Float ridgedMulti(Float x, Float y, Float z) const;
|
|
|
|
Float billow(Float x) const;
|
|
Float billow(Float x, Float y) const;
|
|
Float billow(Float x, Float y, Float z) const;
|
|
|
|
PerlinType m_type;
|
|
uint64_t m_seed;
|
|
|
|
int m_octaves;
|
|
Float m_frequency;
|
|
Float m_amplitude;
|
|
Float m_bias;
|
|
Float m_alpha;
|
|
Float m_beta;
|
|
|
|
// Only used for RidgedMulti
|
|
Float m_offset;
|
|
Float m_gain;
|
|
|
|
unique_ptr<int[]> p;
|
|
unique_ptr<Float[][3]> g3;
|
|
unique_ptr<Float[][2]> g2;
|
|
unique_ptr<Float[]> g1;
|
|
};
|
|
|
|
typedef Perlin<float> PerlinF;
|
|
typedef Perlin<double> PerlinD;
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::s_curve(Float t) {
|
|
return t * t * (3.0 - 2.0 * t);
|
|
}
|
|
|
|
template <typename Float>
|
|
void Perlin<Float>::setup(Float v, int& b0, int& b1, Float& r0, Float& r1) {
|
|
int iv = floor(v);
|
|
Float fv = v - iv;
|
|
|
|
b0 = iv & (PerlinSampleSize - 1);
|
|
b1 = (iv + 1) & (PerlinSampleSize - 1);
|
|
r0 = fv;
|
|
r1 = fv - 1.0;
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::at2(Float* q, Float rx, Float ry) {
|
|
return rx * q[0] + ry * q[1];
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::at3(Float* q, Float rx, Float ry, Float rz) {
|
|
return rx * q[0] + ry * q[1] + rz * q[2];
|
|
}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>::Perlin() {
|
|
m_type = PerlinType::Uninitialized;
|
|
m_alpha = 0;
|
|
m_amplitude = 0;
|
|
m_frequency = 0;
|
|
m_seed = 0;
|
|
m_gain = 0;
|
|
m_beta = 0;
|
|
m_offset = 0;
|
|
m_bias = 0;
|
|
m_octaves = 0;
|
|
}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>::Perlin(unsigned octaves, Float freq, Float amp, Float bias, Float alpha, Float beta, uint64_t seed) {
|
|
m_type = PerlinType::Perlin;
|
|
m_seed = seed;
|
|
|
|
m_octaves = octaves;
|
|
m_frequency = freq;
|
|
m_amplitude = amp;
|
|
m_bias = bias;
|
|
m_alpha = alpha;
|
|
m_beta = beta;
|
|
|
|
// TODO: These ought to be configurable
|
|
m_offset = 1.0;
|
|
m_gain = 2.0;
|
|
|
|
init(m_seed);
|
|
}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>::Perlin(PerlinType type, unsigned octaves, Float freq, Float amp, Float bias, Float alpha, Float beta, uint64_t seed) {
|
|
m_type = type;
|
|
m_seed = seed;
|
|
|
|
m_octaves = octaves;
|
|
m_frequency = freq;
|
|
m_amplitude = amp;
|
|
m_bias = bias;
|
|
m_alpha = alpha;
|
|
m_beta = beta;
|
|
|
|
// TODO: These ought to be configurable
|
|
m_offset = 1.0;
|
|
m_gain = 2.0;
|
|
|
|
init(m_seed);
|
|
}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>::Perlin(Json const& config, uint64_t seed)
|
|
: Perlin(config.set("seed", seed)) {}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>::Perlin(Json const& json) {
|
|
m_seed = json.getUInt("seed");
|
|
m_octaves = json.getInt("octaves", 1);
|
|
m_frequency = json.getDouble("frequency", 1.0);
|
|
m_amplitude = json.getDouble("amplitude", 1.0);
|
|
m_bias = json.getDouble("bias", 0.0);
|
|
m_alpha = json.getDouble("alpha", 2.0);
|
|
m_beta = json.getDouble("beta", 2.0);
|
|
|
|
m_offset = json.getDouble("offset", 1.0);
|
|
m_gain = json.getDouble("gain", 2.0);
|
|
|
|
m_type = PerlinTypeNames.getLeft(json.getString("type"));
|
|
|
|
init(m_seed);
|
|
}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>::Perlin(Perlin const& perlin) {
|
|
*this = perlin;
|
|
}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>::Perlin(Perlin&& perlin) {
|
|
*this = move(perlin);
|
|
}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>& Perlin<Float>::operator=(Perlin const& perlin) {
|
|
if (perlin.m_type == PerlinType::Uninitialized) {
|
|
m_type = PerlinType::Uninitialized;
|
|
p.reset();
|
|
g3.reset();
|
|
g2.reset();
|
|
g1.reset();
|
|
|
|
} else if (this != &perlin) {
|
|
m_type = perlin.m_type;
|
|
m_seed = perlin.m_seed;
|
|
m_octaves = perlin.m_octaves;
|
|
m_frequency = perlin.m_frequency;
|
|
m_amplitude = perlin.m_amplitude;
|
|
m_bias = perlin.m_bias;
|
|
m_alpha = perlin.m_alpha;
|
|
m_beta = perlin.m_beta;
|
|
m_offset = perlin.m_offset;
|
|
m_gain = perlin.m_gain;
|
|
|
|
p.reset(new int[PerlinSampleSize + PerlinSampleSize + 2]);
|
|
g3.reset(new Float[PerlinSampleSize + PerlinSampleSize + 2][3]);
|
|
g2.reset(new Float[PerlinSampleSize + PerlinSampleSize + 2][2]);
|
|
g1.reset(new Float[PerlinSampleSize + PerlinSampleSize + 2]);
|
|
|
|
std::memcpy(p.get(), perlin.p.get(), (PerlinSampleSize + PerlinSampleSize + 2) * sizeof(int));
|
|
std::memcpy(g3.get(), perlin.g3.get(), (PerlinSampleSize + PerlinSampleSize + 2) * sizeof(Float) * 3);
|
|
std::memcpy(g2.get(), perlin.g2.get(), (PerlinSampleSize + PerlinSampleSize + 2) * sizeof(Float) * 2);
|
|
std::memcpy(g1.get(), perlin.g1.get(), (PerlinSampleSize + PerlinSampleSize + 2) * sizeof(Float));
|
|
}
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename Float>
|
|
Perlin<Float>& Perlin<Float>::operator=(Perlin&& perlin) {
|
|
m_type = perlin.m_type;
|
|
m_seed = perlin.m_seed;
|
|
m_octaves = perlin.m_octaves;
|
|
m_frequency = perlin.m_frequency;
|
|
m_amplitude = perlin.m_amplitude;
|
|
m_bias = perlin.m_bias;
|
|
m_alpha = perlin.m_alpha;
|
|
m_beta = perlin.m_beta;
|
|
m_offset = perlin.m_offset;
|
|
m_gain = perlin.m_gain;
|
|
|
|
p = move(perlin.p);
|
|
g3 = move(perlin.g3);
|
|
g2 = move(perlin.g2);
|
|
g1 = move(perlin.g1);
|
|
|
|
return *this;
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::get(Float x) const {
|
|
switch (m_type) {
|
|
case PerlinType::Perlin:
|
|
return perlin(x);
|
|
case PerlinType::Billow:
|
|
return billow(x);
|
|
case PerlinType::RidgedMulti:
|
|
return ridgedMulti(x);
|
|
default:
|
|
throw PerlinException("::get called on uninitialized Perlin");
|
|
}
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::get(Float x, Float y) const {
|
|
switch (m_type) {
|
|
case PerlinType::Perlin:
|
|
return perlin(x, y);
|
|
case PerlinType::Billow:
|
|
return billow(x, y);
|
|
case PerlinType::RidgedMulti:
|
|
return ridgedMulti(x, y);
|
|
default:
|
|
throw PerlinException("::get called on uninitialized Perlin");
|
|
}
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::get(Float x, Float y, Float z) const {
|
|
switch (m_type) {
|
|
case PerlinType::Perlin:
|
|
return perlin(x, y, z);
|
|
case PerlinType::Billow:
|
|
return billow(x, y, z);
|
|
case PerlinType::RidgedMulti:
|
|
return ridgedMulti(x, y, z);
|
|
default:
|
|
throw PerlinException("::get called on uninitialized Perlin");
|
|
}
|
|
}
|
|
|
|
template <typename Float>
|
|
PerlinType Perlin<Float>::type() const {
|
|
return m_type;
|
|
}
|
|
|
|
template <typename Float>
|
|
unsigned Perlin<Float>::octaves() const {
|
|
return m_octaves;
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::frequency() const {
|
|
return m_frequency;
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::amplitude() const {
|
|
return m_amplitude;
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::bias() const {
|
|
return m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::alpha() const {
|
|
return m_alpha;
|
|
}
|
|
|
|
template <typename Float>
|
|
Float Perlin<Float>::beta() const {
|
|
return m_beta;
|
|
}
|
|
|
|
template <typename Float>
|
|
Json Perlin<Float>::toJson() const {
|
|
return JsonObject{
|
|
{"seed", m_seed},
|
|
{"octaves", m_octaves},
|
|
{"frequency", m_frequency},
|
|
{"amplitude", m_amplitude},
|
|
{"bias", m_bias},
|
|
{"alpha", m_alpha},
|
|
{"beta", m_beta},
|
|
{"offset", m_offset},
|
|
{"gain", m_gain},
|
|
{"type", PerlinTypeNames.getRight(m_type)}
|
|
};
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::noise1(Float arg) const {
|
|
int bx0, bx1;
|
|
Float rx0, rx1, sx, u, v;
|
|
|
|
setup(arg, bx0, bx1, rx0, rx1);
|
|
|
|
sx = s_curve(rx0);
|
|
u = rx0 * g1[p[bx0]];
|
|
v = rx1 * g1[p[bx1]];
|
|
|
|
return (lerp(sx, u, v));
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::noise2(Float vec[2]) const {
|
|
int bx0, bx1, by0, by1, b00, b10, b01, b11;
|
|
Float rx0, rx1, ry0, ry1, sx, sy, a, b, u, v;
|
|
int i, j;
|
|
|
|
setup(vec[0], bx0, bx1, rx0, rx1);
|
|
setup(vec[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);
|
|
|
|
u = at2(g2[b00], rx0, ry0);
|
|
v = at2(g2[b10], rx1, ry0);
|
|
a = lerp(sx, u, v);
|
|
|
|
u = at2(g2[b01], rx0, ry1);
|
|
v = at2(g2[b11], rx1, ry1);
|
|
b = lerp(sx, u, v);
|
|
|
|
return lerp(sy, a, b);
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::noise3(Float vec[3]) const {
|
|
int bx0, bx1, by0, by1, bz0, bz1, b00, b10, b01, b11;
|
|
Float rx0, rx1, ry0, ry1, rz0, rz1, sx, sy, sz, a, b, c, d, u, v;
|
|
int i, j;
|
|
|
|
setup(vec[0], bx0, bx1, rx0, rx1);
|
|
setup(vec[1], by0, by1, ry0, ry1);
|
|
setup(vec[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];
|
|
|
|
sx = s_curve(rx0);
|
|
sy = s_curve(ry0);
|
|
sz = s_curve(rz0);
|
|
|
|
u = at3(g3[b00 + bz0], rx0, ry0, rz0);
|
|
v = at3(g3[b10 + bz0], rx1, ry0, rz0);
|
|
a = lerp(sx, u, v);
|
|
|
|
u = at3(g3[b01 + bz0], rx0, ry1, rz0);
|
|
v = at3(g3[b11 + bz0], rx1, ry1, rz0);
|
|
b = lerp(sx, u, v);
|
|
|
|
c = lerp(sy, a, b);
|
|
|
|
u = at3(g3[b00 + bz1], rx0, ry0, rz1);
|
|
v = at3(g3[b10 + bz1], rx1, ry0, rz1);
|
|
a = lerp(sx, u, v);
|
|
|
|
u = at3(g3[b01 + bz1], rx0, ry1, rz1);
|
|
v = at3(g3[b11 + bz1], rx1, ry1, rz1);
|
|
b = lerp(sx, u, v);
|
|
|
|
d = lerp(sy, a, b);
|
|
|
|
return lerp(sz, c, d);
|
|
}
|
|
|
|
template <typename Float>
|
|
void Perlin<Float>::normalize2(Float v[2]) const {
|
|
Float s;
|
|
|
|
s = sqrt(v[0] * v[0] + v[1] * v[1]);
|
|
if (s == 0.0f) {
|
|
v[0] = 1.0f;
|
|
v[1] = 0.0f;
|
|
} else {
|
|
v[0] = v[0] / s;
|
|
v[1] = v[1] / s;
|
|
}
|
|
}
|
|
|
|
template <typename Float>
|
|
void Perlin<Float>::normalize3(Float v[3]) const {
|
|
Float s;
|
|
|
|
s = sqrt(v[0] * v[0] + v[1] * v[1] + v[2] * v[2]);
|
|
if (s == 0.0f) {
|
|
v[0] = 1.0f;
|
|
v[1] = 0.0f;
|
|
v[2] = 0.0f;
|
|
} else {
|
|
v[0] = v[0] / s;
|
|
v[1] = v[1] / s;
|
|
v[2] = v[2] / s;
|
|
}
|
|
}
|
|
|
|
template <typename Float>
|
|
void Perlin<Float>::init(uint64_t seed) {
|
|
RandomSource randomSource(seed);
|
|
|
|
p.reset(new int[PerlinSampleSize + PerlinSampleSize + 2]);
|
|
g3.reset(new Float[PerlinSampleSize + PerlinSampleSize + 2][3]);
|
|
g2.reset(new Float[PerlinSampleSize + PerlinSampleSize + 2][2]);
|
|
g1.reset(new Float[PerlinSampleSize + PerlinSampleSize + 2]);
|
|
|
|
int i, j, k;
|
|
|
|
for (i = 0; i < PerlinSampleSize; i++) {
|
|
p[i] = i;
|
|
g1[i] = (Float)(randomSource.randInt(-PerlinSampleSize, PerlinSampleSize)) / PerlinSampleSize;
|
|
|
|
for (j = 0; j < 2; j++)
|
|
g2[i][j] = (Float)(randomSource.randInt(-PerlinSampleSize, PerlinSampleSize)) / PerlinSampleSize;
|
|
normalize2(g2[i]);
|
|
|
|
for (j = 0; j < 3; j++)
|
|
g3[i][j] = (Float)(randomSource.randInt(-PerlinSampleSize, PerlinSampleSize)) / PerlinSampleSize;
|
|
normalize3(g3[i]);
|
|
}
|
|
|
|
while (--i) {
|
|
k = p[i];
|
|
p[i] = p[j = randomSource.randUInt(PerlinSampleSize - 1)];
|
|
p[j] = k;
|
|
}
|
|
|
|
for (i = 0; i < PerlinSampleSize + 2; i++) {
|
|
p[PerlinSampleSize + i] = p[i];
|
|
g1[PerlinSampleSize + i] = g1[i];
|
|
for (j = 0; j < 2; j++)
|
|
g2[PerlinSampleSize + i][j] = g2[i][j];
|
|
for (j = 0; j < 3; j++)
|
|
g3[PerlinSampleSize + i][j] = g3[i][j];
|
|
}
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::perlin(Float x) const {
|
|
int i;
|
|
Float val, sum = 0;
|
|
Float p, scale = 1;
|
|
|
|
p = x * m_frequency;
|
|
for (i = 0; i < m_octaves; i++) {
|
|
val = noise1(p);
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
p *= m_beta;
|
|
}
|
|
return sum * m_amplitude + m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::perlin(Float x, Float y) const {
|
|
int i;
|
|
Float val, sum = 0;
|
|
Float p[2], scale = 1;
|
|
|
|
p[0] = x * m_frequency;
|
|
p[1] = y * m_frequency;
|
|
for (i = 0; i < m_octaves; i++) {
|
|
val = noise2(p);
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
p[0] *= m_beta;
|
|
p[1] *= m_beta;
|
|
}
|
|
return sum * m_amplitude + m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::perlin(Float x, Float y, Float z) const {
|
|
int i;
|
|
Float val, sum = 0;
|
|
Float p[3], scale = 1;
|
|
|
|
p[0] = x * m_frequency;
|
|
p[1] = y * m_frequency;
|
|
p[2] = z * m_frequency;
|
|
for (i = 0; i < m_octaves; i++) {
|
|
val = noise3(p);
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
p[0] *= m_beta;
|
|
p[1] *= m_beta;
|
|
p[2] *= m_beta;
|
|
}
|
|
|
|
return sum * m_amplitude + m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::ridgedMulti(Float x) const {
|
|
Float val, sum = 0;
|
|
Float scale = 1;
|
|
Float weight = 1.0;
|
|
|
|
x *= m_frequency;
|
|
for (int i = 0; i < m_octaves; ++i) {
|
|
val = noise1(x);
|
|
|
|
val = m_offset - fabs(val);
|
|
val *= val;
|
|
val *= weight;
|
|
|
|
weight = clamp<Float>(val * m_gain, 0.0, 1.0);
|
|
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
x *= m_beta;
|
|
}
|
|
|
|
return ((sum * 1.25) - 1.0) * m_amplitude + m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::ridgedMulti(Float x, Float y) const {
|
|
Float val, sum = 0;
|
|
Float p[2], scale = 1;
|
|
Float weight = 1.0;
|
|
|
|
p[0] = x * m_frequency;
|
|
p[1] = y * m_frequency;
|
|
for (int i = 0; i < m_octaves; ++i) {
|
|
val = noise2(p);
|
|
|
|
val = m_offset - fabs(val);
|
|
val *= val;
|
|
val *= weight;
|
|
|
|
weight = clamp<Float>(val * m_gain, 0.0, 1.0);
|
|
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
p[0] *= m_beta;
|
|
p[1] *= m_beta;
|
|
}
|
|
|
|
return ((sum * 1.25) - 1.0) * m_amplitude + m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::ridgedMulti(Float x, Float y, Float z) const {
|
|
Float val, sum = 0;
|
|
Float p[3], scale = 1;
|
|
Float weight = 1.0;
|
|
|
|
p[0] = x * m_frequency;
|
|
p[1] = y * m_frequency;
|
|
p[2] = z * m_frequency;
|
|
for (int i = 0; i < m_octaves; ++i) {
|
|
val = noise3(p);
|
|
|
|
val = m_offset - fabs(val);
|
|
val *= val;
|
|
val *= weight;
|
|
|
|
weight = clamp<Float>(val * m_gain, 0.0, 1.0);
|
|
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
p[0] *= m_beta;
|
|
p[1] *= m_beta;
|
|
p[2] *= m_beta;
|
|
}
|
|
|
|
return ((sum * 1.25) - 1.0) * m_amplitude + m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::billow(Float x) const {
|
|
Float val, sum = 0;
|
|
Float p, scale = 1;
|
|
|
|
p = x * m_frequency;
|
|
for (int i = 0; i < m_octaves; i++) {
|
|
val = noise1(p);
|
|
val = 2.0 * fabs(val) - 1.0;
|
|
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
p *= m_beta;
|
|
}
|
|
return (sum + 0.5) * m_amplitude + m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::billow(Float x, Float y) const {
|
|
Float val, sum = 0;
|
|
Float p[2], scale = 1;
|
|
|
|
p[0] = x * m_frequency;
|
|
p[1] = y * m_frequency;
|
|
for (int i = 0; i < m_octaves; i++) {
|
|
val = noise2(p);
|
|
val = 2.0 * fabs(val) - 1.0;
|
|
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
p[0] *= m_beta;
|
|
p[1] *= m_beta;
|
|
}
|
|
return (sum + 0.5) * m_amplitude + m_bias;
|
|
}
|
|
|
|
template <typename Float>
|
|
inline Float Perlin<Float>::billow(Float x, Float y, Float z) const {
|
|
Float val, sum = 0;
|
|
Float p[3], scale = 1;
|
|
|
|
p[0] = x * m_frequency;
|
|
p[1] = y * m_frequency;
|
|
p[2] = z * m_frequency;
|
|
for (int i = 0; i < m_octaves; i++) {
|
|
val = noise3(p);
|
|
val = 2.0 * fabs(val) - 1.0;
|
|
|
|
sum += val / scale;
|
|
scale *= m_alpha;
|
|
p[0] *= m_beta;
|
|
p[1] *= m_beta;
|
|
p[2] *= m_beta;
|
|
}
|
|
|
|
return (sum + 0.5) * m_amplitude + m_bias;
|
|
}
|
|
|
|
}
|
|
|
|
#endif
|