shader_type spatial;
render_mode blend_mix, cull_back, diffuse_burley, specular_schlick_ggx;
uniform float variation = 0.0;
varying float elapsed_time;
void vertex() {
elapsed_time = TIME;
}
float dot2(vec2 x) { return dot(x, x); }
float rand(vec2 x) {
return fract(cos(mod(dot(x, vec2(13.9898, 8.141)), 3.14)) * 43758.5);
}
vec2 rand2(vec2 x) {
return fract(cos(mod(vec2(dot(x, vec2(13.9898, 8.141)),
dot(x, vec2(3.4562, 17.398))), vec2(3.14))) * 43758.5);
}
vec3 rand3(vec2 x) {
return fract(cos(mod(vec3(dot(x, vec2(13.9898, 8.141)),
dot(x, vec2(3.4562, 17.398)),
dot(x, vec2(13.254, 5.867))), vec3(3.14))) * 43758.5);
}
vec3 rgb2hsv(vec3 c) {
vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
float d = q.x - min(q.w, q.y);
float e = 1.0e-10;
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
}
vec3 hsv2rgb(vec3 c) {
vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}
float oldfbm_value(vec2 coord, vec2 size, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float p00 = rand(mod(o, size));
float p01 = rand(mod(o + vec2(0.0, 1.0), size));
float p10 = rand(mod(o + vec2(1.0, 0.0), size));
float p11 = rand(mod(o + vec2(1.0, 1.0), size));
vec2 t = f * f * (3.0 - 2.0 * f);
return mix(mix(p00, p10, t.x), mix(p01, p11, t.x), t.y);
}
float oldfbm_perlin(vec2 coord, vec2 size, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float a00 = rand(mod(o, size)) * 6.28318530718;
float a01 = rand(mod(o + vec2(0.0, 1.0), size)) * 6.28318530718;
float a10 = rand(mod(o + vec2(1.0, 0.0), size)) * 6.28318530718;
float a11 = rand(mod(o + vec2(1.0, 1.0), size)) * 6.28318530718;
vec2 v00 = vec2(cos(a00), sin(a00));
vec2 v01 = vec2(cos(a01), sin(a01));
vec2 v10 = vec2(cos(a10), sin(a10));
vec2 v11 = vec2(cos(a11), sin(a11));
float p00 = dot(v00, f);
float p01 = dot(v01, f - vec2(0.0, 1.0));
float p10 = dot(v10, f - vec2(1.0, 0.0));
float p11 = dot(v11, f - vec2(1.0, 1.0));
vec2 t = f * f * (3.0 - 2.0 * f);
return 0.5 + mix(mix(p00, p10, t.x), mix(p01, p11, t.x), t.y);
}
float oldfbm_perlinabs(vec2 coord, vec2 size, float seed) {
return abs(2.0*oldfbm_perlin(coord, size, seed)-1.0);
}
float oldfbm_cellular(vec2 coord, vec2 size, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
float dist = sqrt((f - node).x * (f - node).x + (f - node).y * (f - node).y);
min_dist = min(min_dist, dist);
}
}
return min_dist;
}
float oldfbm_cellular2(vec2 coord, vec2 size, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist1 = 2.0;
float min_dist2 = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
float dist = sqrt((f - node).x * (f - node).x + (f - node).y * (f - node).y);
if (min_dist1 > dist) {
min_dist2 = min_dist1;
min_dist1 = dist;
} else if (min_dist2 > dist) {
min_dist2 = dist;
}
}
}
return min_dist2-min_dist1;
}
float oldfbm_cellular3(vec2 coord, vec2 size, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 node = rand2(mod(o + vec2(x, y), size))*0.5 + vec2(x, y);
float dist = abs((f - node).x) + abs((f - node).y);
min_dist = min(min_dist, dist);
}
}
return min_dist;
}
float oldfbm_cellular4(vec2 coord, vec2 size, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist1 = 2.0;
float min_dist2 = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 node = rand2(mod(o + vec2(x, y), size))*0.5 + vec2(x, y);
float dist = abs((f - node).x) + abs((f - node).y);
if (min_dist1 > dist) {
min_dist2 = min_dist1;
min_dist1 = dist;
} else if (min_dist2 > dist) {
min_dist2 = dist;
}
}
}
return min_dist2-min_dist1;
}
float oldfbm_cellular5(vec2 coord, vec2 size, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
float dist = max(abs((f - node).x), abs((f - node).y));
min_dist = min(min_dist, dist);
}
}
return min_dist;
}
float oldfbm_cellular6(vec2 coord, vec2 size, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist1 = 2.0;
float min_dist2 = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
float dist = max(abs((f - node).x), abs((f - node).y));
if (min_dist1 > dist) {
min_dist2 = min_dist1;
min_dist1 = dist;
} else if (min_dist2 > dist) {
min_dist2 = dist;
}
}
}
return min_dist2-min_dist1;
}
// include: blend
vec3 blend_normal(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*c1 + (1.0-opacity)*c2;
}
vec3 blend_dissolve(vec2 uv, vec3 c1, vec3 c2, float opacity) {
if (rand(uv) < opacity) {
return c1;
} else {
return c2;
}
}
vec3 blend_multiply(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*c1*c2 + (1.0-opacity)*c2;
}
vec3 blend_screen(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*(1.0-(1.0-c1)*(1.0-c2)) + (1.0-opacity)*c2;
}
float blend_overlay_f(float c1, float c2) {
return (c1 < 0.5) ? (2.0*c1*c2) : (1.0-2.0*(1.0-c1)*(1.0-c2));
}
vec3 blend_overlay(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_overlay_f(c1.x, c2.x), blend_overlay_f(c1.y, c2.y), blend_overlay_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
vec3 blend_hard_light(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*0.5*(c1*c2+blend_overlay(uv, c1, c2, 1.0)) + (1.0-opacity)*c2;
}
float blend_soft_light_f(float c1, float c2) {
return (c2 < 0.5) ? (2.0*c1*c2+c1*c1*(1.0-2.0*c2)) : 2.0*c1*(1.0-c2)+sqrt(c1)*(2.0*c2-1.0);
}
vec3 blend_soft_light(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_soft_light_f(c1.x, c2.x), blend_soft_light_f(c1.y, c2.y), blend_soft_light_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
float blend_burn_f(float c1, float c2) {
return (c1==0.0)?c1:max((1.0-((1.0-c2)/c1)),0.0);
}
vec3 blend_burn(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_burn_f(c1.x, c2.x), blend_burn_f(c1.y, c2.y), blend_burn_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
float blend_dodge_f(float c1, float c2) {
return (c1==1.0)?c1:min(c2/(1.0-c1),1.0);
}
vec3 blend_dodge(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_dodge_f(c1.x, c2.x), blend_dodge_f(c1.y, c2.y), blend_dodge_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
vec3 blend_lighten(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*max(c1, c2) + (1.0-opacity)*c2;
}
vec3 blend_darken(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*min(c1, c2) + (1.0-opacity)*c2;
}
vec3 blend_difference(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*clamp(c2-c1, vec3(0.0), vec3(1.0)) + (1.0-opacity)*c2;
}
vec3 blend_additive(vec2 uv, vec3 c1, vec3 c2, float oppacity) {
return c2 + c1 * oppacity;
}
vec3 blend_addsub(vec2 uv, vec3 c1, vec3 c2, float oppacity) {
return c2 + (c1 - .5) * 2.0 * oppacity;
}
float square(float v) { return v * v; }
vec2 square2(vec2 v) { return v * v; }
float shape_circle(vec2 uv, float sides, float size, float edge) {
uv = 2.0*uv-1.0;
edge = max(edge, 1.0e-8);
float distance = length(uv);
return clamp((1.0-distance/size)/edge, 0.0, 1.0);
}
float shape_polygon(vec2 uv, float sides, float size, float edge) {
uv = 2.0*uv-1.0;
edge = max(edge, 1.0e-8);
float angle = atan(uv.x, uv.y)+3.14159265359;
float slice = 6.28318530718/sides;
return clamp((1.0-(cos(floor(0.5+angle/slice)*slice-angle)*length(uv))/size)/edge, 0.0, 1.0);
}
float shape_star(vec2 uv, float sides, float size, float edge) {
uv = 2.0*uv-1.0;
edge = max(edge, 1.0e-8);
float angle = atan(uv.x, uv.y);
float slice = 6.28318530718/sides;
return clamp((1.0-(cos(floor(angle*sides/6.28318530718-0.5+2.0*step(fract(angle*sides/6.28318530718), 0.5))*slice-angle)*length(uv))/size)/edge, 0.0, 1.0);
}
float shape_curved_star(vec2 uv, float sides, float size, float edge) {
uv = 2.0*uv-1.0;
edge = max(edge, 1.0e-8);
float angle = 2.0*(atan(uv.x, uv.y)+3.14159265359);
float slice = 6.28318530718/sides;
return clamp((1.0-cos(floor(0.5+0.5*angle/slice)*2.0*slice-angle)*length(uv)/size)/edge, 0.0, 1.0);
}
float shape_rays(vec2 uv, float sides, float size, float edge) {
uv = 2.0*uv-1.0;
edge = 0.5*max(edge, 1.0e-8)*size;
float slice = 6.28318530718/sides;
float angle = mod(atan(uv.x, uv.y)+3.14159265359, slice)/slice;
return clamp(min((size-angle)/edge, angle/edge), 0.0, 1.0);
}
float pingpong(float a, float b)
{
return (b != 0.0) ? abs(fract((a - b) / (b * 2.0)) * b * 2.0 - b) : 0.0;
}
vec4 o56_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(0.343750,0.343750,0.343750,1.000000);
if (x < 1.000000) return mix(vec4(0.343750,0.343750,0.343750,1.000000),vec4(0.800781,0.800781,0.800781,1.000000),((x-0.000000)/(1.000000-0.000000)));
return vec4(0.800781,0.800781,0.800781,1.000000);
}
float old_value_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float p00 = rand(mod(o, size));
float p01 = rand(mod(o + vec2(0.0, 1.0), size));
float p10 = rand(mod(o + vec2(1.0, 0.0), size));
float p11 = rand(mod(o + vec2(1.0, 1.0), size));
p00 = sin(p00 * 6.28318530718 + offset * 6.28318530718) / 2.0 + 0.5;
p01 = sin(p01 * 6.28318530718 + offset * 6.28318530718) / 2.0 + 0.5;
p10 = sin(p10 * 6.28318530718 + offset * 6.28318530718) / 2.0 + 0.5;
p11 = sin(p11 * 6.28318530718 + offset * 6.28318530718) / 2.0 + 0.5;
vec2 t = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
return mix(mix(p00, p10, t.x), mix(p01, p11, t.x), t.y);
}
float old_fbm_2d_value(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_value_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_perlin_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float a00 = rand(mod(o, size)) * 6.28318530718 + offset * 6.28318530718;
float a01 = rand(mod(o + vec2(0.0, 1.0), size)) * 6.28318530718 + offset * 6.28318530718;
float a10 = rand(mod(o + vec2(1.0, 0.0), size)) * 6.28318530718 + offset * 6.28318530718;
float a11 = rand(mod(o + vec2(1.0, 1.0), size)) * 6.28318530718 + offset * 6.28318530718;
vec2 v00 = vec2(cos(a00), sin(a00));
vec2 v01 = vec2(cos(a01), sin(a01));
vec2 v10 = vec2(cos(a10), sin(a10));
vec2 v11 = vec2(cos(a11), sin(a11));
float p00 = dot(v00, f);
float p01 = dot(v01, f - vec2(0.0, 1.0));
float p10 = dot(v10, f - vec2(1.0, 0.0));
float p11 = dot(v11, f - vec2(1.0, 1.0));
vec2 t = f * f * f * (f * (f * 6.0 - 15.0) + 10.0);
return 0.5 + mix(mix(p00, p10, t.x), mix(p01, p11, t.x), t.y);
}
float old_fbm_2d_perlin(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_perlin_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_perlinabs_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
return abs(2.0*old_perlin_noise_2d(coord, size, offset, seed)-1.0);
}
float old_fbm_2d_perlinabs(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_perlinabs_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_fbm_2d_mod289(float x) {
return x - floor(x * (1.0 / 289.0)) * 289.0;
}
float old_fbm_2d_permute(float x) {
return old_fbm_2d_mod289(((x * 34.0) + 1.0) * x);
}
vec2 old_fbm_2d_rgrad2(vec2 p, float rot, float seed) {
float u = old_fbm_2d_permute(old_fbm_2d_permute(p.x) + p.y) * 0.0243902439 + rot; // Rotate by shift
u = fract(u) * 6.28318530718; // 2*pi
return vec2(cos(u), sin(u));
}
float old_simplex_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
coord *= 2.0; // needed for it to tile
coord += rand2(vec2(seed, 1.0-seed)) + size;
size *= 2.0; // needed for it to tile
coord.y += 0.001;
vec2 uv = vec2(coord.x + coord.y*0.5, coord.y);
vec2 i0 = floor(uv);
vec2 f0 = fract(uv);
vec2 i1 = (f0.x > f0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
vec2 p0 = vec2(i0.x - i0.y * 0.5, i0.y);
vec2 p1 = vec2(p0.x + i1.x - i1.y * 0.5, p0.y + i1.y);
vec2 p2 = vec2(p0.x + 0.5, p0.y + 1.0);
i1 = i0 + i1;
vec2 i2 = i0 + vec2(1.0, 1.0);
vec2 d0 = coord - p0;
vec2 d1 = coord - p1;
vec2 d2 = coord - p2;
vec3 xw = mod(vec3(p0.x, p1.x, p2.x), size.x);
vec3 yw = mod(vec3(p0.y, p1.y, p2.y), size.y);
vec3 iuw = xw + 0.5 * yw;
vec3 ivw = yw;
vec2 g0 = old_fbm_2d_rgrad2(vec2(iuw.x, ivw.x), offset, seed);
vec2 g1 = old_fbm_2d_rgrad2(vec2(iuw.y, ivw.y), offset, seed);
vec2 g2 = old_fbm_2d_rgrad2(vec2(iuw.z, ivw.z), offset, seed);
vec3 w = vec3(dot(g0, d0), dot(g1, d1), dot(g2, d2));
vec3 t = 0.8 - vec3(dot(d0, d0), dot(d1, d1), dot(d2, d2));
t = max(t, vec3(0.0));
vec3 t2 = t * t;
vec3 t4 = t2 * t2;
float n = dot(t4, w);
return 0.5 + 5.5 * n;
}
float old_fbm_2d_simplex(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_simplex_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_cellular_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 neighbor = vec2(float(x),float(y));
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
node = 0.5 + 0.25 * sin(offset * 6.28318530718 + 6.28318530718 * node);
vec2 diff = neighbor + node - f;
float dist = length(diff);
min_dist = min(min_dist, dist);
}
}
return min_dist;
}
float old_fbm_2d_cellular(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_cellular_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_cellular2_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist1 = 2.0;
float min_dist2 = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 neighbor = vec2(float(x),float(y));
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
node = 0.5 + 0.25 * sin(offset * 6.28318530718 + 6.28318530718*node);
vec2 diff = neighbor + node - f;
float dist = length(diff);
if (min_dist1 > dist) {
min_dist2 = min_dist1;
min_dist1 = dist;
} else if (min_dist2 > dist) {
min_dist2 = dist;
}
}
}
return min_dist2-min_dist1;
}
float old_fbm_2d_cellular2(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_cellular2_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_cellular3_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 neighbor = vec2(float(x),float(y));
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
node = 0.5 + 0.25 * sin(offset * 6.28318530718 + 6.28318530718*node);
vec2 diff = neighbor + node - f;
float dist = abs((diff).x) + abs((diff).y);
min_dist = min(min_dist, dist);
}
}
return min_dist;
}
float old_fbm_2d_cellular3(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_cellular3_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_cellular4_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist1 = 2.0;
float min_dist2 = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 neighbor = vec2(float(x),float(y));
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
node = 0.5 + 0.25 * sin(offset * 6.28318530718 + 6.28318530718*node);
vec2 diff = neighbor + node - f;
float dist = abs((diff).x) + abs((diff).y);
if (min_dist1 > dist) {
min_dist2 = min_dist1;
min_dist1 = dist;
} else if (min_dist2 > dist) {
min_dist2 = dist;
}
}
}
return min_dist2-min_dist1;
}
float old_fbm_2d_cellular4(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_cellular4_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_cellular5_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 neighbor = vec2(float(x),float(y));
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
node = 0.5 + 0.5 * sin(offset * 6.28318530718 + 6.28318530718*node);
vec2 diff = neighbor + node - f;
float dist = max(abs((diff).x), abs((diff).y));
min_dist = min(min_dist, dist);
}
}
return min_dist;
}
float old_fbm_2d_cellular5(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_cellular5_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
float old_cellular6_noise_2d(vec2 coord, vec2 size, float offset, float seed) {
vec2 o = floor(coord)+rand2(vec2(seed, 1.0-seed))+size;
vec2 f = fract(coord);
float min_dist1 = 2.0;
float min_dist2 = 2.0;
for(float x = -1.0; x <= 1.0; x++) {
for(float y = -1.0; y <= 1.0; y++) {
vec2 neighbor = vec2(float(x),float(y));
vec2 node = rand2(mod(o + vec2(x, y), size)) + vec2(x, y);
node = 0.5 + 0.25 * sin(offset * 6.28318530718 + 6.28318530718*node);
vec2 diff = neighbor + node - f;
float dist = max(abs((diff).x), abs((diff).y));
if (min_dist1 > dist) {
min_dist2 = min_dist1;
min_dist1 = dist;
} else if (min_dist2 > dist) {
min_dist2 = dist;
}
}
}
return min_dist2-min_dist1;
}
float old_fbm_2d_cellular6(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_cellular6_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// MIT License Inigo Quilez - https://www.shadertoy.com/view/Xd23Dh
float old_voronoise_noise_2d( vec2 coord, vec2 size, float offset, float seed) {
vec2 i = floor(coord) + rand2(vec2(seed, 1.0-seed)) + size;
vec2 f = fract(coord);
vec2 a = vec2(0.0);
for( int y=-2; y<=2; y++ ) {
for( int x=-2; x<=2; x++ ) {
vec2 g = vec2( float(x), float(y) );
vec3 o = rand3( mod(i + g, size) + vec2(seed) );
o.xy += 0.25 * sin(offset * 6.28318530718 + 6.28318530718*o.xy);
vec2 d = g - f + o.xy;
float w = pow( 1.0-smoothstep(0.0, 1.414, length(d)), 1.0 );
a += vec2(o.z*w,w);
}
}
return a.x/a.y;
}
float old_fbm_2d_voronoise(vec2 coord, vec2 size, int folds, int octaves, float persistence, float offset, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = old_voronoise_noise_2d(coord*size, size, offset, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// include: adjust_hsv
vec3 rgb_to_hsv(vec3 c) {
vec4 K = vec4(0.0, -1.0 / 3.0, 2.0 / 3.0, -1.0);
vec4 p = c.g < c.b ? vec4(c.bg, K.wz) : vec4(c.gb, K.xy);
vec4 q = c.r < p.x ? vec4(p.xyw, c.r) : vec4(c.r, p.yzx);
float d = q.x - min(q.w, q.y);
float e = 1.0e-10;
return vec3(abs(q.z + (q.w - q.y) / (6.0 * d + e)), d / (q.x + e), q.x);
}
vec3 hsv_to_rgb(vec3 c) {
vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
return c.z * mix(K.xxx, clamp(p - K.xxx, 0.0, 1.0), c.y);
}
float blend_linear_light_f(float c1, float c2) {
return (c1 + 2.0 * c2) - 1.0;
}
vec3 blend_linear_light(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_linear_light_f(c1.x, c2.x), blend_linear_light_f(c1.y, c2.y), blend_linear_light_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
float blend_vivid_light_f(float c1, float c2) {
return (c1 < 0.5) ? 1.0 - (1.0 - c2) / (2.0 * c1) : c2 / (2.0 * (1.0 - c1));
}
vec3 blend_vivid_light(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_vivid_light_f(c1.x, c2.x), blend_vivid_light_f(c1.y, c2.y), blend_vivid_light_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
float blend_pin_light_f( float c1, float c2) {
return (2.0 * c1 - 1.0 > c2) ? 2.0 * c1 - 1.0 : ((c1 < 0.5 * c2) ? 2.0 * c1 : c2);
}
vec3 blend_pin_light(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_pin_light_f(c1.x, c2.x), blend_pin_light_f(c1.y, c2.y), blend_pin_light_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
float blend_hard_mix_f(float c1, float c2) {
return floor(c1 + c2);
}
vec3 blend_hard_mix(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_hard_mix_f(c1.x, c2.x), blend_hard_mix_f(c1.y, c2.y), blend_hard_mix_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
float blend_exclusion_f(float c1, float c2) {
return c1 + c2 - 2.0 * c1 * c2;
}
vec3 blend_exclusion(vec2 uv, vec3 c1, vec3 c2, float opacity) {
return opacity*vec3(blend_exclusion_f(c1.x, c2.x), blend_exclusion_f(c1.y, c2.y), blend_exclusion_f(c1.z, c2.z)) + (1.0-opacity)*c2;
}
vec3 blend_hue(vec2 uv, vec3 c1, vec3 c2, float opacity) {
vec3 outcol = c2;
vec3 hsv, hsv2, tmp;
hsv2 = rgb_to_hsv(c1);
if (hsv2.y != 0.0) {
hsv = rgb_to_hsv(outcol);
hsv.x = hsv2.x;
tmp = hsv_to_rgb(hsv);
outcol = mix(outcol, tmp, opacity);
}
return outcol;
}
vec3 blend_saturation(vec2 uv, vec3 c1, vec3 c2, float opacity) {
float facm = 1.0 - opacity;
vec3 outcol = c2;
vec3 hsv, hsv2;
hsv = rgb_to_hsv(outcol);
if (hsv.y != 0.0) {
hsv2 = rgb_to_hsv(c1);
hsv.y = facm * hsv.y + opacity * hsv2.y;
outcol = hsv_to_rgb(hsv);
}
return outcol;
}
vec3 blend_color(vec2 uv, vec3 c1, vec3 c2, float opacity) {
float facm = 1.0 - opacity;
vec3 outcol = c2;
vec3 hsv, hsv2, tmp;
hsv2 = rgb_to_hsv(c1);
if (hsv2.y != 0.0) {
hsv = rgb_to_hsv(outcol);
hsv.x = hsv2.x;
hsv.y = hsv2.y;
tmp = hsv_to_rgb(hsv);
outcol = mix(outcol, tmp, opacity);
}
return outcol;
}
vec3 blend_value(vec2 uv, vec3 c1, vec3 c2, float opacity) {
float facm = 1.0 - opacity;
vec3 hsv, hsv2;
hsv = rgb_to_hsv(c2);
hsv2 = rgb_to_hsv(c1);
hsv.z = facm * hsv.z + opacity * hsv2.z;
return hsv_to_rgb(hsv);
}
vec4 o60_gradient_gradient_fct(float x) {
if (x < 0.198117) return vec4(0.000000,0.000000,0.000000,1.000000);
if (x < 0.426931) return mix(vec4(0.000000,0.000000,0.000000,1.000000),vec4(1.000000,1.000000,1.000000,1.000000),((x-0.198117)/(0.426931-0.198117)));
return vec4(1.000000,1.000000,1.000000,1.000000);
}
vec4 o107_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(0.309326,0.222656,0.500000,1.000000);
if (x < 0.826774) return mix(vec4(0.309326,0.222656,0.500000,1.000000),vec4(0.409726,0.319153,0.492188,1.000000),((x-0.000000)/(0.826774-0.000000)));
return vec4(0.409726,0.319153,0.492188,1.000000);
}
vec2 transform2_clamp(vec2 uv) {
return clamp(uv, vec2(0.0), vec2(1.0));
}
vec2 transform2(vec2 uv, vec2 translate, float rotate, vec2 scale) {
vec2 rv;
uv -= translate;
uv -= vec2(0.5);
rv.x = cos(rotate)*uv.x + sin(rotate)*uv.y;
rv.y = -sin(rotate)*uv.x + cos(rotate)*uv.y;
rv /= scale;
rv += vec2(0.5);
return rv;
}
// Based on https://www.shadertoy.com/view/ldl3W8
// The MIT License
// Copyright © 2013 Inigo Quilez
vec3 iq_voronoi(vec2 x, vec2 size, vec2 stretch, float randomness, vec2 seed) {
vec2 n = floor(x);
vec2 f = fract(x);
vec2 mg, mr, mc;
float md = 8.0;
for (int j=-1; j<=1; j++)
for (int i=-1; i<=1; i++) {
vec2 g = vec2(float(i),float(j));
vec2 o = randomness*rand2(seed + mod(n + g + size, size));
vec2 c = g + o;
vec2 r = c - f;
vec2 rr = r*stretch;
float d = dot(rr,rr);
if (d<md) {
mc = c;
md = d;
mr = r;
mg = g;
}
}
md = 8.0;
for (int j=-2; j<=2; j++)
for (int i=-2; i<=2; i++) {
vec2 g = mg + vec2(float(i),float(j));
vec2 o = randomness*rand2(seed + mod(n + g + size, size));
vec2 r = g + o - f;
vec2 rr = (mr-r)*stretch;
if (dot(rr,rr)>0.00001)
md = min(md, dot(0.5*(mr+r)*stretch, normalize((r-mr)*stretch)));
}
return vec3(md, mc+n);
}
vec4 voronoi(vec2 uv, vec2 size, vec2 stretch, float intensity, float randomness, float seed) {
uv *= size;
vec3 v = iq_voronoi(uv, size, stretch, randomness, rand2(vec2(seed, 1.0-seed)));
return vec4(v.yz, intensity*length((uv-v.yz)*stretch), v.x);
}
vec4 o142_gradient_gradient_fct(float x) {
if (x < 0.130475) return vec4(0.000000,0.000000,0.000000,1.000000);
if (x < 1.000000) return mix(vec4(0.000000,0.000000,0.000000,1.000000),vec4(1.000000,1.000000,1.000000,1.000000),((x-0.130475)/(1.000000-0.130475)));
return vec4(1.000000,1.000000,1.000000,1.000000);
}
// include: custom_uv
vec2 get_from_tileset(float count, float seed, vec2 uv) {
return clamp((uv+floor(rand2(vec2(seed))*count))/count, vec2(0.0), vec2(1.0));
}
vec2 old_custom_uv_transform(vec2 uv, vec2 cst_scale, float rnd_rotate, float rnd_scale, vec2 seed) {
seed = rand2(seed);
uv -= vec2(0.5);
float angle = (seed.x * 2.0 - 1.0) * rnd_rotate;
float ca = cos(angle);
float sa = sin(angle);
uv = vec2(ca*uv.x+sa*uv.y, -sa*uv.x+ca*uv.y);
uv *= (seed.y-0.5)*2.0*rnd_scale+1.0;
uv /= cst_scale;
uv += vec2(0.5);
return uv;
}
vec4 o155_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(0.000000,0.000000,0.000000,1.000000);
if (x < 0.302719) return mix(vec4(0.000000,0.000000,0.000000,1.000000),vec4(0.613281,0.613281,0.613281,1.000000),((x-0.000000)/(0.302719-0.000000)));
if (x < 1.000000) return mix(vec4(0.613281,0.613281,0.613281,1.000000),vec4(1.000000,1.000000,1.000000,1.000000),((x-0.302719)/(1.000000-0.302719)));
return vec4(1.000000,1.000000,1.000000,1.000000);
}
float sphere(vec2 uv, vec2 c, float r) {
uv -= c;
uv /= r;
return 2.0*r*sqrt(max(0.0, 1.0-dot(uv, uv)));
}
vec4 o230_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(0.000000,0.000000,0.000000,1.000000);
if (x < 1.000000) return mix(vec4(0.000000,0.000000,0.000000,1.000000),vec4(1.000000,1.000000,1.000000,1.000000),((x-0.000000)/(1.000000-0.000000)));
return vec4(1.000000,1.000000,1.000000,1.000000);
}
vec4 o259_gradient_gradient_fct(float x) {
if (x < 0.280668) return vec4(0.763210,0.754547,0.839844,1.000000);
if (x < 0.717816) return mix(vec4(0.763210,0.754547,0.839844,1.000000),vec4(1.000000,1.000000,1.000000,1.000000),((x-0.280668)/(0.717816-0.280668)));
return vec4(1.000000,1.000000,1.000000,1.000000);
}
vec4 o286_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(0.000000,0.000000,0.000000,1.000000);
if (x < 0.606388) return mix(vec4(0.000000,0.000000,0.000000,1.000000),vec4(0.664062,0.352783,0.564356,1.000000),((x-0.000000)/(0.606388-0.000000)));
return vec4(0.664062,0.352783,0.564356,1.000000);
}
vec4 o287_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(0.000000,0.000000,0.000000,1.000000);
if (x < 1.000000) return mix(vec4(0.000000,0.000000,0.000000,1.000000),vec4(1.000000,1.000000,1.000000,1.000000),((x-0.000000)/(1.000000-0.000000)));
return vec4(1.000000,1.000000,1.000000,1.000000);
}
vec4 o301_gradient_gradient_fct(float x) {
if (x < 0.477491) return vec4(0.566559,0.646175,0.917969,1.000000);
if (x < 0.890110) return mix(vec4(0.566559,0.646175,0.917969,1.000000),vec4(0.237335,0.328392,0.601562,1.000000),((x-0.477491)/(0.890110-0.477491)));
return vec4(0.237335,0.328392,0.601562,1.000000);
}
vec4 o303_gradient_gradient_fct(float x) {
if (x < 0.499287) return vec4(0.000000,0.000000,0.000000,1.000000);
if (x < 0.725315) return mix(vec4(0.000000,0.000000,0.000000,1.000000),vec4(0.316010,0.742188,0.582371,1.000000),((x-0.499287)/(0.725315-0.499287)));
if (x < 0.932952) return mix(vec4(0.316010,0.742188,0.582371,1.000000),vec4(0.363281,1.000000,0.985077,1.000000),((x-0.725315)/(0.932952-0.725315)));
return vec4(0.363281,1.000000,0.985077,1.000000);
}
vec4 rot2Dnm(vec4 nm, float a)
{
a = a * 6.2831853 / 360.0;
return vec4((nm.xy - vec2(0.5)) * mat2(vec2(cos(a), sin(a)), vec2(-sin(a),cos(a))) + vec2(0.5), 0.0, 1.0);
}
vec4 o346_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(0.000000,0.000000,0.000000,1.000000);
if (x < 1.000000) return mix(vec4(0.000000,0.000000,0.000000,1.000000),vec4(1.000000,1.000000,1.000000,1.000000),((x-0.000000)/(1.000000-0.000000)));
return vec4(1.000000,1.000000,1.000000,1.000000);
}
vec4 o384_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(0.343750,0.343750,0.343750,1.000000);
if (x < 1.000000) return mix(vec4(0.343750,0.343750,0.343750,1.000000),vec4(0.800781,0.800781,0.800781,1.000000),((x-0.000000)/(1.000000-0.000000)));
return vec4(0.800781,0.800781,0.800781,1.000000);
}
vec4 o388_gradient_gradient_fct(float x) {
if (x < 0.000000) return vec4(1.000000,1.000000,1.000000,1.000000);
if (x < 1.000000) return mix(vec4(1.000000,1.000000,1.000000,1.000000),vec4(0.433594,0.433594,0.433594,1.000000),((x-0.000000)/(1.000000-0.000000)));
return vec4(0.433594,0.433594,0.433594,1.000000);
}
// instance: o18
float o18_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o19
float o19_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o23
float o23_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o24
float o24_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o25
float o25_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o30
float o30_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o31
float o31_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o32
float o32_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o34
float o34_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o43
vec4 o43_fct(vec2 uv) {
float e = 1.0/2048.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000001, 4.800000*0.0(uv));
for (float i = -50.0; i <= 50.0; i += 1.0) {
float coef = exp(-0.5*(pow(i/sigma, 2.0)))/(6.28318530718*sigma*sigma);
rv += vec4(0.5, 0.5, 0.5, 1.0)(uv+vec2(i*e, 0.0))*coef;
sum += coef;
}
return rv/sum;
}
// instance: o40
vec4 o40_fct(vec2 uv) {
float e = 1.0/2048.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000001, 4.800000*0.0(uv));
for (float i = -50.0; i <= 50.0; i += 1.0) {
float coef = exp(-0.5*(pow(i/sigma, 2.0)))/(6.28318530718*sigma*sigma);
rv += o43_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o11
/*
License: GPL-2.0-or-later
https://projects.blender.org/blender/blender/src/branch/main/source/blender/compositor/
realtime_compositor/compositor_kuwahara_anisotropic.glsl
*/
vec4 o11_anisotropic_kuwahara(vec2 uv, float size, float eccentricity, float sharpness) {
float o = 1.0/512.0;
const float M_PI = 3.14159265358979323846;
const float M_SQRT1_2 = 0.70710678118654752440;
sharpness = clamp(sharpness, 0.0, 1.0);
sharpness = sharpness * sharpness * 16.0;
eccentricity = 1.0/max(0.01, eccentricity);
float dxdx = o40_0_0_rgba.x;
float dxdy = o40_0_0_rgba.y;
float dydy = o40_0_0_rgba.w;
float eigenvalue_first_term = (dxdx + dydy) / 2.0;
float eigenvalue_square_root_term = sqrt(square(dxdx - dydy) + 4.0 * square(dxdy)) / 2.0;
float first_eigenvalue = eigenvalue_first_term + eigenvalue_square_root_term;
float second_eigenvalue = eigenvalue_first_term - eigenvalue_square_root_term;
vec2 eigenvector = vec2(first_eigenvalue - dxdx, -dxdy);
float eigenvector_length = length(eigenvector);
vec2 unit_eigenvector = eigenvector_length != 0.0 ? eigenvector / eigenvector_length : vec2(1.0);
float eigenvalue_sum = first_eigenvalue + second_eigenvalue;
float eigenvalue_difference = first_eigenvalue - second_eigenvalue;
float anisotropy = eigenvalue_sum > 0.0 ? eigenvalue_difference / eigenvalue_sum : 0.0;
float radius = max(0.0, size);
float ellipse_width_factor = (eccentricity + anisotropy) / eccentricity;
float ellipse_width = ellipse_width_factor * radius;
float ellipse_height = radius / ellipse_width_factor;
float cosine = unit_eigenvector.x;
float sine = unit_eigenvector.y;
mat2 inverse_ellipse_matrix = mat2(
vec2(cosine / ellipse_width, -sine / ellipse_height),
vec2(sine / ellipse_width, cosine / ellipse_height));
vec2 ellipse_major_axis = ellipse_width * unit_eigenvector;
vec2 ellipse_minor_axis = ellipse_height * unit_eigenvector.yx * vec2(-1, 1);
ivec2 ellipse_bounds = ivec2( ceil(sqrt(square2(ellipse_major_axis) + square2(ellipse_minor_axis))));
const int number_of_sectors = 8;
float sector_center_overlap_parameter = 2.0 / radius;
float sector_envelope_angle = ((3.0 / 2.0) * M_PI) / float(number_of_sectors);
float cross_sector_overlap_parameter = (sector_center_overlap_parameter +
cos(sector_envelope_angle)) /
square(sin(sector_envelope_angle));
vec4 weighted_mean_of_squared_color_of_sectors[8];
vec4 weighted_mean_of_color_of_sectors[8];
float sum_of_weights_of_sectors[8];
vec4 center_color = o14_0_0_rgba;
vec4 center_color_squared = center_color * center_color;
float center_weight = 1.0 / float(number_of_sectors);
vec4 weighted_center_color = center_color * center_weight;
vec4 weighted_center_color_squared = center_color_squared * center_weight;
for (int i = 0; i < number_of_sectors; i++) {
weighted_mean_of_squared_color_of_sectors[i] = weighted_center_color_squared;
weighted_mean_of_color_of_sectors[i] = weighted_center_color;
sum_of_weights_of_sectors[i] = center_weight;
}
for (int j = 0; j <= ellipse_bounds.y; j++) {
for (int i = -ellipse_bounds.x; i <= ellipse_bounds.x; i++) {
if (j == 0 && i <= 0) {
continue;
}
vec2 disk_point = inverse_ellipse_matrix * vec2(float(i), float(j));
float disk_point_length_squared = dot(disk_point, disk_point);
if (disk_point_length_squared > 1.0) {
continue;
}
float sector_weights[8];
vec2 polynomial = sector_center_overlap_parameter -
cross_sector_overlap_parameter * square2(disk_point);
sector_weights[0] = square(max(0.0, disk_point.y + polynomial.x));
sector_weights[2] = square(max(0.0, -disk_point.x + polynomial.y));
sector_weights[4] = square(max(0.0, -disk_point.y + polynomial.x));
sector_weights[6] = square(max(0.0, disk_point.x + polynomial.y));
vec2 rotated_disk_point = M_SQRT1_2 *
vec2(disk_point.x - disk_point.y, disk_point.x + disk_point.y);
vec2 rotated_polynomial = sector_center_overlap_parameter -
cross_sector_overlap_parameter * square2(rotated_disk_point);
sector_weights[1] = square(max(0.0, rotated_disk_point.y + rotated_polynomial.x));
sector_weights[3] = square(max(0.0, -rotated_disk_point.x + rotated_polynomial.y));
sector_weights[5] = square(max(0.0, -rotated_disk_point.y + rotated_polynomial.x));
sector_weights[7] = square(max(0.0, rotated_disk_point.x + rotated_polynomial.y));
float sector_weights_sum = sector_weights[0] + sector_weights[1] + sector_weights[2] +
sector_weights[3] + sector_weights[4] + sector_weights[5] +
sector_weights[6] + sector_weights[7];
float radial_gaussian_weight = exp(-M_PI * disk_point_length_squared) / sector_weights_sum;
vec4 upper_color = o14_0_0_rgba;
vec4 lower_color = o14_0_0_rgba;
vec4 upper_color_squared = upper_color * upper_color;
vec4 lower_color_squared = lower_color * lower_color;
for (int k = 0; k < number_of_sectors; k++) {
float weight = sector_weights[k] * radial_gaussian_weight;
int upper_index = k;
sum_of_weights_of_sectors[upper_index] += weight;
weighted_mean_of_color_of_sectors[upper_index] += upper_color * weight;
weighted_mean_of_squared_color_of_sectors[upper_index] += upper_color_squared * weight;
int lower_index = (k + number_of_sectors / 2) % number_of_sectors;
sum_of_weights_of_sectors[lower_index] += weight;
weighted_mean_of_color_of_sectors[lower_index] += lower_color * weight;
weighted_mean_of_squared_color_of_sectors[lower_index] += lower_color_squared * weight;
}
}
}
float sum_of_weights = 0.0;
vec4 weighted_sum = vec4(0.0);
for (int i = 0; i < number_of_sectors; i++) {
weighted_mean_of_color_of_sectors[i] /= sum_of_weights_of_sectors[i];
weighted_mean_of_squared_color_of_sectors[i] /= sum_of_weights_of_sectors[i];
vec4 color_mean = weighted_mean_of_color_of_sectors[i];
vec4 squared_color_mean = weighted_mean_of_squared_color_of_sectors[i];
vec4 color_variance = abs(squared_color_mean - color_mean * color_mean);
float standard_deviation = dot(sqrt(color_variance.rgb), vec3(1.0));
float weight = 1.0 / pow(max(0.02, standard_deviation), sharpness);
sum_of_weights += weight;
weighted_sum += color_mean * weight;
}
weighted_sum /= sum_of_weights;
return weighted_sum;
}
// instance: o53
vec4 tiler_o53(vec2 uv, vec2 tile, int overlap, vec2 _seed) {
float c = 0.0;
vec3 rc = vec3(0.0);
vec3 rc1;
for (int dx = -overlap; dx <= overlap; ++dx) {
for (int dy = -overlap; dy <= overlap; ++dy) {
vec2 pos = uv*tile+vec2(float(dx), float(dy)); pos = fract((floor(mod(pos, tile))+vec2(0.5))/tile)-vec2(0.5);
vec2 seed = rand2(pos+_seed);
rc1 = rand3(seed);
pos = fract(pos+vec2(0.000000/tile.x, 0.0)*floor(mod(pos.y*tile.y, 2.0))+1.000000*seed/tile);
float mask = (o56_0_0_rgba).r(fract(pos+vec2(0.5)));
if (mask > 0.01) {
vec2 pv = fract(uv - pos)-vec2(0.5);
seed = rand2(seed);
float angle = (seed.x * 2.0 - 1.0) * 0.000000 * 0.01745329251;
float ca = cos(angle);
float sa = sin(angle);
pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
pv *= (seed.y-0.5)*2.0*0.700000+1.0;
pv /= vec2(0.004 / /*?d_scale*/0.0, 0.004 / /*?d_scale*/0.0);
pv += vec2(0.5);
seed = rand2(seed);
vec2 clamped_pv = clamp(pv, vec2(0.0), vec2(1.0));
if (pv.x != clamped_pv.x || pv.y != clamped_pv.y) {
continue;
}
float c1 = o54_0_0_f*mask*(1.0-0.860000*seed.x);
//c = max(c, c1);
c = c + c1;
rc = mix(rc, rc1, step(c, c1));
}
}
}
return vec4(rc, c);
}
// instance: o69
vec4 o69_blur(vec2 uv, vec2 scale, float sigma, int quality) {
vec4 O = vec4(0.0);
float samples = sigma * 4.0;
int LOD = max(0, int(log2(float(samples)))-quality-2);
int sLOD = 1 << LOD;
int s = max(1, int(samples/float(sLOD)));
float sum = 0.0;
for (int i = 0; i < s*s; i++) {
vec2 d = vec2(float(i%s), float(i/s))*float(sLOD) - 0.5*float(samples);
vec2 dd = d / sigma;
float g = exp(-.5*dot(dd,dd))/(6.28*sigma*sigma);
O += g * textureLod(o71_0_0_rgba.texture, uv + scale * d, float(LOD));
sum += g;
}
return O / sum;
}
// instance: o77
vec4 o77_blur(vec2 uv, vec2 scale, float sigma, int quality) {
vec4 O = vec4(0.0);
float samples = sigma * 4.0;
int LOD = max(0, int(log2(float(samples)))-quality-2);
int sLOD = 1 << LOD;
int s = max(1, int(samples/float(sLOD)));
float sum = 0.0;
for (int i = 0; i < s*s; i++) {
vec2 d = vec2(float(i%s), float(i/s))*float(sLOD) - 0.5*float(samples);
vec2 dd = d / sigma;
float g = exp(-.5*dot(dd,dd))/(6.28*sigma*sigma);
O += g * textureLod(o79_0_0_rgba.texture, uv + scale * d, float(LOD));
sum += g;
}
return O / sum;
}
// instance: o85
vec4 o85_blur(vec2 uv, vec2 scale, float sigma, int quality) {
vec4 O = vec4(0.0);
float samples = sigma * 4.0;
int LOD = max(0, int(log2(float(samples)))-quality-2);
int sLOD = 1 << LOD;
int s = max(1, int(samples/float(sLOD)));
float sum = 0.0;
for (int i = 0; i < s*s; i++) {
vec2 d = vec2(float(i%s), float(i/s))*float(sLOD) - 0.5*float(samples);
vec2 dd = d / sigma;
float g = exp(-.5*dot(dd,dd))/(6.28*sigma*sigma);
O += g * textureLod(o87_0_0_rgba.texture, uv + scale * d, float(LOD));
sum += g;
}
return O / sum;
}
// instance: o93
vec4 o93_blur(vec2 uv, vec2 scale, float sigma, int quality) {
vec4 O = vec4(0.0);
float samples = sigma * 4.0;
int LOD = max(0, int(log2(float(samples)))-quality-2);
int sLOD = 1 << LOD;
int s = max(1, int(samples/float(sLOD)));
float sum = 0.0;
for (int i = 0; i < s*s; i++) {
vec2 d = vec2(float(i%s), float(i/s))*float(sLOD) - 0.5*float(samples);
vec2 dd = d / sigma;
float g = exp(-.5*dot(dd,dd))/(6.28*sigma*sigma);
O += g * textureLod(o95_0_0_rgba.texture, uv + scale * d, float(LOD));
sum += g;
}
return O / sum;
}
// instance: o100
vec4 o100_blur(vec2 uv, vec2 scale, float sigma, int quality) {
vec4 O = vec4(0.0);
float samples = sigma * 4.0;
int LOD = max(0, int(log2(float(samples)))-quality-2);
int sLOD = 1 << LOD;
int s = max(1, int(samples/float(sLOD)));
float sum = 0.0;
for (int i = 0; i < s*s; i++) {
vec2 d = vec2(float(i%s), float(i/s))*float(sLOD) - 0.5*float(samples);
vec2 dd = d / sigma;
float g = exp(-.5*dot(dd,dd))/(6.28*sigma*sigma);
O += g * textureLod(o102_0_0_rgba.texture, uv + scale * d, float(LOD));
sum += g;
}
return O / sum;
}
// instance: o129
vec2 o129_slope(vec2 uv, float epsilon) {
return vec2(o133_0_0_f-o133_0_0_f, o133_0_0_f-o133_0_0_f);
}
// instance: o127
vec4 tiler_o127(vec2 uv, vec2 tile, int overlap, inout vec3 instance_uv, vec2 _seed) {
float c = 0.0;
vec3 rc = vec3(0.0);
vec3 rc1;
for (int dx = -overlap; dx <= overlap; ++dx) {
for (int dy = -overlap; dy <= overlap; ++dy) {
vec2 pos = uv*tile+vec2(float(dx), float(dy)); pos = fract((floor(mod(pos, tile))+vec2(0.5))/tile)-vec2(0.5);
vec2 seed = rand2(pos+_seed);
rc1 = rand3(seed);
vec2 tile_index = floor(uv * tile) + vec2(float(dx), float(dy));
pos += vec2((0.000000/tile.x)*mod(mod(tile_index.y, tile.y), 2.0), 0.0)+1.000000*seed/tile;
float mask = 1.0(fract(pos+vec2(0.5)));
if (mask > 0.01) {
vec2 pv = fract(uv - pos)-vec2(0.5);
seed = rand2(seed);
float angle = (seed.x * 2.0 - 1.0) * 118.100000 * 0.01745329251;
float ca = cos(angle);
float sa = sin(angle);
pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
pv *= (seed.y-0.5)*2.0*0.510000+1.0;
pv /= vec2(0.390000, 0.390000);
pv += vec2(0.5);
seed = rand2(seed);
vec2 clamped_pv = clamp(pv, vec2(0.0), vec2(1.0));
if (pv.x != clamped_pv.x || pv.y != clamped_pv.y) {
continue;
}
vec2 full_uv = pv;
pv = get_from_tileset( 1.0, seed.x, pv);
float c1 = (o128_0_0_rgba).r*mask*(1.0-1.000000*seed.x);
c = max(c, c1);
rc = mix(rc, rc1, step(c, c1));
instance_uv = mix(instance_uv, vec3(full_uv, seed.x), step(c, c1));
}
}
}
return vec4(rc, c);
}
// instance: o126
vec2 o126_slope(vec2 uv, float epsilon) {
return vec2(o144_0_0_f-o144_0_0_f, o144_0_0_f-o144_0_0_f);
}
// instance: o167
vec4 tiler_o167(vec2 uv, vec2 tile, int overlap, inout vec3 instance_uv, vec2 _seed) {
float c = 0.0;
vec3 rc = vec3(0.0);
vec3 rc1;
for (int dx = -overlap; dx <= overlap; ++dx) {
for (int dy = -overlap; dy <= overlap; ++dy) {
vec2 pos = uv*tile+vec2(float(dx), float(dy)); pos = fract((floor(mod(pos, tile))+vec2(0.5))/tile)-vec2(0.5);
vec2 seed = rand2(pos+_seed);
rc1 = rand3(seed);
vec2 tile_index = floor(uv * tile) + vec2(float(dx), float(dy));
pos += vec2((0.000000/tile.x)*mod(mod(tile_index.y, tile.y), 2.0), 0.0)+1.000000*seed/tile;
float mask = (o169_0_0_rgba).r(fract(pos+vec2(0.5)));
if (mask > 0.01) {
vec2 pv = fract(uv - pos)-vec2(0.5);
seed = rand2(seed);
float angle = (seed.x * 2.0 - 1.0) * 179.100000 * 0.01745329251;
float ca = cos(angle);
float sa = sin(angle);
pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
pv *= (seed.y-0.5)*2.0*0.560000+1.0;
pv /= vec2(0.080000, 0.080000);
pv += vec2(0.5);
seed = rand2(seed);
vec2 clamped_pv = clamp(pv, vec2(0.0), vec2(1.0));
if (pv.x != clamped_pv.x || pv.y != clamped_pv.y) {
continue;
}
vec2 full_uv = pv;
pv = get_from_tileset( 1.0, seed.x, pv);
float c1 = o168_0_0_f*mask*(1.0-1.000000*seed.x);
c = max(c, c1);
rc = mix(rc, rc1, step(c, c1));
instance_uv = mix(instance_uv, vec3(full_uv, seed.x), step(c, c1));
}
}
}
return vec4(rc, c);
}
// instance: o166
vec2 o166_slope(vec2 uv, float epsilon) {
return vec2(o171_0_0_f-o171_0_0_f, o171_0_0_f-o171_0_0_f);
}
// instance: o164
vec4 o164_fct(vec2 uv) {
float e = 1.0/2048.0;
//range based on 68–95–99.7 rule
float scaled_sigma = 0.190000 /10.0;
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o166_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o161
vec4 o161_fct(vec2 uv) {
float e = 1.0/2048.0;
float scaled_sigma = 0.190000/10.0;
//range based on 68–95–99.7 rule
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o164_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o156
vec2 o156_slope(vec2 uv, float epsilon) {
return vec2(o174_0_0_f-o174_0_0_f, o174_0_0_f-o174_0_0_f);
}
// instance: o121
vec4 o121_fct(vec2 uv) {
float e = 1.0/2048.0;
//range based on 68–95–99.7 rule
float scaled_sigma = 0.230000 /10.0;
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*o154_0_0_f);
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o123_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o118
vec4 o118_fct(vec2 uv) {
float e = 1.0/2048.0;
float scaled_sigma = 0.230000/10.0;
//range based on 68–95–99.7 rule
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*o154_0_0_f);
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o121_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o205
vec4 o205_fct(vec2 uv) {
float e = 1.0/2048.0;
//range based on 68–95–99.7 rule
float scaled_sigma = 0.180000 /10.0;
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o166_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o202
vec4 o202_fct(vec2 uv) {
float e = 1.0/2048.0;
float scaled_sigma = 0.180000/10.0;
//range based on 68–95–99.7 rule
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o205_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o196
vec4 o196_fct(vec2 uv) {
float e = 1.0/2048.0;
//range based on 68–95–99.7 rule
float scaled_sigma = 0.010000 /10.0;
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o198_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o193
vec4 o193_fct(vec2 uv) {
float e = 1.0/2048.0;
float scaled_sigma = 0.010000/10.0;
//range based on 68–95–99.7 rule
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o196_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o188
vec4 o188_fct(vec2 uv)
{
float e = 1.0 / 2048.0;
vec4 result = vec4(0.0);
vec4 current = o193_0_0_rgba;
float sum = 0.0;
// Multiply the sigma by the strength map.
float sigma_space = max(0.000001, 5.600000 * (o209_0_0_rgba).r(uv));
float sigma_color = max(0.000001, 0.260000 * (o209_0_0_rgba).r(uv));
// Precalculate sigma coefficients for each Gaussian function.
float coeff_space = 1.0 / (2.0 * sigma_space * sigma_space);
float coeff_color = 1.0 / (2.0 * sigma_color * sigma_color);
for (int x = -32; x <= 32; x++)
{
for (int y = -32; y <= 32; y++)
{
vec2 delta_space = vec2(float(x), float(y));
vec4 _sample = o193_0_0_rgba;
vec4 delta_color = _sample - current;
float distance_space = dot(delta_space, delta_space);
float distance_color = dot(delta_color, delta_color);
float weight = exp(-distance_space * coeff_space - distance_color * coeff_color);
result += _sample * weight;
sum += weight;
}
}
return result / sum;
}
// instance: o224
vec3 o224_fct(vec2 uv) {
float dx = 1.0/1024.0;
float v = 0.0;
vec2 slope = vec2(0.0);
int iterations = int(ceil(4.000000 * 15.000000));
iterations = max(1, iterations);
vec2 it_uv = uv;
vec3 pt_value = (o202_0_0_rgba).rgb(uv);
vec3 rv = vec3(0.0);
for(int i = 0;i<iterations;i++){
v = o226_0_0_f;
slope = vec2(o226_0_0_f-v, o226_0_0_f-v) * 2.0;
it_uv += slope * 4.000000 * 4.000000 / float(iterations);
rv += min((o202_0_0_rgba).rgb(it_uv), pt_value);
}
return rv/float(iterations);
}
// instance: o246
vec4 tiler_o246(vec2 uv, vec2 tile, int overlap, inout vec3 instance_uv, vec2 _seed) {
float c = 0.0;
vec3 rc = vec3(0.0);
vec3 rc1;
for (int dx = -overlap; dx <= overlap; ++dx) {
for (int dy = -overlap; dy <= overlap; ++dy) {
vec2 pos = uv*tile+vec2(float(dx), float(dy)); pos = fract((floor(mod(pos, tile))+vec2(0.5))/tile)-vec2(0.5);
vec2 seed = rand2(pos+_seed);
rc1 = rand3(seed);
vec2 tile_index = floor(uv * tile) + vec2(float(dx), float(dy));
pos += vec2((0.000000/tile.x)*mod(mod(tile_index.y, tile.y), 2.0), 0.0)+1.000000*seed/tile;
float mask = (o248_0_0_rgba).r(fract(pos+vec2(0.5)));
if (mask > 0.01) {
vec2 pv = fract(uv - pos)-vec2(0.5);
seed = rand2(seed);
float angle = (seed.x * 2.0 - 1.0) * 45.000000 * 0.01745329251;
float ca = cos(angle);
float sa = sin(angle);
pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
pv *= (seed.y-0.5)*2.0*0.350000+1.0;
pv /= vec2(0.020000, 0.020000);
pv += vec2(0.5);
seed = rand2(seed);
vec2 clamped_pv = clamp(pv, vec2(0.0), vec2(1.0));
if (pv.x != clamped_pv.x || pv.y != clamped_pv.y) {
continue;
}
vec2 full_uv = pv;
pv = get_from_tileset( 1.0, seed.x, pv);
float c1 = o247_0_0_f*mask*(1.0-0.310000*seed.x);
c = max(c, c1);
rc = mix(rc, rc1, step(c, c1));
instance_uv = mix(instance_uv, vec3(full_uv, seed.x), step(c, c1));
}
}
}
return vec4(rc, c);
}
// instance: o251
vec4 tiler_o251(vec2 uv, vec2 tile, int overlap, inout vec3 instance_uv, vec2 _seed) {
float c = 0.0;
vec3 rc = vec3(0.0);
vec3 rc1;
for (int dx = -overlap; dx <= overlap; ++dx) {
for (int dy = -overlap; dy <= overlap; ++dy) {
vec2 pos = uv*tile+vec2(float(dx), float(dy)); pos = fract((floor(mod(pos, tile))+vec2(0.5))/tile)-vec2(0.5);
vec2 seed = rand2(pos+_seed);
rc1 = rand3(seed);
vec2 tile_index = floor(uv * tile) + vec2(float(dx), float(dy));
pos += vec2((0.000000/tile.x)*mod(mod(tile_index.y, tile.y), 2.0), 0.0)+1.000000*seed/tile;
float mask = (o253_0_0_rgba).r(fract(pos+vec2(0.5)));
if (mask > 0.01) {
vec2 pv = fract(uv - pos)-vec2(0.5);
seed = rand2(seed);
float angle = (seed.x * 2.0 - 1.0) * 45.000000 * 0.01745329251;
float ca = cos(angle);
float sa = sin(angle);
pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
pv *= (seed.y-0.5)*2.0*0.520000+1.0;
pv /= vec2(0.007000, 0.006000);
pv += vec2(0.5);
seed = rand2(seed);
vec2 clamped_pv = clamp(pv, vec2(0.0), vec2(1.0));
if (pv.x != clamped_pv.x || pv.y != clamped_pv.y) {
continue;
}
vec2 full_uv = pv;
pv = get_from_tileset( 1.0, seed.x, pv);
float c1 = o252_0_0_f*mask*(1.0-1.000000*seed.x);
c = max(c, c1);
rc = mix(rc, rc1, step(c, c1));
instance_uv = mix(instance_uv, vec3(full_uv, seed.x), step(c, c1));
}
}
}
return vec4(rc, c);
}
// instance: o255
vec4 tiler_o255(vec2 uv, vec2 tile, int overlap, inout vec3 instance_uv, vec2 _seed) {
float c = 0.0;
vec3 rc = vec3(0.0);
vec3 rc1;
for (int dx = -overlap; dx <= overlap; ++dx) {
for (int dy = -overlap; dy <= overlap; ++dy) {
vec2 pos = uv*tile+vec2(float(dx), float(dy)); pos = fract((floor(mod(pos, tile))+vec2(0.5))/tile)-vec2(0.5);
vec2 seed = rand2(pos+_seed);
rc1 = rand3(seed);
vec2 tile_index = floor(uv * tile) + vec2(float(dx), float(dy));
pos += vec2((0.000000/tile.x)*mod(mod(tile_index.y, tile.y), 2.0), 0.0)+1.000000*seed/tile;
float mask = (o257_0_0_rgba).r(fract(pos+vec2(0.5)));
if (mask > 0.01) {
vec2 pv = fract(uv - pos)-vec2(0.5);
seed = rand2(seed);
float angle = (seed.x * 2.0 - 1.0) * 179.100000 * 0.01745329251;
float ca = cos(angle);
float sa = sin(angle);
pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
pv *= (seed.y-0.5)*2.0*0.250000+1.0;
pv /= vec2(0.060000, 0.060000);
pv += vec2(0.5);
seed = rand2(seed);
vec2 clamped_pv = clamp(pv, vec2(0.0), vec2(1.0));
if (pv.x != clamped_pv.x || pv.y != clamped_pv.y) {
continue;
}
vec2 full_uv = pv;
pv = get_from_tileset( 1.0, seed.x, pv);
float c1 = o256_0_0_f*mask*(1.0-0.000000*seed.x);
c = max(c, c1);
rc = mix(rc, rc1, step(c, c1));
instance_uv = mix(instance_uv, vec3(full_uv, seed.x), step(c, c1));
}
}
}
return vec4(rc, c);
}
// instance: o267
vec4 o267_fct(vec2 uv) {
float e = 1.0/2048.0;
//range based on 68–95–99.7 rule
float scaled_sigma = 0.350000 /10.0;
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += vec4(vec3(o154_0_0_f), 1.0)(uv+vec2(i, 0.0))*coef;
sum += coef;
}
return rv/sum;
}
// instance: o264
vec4 o264_fct(vec2 uv) {
float e = 1.0/2048.0;
float scaled_sigma = 0.350000/10.0;
//range based on 68–95–99.7 rule
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o267_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o279
vec4 o279_fct(vec2 uv) {
float e = 1.0/2048.0;
//range based on 68–95–99.7 rule
float scaled_sigma = 0.480000 /10.0;
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += vec4(vec3(o281_0_0_f), 1.0)(uv+vec2(i, 0.0))*coef;
sum += coef;
}
return rv/sum;
}
// instance: o276
vec4 o276_fct(vec2 uv) {
float e = 1.0/2048.0;
float scaled_sigma = 0.480000/10.0;
//range based on 68–95–99.7 rule
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o279_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o255
// instance: o314
vec3 nm_o314(vec2 uv, float amount, float size) {
vec3 e = vec3(1.0/size, -1.0/size, 0);
vec2 rv;
if (0 == 0) {
rv = vec2(1.0, -1.0)*o317_0_0_f;
rv += vec2(-1.0, 1.0)*o317_0_0_f;
rv += vec2(1.0, 1.0)*o317_0_0_f;
rv += vec2(-1.0, -1.0)*o317_0_0_f;
rv += vec2(2.0, 0.0)*o317_0_0_f;
rv += vec2(-2.0, 0.0)*o317_0_0_f;
rv += vec2(0.0, 2.0)*o317_0_0_f;
rv += vec2(0.0, -2.0)*o317_0_0_f;
rv *= size*amount/128.0;
} else if (0 == 1) {
rv = vec2(3.0, -3.0)*o317_0_0_f;
rv += vec2(-3.0, 3.0)*o317_0_0_f;
rv += vec2(3.0, 3.0)*o317_0_0_f;
rv += vec2(-3.0, -3.0)*o317_0_0_f;
rv += vec2(10.0, 0.0)*o317_0_0_f;
rv += vec2(-10.0, 0.0)*o317_0_0_f;
rv += vec2(0.0, 10.0)*o317_0_0_f;
rv += vec2(0.0, -10.0)*o317_0_0_f;
rv *= size*amount/512.0;
} else if (0 == 2) {
rv = vec2(2.0, 0.0)*o317_0_0_f;
rv += vec2(-2.0, 0.0)*o317_0_0_f;
rv += vec2(0.0, 2.0)*o317_0_0_f;
rv += vec2(0.0, -2.0)*o317_0_0_f;
rv *= size*amount/64.0;
} else {
rv = vec2(1.0, 0.0)*o317_0_0_f;
rv += vec2(0.0, 1.0)*o317_0_0_f;
rv += vec2(-1.0, -1.0)*o317_0_0_f;
rv *= size*amount/20.0;
}
return vec3(0.5)+0.5*normalize(vec3(rv, -1.0));
}
// instance: o310
vec4 o310_func(vec2 uv, float n, float amp)
{
vec2 nm = o312_0_0_rgba.xy;
vec2 ofs = (nm - vec2(0.5)) * amp;
for (float i=1.; i<n; i++)
{
ofs = (o312_0_0_rgba.xy - vec2(0.5)) * amp;
amp*= 2.0;
}
//(o312_0_0_rgba.xy - vec2(0.5));
return vec4(vec3(o311_0_0_f), 1.0)(uv + ofs);
}
// instance: o321
vec3 nm_o321(vec2 uv, float amount, float size) {
vec3 e = vec3(1.0/size, -1.0/size, 0);
vec2 rv;
if (0 == 0) {
rv = vec2(1.0, -1.0)*o324_0_0_f;
rv += vec2(-1.0, 1.0)*o324_0_0_f;
rv += vec2(1.0, 1.0)*o324_0_0_f;
rv += vec2(-1.0, -1.0)*o324_0_0_f;
rv += vec2(2.0, 0.0)*o324_0_0_f;
rv += vec2(-2.0, 0.0)*o324_0_0_f;
rv += vec2(0.0, 2.0)*o324_0_0_f;
rv += vec2(0.0, -2.0)*o324_0_0_f;
rv *= size*amount/128.0;
} else if (0 == 1) {
rv = vec2(3.0, -3.0)*o324_0_0_f;
rv += vec2(-3.0, 3.0)*o324_0_0_f;
rv += vec2(3.0, 3.0)*o324_0_0_f;
rv += vec2(-3.0, -3.0)*o324_0_0_f;
rv += vec2(10.0, 0.0)*o324_0_0_f;
rv += vec2(-10.0, 0.0)*o324_0_0_f;
rv += vec2(0.0, 10.0)*o324_0_0_f;
rv += vec2(0.0, -10.0)*o324_0_0_f;
rv *= size*amount/512.0;
} else if (0 == 2) {
rv = vec2(2.0, 0.0)*o324_0_0_f;
rv += vec2(-2.0, 0.0)*o324_0_0_f;
rv += vec2(0.0, 2.0)*o324_0_0_f;
rv += vec2(0.0, -2.0)*o324_0_0_f;
rv *= size*amount/64.0;
} else {
rv = vec2(1.0, 0.0)*o324_0_0_f;
rv += vec2(0.0, 1.0)*o324_0_0_f;
rv += vec2(-1.0, -1.0)*o324_0_0_f;
rv *= size*amount/20.0;
}
return vec3(0.5)+0.5*normalize(vec3(rv, -1.0));
}
// instance: o309
vec4 o309_func(vec2 uv, float n, float amp)
{
vec2 nm = o319_0_0_rgba.xy;
vec2 ofs = (nm - vec2(0.5)) * amp;
for (float i=1.; i<n; i++)
{
ofs = (o319_0_0_rgba.xy - vec2(0.5)) * amp;
amp*= 2.0;
}
//(o319_0_0_rgba.xy - vec2(0.5));
return o310_0_0_rgba;
}
// instance: o307
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Copyright (c) 2018-2019 Michele Morrone
// All rights reserved.
//
// https://michelemorrone.eu - https://BrutPitt.com
//
// me@michelemorrone.eu - brutpitt@gmail.com
// twitter: @BrutPitt - github: BrutPitt
//
// https://github.com/BrutPitt/glslSmartDeNoise/
//
// This software is distributed under the terms of the BSD 2-Clause license
// Adapted for Material Maker by wojtekpil
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// smartDeNoise - parameters
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// sampler2D tex - sampler image / texture
// vec2 uv - actual fragment coord
// float sigma > 0 - sigma Standard Deviation
// float kSigma >= 0 - sigma coefficient
// kSigma * sigma --> radius of the circular kernel
// float threshold - edge sharpening threshold
vec4 o307_smartDeNoise(vec2 uv, float sigma, float kSigma, float threshold)
{
float INV_SQRT_OF_2PI = 0.39894228040143267793994605993439; // 1.0/SQRT_OF_2PI
float INV_PI = 0.31830988618379067153776752674503;
float radius = round(kSigma*sigma);
float radQ = radius * radius;
float invSigmaQx2 = .5 / (sigma * sigma); // 1.0 / (sigma^2 * 2.0)
float invSigmaQx2PI = INV_PI * invSigmaQx2; // 1/(2 * PI * sigma^2)
float invThresholdSqx2 = .5 / (threshold * threshold); // 1.0 / (sigma^2 * 2.0)
float invThresholdSqrt2PI = INV_SQRT_OF_2PI / threshold; // 1.0 / (sqrt(2*PI) * sigma^2)
vec4 centrPx = o309_0_0_rgba;
float zBuff = 0.0;
vec4 aBuff = vec4(0.0);
vec2 size = vec2(1024.0, 1024.0);
vec2 d;
for (d.x=-radius; d.x <= radius; d.x++) {
float pt = sqrt(radQ-d.x*d.x); // pt = yRadius: have circular trend
for (d.y=-pt; d.y <= pt; d.y++) {
float blurFactor = exp( -dot(d , d) * invSigmaQx2 ) * invSigmaQx2PI;
vec4 walkPx = o309_0_0_rgba;
vec4 dC = walkPx-centrPx;
float deltaFactor = exp( -dot(dC, dC) * invThresholdSqx2) * invThresholdSqrt2PI * blurFactor;
zBuff += deltaFactor;
aBuff += deltaFactor*walkPx;
}
}
return aBuff/zBuff;
}
// instance: o338
vec4 o338_fct(vec2 uv) {
float e = 1.0/2048.0;
//range based on 68–95–99.7 rule
float scaled_sigma = 0.120000 /10.0;
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += vec4(vec3(o341_0_0_f), 1.0)(uv+vec2(i, 0.0))*coef;
sum += coef;
}
return rv/sum;
}
// instance: o335
vec4 o335_fct(vec2 uv) {
float e = 1.0/2048.0;
float scaled_sigma = 0.120000/10.0;
//range based on 68–95–99.7 rule
float sampling_range = scaled_sigma*3.0;
vec4 rv = vec4(0.0);
float sum = 0.0;
float sigma = max(0.000015, scaled_sigma*0.0(uv));
float mapped_quality = 1.0 + (100.000000 - 1.0) * (2048.0 - 1.0) / (100.0 - 1.0);
float step_size = max(e,1.0/mapped_quality);
//maxium number of loop iterations = 1024
step_size = max(sampling_range*2.0/1024.0,step_size);
step_size -= mod(step_size, e);
float coef_diff = 6.28318530718*sigma*sigma;
for (float i = -sampling_range; i <= sampling_range; i += step_size) {
float i_sigma = i/sigma;
float coef = exp(-0.5*i_sigma*i_sigma)/coef_diff;
rv += o338_0_0_rgba*coef;
sum += coef;
}
return rv/sum;
}
// instance: o328
vec3 nm_o328(vec2 uv, float amount, float size) {
vec3 e = vec3(1.0/size, -1.0/size, 0);
vec2 rv;
if (0 == 0) {
rv = vec2(1.0, -1.0)*o331_0_0_f;
rv += vec2(-1.0, 1.0)*o331_0_0_f;
rv += vec2(1.0, 1.0)*o331_0_0_f;
rv += vec2(-1.0, -1.0)*o331_0_0_f;
rv += vec2(2.0, 0.0)*o331_0_0_f;
rv += vec2(-2.0, 0.0)*o331_0_0_f;
rv += vec2(0.0, 2.0)*o331_0_0_f;
rv += vec2(0.0, -2.0)*o331_0_0_f;
rv *= size*amount/128.0;
} else if (0 == 1) {
rv = vec2(3.0, -3.0)*o331_0_0_f;
rv += vec2(-3.0, 3.0)*o331_0_0_f;
rv += vec2(3.0, 3.0)*o331_0_0_f;
rv += vec2(-3.0, -3.0)*o331_0_0_f;
rv += vec2(10.0, 0.0)*o331_0_0_f;
rv += vec2(-10.0, 0.0)*o331_0_0_f;
rv += vec2(0.0, 10.0)*o331_0_0_f;
rv += vec2(0.0, -10.0)*o331_0_0_f;
rv *= size*amount/512.0;
} else if (0 == 2) {
rv = vec2(2.0, 0.0)*o331_0_0_f;
rv += vec2(-2.0, 0.0)*o331_0_0_f;
rv += vec2(0.0, 2.0)*o331_0_0_f;
rv += vec2(0.0, -2.0)*o331_0_0_f;
rv *= size*amount/64.0;
} else {
rv = vec2(1.0, 0.0)*o331_0_0_f;
rv += vec2(0.0, 1.0)*o331_0_0_f;
rv += vec2(-1.0, -1.0)*o331_0_0_f;
rv *= size*amount/20.0;
}
return vec3(0.5)+0.5*normalize(vec3(rv, -1.0));
}
// instance: o304
vec4 o304_func(vec2 uv, float n, float amp)
{
vec2 nm = o326_0_0_rgba.xy;
vec2 ofs = (nm - vec2(0.5)) * amp;
for (float i=1.; i<n; i++)
{
ofs = (o326_0_0_rgba.xy - vec2(0.5)) * amp;
amp*= 2.0;
}
//(o326_0_0_rgba.xy - vec2(0.5));
return o307_0_0_rgba;
}
// instance: o367
float o367_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o368
float o368_fbm(vec2 coord, vec2 size, int folds, int octaves, float persistence, float seed) {
float normalize_factor = 0.0;
float value = 0.0;
float scale = 1.0;
for (int i = 0; i < octaves; i++) {
float noise = oldfbm_perlin(coord*size, size, seed);
for (int f = 0; f < folds; ++f) {
noise = abs(2.0*noise-1.0);
}
value += noise * scale;
normalize_factor += scale;
size *= 2.0;
scale *= persistence;
}
return value / normalize_factor;
}
// instance: o360
/*
License: GPL-2.0-or-later
https://projects.blender.org/blender/blender/src/branch/main/source/blender/compositor/
realtime_compositor/compositor_kuwahara_anisotropic.glsl
*/
vec4 o360_anisotropic_kuwahara(vec2 uv, float size, float eccentricity, float sharpness) {
float o = 1.0/512.0;
const float M_PI = 3.14159265358979323846;
const float M_SQRT1_2 = 0.70710678118654752440;
sharpness = clamp(sharpness, 0.0, 1.0);
sharpness = sharpness * sharpness * 16.0;
eccentricity = 1.0/max(0.01, eccentricity);
float dxdx = o40_0_0_rgba.x;
float dxdy = o40_0_0_rgba.y;
float dydy = o40_0_0_rgba.w;
float eigenvalue_first_term = (dxdx + dydy) / 2.0;
float eigenvalue_square_root_term = sqrt(square(dxdx - dydy) + 4.0 * square(dxdy)) / 2.0;
float first_eigenvalue = eigenvalue_first_term + eigenvalue_square_root_term;
float second_eigenvalue = eigenvalue_first_term - eigenvalue_square_root_term;
vec2 eigenvector = vec2(first_eigenvalue - dxdx, -dxdy);
float eigenvector_length = length(eigenvector);
vec2 unit_eigenvector = eigenvector_length != 0.0 ? eigenvector / eigenvector_length : vec2(1.0);
float eigenvalue_sum = first_eigenvalue + second_eigenvalue;
float eigenvalue_difference = first_eigenvalue - second_eigenvalue;
float anisotropy = eigenvalue_sum > 0.0 ? eigenvalue_difference / eigenvalue_sum : 0.0;
float radius = max(0.0, size);
float ellipse_width_factor = (eccentricity + anisotropy) / eccentricity;
float ellipse_width = ellipse_width_factor * radius;
float ellipse_height = radius / ellipse_width_factor;
float cosine = unit_eigenvector.x;
float sine = unit_eigenvector.y;
mat2 inverse_ellipse_matrix = mat2(
vec2(cosine / ellipse_width, -sine / ellipse_height),
vec2(sine / ellipse_width, cosine / ellipse_height));
vec2 ellipse_major_axis = ellipse_width * unit_eigenvector;
vec2 ellipse_minor_axis = ellipse_height * unit_eigenvector.yx * vec2(-1, 1);
ivec2 ellipse_bounds = ivec2( ceil(sqrt(square2(ellipse_major_axis) + square2(ellipse_minor_axis))));
const int number_of_sectors = 8;
float sector_center_overlap_parameter = 2.0 / radius;
float sector_envelope_angle = ((3.0 / 2.0) * M_PI) / float(number_of_sectors);
float cross_sector_overlap_parameter = (sector_center_overlap_parameter +
cos(sector_envelope_angle)) /
square(sin(sector_envelope_angle));
vec4 weighted_mean_of_squared_color_of_sectors[8];
vec4 weighted_mean_of_color_of_sectors[8];
float sum_of_weights_of_sectors[8];
vec4 center_color = o363_0_0_rgba;
vec4 center_color_squared = center_color * center_color;
float center_weight = 1.0 / float(number_of_sectors);
vec4 weighted_center_color = center_color * center_weight;
vec4 weighted_center_color_squared = center_color_squared * center_weight;
for (int i = 0; i < number_of_sectors; i++) {
weighted_mean_of_squared_color_of_sectors[i] = weighted_center_color_squared;
weighted_mean_of_color_of_sectors[i] = weighted_center_color;
sum_of_weights_of_sectors[i] = center_weight;
}
for (int j = 0; j <= ellipse_bounds.y; j++) {
for (int i = -ellipse_bounds.x; i <= ellipse_bounds.x; i++) {
if (j == 0 && i <= 0) {
continue;
}
vec2 disk_point = inverse_ellipse_matrix * vec2(float(i), float(j));
float disk_point_length_squared = dot(disk_point, disk_point);
if (disk_point_length_squared > 1.0) {
continue;
}
float sector_weights[8];
vec2 polynomial = sector_center_overlap_parameter -
cross_sector_overlap_parameter * square2(disk_point);
sector_weights[0] = square(max(0.0, disk_point.y + polynomial.x));
sector_weights[2] = square(max(0.0, -disk_point.x + polynomial.y));
sector_weights[4] = square(max(0.0, -disk_point.y + polynomial.x));
sector_weights[6] = square(max(0.0, disk_point.x + polynomial.y));
vec2 rotated_disk_point = M_SQRT1_2 *
vec2(disk_point.x - disk_point.y, disk_point.x + disk_point.y);
vec2 rotated_polynomial = sector_center_overlap_parameter -
cross_sector_overlap_parameter * square2(rotated_disk_point);
sector_weights[1] = square(max(0.0, rotated_disk_point.y + rotated_polynomial.x));
sector_weights[3] = square(max(0.0, -rotated_disk_point.x + rotated_polynomial.y));
sector_weights[5] = square(max(0.0, -rotated_disk_point.y + rotated_polynomial.x));
sector_weights[7] = square(max(0.0, rotated_disk_point.x + rotated_polynomial.y));
float sector_weights_sum = sector_weights[0] + sector_weights[1] + sector_weights[2] +
sector_weights[3] + sector_weights[4] + sector_weights[5] +
sector_weights[6] + sector_weights[7];
float radial_gaussian_weight = exp(-M_PI * disk_point_length_squared) / sector_weights_sum;
vec4 upper_color = o363_0_0_rgba;
vec4 lower_color = o363_0_0_rgba;
vec4 upper_color_squared = upper_color * upper_color;
vec4 lower_color_squared = lower_color * lower_color;
for (int k = 0; k < number_of_sectors; k++) {
float weight = sector_weights[k] * radial_gaussian_weight;
int upper_index = k;
sum_of_weights_of_sectors[upper_index] += weight;
weighted_mean_of_color_of_sectors[upper_index] += upper_color * weight;
weighted_mean_of_squared_color_of_sectors[upper_index] += upper_color_squared * weight;
int lower_index = (k + number_of_sectors / 2) % number_of_sectors;
sum_of_weights_of_sectors[lower_index] += weight;
weighted_mean_of_color_of_sectors[lower_index] += lower_color * weight;
weighted_mean_of_squared_color_of_sectors[lower_index] += lower_color_squared * weight;
}
}
}
float sum_of_weights = 0.0;
vec4 weighted_sum = vec4(0.0);
for (int i = 0; i < number_of_sectors; i++) {
weighted_mean_of_color_of_sectors[i] /= sum_of_weights_of_sectors[i];
weighted_mean_of_squared_color_of_sectors[i] /= sum_of_weights_of_sectors[i];
vec4 color_mean = weighted_mean_of_color_of_sectors[i];
vec4 squared_color_mean = weighted_mean_of_squared_color_of_sectors[i];
vec4 color_variance = abs(squared_color_mean - color_mean * color_mean);
float standard_deviation = dot(sqrt(color_variance.rgb), vec3(1.0));
float weight = 1.0 / pow(max(0.02, standard_deviation), sharpness);
sum_of_weights += weight;
weighted_sum += color_mean * weight;
}
weighted_sum /= sum_of_weights;
return weighted_sum;
}
// instance: o381
vec4 tiler_o381(vec2 uv, vec2 tile, int overlap, vec2 _seed) {
float c = 0.0;
vec3 rc = vec3(0.0);
vec3 rc1;
for (int dx = -overlap; dx <= overlap; ++dx) {
for (int dy = -overlap; dy <= overlap; ++dy) {
vec2 pos = uv*tile+vec2(float(dx), float(dy)); pos = fract((floor(mod(pos, tile))+vec2(0.5))/tile)-vec2(0.5);
vec2 seed = rand2(pos+_seed);
rc1 = rand3(seed);
pos = fract(pos+vec2(0.000000/tile.x, 0.0)*floor(mod(pos.y*tile.y, 2.0))+1.000000*seed/tile);
float mask = (o384_0_0_rgba).r(fract(pos+vec2(0.5)));
if (mask > 0.01) {
vec2 pv = fract(uv - pos)-vec2(0.5);
seed = rand2(seed);
float angle = (seed.x * 2.0 - 1.0) * 0.000000 * 0.01745329251;
float ca = cos(angle);
float sa = sin(angle);
pv = vec2(ca*pv.x+sa*pv.y, -sa*pv.x+ca*pv.y);
pv *= (seed.y-0.5)*2.0*0.700000+1.0;
pv /= vec2(0.004 / /*?d_scale*/0.0, 0.004 / /*?d_scale*/0.0);
pv += vec2(0.5);
seed = rand2(seed);
vec2 clamped_pv = clamp(pv, vec2(0.0), vec2(1.0));
if (pv.x != clamped_pv.x || pv.y != clamped_pv.y) {
continue;
}
float c1 = o382_0_0_f*mask*(1.0-0.860000*seed.x);
//c = max(c, c1);
c = c + c1;
rc = mix(rc, rc1, step(c, c1));
}
}
}
return vec4(rc, c);
}
// instance: o349
vec3 o349_fct(vec2 uv) {
vec2 e = vec2(1.0/2048.0, 0.0);
vec3 rv = 5.0*(o351_0_0_rgba).rgb(uv);
rv -= (o351_0_0_rgba).rgb(uv+e.xy);
rv -= (o351_0_0_rgba).rgb(uv-e.xy);
rv -= (o351_0_0_rgba).rgb(uv+e.yx);
rv -= (o351_0_0_rgba).rgb(uv-e.yx);
return rv;
}
// instance: o398
//inspired by:
//http://developer.download.nvidia.com/presentations/2008/SIGGRAPH/HBAO_SIG08b.pdf
//https://gist.github.com/dotModded/981206ae1f4e760b7348
//https://github.com/scanberg/hbao/blob/master/resources/shaders/hbao_full_frag.glsl
//radius - radius of influence in screen space
//angleBiasDeg - ~minimum angle for AO
//intensity - increase strength of caclulated AO
//noiseScale - for randomization values
float o398_hbao(vec2 uv, float radius, float angleBiasDeg, float intensity, vec2 noiseScale) {
int samplig_directions = 8;
int steps = int(4.000000);
float angleBias = 0.0174532925 * angleBiasDeg;
vec2 epsilon = vec2(0.001, 0.0);
vec3 c_point = vec3(uv*2.0 - 1.0, (o110_0_0_rgba).r(uv)*0.080000);
vec2 uvpdx = uv+epsilon;
vec2 uvpdy = uv+epsilon.yx;
vec3 c_point_pdx = vec3(uvpdx*2.0 - 1.0, (o110_0_0_rgba).r(uvpdx)*0.080000);
vec3 c_point_pdy = vec3(uvpdy*2.0 - 1.0, (o110_0_0_rgba).r(uvpdy)*0.080000);
//fun with dfdx & dfdy - https://community.khronos.org/t/getting-the-normal-with-dfdx-and-dfdy/70177
vec3 c_normal = normalize(cross(c_point_pdx-c_point, c_point_pdy-c_point));
float cosMaxRot = cos(6.28318530718 / float(samplig_directions));
float sinMaxROt = sin(6.28318530718 / float(samplig_directions));
// it should be faster than standard rotation in each iteartion
mat2 deltaRotationMatrix = mat2(
vec2(cosMaxRot, -sinMaxROt),
vec2(sinMaxROt, cosMaxRot)
);
// calculate starting offset, as the smallest step
vec2 offset_uv = vec2(1.0, 0.0) * (radius /float(steps));
//randomize angle
vec3 sampleNoise = rand3(uv * noiseScale);
sampleNoise.xy = sampleNoise.xy * 2.0 - vec2(1.0);
mat2 rotationMatrix = mat2(vec2(sampleNoise.x, -sampleNoise.y),
vec2(sampleNoise.y, sampleNoise.x));
// apply a random rotation to the base step vector
offset_uv = rotationMatrix * offset_uv;
float jitter = sampleNoise.z;
float occlusion = 0.0;
for (int i = 0; i < samplig_directions; ++i) {
// incrementally rotate sample direction
offset_uv = deltaRotationMatrix * offset_uv;
float oldAngle = angleBias;
for (int j = 0; j < steps; ++j) {
//add jitter & distance to offset UV
vec2 sample_uv = uv + (jitter + float(j)) * offset_uv;
vec3 s_point = vec3(sample_uv*2.0 - 1.0, (o110_0_0_rgba).r(sample_uv)*0.080000);
vec3 sample_tan = (s_point - c_point); //not sure if correct, but looks ok
// 90 deg - (angle between normal from current point & sampled tangent)
//https://math.stackexchange.com/questions/654315/how-to-convert-a-dot-product-of-two-vectors-to-the-angle-between-the-vectors
float gamma = 1.57079632679 - acos(dot(c_normal, normalize(sample_tan)));
if (gamma > oldAngle) {
float value = sin(gamma) - sin(oldAngle);
float attenuation = clamp(1.0 - pow(length(sample_tan.xy)/radius, 2.0), 0.0, 1.0);
occlusion += attenuation * value;
//occlusion += value;
oldAngle = gamma;
}
}
}
occlusion = 1.0 - occlusion / float(samplig_directions);
return clamp(pow(occlusion, 1.0 + intensity), 0.0, 1.0);
}
// instance: o396
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// Copyright (c) 2018-2019 Michele Morrone
// All rights reserved.
//
// https://michelemorrone.eu - https://BrutPitt.com
//
// me@michelemorrone.eu - brutpitt@gmail.com
// twitter: @BrutPitt - github: BrutPitt
//
// https://github.com/BrutPitt/glslSmartDeNoise/
//
// This software is distributed under the terms of the BSD 2-Clause license
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
// smartDeNoise - parameters
//~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
//
// sampler2D tex - sampler image / texture
// vec2 uv - actual fragment coord
// float sigma > 0 - sigma Standard Deviation
// float kSigma >= 0 - sigma coefficient
// kSigma * sigma --> radius of the circular kernel
// float threshold - edge sharpening threshold
vec4 o396_smartDeNoise(vec2 uv, float sigma, float kSigma, float threshold)
{
float INV_SQRT_OF_2PI = 0.39894228040143267793994605993439; // 1.0/SQRT_OF_2PI
float INV_PI = 0.31830988618379067153776752674503;
float radius = round(kSigma*sigma);
float radQ = radius * radius;
float invSigmaQx2 = .5 / (sigma * sigma); // 1.0 / (sigma^2 * 2.0)
float invSigmaQx2PI = INV_PI * invSigmaQx2; // 1/(2 * PI * sigma^2)
float invThresholdSqx2 = .5 / (threshold * threshold); // 1.0 / (sigma^2 * 2.0)
float invThresholdSqrt2PI = INV_SQRT_OF_2PI / threshold; // 1.0 / (sqrt(2*PI) * sigma^2)
vec4 centrPx = vec4(vec3(o398_0_0_f), 1.0)(uv);
float zBuff = 0.0;
vec4 aBuff = vec4(0.0);
vec2 size = vec2(1024.0, 1024.0);
vec2 d;
for (d.x=-radius; d.x <= radius; d.x++) {
float pt = sqrt(radQ-d.x*d.x); // pt = yRadius: have circular trend
for (d.y=-pt; d.y <= pt; d.y++) {
float blurFactor = exp( -dot(d , d) * invSigmaQx2 ) * invSigmaQx2PI;
vec4 walkPx = vec4(vec3(o398_0_0_f), 1.0)(uv+d/size);
vec4 dC = walkPx-centrPx;
float deltaFactor = exp( -dot(dC, dC) * invThresholdSqx2) * invThresholdSqrt2PI * blurFactor;
zBuff += deltaFactor;
aBuff += deltaFactor*walkPx;
}
}
return aBuff/zBuff;
}
void fragment() {
float _seed_variation_ = variation;
vec2 uv = UV;
float o0_seed = 0.123450;
float o1_seed = 0.123450;
float o2_seed = 0.123450;
float o3_seed = 0.123450;
float o4_seed = 0.123450;
float o5_seed = 0.123450;
float o6_seed = 0.123450;
float o7_seed = 0.123450;
vec4 o7_0_0_rgba = vec4(0.295654, 0.314493, 0.437500, 1.000000);
float o8_seed = 0.123450;
float o11_seed = 0.123450;
float o14_seed = 0.123450;
float o15_seed = 0.123450;
float o16_seed = 0.123450;
float o17_seed = 0.123450;
float o18_seed = 0.123450;
float o18_0_0_f = o18_fbm(uv, vec2(4.000000, 6.000000), int(0.000000), int(15.000000), 0.620000, float((float(o18_seed) + fract(_seed_variation_))));
float o19_seed = 0.123450;
float o19_0_0_f = o19_fbm(uv, vec2(6.000000, 4.000000), int(0.000000), int(15.000000), 0.620000, float((float(o19_seed) + fract(_seed_variation_))));
float o22_seed = 0.123450;
float o23_seed = 0.123450;
float o23_0_0_f = o23_fbm(uv, vec2(6.000000, 4.000000), int(0.000000), int(15.000000), 0.620000, float((float(o23_seed) + fract(_seed_variation_))));
float o24_seed = 0.123450;
float o24_0_0_f = o24_fbm(uv, vec2(6.000000, 4.000000), int(0.000000), int(15.000000), 0.620000, float((float(o24_seed) + fract(_seed_variation_))));
float o25_seed = 0.123450;
float o25_0_0_f = o25_fbm(uv, vec2(6.000000, 4.000000), int(0.000000), int(15.000000), 0.620000, float((float(o25_seed) + fract(_seed_variation_))));
vec4 o22_0_0_rgba = vec4(o23_0_0_f, o24_0_0_f, o25_0_0_f, 1.0(uv));
// shader: _sg13_791_2
vec2 o17_warp_1 = uv + 2.000000 * vec2(0.500000*(o22_0_0_rgba).rgb(uv).r, -0.500000*(o22_0_0_rgba).rgb(uv).g);
vec2 o17_warp_2 = uv - 2.000000 * vec2(0.500000*(o22_0_0_rgba).rgb(uv).g, -0.500000*(o22_0_0_rgba).rgb(uv).r);
// vec2 o17_mingle = vec2(/*?mingle_strength*/0.0*/*?mingle_u*/0.0, /*?mingle_strength*/0.0*/*?mingle_v*/0.0);
//float o17_blend = smoothstep(mingle_/*?mingle_mode*/0.0, 0.5);
float o17_blend = smoothstep(0.500000-0.500000, 0.500000+0.500000, (o22_0_0_rgba).rgb(uv).b);
vec3 o17_0_0_rgb = blend_burn( uv, vec3(o18_0_0_f)(o17_warp_1), vec3(o19_0_0_f)(o17_warp_2), 1.000000*o17_blend );
float o26_seed = 0.123450;
float o29_seed = 0.123450;
float o30_seed = 0.123450;
float o30_0_0_f = o30_fbm(uv, vec2(4.000000, 6.000000), int(0.000000), int(15.000000), 0.620000, float((float(o30_seed) + fract(_seed_variation_))));
float o31_seed = 0.123450;
float o31_0_0_f = o31_fbm(uv, vec2(4.000000, 6.000000), int(0.000000), int(15.000000), 0.620000, float((float(o31_seed) + fract(_seed_variation_))));
float o32_seed = 0.123450;
float o32_0_0_f = o32_fbm(uv, vec2(4.000000, 6.000000), int(0.000000), int(15.000000), 0.620000, float((float(o32_seed) + fract(_seed_variation_))));
vec4 o29_0_0_rgba = vec4(o30_0_0_f, o31_0_0_f, o32_0_0_f, 1.0(uv));
// shader: _sg13_791_3
vec2 o26_warp_1 = uv + 2.000000 * vec2((-0.500000)*(o29_0_0_rgba).rgb(uv).r, -(-0.500000)*(o29_0_0_rgba).rgb(uv).g);
vec2 o26_warp_2 = uv - 2.000000 * vec2((-0.500000)*(o29_0_0_rgba).rgb(uv).g, -(-0.500000)*(o29_0_0_rgba).rgb(uv).r);
// vec2 o26_mingle = vec2(/*?mingle_strength*/0.0*/*?mingle_u*/0.0, /*?mingle_strength*/0.0*/*?mingle_v*/0.0);
//float o26_blend = smoothstep(mingle_/*?mingle_mode*/0.0, 0.5);
float o26_blend = smoothstep(0.500000-0.500000, 0.500000+0.500000, (o29_0_0_rgba).rgb(uv).b);
vec3 o26_0_0_rgb = blend_dodge( uv, vec3(o19_0_0_f)(o26_warp_1), vec3(o18_0_0_f)(o26_warp_2), 1.000000*o26_blend );
float o33_seed = 0.123450;
float o34_seed = 0.123450;
float o34_0_0_f = o34_fbm(uv, vec2(4.000000, 6.000000), int(0.000000), int(15.000000), 0.620000, float((float(o34_seed) + fract(_seed_variation_))));
vec4 o33_0_0_rgba = vec4(o30_0_0_f, o31_0_0_f, o32_0_0_f, o34_0_0_f);
// shader: _sg13_791_4
vec2 o16_warp_1 = uv + 2.000000 * vec2(0.500000*o33_0_0_rgba.r, -(-0.500000)*o33_0_0_rgba.g);
vec2 o16_warp_2 = uv - 2.000000 * vec2(0.500000*o33_0_0_rgba.g, -(-0.500000)*o33_0_0_rgba.r);
float o16_blend_1 = smoothstep(0.500000-0.500000, 0.500000+0.500000, o33_0_0_rgba.b);
float o16_blend_2 = smoothstep(0.500000-0.500000, 0.500000+0.500000, o33_0_0_rgba.b);
vec3 o16_0_0_rgb = blend_overlay( uv, o17_0_0_rgb, o26_0_0_rgb, 1.000000*o16_blend_1 );
float o16_seed = 0.123450;
// shader: _sg13_791_4
vec2 o16_warp_1 = uv + 2.000000 * vec2(0.500000*o33_0_0_rgba.r, -(-0.500000)*o33_0_0_rgba.g);
vec2 o16_warp_2 = uv - 2.000000 * vec2(0.500000*o33_0_0_rgba.g, -(-0.500000)*o33_0_0_rgba.r);
float o16_blend_1 = smoothstep(0.500000-0.500000, 0.500000+0.500000, o33_0_0_rgba.b);
float o16_blend_2 = smoothstep(0.500000-0.500000, 0.500000+0.500000, o33_0_0_rgba.b);
vec3 o16_1_0_rgb = blend_overlay( uv, o17_0_0_rgb, o26_0_0_rgb, 1.000000*o16_blend_2 );
float o35_seed = 0.123450;
// tones_step: _sg13_tones_step
vec3 o35_false = clamp((vec4(vec3(o18_0_0_f), 1.0)(uv).rgb-vec3(0.500000))/max(0.0001, 0.660000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o35_true = vec3(1.0)-o35_false;
vec4 o35_0_0_rgba = vec4(o35_false, vec4(vec3(o18_0_0_f), 1.0)(uv).a);
// blend: _sg13_blend
vec4 o15_s1 = vec4(o16_0_0_rgb, 1.0)(uv);
vec4 o15_s2 = vec4(o16_1_0_rgb, 1.0)(uv);
float o15_a = 1.000000*(o35_0_0_rgba).r(uv);
vec4 o15_0_0_rgba = vec4(blend_burn(uv, o15_s1.rgb, o15_s2.rgb, o15_a*o15_s1.a), min(1.0, o15_s2.a+o15_a*o15_s1.a));
// tones_step: _sg13_tones_step_3
vec3 o14_false = clamp((o15_0_0_rgba.rgb-vec3(0.500000))/max(0.0001, 0.660000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o14_true = vec3(1.0)-o14_false;
vec4 o14_0_0_rgba = vec4(o14_false, o15_0_0_rgba.a);
float o40_seed = 0.123450;
float o43_seed = 0.123450;
vec4 o43_0_0_rgba = o43_fct(uv);
vec4 o40_0_0_rgba = o40_fct(uv);
vec4 o11_0_0_rgba = o11_anisotropic_kuwahara(uv, 6.000000, 1.000000, 1.000000);
float o46_seed = 0.123450;
float o47_seed = 0.123450;
float o48_seed = 0.123450;
float o52_seed = 0.123450;
float o53_seed = 378429.693450;
float o54_seed = 0.123450;
float o55_seed = 0.123450;
float o55_0_0_f = shape_circle(uv, 6.000000+1.0e-5, 1.000000*1.0(uv), 0.320000*1.0(uv));
// math: _sg49_math_2
float o54_clamp_false = sin(o55_0_0_f*3.14 / 2.0(uv));
float o54_clamp_true = clamp(o54_clamp_false, 0.0, 1.0);
float o54_0_0_f = o54_clamp_false;
float o56_seed = 0.123450;
float o57_seed = 13014524.123450;
float o57_0_0_f = old_fbm_2d_perlin(uv, vec2(2.0 * /*?d_scale*/0.0, 2.0 * /*?d_scale*/0.0), int(0.000000), int(2.000000), 0.500000, 0.000000(uv), (float(o57_seed) + fract(_seed_variation_)));
vec4 o56_0_0_rgba = o56_gradient_gradient_fct;
// shader: _sg49_tiler
vec4 o53_rch = tiler_o53(uv, vec2(256.0 * /*?d_scale*/0.0, 256.0 * /*?d_scale*/0.0), int(2.000000), vec2(float((float(o53_seed) + fract(_seed_variation_)))));
float o53_0_0_f = o53_rch.a;
// math: _sg49_math
float o52_clamp_false = o53_0_0_f*0.480000(uv);
float o52_clamp_true = clamp(o52_clamp_false, 0.0, 1.0);
float o52_0_0_f = o52_clamp_false;
float o58_seed = 12838328.443450;
float o58_0_0_f = old_fbm_2d_perlin(uv, vec2(6.000000, 6.000000), int(0.000000), int(2.000000), 0.500000, 0.000000(uv), (float(o58_seed) + fract(_seed_variation_)));
// blend2: blend2_12
vec4 o48_b = vec4(vec3(o52_0_0_f), 1.0)(uv);
vec4 o48_l;
float o48_a;
o48_l = vec4(vec3(o58_0_0_f), 1.0)(uv);
o48_a = 0.500000*1.0(uv);
o48_b = vec4(blend_normal(uv, o48_l.rgb, o48_b.rgb, o48_a*o48_l.a), min(1.0, o48_b.a+o48_a*o48_l.a));
vec4 o48_0_0_rgba = o48_b;
// tones_step: tones_step_5
vec3 o47_false = clamp((o48_0_0_rgba.rgb-vec3(0.360000))/max(0.0001, 0.130000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o47_true = vec3(1.0)-o47_false;
vec4 o47_0_0_rgba = vec4(o47_false, o48_0_0_rgba.a);
float o46_0_0_f = (o47_0_0_rgba).r + fract(_seed_variation_))+0.000000);
float o59_seed = 0.123450;
float o46_seed = 0.123450;
float o46_1_0_f = (o47_0_0_rgba).r + fract(_seed_variation_))+0.100000);
vec4 o59_0_0_rgba = vec4(vec3(1.0)-vec4(vec3(o46_1_0_f), 1.0)(uv).rgb, vec4(vec3(o46_1_0_f), 1.0)(uv).a);
// blend2: blend2_13
vec4 o8_b = o11_0_0_rgba;
vec4 o8_l;
float o8_a;
o8_l = vec4(vec3(o46_0_0_f), 1.0)(uv);
o8_a = 0.760000*(o59_0_0_rgba).r(uv);
o8_b = vec4(blend_screen(uv, o8_l.rgb, o8_b.rgb, o8_a*o8_l.a), min(1.0, o8_b.a+o8_a*o8_l.a));
o8_l = vec4(1.0, uv.y, 1.0, 1.0)(uv);
o8_a = 0.710000*1.0(uv);
o8_b = vec4(blend_multiply(uv, o8_l.rgb, o8_b.rgb, o8_a*o8_l.a), min(1.0, o8_b.a+o8_a*o8_l.a));
vec4 o8_0_0_rgba = o8_b;
// alter_hsv: alter_hsv_2
vec4 o6_rbga = o7_0_0_rgba;
vec3 o6_hsv = rgb_to_hsv(o6_rbga.rgb);
o6_hsv.x = fract(o6_hsv.x+0.150000*1.000000*((o8_0_0_rgba).r(uv)-0.5));
o6_hsv.y = clamp(o6_hsv.y+0.050000*1.000000*((o8_0_0_rgba).r(uv)-0.5), 0.0, 1.0);
o6_hsv.z = clamp(o6_hsv.z+0.090000*1.000000*((o8_0_0_rgba).r(uv)-0.5), 0.0, 1.0);
vec4 o6_0_0_rgba = vec4(hsv_to_rgb(o6_hsv), o6_rbga.a);
float o60_seed = 0.123450;
float o61_seed = 0.123450;
float o62_seed = 0.123450;
float o64_seed = 0.123450;
float o65_seed = 0.123450;
float o69_seed = 0.123450;
float o71_seed = 0.123450;
vec4 o71_0_0_rgba = vec4(0.5, 0.5, 0.5, 1.0)(uv);
// fast_blur_shader: _sg67_fast_blur_shader
vec4 o69_blurred = o69_blur(uv, vec2(1.0)/o71_0_0_rgba.size, max(1.0, floor(100.000000*o71_0_0_rgba.size/2048.0)), int(1.000000));
vec4 o69_0_0_rgba = o69_blurred;
float o73_seed = 0.123450;
float o77_seed = 0.123450;
float o79_seed = 0.123450;
vec4 o79_0_0_rgba = vec4(0.5, 0.5, 0.5, 1.0)(uv);
// fast_blur_shader: _sg75_fast_blur_shader
vec4 o77_blurred = o77_blur(uv, vec2(1.0)/o79_0_0_rgba.size, max(1.0, floor(100.000000*o79_0_0_rgba.size/2048.0)), int(1.000000));
vec4 o77_0_0_rgba = o77_blurred;
float o81_seed = 0.123450;
float o85_seed = 0.123450;
float o87_seed = 0.123450;
vec4 o87_0_0_rgba = vec4(0.5, 0.5, 0.5, 1.0)(uv);
// fast_blur_shader: _sg83_fast_blur_shader
vec4 o85_blurred = o85_blur(uv, vec2(1.0)/o87_0_0_rgba.size, max(1.0, floor(100.000000*o87_0_0_rgba.size/2048.0)), int(1.000000));
vec4 o85_0_0_rgba = o85_blurred;
float o89_seed = 0.123450;
float o93_seed = 0.123450;
float o95_seed = 0.123450;
vec4 o95_0_0_rgba = vec4(0.5, 0.5, 0.5, 1.0)(uv);
// fast_blur_shader: _sg91_fast_blur_shader
vec4 o93_blurred = o93_blur(uv, vec2(1.0)/o95_0_0_rgba.size, max(1.0, floor(100.000000*o95_0_0_rgba.size/2048.0)), int(1.000000));
vec4 o93_0_0_rgba = o93_blurred;
float o100_seed = 0.123450;
float o102_seed = 0.123450;
vec4 o102_0_0_rgba = vec4(0.5, 0.5, 0.5, 1.0)(uv);
// fast_blur_shader: _sg98_fast_blur_shader
vec4 o100_blurred = o100_blur(uv, vec2(1.0)/o102_0_0_rgba.size, max(1.0, floor(100.000000*o102_0_0_rgba.size/2048.0)), int(1.000000));
vec4 o100_0_0_rgba = o100_blurred;
// blend: _sg63_blend
vec4 o89_s1 = o93_0_0_rgba;
vec4 o89_s2 = o100_0_0_rgba;
float o89_a = 1.000000*1.0(uv);
vec4 o89_0_0_rgba = vec4(blend_overlay(uv, o89_s1.rgb, o89_s2.rgb, o89_a*o89_s1.a), min(1.0, o89_s2.a+o89_a*o89_s1.a));
// blend: _sg63_blend_2
vec4 o81_s1 = o85_0_0_rgba;
vec4 o81_s2 = o89_0_0_rgba;
float o81_a = 1.000000*1.0(uv);
vec4 o81_0_0_rgba = vec4(blend_overlay(uv, o81_s1.rgb, o81_s2.rgb, o81_a*o81_s1.a), min(1.0, o81_s2.a+o81_a*o81_s1.a));
// blend: _sg63_blend_3
vec4 o73_s1 = o77_0_0_rgba;
vec4 o73_s2 = o81_0_0_rgba;
float o73_a = 1.000000*1.0(uv);
vec4 o73_0_0_rgba = vec4(blend_overlay(uv, o73_s1.rgb, o73_s2.rgb, o73_a*o73_s1.a), min(1.0, o73_s2.a+o73_a*o73_s1.a));
// blend: _sg63_blend_4
vec4 o65_s1 = o69_0_0_rgba;
vec4 o65_s2 = o73_0_0_rgba;
float o65_a = 1.000000*1.0(uv);
vec4 o65_0_0_rgba = vec4(blend_overlay(uv, o65_s1.rgb, o65_s2.rgb, o65_a*o65_s1.a), min(1.0, o65_s2.a+o65_a*o65_s1.a));
vec4 o64_0_0_rgba = vec4(vec3(1.0)-o65_0_0_rgba.rgb, o65_0_0_rgba.a);
// math: _sg28_math_2
float o62_clamp_false = (o64_0_0_rgba).r(uv)-0.500000(uv);
float o62_clamp_true = clamp(o62_clamp_false, 0.0, 1.0);
float o62_0_0_f = o62_clamp_false;
// math: _sg28_math_3
float o61_clamp_false = o62_0_0_f*2.000000(uv);
float o61_clamp_true = clamp(o61_clamp_false, 0.0, 1.0);
float o61_0_0_f = o61_clamp_true;
vec4 o60_0_0_rgba = o60_gradient_gradient_fct;
// blend2: blend2_14
vec4 o5_b = o6_0_0_rgba;
vec4 o5_l;
float o5_a;
o5_l = o60_0_0_rgba;
o5_a = 0.500000*1.0(uv);
o5_b = vec4(blend_normal(uv, o5_l.rgb, o5_b.rgb, o5_a*o5_l.a), min(1.0, o5_b.a+o5_a*o5_l.a));
vec4 o5_0_0_rgba = o5_b;
float o104_seed = 0.123450;
float o105_seed = 0.123450;
float o106_seed = 0.123450;
float o107_seed = 0.123450;
float o110_seed = 0.123450;
float o112_seed = 0.123450;
float o113_seed = 0.123450;
float o114_seed = 0.123450;
float o118_seed = 0.123450;
float o121_seed = 0.123450;
float o123_seed = 0.123450;
float o124_seed = 0.123450;
float o125_seed = 0.123450;
float o125_0_0_f = 0.750000;
float o126_seed = 0.123450;
float o127_seed = 26399828.603450;
float o128_seed = 0.123450;
float o129_seed = 0.123450;
float o130_seed = 0.123450;
float o131_seed = 0.123450;
float o131_0_0_f = shape_polygon(uv, 10.000000+1.0e-5, 0.940000*1.0(uv), 0.610000*1.0(uv));
vec4 o130_0_0_rgba = vec4(vec3(o131_0_0_f), 1.0)(transform2_clamp(transform2(uv, vec2(0.000000*(2.0*1.0(uv)-1.0), 0.000000*(2.0*1.0(uv)-1.0)), 0.000000*0.01745329251*(2.0*1.0(uv)-1.0), vec2(0.610000*(2.0*1.0(uv)-1.0), 1.000000*(2.0*1.0(uv)-1.0)))));
float o133_seed = 0.123450;
float o134_seed = 0.123450;
float o135_seed = 0.123450;
float o136_seed = 0.123450;
float o137_seed = 0.123450;
float o138_seed = 0.123450;
// voronoi: _sg132_voronoi
vec4 o138_xyzw = voronoi(uv, vec2(16.000000, 16.000000), vec2(0.850000, 0.850000), 1.000000, 1.000000, (float(o138_seed) + fract(_seed_variation_)));
float o138_0_0_f = o138_xyzw.z;
// math: _sg132_math_2
float o137_clamp_false = sqrt(1.0-o138_0_0_f*o138_0_0_f);
float o137_clamp_true = clamp(o137_clamp_false, 0.0, 1.0);
float o137_0_0_f = o137_clamp_false;
float o139_seed = 0.123450;
float o140_seed = 19987747.123450;
// voronoi: _sg132_voronoi_2
vec4 o140_xyzw = voronoi(uv, vec2(16.000000, 16.000000), vec2(0.850000, 0.850000), 1.000000, 1.000000, (float(o140_seed) + fract(_seed_variation_)));
float o140_0_0_f = o140_xyzw.z;
// math: _sg132_math_3
float o139_clamp_false = sqrt(1.0-o140_0_0_f*o140_0_0_f);
float o139_clamp_true = clamp(o139_clamp_false, 0.0, 1.0);
float o139_0_0_f = o139_clamp_false;
// math: _sg132_math_4
float o136_clamp_false = max(o137_0_0_f,o139_0_0_f);
float o136_clamp_true = clamp(o136_clamp_false, 0.0, 1.0);
float o136_0_0_f = o136_clamp_false;
float o141_seed = 0.123450;
// math: _sg132_math
float o141_clamp_false = min(o137_0_0_f,o139_0_0_f);
float o141_clamp_true = clamp(o141_clamp_false, 0.0, 1.0);
float o141_0_0_f = o141_clamp_false;
// math: _sg132_math_5
float o135_clamp_false = o136_0_0_f-o141_0_0_f;
float o135_clamp_true = clamp(o135_clamp_false, 0.0, 1.0);
float o135_0_0_f = o135_clamp_false;
// math: _sg132_math_6
float o134_clamp_false = o135_0_0_f/o136_0_0_f;
float o134_clamp_true = clamp(o134_clamp_false, 0.0, 1.0);
float o134_0_0_f = o134_clamp_false;
// math: _sg132_math_7
float o133_clamp_false = o134_0_0_f*1.450000(uv);
float o133_clamp_true = clamp(o133_clamp_false, 0.0, 1.0);
float o133_0_0_f = o133_clamp_false;
// warp: warp_3
vec2 o129_slope = o129_slope(uv, 0.100000);
vec2 o129_warp = o129_slope;
vec4 o129_0_0_rgba = o130_0_0_rgba;
float o142_seed = 0.123450;
// gradient: gradient_2
float o142_r = 0.5+(cos((-90.000000)*0.01745329251)*(uv.x-0.5)+sin((-90.000000)*0.01745329251)*(uv.y-0.5))/(cos(abs(mod((-90.000000), 90.0)-45.0)*0.01745329251)*1.41421356237);
vec4 o142_0_0_rgba = o142_gradient_gradient_fct;
// blend2: blend2_7
vec4 o128_b = o129_0_0_rgba;
vec4 o128_l;
float o128_a;
o128_l = o142_0_0_rgba;
o128_a = 0.500000*1.0(uv);
o128_b = vec4(blend_normal(uv, o128_l.rgb, o128_b.rgb, o128_a*o128_l.a), min(1.0, o128_b.a+o128_a*o128_l.a));
vec4 o128_0_0_rgba = o128_b;
// tiler: tiler_3
vec3 o127_instance_uv = vec3(0.0);
vec4 o127_rch = tiler_o127(uv, vec2(12.000000, 12.000000), int(4.000000), o127_instance_uv, vec2(float((float(o127_seed) + fract(_seed_variation_)))));
float o127_0_0_f = o127_rch.a;
float o144_seed = 0.123450;
float o145_seed = 0.123450;
float o146_seed = 0.123450;
float o147_seed = 0.123450;
float o148_seed = 0.123450;
float o149_seed = 0.123450;
// voronoi: _sg143_voronoi
vec4 o149_xyzw = voronoi(uv, vec2(16.000000, 16.000000), vec2(0.850000, 0.850000), 1.000000, 1.000000, (float(o149_seed) + fract(_seed_variation_)));
float o149_0_0_f = o149_xyzw.z;
// math: _sg143_math_2
float o148_clamp_false = sqrt(1.0-o149_0_0_f*o149_0_0_f);
float o148_clamp_true = clamp(o148_clamp_false, 0.0, 1.0);
float o148_0_0_f = o148_clamp_false;
float o150_seed = 0.123450;
float o151_seed = 19987747.123450;
// voronoi: _sg143_voronoi_2
vec4 o151_xyzw = voronoi(uv, vec2(16.000000, 16.000000), vec2(0.850000, 0.850000), 1.000000, 1.000000, (float(o151_seed) + fract(_seed_variation_)));
float o151_0_0_f = o151_xyzw.z;
// math: _sg143_math_3
float o150_clamp_false = sqrt(1.0-o151_0_0_f*o151_0_0_f);
float o150_clamp_true = clamp(o150_clamp_false, 0.0, 1.0);
float o150_0_0_f = o150_clamp_false;
// math: _sg143_math_4
float o147_clamp_false = max(o148_0_0_f,o150_0_0_f);
float o147_clamp_true = clamp(o147_clamp_false, 0.0, 1.0);
float o147_0_0_f = o147_clamp_false;
float o152_seed = 0.123450;
// math: _sg143_math
float o152_clamp_false = min(o148_0_0_f,o150_0_0_f);
float o152_clamp_true = clamp(o152_clamp_false, 0.0, 1.0);
float o152_0_0_f = o152_clamp_false;
// math: _sg143_math_5
float o146_clamp_false = o147_0_0_f-o152_0_0_f;
float o146_clamp_true = clamp(o146_clamp_false, 0.0, 1.0);
float o146_0_0_f = o146_clamp_false;
// math: _sg143_math_6
float o145_clamp_false = o146_0_0_f/o147_0_0_f;
float o145_clamp_true = clamp(o145_clamp_false, 0.0, 1.0);
float o145_0_0_f = o145_clamp_false;
// math: _sg143_math_7
float o144_clamp_false = o145_0_0_f*1.450000(uv);
float o144_clamp_true = clamp(o144_clamp_false, 0.0, 1.0);
float o144_0_0_f = o144_clamp_false;
// warp: warp_4
vec2 o126_slope = o126_slope(uv, 0.100000);
vec2 o126_warp = o126_slope;
vec4 o126_0_0_rgba = vec4(vec3(o127_0_0_f), 1.0)(uv+0.065000*1.0(uv)*o126_warp);
// blend2: blend2_9
vec4 o124_b = vec4(vec3(o125_0_0_f), 1.0)(uv);
vec4 o124_l;
float o124_a;
o124_l = o126_0_0_rgba;
o124_a = 0.500000*1.0(uv);
o124_b = vec4(blend_normal(uv, o124_l.rgb, o124_b.rgb, o124_a*o124_l.a), min(1.0, o124_b.a+o124_a*o124_l.a));
vec4 o124_0_0_rgba = o124_b;
float o153_seed = 0.123450;
vec4 o153_0_0_rgba = o126_0_0_rgba;
// blend2: blend2_19
vec4 o123_b = o124_0_0_rgba;
vec4 o123_l;
float o123_a;
o123_l = o153_0_0_rgba;
o123_a = 0.500000*1.0(uv);
o123_b = vec4(blend_normal(uv, o123_l.rgb, o123_b.rgb, o123_a*o123_l.a), min(1.0, o123_b.a+o123_a*o123_l.a));
vec4 o123_0_0_rgba = o123_b;
float o154_seed = 0.123450;
float o155_seed = 0.123450;
float o156_seed = 0.123450;
float o157_seed = 0.123450;
float o161_seed = 0.123450;
float o164_seed = 0.123450;
float o166_seed = 0.123450;
float o167_seed = 36441482.363450;
float o168_seed = 0.123450;
float o168_0_0_f = sphere(uv, vec2(0.500000, 0.500000), 0.500000);
float o169_seed = 0.123450;
float o170_seed = 9004590.843450;
float o170_0_0_f = old_fbm_2d_perlin(uv, vec2(4.000000, 4.000000), int(0.000000), int(4.000000), 0.500000, 0.000000(uv), (float(o170_seed) + fract(_seed_variation_)));
// tones_step: tones_step
vec3 o169_false = clamp((vec4(vec3(o170_0_0_f), 1.0)(uv).rgb-vec3(0.530000))/max(0.0001, 0.000000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o169_true = vec3(1.0)-o169_false;
vec4 o169_0_0_rgba = vec4(o169_false, vec4(vec3(o170_0_0_f), 1.0)(uv).a);
// tiler: tiler_2
vec3 o167_instance_uv = vec3(0.0);
vec4 o167_rch = tiler_o167(uv, vec2(12.000000, 12.000000), int(2.000000), o167_instance_uv, vec2(float((float(o167_seed) + fract(_seed_variation_)))));
float o167_0_0_f = o167_rch.a;
float o171_seed = 0.123450;
float o171_0_0_f = old_fbm_2d_perlin(uv, vec2(16.000000, 16.000000), int(0.000000), int(1.000000), 0.500000, 0.000000(uv), (float(o171_seed) + fract(_seed_variation_)));
// warp: warp_5
vec2 o166_slope = o166_slope(uv, 0.100000);
vec2 o166_warp = o166_slope;
vec4 o166_0_0_rgba = vec4(vec3(o167_0_0_f), 1.0)(uv+0.015000*1.0(uv)*o166_warp);
vec4 o164_0_0_rgba = o164_fct(uv);
vec4 o161_0_0_rgba = o161_fct(uv);
// tones_step: tones_step_3
vec3 o157_false = clamp((o161_0_0_rgba.rgb-vec3(0.050000))/max(0.0001, 0.030000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o157_true = vec3(1.0)-o157_false;
vec4 o157_0_0_rgba = vec4(o157_true, o161_0_0_rgba.a);
float o174_seed = 0.123450;
float o175_seed = 0.123450;
float o176_seed = 0.123450;
float o177_seed = 0.123450;
float o178_seed = 0.123450;
float o179_seed = 0.123450;
// voronoi: _sg173_voronoi
vec4 o179_xyzw = voronoi(uv, vec2(16.000000, 16.000000), vec2(0.850000, 0.850000), 1.000000, 1.000000, (float(o179_seed) + fract(_seed_variation_)));
float o179_0_0_f = o179_xyzw.z;
// math: _sg173_math_2
float o178_clamp_false = sqrt(1.0-o179_0_0_f*o179_0_0_f);
float o178_clamp_true = clamp(o178_clamp_false, 0.0, 1.0);
float o178_0_0_f = o178_clamp_false;
float o180_seed = 0.123450;
float o181_seed = 19987747.123450;
// voronoi: _sg173_voronoi_2
vec4 o181_xyzw = voronoi(uv, vec2(16.000000, 16.000000), vec2(0.850000, 0.850000), 1.000000, 1.000000, (float(o181_seed) + fract(_seed_variation_)));
float o181_0_0_f = o181_xyzw.z;
// math: _sg173_math_3
float o180_clamp_false = sqrt(1.0-o181_0_0_f*o181_0_0_f);
float o180_clamp_true = clamp(o180_clamp_false, 0.0, 1.0);
float o180_0_0_f = o180_clamp_false;
// math: _sg173_math_4
float o177_clamp_false = max(o178_0_0_f,o180_0_0_f);
float o177_clamp_true = clamp(o177_clamp_false, 0.0, 1.0);
float o177_0_0_f = o177_clamp_false;
float o182_seed = 0.123450;
// math: _sg173_math
float o182_clamp_false = min(o178_0_0_f,o180_0_0_f);
float o182_clamp_true = clamp(o182_clamp_false, 0.0, 1.0);
float o182_0_0_f = o182_clamp_false;
// math: _sg173_math_5
float o176_clamp_false = o177_0_0_f-o182_0_0_f;
float o176_clamp_true = clamp(o176_clamp_false, 0.0, 1.0);
float o176_0_0_f = o176_clamp_false;
// math: _sg173_math_6
float o175_clamp_false = o176_0_0_f/o177_0_0_f;
float o175_clamp_true = clamp(o175_clamp_false, 0.0, 1.0);
float o175_0_0_f = o175_clamp_false;
// math: _sg173_math_7
float o174_clamp_false = o175_0_0_f*1.450000(uv);
float o174_clamp_true = clamp(o174_clamp_false, 0.0, 1.0);
float o174_0_0_f = o174_clamp_false;
// warp: warp_2
vec2 o156_slope = o156_slope(uv, 0.100000);
vec2 o156_warp = o156_slope;
vec4 o156_0_0_rgba = o157_0_0_rgba;
vec4 o155_0_0_rgba = o155_gradient_gradient_fct;
// math: math_2
float o154_clamp_false = (1.0-step(0.010000(uv),(o155_0_0_rgba).r(uv)));
float o154_clamp_true = clamp(o154_clamp_false, 0.0, 1.0);
float o154_0_0_f = o154_clamp_false;
vec4 o121_0_0_rgba = o121_fct(uv);
vec4 o118_0_0_rgba = o118_fct(uv);
// blend2: blend2_4
vec4 o114_b = o118_0_0_rgba;
vec4 o114_l;
float o114_a;
o114_l = o155_0_0_rgba;
o114_a = 0.500000*1.0(uv);
o114_b = vec4(blend_normal(uv, o114_l.rgb, o114_b.rgb, o114_a*o114_l.a), min(1.0, o114_b.a+o114_a*o114_l.a));
vec4 o114_0_0_rgba = o114_b;
float o183_seed = 0.123450;
float o184_seed = 0.123450;
float o185_seed = 0.123450;
float o188_seed = 0.123450;
float o193_seed = 0.123450;
float o196_seed = 0.123450;
float o198_seed = 0.123450;
float o202_seed = 0.123450;
float o205_seed = 0.123450;
vec4 o205_0_0_rgba = o205_fct(uv);
vec4 o202_0_0_rgba = o202_fct(uv);
vec4 o198_0_0_rgba = vec4(floor(o202_0_0_rgba.rgb*7.000000)/7.000000, o202_0_0_rgba.a);
vec4 o196_0_0_rgba = o196_fct(uv);
vec4 o193_0_0_rgba = o193_fct(uv);
float o209_seed = 0.123450;
float o211_seed = 0.123450;
float o212_seed = 0.123450;
float o214_seed = 0.123450;
float o216_seed = 0.123450;
float o218_seed = 0.123450;
// blend: _sg210_blend
vec4 o218_s1 = o93_0_0_rgba;
vec4 o218_s2 = o100_0_0_rgba;
float o218_a = 1.000000*1.0(uv);
vec4 o218_0_0_rgba = vec4(blend_overlay(uv, o218_s1.rgb, o218_s2.rgb, o218_a*o218_s1.a), min(1.0, o218_s2.a+o218_a*o218_s1.a));
// blend: _sg210_blend_2
vec4 o216_s1 = o85_0_0_rgba;
vec4 o216_s2 = o218_0_0_rgba;
float o216_a = 1.000000*1.0(uv);
vec4 o216_0_0_rgba = vec4(blend_overlay(uv, o216_s1.rgb, o216_s2.rgb, o216_a*o216_s1.a), min(1.0, o216_s2.a+o216_a*o216_s1.a));
// blend: _sg210_blend_3
vec4 o214_s1 = o77_0_0_rgba;
vec4 o214_s2 = o216_0_0_rgba;
float o214_a = 1.000000*1.0(uv);
vec4 o214_0_0_rgba = vec4(blend_overlay(uv, o214_s1.rgb, o214_s2.rgb, o214_a*o214_s1.a), min(1.0, o214_s2.a+o214_a*o214_s1.a));
// blend: _sg210_blend_4
vec4 o212_s1 = o69_0_0_rgba;
vec4 o212_s2 = o214_0_0_rgba;
float o212_a = 1.000000*1.0(uv);
vec4 o212_0_0_rgba = vec4(blend_overlay(uv, o212_s1.rgb, o212_s2.rgb, o212_a*o212_s1.a), min(1.0, o212_s2.a+o212_a*o212_s1.a));
vec4 o211_0_0_rgba = vec4(vec3(1.0)-o212_0_0_rgba.rgb, o212_0_0_rgba.a);
// tones_step: tones_step_2
vec3 o209_false = clamp((o211_0_0_rgba.rgb-vec3(0.500000))/max(0.0001, 0.040000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o209_true = vec3(1.0)-o209_false;
vec4 o209_0_0_rgba = vec4(o209_false, o211_0_0_rgba.a);
vec4 o188_0_0_rgba = o188_fct(uv);
float o221_seed = 0.123450;
float o224_seed = 0.123450;
float o226_seed = 23827530.363450;
float o226_0_0_f = old_fbm_2d_perlin(uv, vec2(8.000000, 8.000000), int(0.000000), int(3.000000), 0.500000, 0.000000(uv), (float(o226_seed) + fract(_seed_variation_)));
vec3 o224_0_0_rgb = o224_fct(uv);
float o227_seed = 0.123450;
float o228_seed = 23827530.363450;
float o228_0_0_f = old_fbm_2d_perlin(uv, vec2(8.000000, 8.000000), int(0.000000), int(3.000000), 0.500000, 0.000000(uv), (float(o228_seed) + fract(_seed_variation_)));
// remap: remap
float o227_x = o228_0_0_f*((-0.150000)-(-0.020000));
float o227_0_0_f = (-0.020000)+o227_x-mod(o227_x, max(0.000000, 0.00000001));
// math: math
float o221_clamp_false = (o224_0_0_rgb).r(uv)+o227_0_0_f;
float o221_clamp_true = clamp(o221_clamp_false, 0.0, 1.0);
float o221_0_0_f = o221_clamp_true;
// blend2: blend2_3
vec4 o185_b = o188_0_0_rgba;
vec4 o185_l;
float o185_a;
o185_l = vec4(vec3(o221_0_0_f), 1.0)(uv);
o185_a = 0.500000*1.0(uv);
o185_b = vec4(blend_normal(uv, o185_l.rgb, o185_b.rgb, o185_a*o185_l.a), min(1.0, o185_b.a+o185_a*o185_l.a));
vec4 o185_0_0_rgba = o185_b;
float o230_seed = 0.123450;
float o231_seed = 0.123450;
float o232_seed = 0.123450;
float o234_seed = 0.123450;
float o235_seed = 0.123450;
float o237_seed = 0.123450;
float o239_seed = 0.123450;
float o241_seed = 0.123450;
// blend: _sg233_blend
vec4 o241_s1 = o93_0_0_rgba;
vec4 o241_s2 = o100_0_0_rgba;
float o241_a = 1.000000*1.0(uv);
vec4 o241_0_0_rgba = vec4(blend_overlay(uv, o241_s1.rgb, o241_s2.rgb, o241_a*o241_s1.a), min(1.0, o241_s2.a+o241_a*o241_s1.a));
// blend: _sg233_blend_2
vec4 o239_s1 = o85_0_0_rgba;
vec4 o239_s2 = o241_0_0_rgba;
float o239_a = 1.000000*1.0(uv);
vec4 o239_0_0_rgba = vec4(blend_overlay(uv, o239_s1.rgb, o239_s2.rgb, o239_a*o239_s1.a), min(1.0, o239_s2.a+o239_a*o239_s1.a));
// blend: _sg233_blend_3
vec4 o237_s1 = o77_0_0_rgba;
vec4 o237_s2 = o239_0_0_rgba;
float o237_a = 1.000000*1.0(uv);
vec4 o237_0_0_rgba = vec4(blend_overlay(uv, o237_s1.rgb, o237_s2.rgb, o237_a*o237_s1.a), min(1.0, o237_s2.a+o237_a*o237_s1.a));
// blend: _sg233_blend_4
vec4 o235_s1 = o69_0_0_rgba;
vec4 o235_s2 = o237_0_0_rgba;
float o235_a = 1.000000*1.0(uv);
vec4 o235_0_0_rgba = vec4(blend_overlay(uv, o235_s1.rgb, o235_s2.rgb, o235_a*o235_s1.a), min(1.0, o235_s2.a+o235_a*o235_s1.a));
vec4 o234_0_0_rgba = vec4(vec3(1.0)-o235_0_0_rgba.rgb, o235_0_0_rgba.a);
// math: _sg229_math_4
float o232_clamp_false = (o234_0_0_rgba).r(uv)+0.500000(uv);
float o232_clamp_true = clamp(o232_clamp_false, 0.0, 1.0);
float o232_0_0_f = o232_clamp_false;
// remap: _sg229_remap
float o231_x = o232_0_0_f*(1.000000-0.000000);
float o231_0_0_f = 0.000000+o231_x-mod(o231_x, max(0.000000, 0.00000001));
vec4 o230_0_0_rgba = o230_gradient_gradient_fct;
float o244_seed = 0.123450;
float o245_seed = 0.123450;
float o245_0_0_f = old_fbm_2d_perlin(uv, vec2(8.000000, 8.000000), int(0.000000), int(3.000000), 0.500000, 0.000000(uv), (float(o245_seed) + fract(_seed_variation_)));
// tones_step: tones_step_7
vec3 o244_false = clamp((vec4(vec3(o245_0_0_f), 1.0)(uv).rgb-vec3(0.500000))/max(0.0001, 0.100000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o244_true = vec3(1.0)-o244_false;
vec4 o244_0_0_rgba = vec4(o244_false, vec4(vec3(o245_0_0_f), 1.0)(uv).a);
// blend2: blend2_20
vec4 o184_b = o185_0_0_rgba;
vec4 o184_l;
float o184_a;
o184_l = o230_0_0_rgba;
o184_a = 0.500000*(o244_0_0_rgba).r(uv);
o184_b = vec4(blend_normal(uv, o184_l.rgb, o184_b.rgb, o184_a*o184_l.a), min(1.0, o184_b.a+o184_a*o184_l.a));
vec4 o184_0_0_rgba = o184_b;
float o246_seed = 9962693.243450;
float o247_seed = 0.123450;
float o247_0_0_f = sphere(uv, vec2(0.500000, 0.500000), 0.500000);
float o248_seed = 0.123450;
float o249_seed = 0.123450;
// math: math_3
float o249_clamp_false = (o184_0_0_rgba).r(uv)+0.050000(uv);
float o249_clamp_true = clamp(o249_clamp_false, 0.0, 1.0);
float o249_0_0_f = o249_clamp_true;
float o250_seed = 0.123450;
// tones_step: tones_step_8
vec3 o250_false = clamp((o230_0_0_rgba.rgb-vec3(0.950000))/max(0.0001, 0.000000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o250_true = vec3(1.0)-o250_false;
vec4 o250_0_0_rgba = vec4(o250_true, o230_0_0_rgba.a);
// blend2: blend2_24
vec4 o248_b = vec4(vec3(o249_0_0_f), 1.0)(uv);
vec4 o248_l;
float o248_a;
o248_l = o250_0_0_rgba;
o248_a = 0.500000*1.0(uv);
o248_b = vec4(blend_normal(uv, o248_l.rgb, o248_b.rgb, o248_a*o248_l.a), min(1.0, o248_b.a+o248_a*o248_l.a));
vec4 o248_0_0_rgba = o248_b;
// tiler: tiler_6
vec3 o246_instance_uv = vec3(0.0);
vec4 o246_rch = tiler_o246(uv, vec2(20.000000, 20.000000), int(2.000000), o246_instance_uv, vec2(float((float(o246_seed) + fract(_seed_variation_)))));
float o246_0_0_f = o246_rch.a;
// blend2: blend2_23
vec4 o183_b = o184_0_0_rgba;
vec4 o183_l;
float o183_a;
o183_l = vec4(vec3(o246_0_0_f), 1.0)(uv);
o183_a = 0.500000*1.0(uv);
o183_b = vec4(blend_normal(uv, o183_l.rgb, o183_b.rgb, o183_a*o183_l.a), min(1.0, o183_b.a+o183_a*o183_l.a));
vec4 o183_0_0_rgba = o183_b;
// blend2: blend2_2
vec4 o113_b = o114_0_0_rgba;
vec4 o113_l;
float o113_a;
o113_l = o183_0_0_rgba;
o113_a = 0.500000*o154_0_0_f;
o113_b = vec4(blend_normal(uv, o113_l.rgb, o113_b.rgb, o113_a*o113_l.a), min(1.0, o113_b.a+o113_a*o113_l.a));
vec4 o113_0_0_rgba = o113_b;
float o251_seed = 0.123450;
float o252_seed = 0.123450;
float o252_0_0_f = sphere(uv, vec2(0.500000, 0.500000), 0.500000);
float o253_seed = 0.123450;
vec4 o253_0_0_rgba = vec4(vec3(1.0)-vec4(vec3(o154_0_0_f), 1.0)(uv).rgb, vec4(vec3(o154_0_0_f), 1.0)(uv).a);
// tiler: tiler_4
vec3 o251_instance_uv = vec3(0.0);
vec4 o251_rch = tiler_o251(uv, vec2(8.000000, 8.000000), int(2.000000), o251_instance_uv, vec2(float((float(o251_seed) + fract(_seed_variation_)))));
float o251_0_0_f = o251_rch.a;
// blend2: blend2_8
vec4 o112_b = o113_0_0_rgba;
vec4 o112_l;
float o112_a;
o112_l = vec4(vec3(o251_0_0_f), 1.0)(uv);
o112_a = 0.500000*1.0(uv);
o112_b = vec4(blend_normal(uv, o112_l.rgb, o112_b.rgb, o112_a*o112_l.a), min(1.0, o112_b.a+o112_a*o112_l.a));
vec4 o112_0_0_rgba = o112_b;
float o254_seed = 0.123450;
float o255_seed = 36441482.383450;
float o256_seed = 0.123450;
float o256_0_0_f = sphere(uv, vec2(0.500000, 0.500000), 0.500000);
float o257_seed = 0.123450;
float o258_seed = 0.123450;
// tones_step: tones_step_4
vec3 o258_false = clamp((o185_0_0_rgba.rgb-vec3(0.490000))/max(0.0001, 0.000000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o258_true = vec3(1.0)-o258_false;
vec4 o258_0_0_rgba = vec4(o258_false, o185_0_0_rgba.a);
// blend2: blend2_10
vec4 o257_b = o258_0_0_rgba;
vec4 o257_l;
float o257_a;
o257_l = o113_0_0_rgba;
o257_a = 0.500000*1.0(uv);
o257_b = vec4(blend_normal(uv, o257_l.rgb, o257_b.rgb, o257_a*o257_l.a), min(1.0, o257_b.a+o257_a*o257_l.a));
vec4 o257_0_0_rgba = o257_b;
// tiler: tiler_5
vec3 o255_instance_uv = vec3(0.0);
vec4 o255_rch = tiler_o255(uv, vec2(12.000000, 12.000000), int(2.000000), o255_instance_uv, vec2(float((float(o255_seed) + fract(_seed_variation_)))));
float o255_0_0_f = o255_rch.a;
// math: _sg109_math_2
float o254_clamp_false = o255_0_0_f*1.000000(uv);
float o254_clamp_true = clamp(o254_clamp_false, 0.0, 1.0);
float o254_0_0_f = o254_clamp_false;
// blend2: _sg109_blend2_12
vec4 o110_b = o112_0_0_rgba;
vec4 o110_l;
float o110_a;
o110_l = vec4(vec3(o254_0_0_f), 1.0)(uv);
o110_a = 0.500000*1.0(uv);
o110_b = vec4(blend_normal(uv, o110_l.rgb, o110_b.rgb, o110_a*o110_l.a), min(1.0, o110_b.a+o110_a*o110_l.a));
vec4 o110_0_0_rgba = o110_b;
vec4 o107_0_0_rgba = o107_gradient_gradient_fct;
float o259_seed = 0.123450;
float o260_seed = 0.123450;
float o264_seed = 0.123450;
float o267_seed = 0.123450;
vec4 o267_0_0_rgba = o267_fct(uv);
vec4 o264_0_0_rgba = o264_fct(uv);
// math: math_4
float o260_clamp_false = pow((o264_0_0_rgba).r(uv),2.000000(uv));
float o260_clamp_true = clamp(o260_clamp_false, 0.0, 1.0);
float o260_0_0_f = o260_clamp_true;
vec4 o259_0_0_rgba = o259_gradient_gradient_fct;
// blend2: blend2_26
vec4 o106_b = o107_0_0_rgba;
vec4 o106_l;
float o106_a;
o106_l = o259_0_0_rgba;
o106_a = 0.500000*1.0(uv);
o106_b = vec4(blend_normal(uv, o106_l.rgb, o106_b.rgb, o106_a*o106_l.a), min(1.0, o106_b.a+o106_a*o106_l.a));
vec4 o106_0_0_rgba = o106_b;
// adjust_hsv: adjust_hsv
vec4 o105_rbga = o106_0_0_rgba;
vec3 o105_hsv = rgb_to_hsv(o105_rbga.rgb);
o105_hsv.x += (-0.007816);
o105_hsv.y = clamp(o105_hsv.y*1.000000, 0.0, 1.0);
o105_hsv.z = clamp(o105_hsv.z*1.000000, 0.0, 1.0);
vec4 o105_0_0_rgba = vec4(hsv_to_rgb(o105_hsv), o105_rbga.a);
float o270_seed = 0.123450;
vec4 o270_0_0_rgba = vec4(0.154129, 0.270299, 0.433594, 1.000000);
float o272_seed = 0.123450;
float o276_seed = 0.123450;
float o279_seed = 0.123450;
float o281_seed = 0.123450;
float o282_seed = 0.123450;
// math: _sg109_math
float o282_clamp_false = (o112_0_0_rgba).r(uv)+0.000000(uv);
float o282_clamp_true = clamp(o282_clamp_false, 0.0, 1.0);
float o282_0_0_f = o282_clamp_false;
// math: _sg109_math_7
float o281_clamp_false = (1.0-step((o110_0_0_rgba).r(uv),o282_0_0_f));
float o281_clamp_true = clamp(o281_clamp_false, 0.0, 1.0);
float o281_0_0_f = o281_clamp_false;
vec4 o279_0_0_rgba = o279_fct(uv);
vec4 o276_0_0_rgba = o276_fct(uv);
float o284_seed = 0.123450;
float o284_0_0_f = vec4(0.5, 0.5, 0.5, 1.0)(uv).r;
float o284_seed = 0.123450;
float o284_1_0_f = vec4(0.5, 0.5, 0.5, 1.0)(uv).g;
float o272_0_0_f = ((o276_0_0_rgba).r(uv)-o284_0_0_f)/(o284_1_0_f-o284_0_0_f);
// blend2: blend2_27
vec4 o104_b = o105_0_0_rgba;
vec4 o104_l;
float o104_a;
o104_l = o270_0_0_rgba;
o104_a = 0.500000*o272_0_0_f;
o104_b = vec4(blend_normal(uv, o104_l.rgb, o104_b.rgb, o104_a*o104_l.a), min(1.0, o104_b.a+o104_a*o104_l.a));
vec4 o104_0_0_rgba = o104_b;
// blend2: blend2_5
vec4 o4_b = o5_0_0_rgba;
vec4 o4_l;
float o4_a;
o4_l = o104_0_0_rgba;
o4_a = 0.500000*o154_0_0_f;
o4_b = vec4(blend_normal(uv, o4_l.rgb, o4_b.rgb, o4_a*o4_l.a), min(1.0, o4_b.a+o4_a*o4_l.a));
vec4 o4_0_0_rgba = o4_b;
float o286_seed = 0.123450;
float o287_seed = 0.123450;
float o288_seed = 0.123450;
float o289_seed = 0.123450;
float o291_seed = 0.123450;
float o292_seed = 0.123450;
float o294_seed = 0.123450;
float o296_seed = 0.123450;
float o298_seed = 0.123450;
// blend: _sg290_blend
vec4 o298_s1 = o93_0_0_rgba;
vec4 o298_s2 = o100_0_0_rgba;
float o298_a = 1.000000*1.0(uv);
vec4 o298_0_0_rgba = vec4(blend_overlay(uv, o298_s1.rgb, o298_s2.rgb, o298_a*o298_s1.a), min(1.0, o298_s2.a+o298_a*o298_s1.a));
// blend: _sg290_blend_2
vec4 o296_s1 = o85_0_0_rgba;
vec4 o296_s2 = o298_0_0_rgba;
float o296_a = 1.000000*1.0(uv);
vec4 o296_0_0_rgba = vec4(blend_overlay(uv, o296_s1.rgb, o296_s2.rgb, o296_a*o296_s1.a), min(1.0, o296_s2.a+o296_a*o296_s1.a));
// blend: _sg290_blend_3
vec4 o294_s1 = o77_0_0_rgba;
vec4 o294_s2 = o296_0_0_rgba;
float o294_a = 1.000000*1.0(uv);
vec4 o294_0_0_rgba = vec4(blend_overlay(uv, o294_s1.rgb, o294_s2.rgb, o294_a*o294_s1.a), min(1.0, o294_s2.a+o294_a*o294_s1.a));
// blend: _sg290_blend_4
vec4 o292_s1 = o69_0_0_rgba;
vec4 o292_s2 = o294_0_0_rgba;
float o292_a = 1.000000*1.0(uv);
vec4 o292_0_0_rgba = vec4(blend_overlay(uv, o292_s1.rgb, o292_s2.rgb, o292_a*o292_s1.a), min(1.0, o292_s2.a+o292_a*o292_s1.a));
vec4 o291_0_0_rgba = vec4(vec3(1.0)-o292_0_0_rgba.rgb, o292_0_0_rgba.a);
// math: _sg21_math_2
float o289_clamp_false = (o291_0_0_rgba).r(uv)-0.500000(uv);
float o289_clamp_true = clamp(o289_clamp_false, 0.0, 1.0);
float o289_0_0_f = o289_clamp_false;
// math: _sg21_math_3
float o288_clamp_false = o289_0_0_f*2.000000(uv);
float o288_clamp_true = clamp(o288_clamp_false, 0.0, 1.0);
float o288_0_0_f = o288_clamp_true;
vec4 o287_0_0_rgba = o287_gradient_gradient_fct;
vec4 o286_0_0_rgba = o286_gradient_gradient_fct;
// blend2: blend2_21
vec4 o3_b = o4_0_0_rgba;
vec4 o3_l;
float o3_a;
o3_l = o286_0_0_rgba;
o3_a = 0.500000*o154_0_0_f;
o3_b = vec4(blend_normal(uv, o3_l.rgb, o3_b.rgb, o3_a*o3_l.a), min(1.0, o3_b.a+o3_a*o3_l.a));
vec4 o3_0_0_rgba = o3_b;
float o301_seed = 0.123450;
float o302_seed = 0.123450;
float o255_seed = 36441482.383450;
// tiler: tiler_5
vec3 o255_instance_uv = vec3(0.0);
vec4 o255_rch = tiler_o255(uv, vec2(12.000000, 12.000000), int(2.000000), o255_instance_uv, vec2(float((float(o255_seed) + fract(_seed_variation_)))));
vec3 o255_2_0_rgb = o255_instance_uv;
// custom_uv: custom_uv
vec3 o302_map = o255_2_0_rgb;
float o302_rnd = float((float(o302_seed) + fract(_seed_variation_)))+o302_map.z;
vec4 o302_0_0_rgba = vec4(vec3(o256_0_0_f), 1.0), 0.000000*0.01745329251, 0.000000, vec2(o302_map.z, float((float(o302_seed) + fract(_seed_variation_)))))), false ? o302_rnd : 0.0);
vec4 o301_0_0_rgba = o301_gradient_gradient_fct;
// blend2: blend2_11
vec4 o2_b = o3_0_0_rgba;
vec4 o2_l;
float o2_a;
o2_l = o301_0_0_rgba;
o2_a = 0.500000*o281_0_0_f;
o2_b = vec4(blend_normal(uv, o2_l.rgb, o2_b.rgb, o2_a*o2_l.a), min(1.0, o2_b.a+o2_a*o2_l.a));
vec4 o2_0_0_rgba = o2_b;
float o303_seed = 0.123450;
float o304_seed = 0.123450;
float o307_seed = 0.123450;
float o309_seed = 0.123450;
float o310_seed = 0.123450;
float o311_seed = 20966927.483450;
float o311_0_0_f = old_fbm_2d_perlin(uv, vec2(5.000000, 5.000000), int(0.000000), int(5.000000), 0.500000, 0.000000(uv), (float(o311_seed) + fract(_seed_variation_)));
float o312_seed = 0.123450;
float o314_seed = 0.123450;
float o317_seed = 0.123450;
float o318_seed = 31919142.523450;
float o318_0_0_f = old_fbm_2d_perlin(uv, vec2(3.000000, 3.000000), int(0.000000), int(3.000000), 0.500000, 0.000000(uv), (float(o318_seed) + fract(_seed_variation_)));
float o317_0_0_f = o318_0_0_f;
vec3 o314_0_0_rgb = nm_o314(uv, 1.000000, 1024.0);
vec4 o312_0_0_rgba = rot2Dnm(vec4(o314_0_0_rgb, 1.0)(uv), 90.000000);
vec4 o310_0_0_rgba = o310_func(uv, 4.000000, 0.230000);
float o319_seed = 0.123450;
float o321_seed = 0.123450;
float o324_seed = 0.123450;
float o325_seed = 18860313.723450;
float o325_0_0_f = old_fbm_2d_perlin(uv, vec2(2.000000, 2.000000), int(0.000000), int(2.000000), 0.500000, 0.000000(uv), (float(o325_seed) + fract(_seed_variation_)));
float o324_0_0_f = o325_0_0_f;
vec3 o321_0_0_rgb = nm_o321(uv, 1.000000, 1024.0);
vec4 o319_0_0_rgba = rot2Dnm(vec4(o321_0_0_rgb, 1.0)(uv), 90.000000);
vec4 o309_0_0_rgba = o309_func(uv, 3.000000, 0.894000);
vec4 o307_0_0_rgba = o307_smartDeNoise(uv, 3.000000, 4.000000, 0.700000);
float o326_seed = 0.123450;
float o328_seed = 0.123450;
float o331_seed = 0.123450;
float o335_seed = 0.123450;
float o338_seed = 0.123450;
float o341_seed = 0.123450;
float o342_seed = 0.123450;
float o342_0_0_f = vec4(0.5, 0.5, 0.5, 1.0)(uv).r;
float o342_seed = 0.123450;
float o342_1_0_f = vec4(0.5, 0.5, 0.5, 1.0)(uv).g;
float o341_0_0_f = (o255_0_0_f-o342_0_0_f)/(o342_1_0_f-o342_0_0_f);
vec4 o338_0_0_rgba = o338_fct(uv);
vec4 o335_0_0_rgba = o335_fct(uv);
float o331_0_0_f = (o335_0_0_rgba).r(uv);
vec3 o328_0_0_rgb = nm_o328(uv, 1.000000, 1024.0);
vec4 o326_0_0_rgba = rot2Dnm(vec4(o328_0_0_rgb, 1.0)(uv), 111.900000);
vec4 o304_0_0_rgba = o304_func(uv, 3.000000, 0.072000);
vec4 o303_0_0_rgba = o303_gradient_gradient_fct;
// blend2: blend2_22
vec4 o1_b = o2_0_0_rgba;
vec4 o1_l;
float o1_a;
o1_l = o303_0_0_rgba;
o1_a = 0.500000*o281_0_0_f;
o1_b = vec4(blend_normal(uv, o1_l.rgb, o1_b.rgb, o1_a*o1_l.a), min(1.0, o1_b.a+o1_a*o1_l.a));
vec4 o1_0_0_rgba = o1_b;
float o345_seed = 0.123450;
vec4 o345_0_0_rgba = vec4(vec3(1.0)-vec4(vec3(o154_0_0_f), 1.0)(uv).rgb, vec4(vec3(o154_0_0_f), 1.0)(uv).a);
float o346_seed = 0.123450;
float o347_seed = 0.123450;
float o348_seed = 0.123450;
// math: _sg21_math_4
float o348_clamp_false = (o291_0_0_rgba).r(uv)+0.500000(uv);
float o348_clamp_true = clamp(o348_clamp_false, 0.0, 1.0);
float o348_0_0_f = o348_clamp_false;
// remap: _sg21_remap
float o347_x = o348_0_0_f*(1.000000-0.000000);
float o347_0_0_f = 0.000000+o347_x-mod(o347_x, max(0.000000, 0.00000001));
vec4 o346_0_0_rgba = o346_gradient_gradient_fct;
// blend2: blend2_6
vec4 o0_b = o1_0_0_rgba;
vec4 o0_l;
float o0_a;
o0_l = o287_0_0_rgba;
o0_a = 0.500000*(o346_0_0_rgba).r(uv);
o0_b = vec4(blend_dodge(uv, o0_l.rgb, o0_b.rgb, o0_a*o0_l.a), min(1.0, o0_b.a+o0_a*o0_l.a));
o0_l = o345_0_0_rgba;
o0_a = 0.370000*1.0(uv);
o0_b = vec4(blend_burn(uv, o0_l.rgb, o0_b.rgb, o0_a*o0_l.a), min(1.0, o0_b.a+o0_a*o0_l.a));
vec4 o0_0_0_rgba = o0_b;
float o349_seed = 0.123450;
float o351_seed = 0.123450;
float o352_seed = 0.123450;
float o352_0_0_f = 0.870000;
float o353_seed = 0.123450;
float o354_seed = 0.123450;
float o354_0_0_f = 0.700000;
float o355_seed = 0.123450;
vec4 o355_0_0_rgba = vec4(vec3(1.0)-o183_0_0_rgba.rgb, o183_0_0_rgba.a);
// blend2: blend2_25
vec4 o353_b = vec4(vec3(o354_0_0_f), 1.0)(uv);
vec4 o353_l;
float o353_a;
o353_l = o355_0_0_rgba;
o353_a = 0.500000*1.0(uv);
o353_b = vec4(blend_normal(uv, o353_l.rgb, o353_b.rgb, o353_a*o353_l.a), min(1.0, o353_b.a+o353_a*o353_l.a));
vec4 o353_0_0_rgba = o353_b;
float o356_seed = 0.123450;
float o356_0_0_f = 0.160000;
float o357_seed = 0.123450;
float o360_seed = 0.123450;
float o363_seed = 0.123450;
float o364_seed = 0.123450;
float o365_seed = 0.123450;
float o366_seed = 0.123450;
float o367_seed = 0.123450;
float o367_0_0_f = o367_fbm(uv, vec2(4.000000, 6.000000), int(0.000000), int(15.000000), 0.620000, float((float(o367_seed) + fract(_seed_variation_))));
float o368_seed = 0.123450;
float o368_0_0_f = o368_fbm(uv, vec2(6.000000, 4.000000), int(0.000000), int(15.000000), 0.620000, float((float(o368_seed) + fract(_seed_variation_))));
// shader: _sg362_791_2
vec2 o366_warp_1 = uv + 2.000000 * vec2(0.500000*(o22_0_0_rgba).rgb(uv).r, -0.500000*(o22_0_0_rgba).rgb(uv).g);
vec2 o366_warp_2 = uv - 2.000000 * vec2(0.500000*(o22_0_0_rgba).rgb(uv).g, -0.500000*(o22_0_0_rgba).rgb(uv).r);
// vec2 o366_mingle = vec2(/*?mingle_strength*/0.0*/*?mingle_u*/0.0, /*?mingle_strength*/0.0*/*?mingle_v*/0.0);
//float o366_blend = smoothstep(mingle_/*?mingle_mode*/0.0, 0.5);
float o366_blend = smoothstep(0.500000-0.500000, 0.500000+0.500000, (o22_0_0_rgba).rgb(uv).b);
vec3 o366_0_0_rgb = blend_burn( uv, vec3(o367_0_0_f)(o366_warp_1), vec3(o368_0_0_f)(o366_warp_2), 1.000000*o366_blend );
float o370_seed = 0.123450;
// shader: _sg362_791_3
vec2 o370_warp_1 = uv + 2.000000 * vec2((-0.500000)*(o29_0_0_rgba).rgb(uv).r, -(-0.500000)*(o29_0_0_rgba).rgb(uv).g);
vec2 o370_warp_2 = uv - 2.000000 * vec2((-0.500000)*(o29_0_0_rgba).rgb(uv).g, -(-0.500000)*(o29_0_0_rgba).rgb(uv).r);
// vec2 o370_mingle = vec2(/*?mingle_strength*/0.0*/*?mingle_u*/0.0, /*?mingle_strength*/0.0*/*?mingle_v*/0.0);
//float o370_blend = smoothstep(mingle_/*?mingle_mode*/0.0, 0.5);
float o370_blend = smoothstep(0.500000-0.500000, 0.500000+0.500000, (o29_0_0_rgba).rgb(uv).b);
vec3 o370_0_0_rgb = blend_dodge( uv, vec3(o368_0_0_f)(o370_warp_1), vec3(o367_0_0_f)(o370_warp_2), 1.000000*o370_blend );
// shader: _sg362_791_4
vec2 o365_warp_1 = uv + 2.000000 * vec2(0.500000*o33_0_0_rgba.r, -(-0.500000)*o33_0_0_rgba.g);
vec2 o365_warp_2 = uv - 2.000000 * vec2(0.500000*o33_0_0_rgba.g, -(-0.500000)*o33_0_0_rgba.r);
float o365_blend_1 = smoothstep(0.500000-0.500000, 0.500000+0.500000, o33_0_0_rgba.b);
float o365_blend_2 = smoothstep(0.500000-0.500000, 0.500000+0.500000, o33_0_0_rgba.b);
vec3 o365_0_0_rgb = blend_overlay( uv, o366_0_0_rgb, o370_0_0_rgb, 1.000000*o365_blend_1 );
float o365_seed = 0.123450;
// shader: _sg362_791_4
vec2 o365_warp_1 = uv + 2.000000 * vec2(0.500000*o33_0_0_rgba.r, -(-0.500000)*o33_0_0_rgba.g);
vec2 o365_warp_2 = uv - 2.000000 * vec2(0.500000*o33_0_0_rgba.g, -(-0.500000)*o33_0_0_rgba.r);
float o365_blend_1 = smoothstep(0.500000-0.500000, 0.500000+0.500000, o33_0_0_rgba.b);
float o365_blend_2 = smoothstep(0.500000-0.500000, 0.500000+0.500000, o33_0_0_rgba.b);
vec3 o365_1_0_rgb = blend_overlay( uv, o366_0_0_rgb, o370_0_0_rgb, 1.000000*o365_blend_2 );
float o372_seed = 0.123450;
// tones_step: _sg362_tones_step
vec3 o372_false = clamp((vec4(vec3(o367_0_0_f), 1.0)(uv).rgb-vec3(0.500000))/max(0.0001, 0.870000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o372_true = vec3(1.0)-o372_false;
vec4 o372_0_0_rgba = vec4(o372_false, vec4(vec3(o367_0_0_f), 1.0)(uv).a);
// blend: _sg362_blend
vec4 o364_s1 = vec4(o365_0_0_rgb, 1.0)(uv);
vec4 o364_s2 = vec4(o365_1_0_rgb, 1.0)(uv);
float o364_a = 1.000000*(o372_0_0_rgba).r(uv);
vec4 o364_0_0_rgba = vec4(blend_burn(uv, o364_s1.rgb, o364_s2.rgb, o364_a*o364_s1.a), min(1.0, o364_s2.a+o364_a*o364_s1.a));
// tones_step: _sg362_tones_step_3
vec3 o363_false = clamp((o364_0_0_rgba.rgb-vec3(0.500000))/max(0.0001, 0.870000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o363_true = vec3(1.0)-o363_false;
vec4 o363_0_0_rgba = vec4(o363_false, o364_0_0_rgba.a);
vec4 o360_0_0_rgba = o360_anisotropic_kuwahara(uv, 6.000000, 1.000000, 1.000000);
float o374_seed = 0.123450;
float o375_seed = 0.123450;
float o376_seed = 0.123450;
float o380_seed = 0.123450;
float o381_seed = 378429.693450;
float o382_seed = 0.123450;
float o383_seed = 0.123450;
float o383_0_0_f = shape_circle(uv, 6.000000+1.0e-5, 1.000000*1.0(uv), 0.320000*1.0(uv));
// math: _sg377_math_2
float o382_clamp_false = sin(o383_0_0_f*3.14 / 2.0(uv));
float o382_clamp_true = clamp(o382_clamp_false, 0.0, 1.0);
float o382_0_0_f = o382_clamp_false;
float o384_seed = 0.123450;
float o385_seed = 13014524.123450;
float o385_0_0_f = old_fbm_2d_perlin(uv, vec2(2.0 * /*?d_scale*/0.0, 2.0 * /*?d_scale*/0.0), int(0.000000), int(2.000000), 0.500000, 0.000000(uv), (float(o385_seed) + fract(_seed_variation_)));
vec4 o384_0_0_rgba = o384_gradient_gradient_fct;
// shader: _sg377_tiler
vec4 o381_rch = tiler_o381(uv, vec2(256.0 * /*?d_scale*/0.0, 256.0 * /*?d_scale*/0.0), int(2.000000), vec2(float((float(o381_seed) + fract(_seed_variation_)))));
float o381_0_0_f = o381_rch.a;
// math: _sg377_math
float o380_clamp_false = o381_0_0_f*0.480000(uv);
float o380_clamp_true = clamp(o380_clamp_false, 0.0, 1.0);
float o380_0_0_f = o380_clamp_false;
float o386_seed = 10546592.123450;
float o386_0_0_f = old_fbm_2d_perlin(uv, vec2(6.000000, 6.000000), int(0.000000), int(2.000000), 0.500000, 0.000000(uv), (float(o386_seed) + fract(_seed_variation_)));
// blend2: blend2_16
vec4 o376_b = vec4(vec3(o380_0_0_f), 1.0)(uv);
vec4 o376_l;
float o376_a;
o376_l = vec4(vec3(o386_0_0_f), 1.0)(uv);
o376_a = 0.500000*1.0(uv);
o376_b = vec4(blend_normal(uv, o376_l.rgb, o376_b.rgb, o376_a*o376_l.a), min(1.0, o376_b.a+o376_a*o376_l.a));
vec4 o376_0_0_rgba = o376_b;
// tones_step: tones_step_6
vec3 o375_false = clamp((o376_0_0_rgba.rgb-vec3(0.360000))/max(0.0001, 0.130000)+vec3(0.5), vec3(0.0), vec3(1.0));
vec3 o375_true = vec3(1.0)-o375_false;
vec4 o375_0_0_rgba = vec4(o375_false, o376_0_0_rgba.a);
float o374_0_0_f = (o375_0_0_rgba).r + fract(_seed_variation_))+0.000000);
float o387_seed = 0.123450;
float o374_seed = 0.123450;
float o374_1_0_f = (o375_0_0_rgba).r + fract(_seed_variation_))+0.100000);
vec4 o387_0_0_rgba = vec4(vec3(1.0)-vec4(vec3(o374_1_0_f), 1.0)(uv).rgb, vec4(vec3(o374_1_0_f), 1.0)(uv).a);
// blend2: blend2_17
vec4 o357_b = o360_0_0_rgba;
vec4 o357_l;
float o357_a;
o357_l = vec4(vec3(o374_0_0_f), 1.0)(uv);
o357_a = 0.760000*(o387_0_0_rgba).r(uv);
o357_b = vec4(blend_screen(uv, o357_l.rgb, o357_b.rgb, o357_a*o357_l.a), min(1.0, o357_b.a+o357_a*o357_l.a));
o357_l = vec4(1.0, uv.y, 1.0, 1.0)(uv);
o357_a = 0.710000*1.0(uv);
o357_b = vec4(blend_multiply(uv, o357_l.rgb, o357_b.rgb, o357_a*o357_l.a), min(1.0, o357_b.a+o357_a*o357_l.a));
vec4 o357_0_0_rgba = o357_b;
float o388_seed = 0.123450;
vec4 o388_0_0_rgba = o388_gradient_gradient_fct;
float o389_seed = 0.123450;
float o390_seed = 0.123450;
vec4 o390_0_0_rgba = vec4(clamp(o291_0_0_rgba.rgb*1.790000+vec3(0.000000)+0.5-1.790000*0.5, vec3(0.0), vec3(1.0)), o291_0_0_rgba.a);
vec4 o389_0_0_rgba = vec4(vec3(1.0)-o390_0_0_rgba.rgb, o390_0_0_rgba.a);
// blend2: blend2_15
vec4 o351_b = vec4(vec3(o352_0_0_f), 1.0)(uv);
vec4 o351_l;
float o351_a;
o351_l = o353_0_0_rgba;
o351_a = 1.000000*(o357_0_0_rgba).r(uv);
o351_b = vec4(blend_normal(uv, o351_l.rgb, o351_b.rgb, o351_a*o351_l.a), min(1.0, o351_b.a+o351_a*o351_l.a));
o351_l = vec4(vec3(o154_0_0_f), 1.0)(uv);
o351_a = 1.000000*(o388_0_0_rgba).r(uv);
o351_b = vec4(blend_normal(uv, o351_l.rgb, o351_b.rgb, o351_a*o351_l.a), min(1.0, o351_b.a+o351_a*o351_l.a));
o351_l = vec4(vec3(o356_0_0_f), 1.0)(uv);
o351_a = 0.320000*(o389_0_0_rgba).r(uv);
o351_b = vec4(blend_overlay(uv, o351_l.rgb, o351_b.rgb, o351_a*o351_l.a), min(1.0, o351_b.a+o351_a*o351_l.a));
o351_l = vec4(vec3(o281_0_0_f), 1.0)(uv);
o351_a = 0.230000*1.0(uv);
o351_b = vec4(blend_overlay(uv, o351_l.rgb, o351_b.rgb, o351_a*o351_l.a), min(1.0, o351_b.a+o351_a*o351_l.a));
vec4 o351_0_0_rgba = o351_b;
vec3 o349_0_0_rgb = o349_fct(uv);
float o391_seed = 0.123450;
// blend2: blend2_18
vec4 o391_b = vec4(vec3(o281_0_0_f), 1.0)(uv);
vec4 o391_l;
float o391_a;
o391_l = o0_0_0_rgba;
o391_a = 0.500000*1.0(uv);
o391_b = vec4(blend_normal(uv, o391_l.rgb, o391_b.rgb, o391_a*o391_l.a), min(1.0, o391_b.a+o391_a*o391_l.a));
vec4 o391_0_0_rgba = o391_b;
float o396_seed = 0.123450;
float o398_seed = 0.123450;
float o398_0_0_f = o398_hbao(uv,0.100000, 15.000000, 1.000000, vec2(16.0,16.0));
vec4 o396_0_0_rgba = o396_smartDeNoise(uv, 3.000000, 4.000000, 0.700000);
ALBEDO = (o0_0_0_rgba).rgb;
ROUGHNESS = (o349_0_0_rgb).r * 1.0000;
EMISSION = (o391_0_0_rgba).rgb * 0.2000;
NORMAL_MAP = o314_0_0_rgb;
NORMAL_MAP_DEPTH = 1.0000;
AO = (o396_0_0_rgba).r * 1.0000;
}