tri11paragon
/
Parks-n-Rec
mirror of https://github.com/Tri11Paragon/Parks-n-Rec
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity
Parks-n-Rec/include/genetic/operators.h

325 lines
14 KiB
C++
Raw Blame History

//
// Created by brett on 7/11/23.
//
#ifndef PARKSNREC_OPERATORS_H
#define PARKSNREC_OPERATORS_H
#include <blt/std/random.h>
#include <blt/std/time.h>
#include <cmath>
#include <stb/stb_perlin.h>
#include <random>
#include <utility>
namespace parks::genetic {
constexpr long seed = 213434;
double randomDouble(double min, double max) {
std::mt19937 rng(blt::system::getCurrentTimeNanoseconds());
static std::uniform_real_distribution<double> gen(0, 1);
return gen(rng) * (max - min) + min;
}
int randomInt(int min, int max) {
return (int)randomDouble(min, max);
}
struct Color {
Color(double r, double g, double b): r(r), g(g), b(b) {}
explicit Color(double v): Color(v,v,v){}
double r, g, b;
[[nodiscard]] double v() const {
return std::sqrt(r * r + g * g + b * b);
}
};
class Operator {
public:
const std::string opString;
explicit Operator(std::string opString): opString(std::move(opString)) {};
[[nodiscard]] inline virtual Color apply(double x, double y, unsigned int time, Color left, Color right) const = 0;
virtual ~Operator() = default;
};
class ZeroOperator : public Operator {
public:
ZeroOperator(): Operator("0"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return Color(0);
}
};
class OneOperator : public Operator {
public:
OneOperator(): Operator("1"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return Color(1);
}
};
class XOperator : public Operator {
public:
XOperator(): Operator("X"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return Color(x);
}
};
class YOperator : public Operator {
public:
YOperator(): Operator("Y"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return Color(y);
}
};
class MultiplicationOperator : public Operator {
public:
MultiplicationOperator(): Operator("*"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {left.r * right.r, left.g * right.g, left.b * right.b};
}
};
class AdditionOperator : public Operator {
public:
AdditionOperator(): Operator("+"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {left.r + right.r, left.g + right.g, left.b + right.b};
}
};
class SubtractionOperator : public Operator {
public:
SubtractionOperator(): Operator("-"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {left.r - right.r, left.g - right.g, left.b - right.b};
}
};
class ModOperator : public Operator {
public:
ModOperator(): Operator("%"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {(double)((long)left.r % (long)std::max(1.0, right.r)),
(double)((long)left.g % (long)std::max(1.0, right.g)),
(double)((long)left.b % (long)std::max(1.0, right.b))};
}
};
class MinOperator : public Operator {
public:
MinOperator(): Operator("Min"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {std::min(left.r, right.r), std::min(left.g, right.g), std::min(left.b, right.b)};
}
};
class MaxOperator : public Operator {
public:
MaxOperator(): Operator("Max"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {std::max(left.r, right.r), std::max(left.g, right.g), std::max(left.b, right.b)};
}
};
class LogOperator : public Operator {
public:
LogOperator(): Operator("Log"){}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {std::log(left.r) + std::log(right.r), std::log(left.g) + std::log(right.g), std::log(left.b) + std::log(right.b)};
}
};
class PerlinBWOperator : public Operator {
private:
double _y, _z;
float scale = 256.523;
public:
PerlinBWOperator(): Operator("PerlinBW"){
constexpr double MIN = 0;
constexpr double MAX = 8192;
constexpr double SCALE_MAX = 256;
do {
_y = randomDouble(MIN, MAX);
} while (trunc(_y) == _y);
do {
_z = randomDouble(MIN, MAX);
} while (trunc(_z) == _z);
do {
scale = (float)randomDouble(MIN, SCALE_MAX);
} while (trunc((double)scale) == (double)scale);
}
public:
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return Color{
stb_perlin_noise3((float)left.v() / scale, (float)_y, (float)_z, 0, 0, 0)
+ stb_perlin_noise3((float)right.v() / scale, (float)_y, (float)_z, 0, 0, 0)
};
}
};
class PerlinColorOperator : public Operator {
private:
double _y, _z;
float scale = 256.523;
public:
PerlinColorOperator(): Operator("PerlinColor"){
constexpr double MIN = 0;
constexpr double MAX = 8192;
constexpr double SCALE_MAX = 256;
do {
_y = randomDouble(MIN, MAX);
} while (trunc(_y) == _y);
do {
_z = randomDouble(MIN, MAX);
} while (trunc(_z) == _z);
do {
scale = (float)randomDouble(MIN, SCALE_MAX);
} while (trunc((double)scale) == (double)scale);
}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {
stb_perlin_noise3((float)left.r / scale, (float)_y, (float)_z, 0, 0, 0)
+ stb_perlin_noise3((float)right.r / scale, (float)_y, (float)_z, 0, 0, 0),
stb_perlin_noise3((float)left.g / scale, (float)_y, (float)_z, 0, 0, 0)
+ stb_perlin_noise3((float)right.g / scale, (float)_y, (float)_z, 0, 0, 0),
stb_perlin_noise3((float)left.b / scale, (float)_y, (float)_z, 0, 0, 0)
+ stb_perlin_noise3((float)right.b / scale, (float)_y, (float)_z, 0, 0, 0)
};
}
};
class PerlinRidgeOperator : public Operator {
private:
double _y, _z;
int octaves;
float lacunarity = 2.0;
float gain = 0.5;
float offset = 1.0;
float scale = 256.523;
public:
PerlinRidgeOperator(): Operator("PerlinRidge"){
constexpr double MIN = 0;
constexpr double MAX = 8192;
constexpr double SCALE_MAX = 256;
do {
_y = randomDouble(MIN, MAX);
} while (trunc(_y) == _y);
do {
_z = randomDouble(MIN, MAX);
} while (trunc(_z) == _z);
do {
scale = (float)randomDouble(MIN, SCALE_MAX);
} while (trunc((double)scale) == (double)scale);
octaves = randomInt(2, 12);
gain = (float)randomDouble(0.1, 1);
}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {
stb_perlin_ridge_noise3((float)left.r / scale, (float)_y, (float)_z, lacunarity, gain, offset, octaves)
+ stb_perlin_ridge_noise3((float)right.r / scale, (float)_y, (float)_z, lacunarity, gain, offset, octaves),
stb_perlin_ridge_noise3((float)left.g / scale, (float)_y, (float)_z, lacunarity, gain, offset, octaves)
+ stb_perlin_ridge_noise3((float)right.g / scale, (float)_y, (float)_z, lacunarity, gain, offset, octaves),
stb_perlin_ridge_noise3((float)left.b / scale, (float)_y, (float)_z, lacunarity, gain, offset, octaves)
+ stb_perlin_ridge_noise3((float)right.b / scale, (float)_y, (float)_z, lacunarity, gain, offset, octaves)
};
}
};
class PerlinFBMOperator : public Operator {
private:
double _y, _z;
int octaves;
float lacunarity = 2.0;
float gain = 0.5;
float scale = 256.523;
public:
PerlinFBMOperator(): Operator("PerlinFBM"){
constexpr double MIN = 0;
constexpr double MAX = 8192;
constexpr double SCALE_MAX = 256;
do {
_y = randomDouble(MIN, MAX);
} while (trunc(_y) == _y);
do {
_z = randomDouble(MIN, MAX);
} while (trunc(_z) == _z);
do {
scale = (float)randomDouble(MIN, SCALE_MAX);
} while (trunc((double)scale) == (double)scale);
octaves = randomInt(2, 12);
gain = (float)randomDouble(0.1, 1);
}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {
stb_perlin_fbm_noise3((float)left.r / scale, (float)_y, (float)_z, lacunarity, gain, octaves)
+ stb_perlin_fbm_noise3((float)right.r / scale, (float)_y, (float)_z, lacunarity, gain, octaves),
stb_perlin_fbm_noise3((float)left.g / scale, (float)_y, (float)_z, lacunarity, gain, octaves)
+ stb_perlin_fbm_noise3((float)right.g / scale, (float)_y, (float)_z, lacunarity, gain, octaves),
stb_perlin_fbm_noise3((float)left.b / scale, (float)_y, (float)_z, lacunarity, gain, octaves)
+ stb_perlin_fbm_noise3((float)right.b / scale, (float)_y, (float)_z, lacunarity, gain, octaves)
};
}
};
class PerlinTurbulenceOperator : public Operator {
private:
double _y, _z;
int octaves;
float lacunarity = 2.0;
float gain = 0.5;
float scale = 256.523;
public:
PerlinTurbulenceOperator(): Operator("PerlinTurb"){
constexpr double MIN = 0;
constexpr double MAX = 8192;
constexpr double SCALE_MAX = 256;
do {
_y = randomDouble(MIN, MAX);
} while (trunc(_y) == _y);
do {
_z = randomDouble(MIN, MAX);
} while (trunc(_z) == _z);
do {
scale = (float)randomDouble(MIN, SCALE_MAX);
} while (trunc((double)scale) == (double)scale);
octaves = randomInt(2, 12);
gain = (float)randomDouble(0.1, 1);
}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {
stb_perlin_turbulence_noise3((float)left.r / scale, (float)_y, (float)_z, lacunarity, gain, octaves)
+ stb_perlin_turbulence_noise3((float)right.r / scale, (float)_y, (float)_z, lacunarity, gain, octaves),
stb_perlin_turbulence_noise3((float)left.g / scale, (float)_y, (float)_z, lacunarity, gain, octaves)
+ stb_perlin_turbulence_noise3((float)right.g / scale, (float)_y, (float)_z, lacunarity, gain, octaves),
stb_perlin_turbulence_noise3((float)left.b / scale, (float)_y, (float)_z, lacunarity, gain, octaves)
+ stb_perlin_turbulence_noise3((float)right.b / scale, (float)_y, (float)_z, lacunarity, gain, octaves)
};
}
};
class ColorNoiseOperator : public Operator {
private:
double scale;
public:
ColorNoiseOperator(): Operator("ColorNoise"){
do {
scale = (float)randomDouble(1, 255);
} while (trunc((double)scale) == (double)scale);
}
[[nodiscard]] inline Color apply(double x, double y, unsigned int time, Color left, Color right) const final {
return {randomDouble(0, scale), randomDouble(0, scale), randomDouble(0, scale)};
}
};
}
#endif //PARKSNREC_OPERATORS_H
Reference in New Issue View Git Blame Copy Permalink