289 lines
9.0 KiB
C++
289 lines
9.0 KiB
C++
/*
|
|
* <Short Description>
|
|
* Copyright (C) 2024 Brett Terpstra
|
|
*
|
|
* This program is free software: you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation, either version 3 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
*/
|
|
#include <functions.h>
|
|
#include <random>
|
|
#include <blt/gfx/stb/stb_perlin.h>
|
|
#include <blt/std/memory_util.h>
|
|
#include <extern.h>
|
|
#include <cmath>
|
|
|
|
#define FUNCTION_COORD() \
|
|
int xi = static_cast<int>(x); \
|
|
int yi = static_cast<int>(y);
|
|
|
|
#define GET_IMAGE(name, pos) auto name = argv[pos]->get(xi, yi);
|
|
|
|
#define SINGLE_FUNCTION(op) \
|
|
FUNCTION_COORD() \
|
|
GET_IMAGE(i1, 0) \
|
|
img.set(blt::vec3{op(i1.x()), op(i1.y()), op(i1.z())}, xi, yi);
|
|
|
|
#define DOUBLE_FUNCTION(op) \
|
|
FUNCTION_COORD() \
|
|
GET_IMAGE(i1, 0) \
|
|
GET_IMAGE(i2, 1) \
|
|
img.set(blt::vec3{op(i1.x(), i2.x()), op(i1.y(), i2.y()), op(i1.z(), i2.z())}, xi, yi);
|
|
|
|
#define BITWISE_FUNCTION(op) \
|
|
FUNCTION_COORD() \
|
|
GET_IMAGE(i1, 0) \
|
|
GET_IMAGE(i2, 1) \
|
|
auto bitsRI1 = blt::mem::type_cast<blt::u32>(i1.x()); \
|
|
auto bitsGI1 = blt::mem::type_cast<blt::u32>(i1.y()); \
|
|
auto bitsBI1 = blt::mem::type_cast<blt::u32>(i1.z()); \
|
|
\
|
|
auto bitsRI2 = blt::mem::type_cast<blt::u32>(i2.x()); \
|
|
auto bitsGI2 = blt::mem::type_cast<blt::u32>(i2.y()); \
|
|
auto bitsBI2 = blt::mem::type_cast<blt::u32>(i2.z()); \
|
|
\
|
|
auto r = blt::mem::type_cast<float>(bitsRI1 op bitsRI2); \
|
|
auto g = blt::mem::type_cast<float>(bitsGI1 op bitsGI2); \
|
|
auto b = blt::mem::type_cast<float>(bitsBI1 op bitsBI2); \
|
|
\
|
|
img.set(blt::vec3{r, g, b}, xi, yi);
|
|
|
|
inline float protect_div(float x, float y, float d = 0)
|
|
{
|
|
if (y == 0)
|
|
return d;
|
|
return x / y;
|
|
}
|
|
|
|
void f_x(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
img = x;
|
|
}
|
|
|
|
void f_y(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
img = y;
|
|
}
|
|
|
|
void f_random(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
static std::random_device dev;
|
|
static std::mt19937_64 engine(dev());
|
|
static std::uniform_real_distribution<float> dist(0, 1);
|
|
img = dist(engine);
|
|
}
|
|
|
|
void f_noise(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
float z = 0.5;
|
|
|
|
float scaleX = width;
|
|
float scaleY = height;
|
|
if (argc >= 1)
|
|
scaleX *= argv[0]->get().x();
|
|
if (argc > 1)
|
|
scaleY *= argv[1]->get().x();
|
|
|
|
auto val = stb_perlin_noise3(protect_div(x, scaleX, z),
|
|
protect_div(y, scaleY, z),
|
|
z, 0, 0, 0);
|
|
img.set({val, val, val}, static_cast<int>(x), static_cast<int>(y));
|
|
}
|
|
|
|
void f_cnoise(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
float z = 0.5;
|
|
|
|
float scaleRX = width;
|
|
float scaleGX = width;
|
|
float scaleBX = width;
|
|
float scaleRY = height;
|
|
float scaleGY = height;
|
|
float scaleBY = height;
|
|
if (argc >= 1)
|
|
scaleRX *= argv[0]->get().x();
|
|
if (argc > 1)
|
|
scaleRY *= argv[1]->get().x();
|
|
if (argc >= 3)
|
|
scaleRX *= argv[2]->get().x();
|
|
if (argc > 3)
|
|
scaleRY *= argv[3]->get().x();
|
|
if (argc >= 5)
|
|
scaleRX *= argv[4]->get().x();
|
|
if (argc > 5)
|
|
scaleRY *= argv[5]->get().x();
|
|
|
|
auto valR = stb_perlin_noise3(protect_div(x, scaleRX, z),
|
|
protect_div(y, scaleRY, z),
|
|
z, 0, 0, 0);
|
|
auto valG = stb_perlin_noise3(protect_div(x, scaleGX, z),
|
|
protect_div(y, scaleGY, z),
|
|
z, 0, 0, 0);
|
|
auto valB = stb_perlin_noise3(protect_div(x, scaleBX, z),
|
|
protect_div(y, scaleBY, z),
|
|
z, 0, 0, 0);
|
|
img.set({valR, valG, valB}, static_cast<int>(x), static_cast<int>(y));
|
|
}
|
|
|
|
void f_scalar(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
img = extra_data[0];
|
|
}
|
|
|
|
void f_color(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
img = blt::vec3{extra_data[0], extra_data[1], extra_data[2]};
|
|
}
|
|
|
|
void f_log(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
SINGLE_FUNCTION(std::log);
|
|
}
|
|
|
|
void f_sqrt(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
SINGLE_FUNCTION(std::sqrt);
|
|
}
|
|
|
|
void f_sin(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
#define F_MOD_SIN(x) ((std::sin(x) + 1) * 0.5f)
|
|
SINGLE_FUNCTION(F_MOD_SIN);
|
|
#undef F_MOD_SIN
|
|
}
|
|
|
|
void f_cos(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
#define F_MOD_COS(x) ((std::cos(x) + 1) * 0.5f)
|
|
SINGLE_FUNCTION(F_MOD_COS);
|
|
#undef F_MOD_COS
|
|
}
|
|
|
|
void f_atan(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
#define F_MOD_ATAN(x) ((std::atan(x) + 1) * 0.5f)
|
|
SINGLE_FUNCTION(F_MOD_ATAN);
|
|
#undef F_MOD_ATAN
|
|
}
|
|
|
|
void f_add(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
#define F_MOD(x, y) (x + y)
|
|
DOUBLE_FUNCTION(F_MOD);
|
|
#undef F_MOD
|
|
}
|
|
|
|
void f_sub(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
#define F_MOD(x, y) (x - y)
|
|
DOUBLE_FUNCTION(F_MOD);
|
|
#undef F_MOD
|
|
}
|
|
|
|
void f_mul(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
#define F_MOD(x, y) (x * y)
|
|
DOUBLE_FUNCTION(F_MOD);
|
|
#undef F_MOD
|
|
}
|
|
|
|
void f_div(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
#define F_MOD(x, y) protect_div(x, y)
|
|
DOUBLE_FUNCTION(F_MOD);
|
|
#undef F_MOD
|
|
}
|
|
|
|
void f_or(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
BITWISE_FUNCTION(|);
|
|
}
|
|
|
|
void f_and(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
BITWISE_FUNCTION(&);
|
|
}
|
|
|
|
void f_xor(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
BITWISE_FUNCTION(^);
|
|
}
|
|
|
|
void f_if(image& img, float x, float y, blt::size_t argc, const image** argv, const data_t& extra_data)
|
|
{
|
|
FUNCTION_COORD();
|
|
GET_IMAGE(i1, 0);
|
|
GET_IMAGE(i2, 1);
|
|
GET_IMAGE(i3, 2);
|
|
|
|
constexpr float SCALE = 0.1;
|
|
|
|
if (i1.x() > SCALE || i1.x() < -SCALE)
|
|
img.set(i2, xi, yi);
|
|
else
|
|
img.set(i3, xi, yi);
|
|
}
|
|
|
|
double on_data(const double* data, blt::size_t len)
|
|
{
|
|
const static float NEGATION = 0;
|
|
willbruh results(data, len);
|
|
switch (results->error)
|
|
{
|
|
case 0:
|
|
if (!std::isnan(results->estimate))
|
|
return results->estimate;
|
|
return 0;
|
|
case 1:
|
|
BLT_INFO("Somehow we have sent more than 5000 values!");
|
|
return 0;
|
|
default:
|
|
return 0;
|
|
case -2:
|
|
// should never consider this a valid solution / punish for having large sections of no difference
|
|
return NEGATION;
|
|
}
|
|
}
|
|
|
|
float eval_DNF_SW(const image& img)
|
|
{
|
|
std::vector<double> order(width * height);
|
|
|
|
for (const auto& v : img.getData())
|
|
order.push_back(v.magnitude());
|
|
|
|
std::sort(order.begin(), order.end());
|
|
|
|
blt::size_t len = 5000;
|
|
blt::size_t current_pos = 0;
|
|
double total = 0;
|
|
while (true)
|
|
{
|
|
if (order.size() - current_pos < len)
|
|
{
|
|
len = order.size() - current_pos;
|
|
if (len <= 0)
|
|
break;
|
|
}
|
|
total += on_data(order.data() + current_pos, len);
|
|
current_pos += len;
|
|
}
|
|
|
|
return static_cast<float>(total);
|
|
}
|
|
|
|
float eval_DNF_KS(const image& img)
|
|
{
|
|
return 0;
|
|
}
|
|
|