Compiling large shader files results in stack overflow #2770
Description
Version of vulkano
0.35.1
OS (incl. version)
Win 11
Selected physical device
NVIDIA GeForce RTX 3060 Ti
Driver (incl. version)
581.29
Issue description
Compiling large (1046 LoC) compute shader results in stack overflow in thread main using the following code:
let compute_ray_tracing = compute::ray_tracing::load(
logical_gpu.vulkano_device.clone(),
).expect("Failed to load shader compute :: ray_tracing");
The stack trace looks like this:
__chkstk() 0x00007ff728762367
enum2$<vulkano::shader::spirv::ExecutionMode>::parse() spirv_parse.rs:12478
enum2$<vulkano::shader::spirv::Instruction>::parse() spirv_parse.rs:4587
vulkano::shader::spirv::iter_instructions::closure$0(*mut vulkano::shader::spirv::iter_instructions::closure_env$0) mod.rs:718
core::iter::sources::from_fn::impl$0::next<enum2$<core::result::Result<enum2$<vulkano::shader::spirv::Instruction>,vulkano::shader::spirv::ParseError>
>,vulkano::shader::spirv::iter_instructions::closure_env$0>(*mut core::iter::sources::from_fn::FromFn<vulkano::shader::spirv::iter_instructions::closure_env$0>) from_fn.rs:71
vulkano::shader::spirv::Spirv::new(ref$<slice2$<u32> >) mod.rs:82
vulkano::shader::ShaderModule::new(alloc::sync::Arc<vulkano::device::Device,alloc::alloc::Global>,vulkano::shader::ShaderModuleCreateInfo) mod.rs:471
where the function Spirv::new receives an array slice in words argument of 17592 elements.
The issue is reproducible in debug and release builds.
Current workaround - increase stack space for Windows target using:
- Create or edit
.cargo/config.toml - Add the following:
[target.x86_64-pc-windows-msvc]
rustflags = ["-C", "link-args=/STACK:<more then 1 MB>"]
Minimal reproducible example
Asked LLM to create a compute shader with 1000+ LoC that reproduces the issue
Big shader
#version 450
layout(local_size_x = 32, local_size_y = 32) in;
layout(set = 0, rgba8, binding = 0) uniform image2D out_image;
struct dummy_a { float x; float y; float z; };
struct dummy_b { float x; float y; };
struct dummy_c { float x; float y; float z; float w; };
struct dummy_d { dummy_a a; dummy_b b; };
struct dummy_e { dummy_c c; dummy_a a; };
struct dummy_f { float x; float y; float z; float w; float v; };
struct dummy_g { dummy_f f; dummy_b b; };
struct dummy_h { float a; float b; float c; float d; float e; float f; };
struct dummy_i { dummy_h h; dummy_a a; };
struct dummy_j { dummy_i i; dummy_b b; };
float fn_a(float x) { return x * 1.1 + 0.1; }
float fn_b(float x) { return x * 2.2 - 0.2; }
float fn_c(float x) { return x * 3.3 + 0.3; }
float fn_d(float x) { return x * 4.4 - 0.4; }
float fn_e(float x) { return x * 5.5 + 0.5; }
float fn_f(float x) { return x * 6.6 - 0.6; }
float fn_g(float x) { return x * 7.7 + 0.7; }
float fn_h(float x) { return x * 8.8 - 0.8; }
float fn_i(float x) { return x * 9.9 + 0.9; }
float fn_j(float x) { return x * 1.0 - 1.0; }
float fn_k(float x) { return x * 1.1 + 1.1; }
float fn_l(float x) { return x * 1.2 - 1.2; }
float fn_m(float x) { return x * 1.3 + 1.3; }
float fn_n(float x) { return x * 1.4 - 1.4; }
float fn_o(float x) { return x * 1.5 + 1.5; }
float fn_p(float x) { return x * 1.6 - 1.6; }
float fn_q(float x) { return x * 1.7 + 1.7; }
float fn_r(float x) { return x * 1.8 - 1.8; }
float fn_s(float x) { return x * 1.9 + 1.9; }
float fn_t(float x) { return x * 2.0 - 2.0; }
float fn_u(float x) { return x * 2.1 + 2.1; }
float fn_v(float x) { return x * 2.2 - 2.2; }
float fn_w(float x) { return x * 2.3 + 2.3; }
float fn_x(float x) { return x * 2.4 - 2.4; }
float fn_y(float x) { return x * 2.5 + 2.5; }
float fn_z(float x) { return x * 2.6 - 2.6; }
vec3 vec_fn_a(vec3 v) { return v * 1.1 + vec3(0.1); }
vec3 vec_fn_b(vec3 v) { return v * 2.2 - vec3(0.2); }
vec3 vec_fn_c(vec3 v) { return v * 3.3 + vec3(0.3); }
vec3 vec_fn_d(vec3 v) { return v * 4.4 - vec3(0.4); }
vec3 vec_fn_e(vec3 v) { return v * 5.5 + vec3(0.5); }
vec3 vec_fn_f(vec3 v) { return v * 6.6 - vec3(0.6); }
vec3 vec_fn_g(vec3 v) { return v * 7.7 + vec3(0.7); }
vec3 vec_fn_h(vec3 v) { return v * 8.8 - vec3(0.8); }
vec3 vec_fn_i(vec3 v) { return v * 9.9 + vec3(0.9); }
vec3 vec_fn_j(vec3 v) { return v * 1.0 - vec3(1.0); }
vec3 vec_fn_k(vec3 v) { return v * 1.1 + vec3(1.1); }
vec3 vec_fn_l(vec3 v) { return v * 1.2 - vec3(1.2); }
vec3 vec_fn_m(vec3 v) { return v * 1.3 + vec3(1.3); }
vec3 vec_fn_n(vec3 v) { return v * 1.4 - vec3(1.4); }
vec3 vec_fn_o(vec3 v) { return v * 1.5 + vec3(1.5); }
vec3 vec_fn_p(vec3 v) { return v * 1.6 - vec3(1.6); }
vec3 vec_fn_q(vec3 v) { return v * 1.7 + vec3(1.7); }
vec3 vec_fn_r(vec3 v) { return v * 1.8 - vec3(1.8); }
vec3 vec_fn_s(vec3 v) { return v * 1.9 + vec3(1.9); }
vec3 vec_fn_t(vec3 v) { return v * 2.0 - vec3(2.0); }
vec3 vec_fn_u(vec3 v) { return v * 2.1 + vec3(2.1); }
vec3 vec_fn_v(vec3 v) { return v * 2.2 - vec3(2.2); }
vec3 vec_fn_w(vec3 v) { return v * 2.3 + vec3(2.3); }
vec3 vec_fn_x(vec3 v) { return v * 2.4 - vec3(2.4); }
vec3 vec_fn_y(vec3 v) { return v * 2.5 + vec3(2.5); }
vec3 vec_fn_z(vec3 v) { return v * 2.6 - vec3(2.6); }
float chain_a(float x) { return fn_a(fn_b(fn_c(x))); }
float chain_b(float x) { return fn_d(fn_e(fn_f(x))); }
float chain_c(float x) { return fn_g(fn_h(fn_i(x))); }
float chain_d(float x) { return fn_j(fn_k(fn_l(x))); }
float chain_e(float x) { return fn_m(fn_n(fn_o(x))); }
float chain_f(float x) { return fn_p(fn_q(fn_r(x))); }
float chain_g(float x) { return fn_s(fn_t(fn_u(x))); }
float chain_h(float x) { return fn_v(fn_w(fn_x(x))); }
float chain_i(float x) { return fn_y(fn_z(fn_a(x))); }
float chain_j(float x) { return fn_b(fn_c(fn_d(x))); }
float chain_k(float x) { return fn_e(fn_f(fn_g(x))); }
float chain_l(float x) { return fn_h(fn_i(fn_j(x))); }
float chain_m(float x) { return fn_k(fn_l(fn_m(x))); }
float chain_n(float x) { return fn_n(fn_o(fn_p(x))); }
float chain_o(float x) { return fn_q(fn_r(fn_s(x))); }
float chain_p(float x) { return fn_t(fn_u(fn_v(x))); }
float chain_q(float x) { return fn_w(fn_x(fn_y(x))); }
float chain_r(float x) { return fn_z(fn_a(fn_b(x))); }
float chain_s(float x) { return fn_c(fn_d(fn_e(x))); }
float chain_t(float x) { return fn_f(fn_g(fn_h(x))); }
float chain_u(float x) { return fn_i(fn_j(fn_k(x))); }
float chain_v(float x) { return fn_l(fn_m(fn_n(x))); }
float chain_w(float x) { return fn_o(fn_p(fn_q(x))); }
float chain_x(float x) { return fn_r(fn_s(fn_t(x))); }
float chain_y(float x) { return fn_u(fn_v(fn_w(x))); }
float chain_z(float x) { return fn_x(fn_y(fn_z(x))); }
vec3 vec_chain_a(vec3 v) { return vec_fn_a(vec_fn_b(vec_fn_c(v))); }
vec3 vec_chain_b(vec3 v) { return vec_fn_d(vec_fn_e(vec_fn_f(v))); }
vec3 vec_chain_c(vec3 v) { return vec_fn_g(vec_fn_h(vec_fn_i(v))); }
vec3 vec_chain_d(vec3 v) { return vec_fn_j(vec_fn_k(vec_fn_l(v))); }
vec3 vec_chain_e(vec3 v) { return vec_fn_m(vec_fn_n(vec_fn_o(v))); }
vec3 vec_chain_f(vec3 v) { return vec_fn_p(vec_fn_q(vec_fn_r(v))); }
vec3 vec_chain_g(vec3 v) { return vec_fn_s(vec_fn_t(vec_fn_u(v))); }
vec3 vec_chain_h(vec3 v) { return vec_fn_v(vec_fn_w(vec_fn_x(v))); }
vec3 vec_chain_i(vec3 v) { return vec_fn_y(vec_fn_z(vec_fn_a(v))); }
vec3 vec_chain_j(vec3 v) { return vec_fn_b(vec_fn_c(vec_fn_d(v))); }
vec3 vec_chain_k(vec3 v) { return vec_fn_e(vec_fn_f(vec_fn_g(v))); }
vec3 vec_chain_l(vec3 v) { return vec_fn_h(vec_fn_i(vec_fn_j(v))); }
vec3 vec_chain_m(vec3 v) { return vec_fn_k(vec_fn_l(vec_fn_m(v))); }
vec3 vec_chain_n(vec3 v) { return vec_fn_n(vec_fn_o(vec_fn_p(v))); }
vec3 vec_chain_o(vec3 v) { return vec_fn_q(vec_fn_r(vec_fn_s(v))); }
vec3 vec_chain_p(vec3 v) { return vec_fn_t(vec_fn_u(vec_fn_v(v))); }
vec3 vec_chain_q(vec3 v) { return vec_fn_w(vec_fn_x(vec_fn_y(v))); }
vec3 vec_chain_r(vec3 v) { return vec_fn_z(vec_fn_a(vec_fn_b(v))); }
vec3 vec_chain_s(vec3 v) { return vec_fn_c(vec_fn_d(vec_fn_e(v))); }
vec3 vec_chain_t(vec3 v) { return vec_fn_f(vec_fn_g(vec_fn_h(v))); }
vec3 vec_chain_u(vec3 v) { return vec_fn_i(vec_fn_j(vec_fn_k(v))); }
vec3 vec_chain_v(vec3 v) { return vec_fn_l(vec_fn_m(vec_fn_n(v))); }
vec3 vec_chain_w(vec3 v) { return vec_fn_o(vec_fn_p(vec_fn_q(v))); }
vec3 vec_chain_x(vec3 v) { return vec_fn_r(vec_fn_s(vec_fn_t(v))); }
vec3 vec_chain_y(vec3 v) { return vec_fn_u(vec_fn_v(vec_fn_w(v))); }
vec3 vec_chain_z(vec3 v) { return vec_fn_x(vec_fn_y(vec_fn_z(v))); }
float mega_chain_a(float x) { return chain_a(chain_b(chain_c(chain_d(x)))); }
float mega_chain_b(float x) { return chain_e(chain_f(chain_g(chain_h(x)))); }
float mega_chain_c(float x) { return chain_i(chain_j(chain_k(chain_l(x)))); }
float mega_chain_d(float x) { return chain_m(chain_n(chain_o(chain_p(x)))); }
float mega_chain_e(float x) { return chain_q(chain_r(chain_s(chain_t(x)))); }
float mega_chain_f(float x) { return chain_u(chain_v(chain_w(chain_x(x)))); }
float mega_chain_g(float x) { return chain_y(chain_z(chain_a(chain_b(x)))); }
float mega_chain_h(float x) { return chain_c(chain_d(chain_e(chain_f(x)))); }
float mega_chain_i(float x) { return chain_g(chain_h(chain_i(chain_j(x)))); }
float mega_chain_j(float x) { return chain_k(chain_l(chain_m(chain_n(x)))); }
vec3 mega_vec_chain_a(vec3 v) { return vec_chain_a(vec_chain_b(vec_chain_c(vec_chain_d(v)))); }
vec3 mega_vec_chain_b(vec3 v) { return vec_chain_e(vec_chain_f(vec_chain_g(vec_chain_h(v)))); }
vec3 mega_vec_chain_c(vec3 v) { return vec_chain_i(vec_chain_j(vec_chain_k(vec_chain_l(v)))); }
vec3 mega_vec_chain_d(vec3 v) { return vec_chain_m(vec_chain_n(vec_chain_o(vec_chain_p(v)))); }
vec3 mega_vec_chain_e(vec3 v) { return vec_chain_q(vec_chain_r(vec_chain_s(vec_chain_t(v)))); }
vec3 mega_vec_chain_f(vec3 v) { return vec_chain_u(vec_chain_v(vec_chain_w(vec_chain_x(v)))); }
vec3 mega_vec_chain_g(vec3 v) { return vec_chain_y(vec_chain_z(vec_chain_a(vec_chain_b(v)))); }
vec3 mega_vec_chain_h(vec3 v) { return vec_chain_c(vec_chain_d(vec_chain_e(vec_chain_f(v)))); }
vec3 mega_vec_chain_i(vec3 v) { return vec_chain_g(vec_chain_h(vec_chain_i(vec_chain_j(v)))); }
vec3 mega_vec_chain_j(vec3 v) { return vec_chain_k(vec_chain_l(vec_chain_m(vec_chain_n(v)))); }
float compute_a(float x, float y) {
float a = mega_chain_a(x);
float b = mega_chain_b(y);
float c = mega_chain_c(a + b);
float d = mega_chain_d(a - b);
float e = mega_chain_e(c * d);
return e;
}
float compute_b(float x, float y) {
float a = mega_chain_f(x);
float b = mega_chain_g(y);
float c = mega_chain_h(a + b);
float d = mega_chain_i(a - b);
float e = mega_chain_j(c * d);
return e;
}
vec3 compute_vec_a(vec3 v, vec3 w) {
vec3 a = mega_vec_chain_a(v);
vec3 b = mega_vec_chain_b(w);
vec3 c = mega_vec_chain_c(a + b);
vec3 d = mega_vec_chain_d(a - b);
vec3 e = mega_vec_chain_e(c * d);
return e;
}
vec3 compute_vec_b(vec3 v, vec3 w) {
vec3 a = mega_vec_chain_f(v);
vec3 b = mega_vec_chain_g(w);
vec3 c = mega_vec_chain_h(a + b);
vec3 d = mega_vec_chain_i(a - b);
vec3 e = mega_vec_chain_j(c * d);
return e;
}
float dummy_branch_a(float x) {
if (x > 0.5) { return compute_a(x, x * 2.0); }
else { return compute_b(x, x * 3.0); }
}
float dummy_branch_b(float x) {
if (x > 0.25) { return compute_a(x * 2.0, x); }
else { return compute_b(x * 3.0, x); }
}
float dummy_branch_c(float x) {
if (x > 0.75) { return compute_a(x, x); }
else { return compute_b(x, x); }
}
vec3 dummy_vec_branch_a(vec3 v) {
if (v.x > 0.5) { return compute_vec_a(v, v * 2.0); }
else { return compute_vec_b(v, v * 3.0); }
}
vec3 dummy_vec_branch_b(vec3 v) {
if (v.y > 0.25) { return compute_vec_a(v * 2.0, v); }
else { return compute_vec_b(v * 3.0, v); }
}
vec3 dummy_vec_branch_c(vec3 v) {
if (v.z > 0.75) { return compute_vec_a(v, v); }
else { return compute_vec_b(v, v); }
}
float loop_a(float x) {
float result = x;
for (int i = 0; i < 4; i++) { result = dummy_branch_a(result); }
return result;
}
float loop_b(float x) {
float result = x;
for (int i = 0; i < 4; i++) { result = dummy_branch_b(result); }
return result;
}
float loop_c(float x) {
float result = x;
for (int i = 0; i < 4; i++) { result = dummy_branch_c(result); }
return result;
}
vec3 vec_loop_a(vec3 v) {
vec3 result = v;
for (int i = 0; i < 4; i++) { result = dummy_vec_branch_a(result); }
return result;
}
vec3 vec_loop_b(vec3 v) {
vec3 result = v;
for (int i = 0; i < 4; i++) { result = dummy_vec_branch_b(result); }
return result;
}
vec3 vec_loop_c(vec3 v) {
vec3 result = v;
for (int i = 0; i < 4; i++) { result = dummy_vec_branch_c(result); }
return result;
}
float mat2_det(float a, float b, float c, float d) { return a * d - b * c; }
float mat2_trace(float a, float d) { return a + d; }
float lerp_f(float a, float b, float t) { return a + (b - a) * t; }
float smooth_f(float x) { return x * x * (3.0 - 2.0 * x); }
float remap_f(float x, float lo, float hi) { return (x - lo) / (hi - lo); }
float clamp01(float x) { return clamp(x, 0.0, 1.0); }
float sq(float x) { return x * x; }
float cb(float x) { return x * x * x; }
float inv(float x) { return 1.0 / (x + 0.0001); }
float neg(float x) { return -x; }
float abf(float x) { return abs(x); }
float sgn(float x) { return sign(x); }
float flr(float x) { return floor(x); }
float cel(float x) { return ceil(x); }
float frc(float x) { return fract(x); }
float rnd(float x) { return round(x); }
float mn2(float a, float b) { return min(a, b); }
float mx2(float a, float b) { return max(a, b); }
float pw2(float x) { return pow(x, 2.0); }
float pw3(float x) { return pow(x, 3.0); }
float pw4(float x) { return pow(x, 4.0); }
float sqr(float x) { return sqrt(abs(x)); }
float lg2(float x) { return log2(abs(x) + 0.0001); }
float ex2(float x) { return exp2(clamp(x, -10.0, 10.0)); }
float sn(float x) { return sin(x); }
float cs(float x) { return cos(x); }
float tn(float x) { return tan(clamp(x, -1.5, 1.5)); }
float asn(float x) { return asin(clamp01(x)); }
float acs(float x) { return acos(clamp01(x)); }
float atn(float x) { return atan(x); }
vec3 lerp_v(vec3 a, vec3 b, float t) { return a + (b - a) * t; }
vec3 smooth_v(vec3 v) { return v * v * (vec3(3.0) - 2.0 * v); }
vec3 remap_v(vec3 v, float lo, float hi) { return (v - lo) / (hi - lo); }
vec3 clamp01_v(vec3 v) { return clamp(v, vec3(0.0), vec3(1.0)); }
vec3 sq_v(vec3 v) { return v * v; }
vec3 cb_v(vec3 v) { return v * v * v; }
vec3 inv_v(vec3 v) { return vec3(1.0) / (v + vec3(0.0001)); }
vec3 neg_v(vec3 v) { return -v; }
vec3 abf_v(vec3 v) { return abs(v); }
vec3 sgn_v(vec3 v) { return sign(v); }
vec3 flr_v(vec3 v) { return floor(v); }
vec3 cel_v(vec3 v) { return ceil(v); }
vec3 frc_v(vec3 v) { return fract(v); }
vec3 rnd_v(vec3 v) { return round(v); }
vec3 mn2_v(vec3 a, vec3 b) { return min(a, b); }
vec3 mx2_v(vec3 a, vec3 b) { return max(a, b); }
vec3 pw2_v(vec3 v) { return pow(v, vec3(2.0)); }
vec3 pw3_v(vec3 v) { return pow(v, vec3(3.0)); }
vec3 sqr_v(vec3 v) { return sqrt(abs(v)); }
vec3 sn_v(vec3 v) { return sin(v); }
vec3 cs_v(vec3 v) { return cos(v); }
vec3 nrm(vec3 v) { return normalize(v + vec3(0.0001)); }
vec3 rfl(vec3 v, vec3 n) { return reflect(v, nrm(n)); }
vec3 rfr(vec3 v, vec3 n, float r) { return refract(nrm(v), nrm(n), r); }
float dt(vec3 a, vec3 b) { return dot(a, b); }
float dt(vec2 a, vec2 b) { return dot(a, b); }
vec3 cr(vec3 a, vec3 b) { return cross(a, b); }
float lngt(vec3 v) { return length(v); }
float lngt(vec2 v) { return length(v); }
float dist(vec3 a, vec3 b) { return distance(a, b); }
float max_3(float a, float b, float c) { return max(a, max(b, c)); }
float mn_3(float a, float b, float c) { return min(a, min(b, c)); }
float hash_a(float n) { return fract(sin(n) * 43758.5453123); }
float math_chain_a(float x) { return sn(cs(tn(x))); }
float math_chain_b(float x) { return sq(cb(sqr(x))); }
float math_chain_c(float x) { return lg2(ex2(abf(x))); }
float math_chain_d(float x) { return smooth_f(remap_f(clamp01(x), 0.1, 0.9)); }
float math_chain_e(float x) { return pw2(pw3(pw4(x * 0.1))); }
float math_chain_f(float x) { return asn(acs(atn(clamp01(x)))); }
float math_chain_g(float x) { return flr(cel(rnd(x))); }
float math_chain_h(float x) { return mn2(mx2(x, -1.0), 1.0); }
float math_chain_i(float x) { return lerp_f(x, neg(x), 0.5); }
float math_chain_j(float x) { return inv(sgn(x) + 0.5); }
vec3 math_vec_chain_a(vec3 v) { return sn_v(cs_v(abf_v(v))); }
vec3 math_vec_chain_b(vec3 v) { return sq_v(cb_v(sqr_v(v * 0.1))); }
vec3 math_vec_chain_c(vec3 v) { return smooth_v(remap_v(clamp01_v(v), 0.1, 0.9)); }
vec3 math_vec_chain_d(vec3 v) { return pw2_v(pw3_v(abf_v(v * 0.1))); }
vec3 math_vec_chain_e(vec3 v) { return mn2_v(mx2_v(v, vec3(-1.0)), vec3(1.0)); }
vec3 math_vec_chain_f(vec3 v) { return lerp_v(v, neg_v(v), 0.5); }
vec3 math_vec_chain_g(vec3 v) { return inv_v(sgn_v(v) + vec3(0.5)); }
vec3 math_vec_chain_h(vec3 v) { return nrm(rfl(v, vec3(0.0, 1.0, 0.0))); }
vec3 math_vec_chain_i(vec3 v) { return flr_v(cel_v(frc_v(v))); }
vec3 math_vec_chain_j(vec3 v) { return rnd_v(abf_v(sn_v(v))); }
float geo_fn_a(vec3 p) { return lngt(p) - 1.0; }
float geo_fn_b(vec3 p) { return mx2(mx2(abf(p.x), abf(p.y)), abf(p.z)) - 1.0; }
float geo_fn_c(vec3 p) { return lngt(vec3(lngt(p.xy) - 0.5, 0.0, p.z)) - 0.25; }
float geo_fn_d(vec3 p) { float d = lngt(p) - 1.0; return d * sgn(dt(p, vec3(0.0, 1.0, 0.0))); }
float geo_fn_e(vec3 p) { vec3 q = abf_v(p) - vec3(1.0); return lngt(mx2_v(q, vec3(0.0))) + mn2(mx2(q.x, mx2(q.y, q.z)), 0.0); }
float geo_fn_f(vec3 p) { return -geo_fn_a(p); }
float geo_fn_g(vec3 p) { return mn2(geo_fn_a(p), geo_fn_b(p)); }
float geo_fn_h(vec3 p) { return mx2(geo_fn_a(p), geo_fn_b(p)); }
float geo_fn_i(vec3 p) { return mx2(geo_fn_a(p), -geo_fn_b(p)); }
float geo_fn_j(vec3 p) { return smooth_f(clamp01(remap_f(geo_fn_a(p), -0.1, 0.1))); }
vec3 geo_color_a(vec3 p) { return vec3(smooth_f(clamp01(geo_fn_a(p) + 0.5))); }
vec3 geo_color_b(vec3 p) { return vec3(clamp01(geo_fn_b(p) * 0.5 + 0.5)); }
vec3 geo_color_c(vec3 p) { return mix(vec3(1.0, 0.0, 0.0), vec3(0.0, 0.0, 1.0), clamp01(geo_fn_c(p))); }
vec3 geo_color_d(vec3 p) { return vec3(abf(geo_fn_d(p))); }
vec3 geo_color_e(vec3 p) { return nrm(vec3(geo_fn_e(p + vec3(0.001, 0.0, 0.0)) - geo_fn_e(p - vec3(0.001, 0.0, 0.0)), geo_fn_e(p + vec3(0.0, 0.001, 0.0)) - geo_fn_e(p - vec3(0.0, 0.001, 0.0)), geo_fn_e(p + vec3(0.0, 0.0, 0.001)) - geo_fn_e(p - vec3(0.0, 0.0, 0.001)))); }
float noise_a(vec2 p) { return frc(sn(dt(p, vec2(127.1, 311.7))) * 43758.5453); }
float noise_b(vec2 p) { vec2 i = flr_v(vec3(p, 0.0)).xy; vec2 f = frc_v(vec3(p, 0.0)).xy; float a = noise_a(i); float b = noise_a(i + vec2(1.0, 0.0)); float c = noise_a(i + vec2(0.0, 1.0)); float d = noise_a(i + vec2(1.0, 1.0)); vec2 u = f * f * (vec2(3.0) - 2.0 * f); return mix(mix(a, b, u.x), mix(c, d, u.x), u.y); }
float noise_c(vec2 p) { return noise_b(p) * 0.5 + noise_b(p * 2.0) * 0.25 + noise_b(p * 4.0) * 0.125; }
float noise_d(vec2 p) { return noise_c(p) * 0.5 + noise_c(p * 2.0 + vec2(5.2, 1.3)) * 0.5; }
float noise_e(vec2 p) { return smooth_f(clamp01(noise_d(p))); }
vec3 palette_a(float t) { return vec3(0.5) + vec3(0.5) * cs_v(6.28318 * (vec3(1.0) * t + vec3(0.0, 0.33, 0.67))); }
vec3 palette_b(float t) { return vec3(0.5) + vec3(0.5) * cs_v(6.28318 * (vec3(1.0, 0.7, 0.4) * t + vec3(0.0, 0.15, 0.20))); }
vec3 palette_c(float t) { return mix(vec3(0.2, 0.1, 0.4), vec3(0.9, 0.6, 0.1), smooth_f(clamp01(t))); }
vec3 palette_d(float t) { return mix(palette_a(t), palette_b(t), 0.5); }
vec3 palette_e(float t) { return nrm(palette_c(t) + vec3(0.01)); }
float combine_a(float a, float b, float c) { return math_chain_a(a) + math_chain_b(b) + math_chain_c(c); }
float combine_b(float a, float b, float c) { return math_chain_d(a) * math_chain_e(b) - math_chain_f(c); }
float combine_c(float a, float b, float c) { return math_chain_g(a + b) + math_chain_h(b + c) + math_chain_i(a + c); }
float combine_d(float a, float b, float c) { return math_chain_j(a * b * c); }
float combine_e(float a, float b, float c) { return mn2(mx2(combine_a(a, b, c), combine_b(a, b, c)), combine_c(a, b, c)); }
vec3 combine_vec_a(vec3 u, vec3 v, vec3 w) { return math_vec_chain_a(u) + math_vec_chain_b(v) + math_vec_chain_c(w); }
vec3 combine_vec_b(vec3 u, vec3 v, vec3 w) { return math_vec_chain_d(u) * math_vec_chain_e(v) - math_vec_chain_f(w); }
vec3 combine_vec_c(vec3 u, vec3 v, vec3 w) { return math_vec_chain_g(u + v) + math_vec_chain_h(v + w) + math_vec_chain_i(u + w); }
vec3 combine_vec_d(vec3 u, vec3 v, vec3 w) { return math_vec_chain_j(u * v * w); }
vec3 combine_vec_e(vec3 u, vec3 v, vec3 w) { return mn2_v(mx2_v(combine_vec_a(u, v, w), combine_vec_b(u, v, w)), combine_vec_c(u, v, w)); }
float shade_a(vec3 p, vec3 n, vec3 l) { return clamp01(dt(n, nrm(l - p))); }
float shade_b(vec3 p, vec3 n, vec3 l, vec3 e) { vec3 h = nrm(nrm(l - p) + nrm(e - p)); return pw4(clamp01(dt(n, h))); }
float shade_c(vec3 p, vec3 n, vec3 l) { return shade_a(p, n, l) * 0.8 + 0.2; }
float shade_d(vec3 p, vec3 n, vec3 l, vec3 e) { return shade_c(p, n, l) + shade_b(p, n, l, e) * 0.5; }
vec3 light_a(vec3 p, vec3 n) { vec3 l = vec3(1.0, 2.0, 3.0); return palette_a(shade_a(p, n, l)); }
vec3 light_b(vec3 p, vec3 n) { vec3 l = vec3(-2.0, 1.0, 1.0); return palette_b(shade_c(p, n, l)); }
vec3 light_c(vec3 p, vec3 n, vec3 e) { vec3 l = vec3(0.0, 3.0, -1.0); return palette_c(shade_d(p, n, l, e)); }
vec3 light_d(vec3 p, vec3 n, vec3 e) { return light_a(p, n) * 0.4 + light_b(p, n) * 0.4 + light_c(p, n, e) * 0.2; }
float march_a(vec3 ro, vec3 rd) { float t = 0.0; for (int i = 0; i < 16; i++) { float d = geo_fn_a(ro + rd * t); if (d < 0.001) break; t += d; if (t > 10.0) break; } return t; }
float march_b(vec3 ro, vec3 rd) { float t = 0.0; for (int i = 0; i < 16; i++) { float d = geo_fn_b(ro + rd * t); if (d < 0.001) break; t += d; if (t > 10.0) break; } return t; }
float march_c(vec3 ro, vec3 rd) { float t = 0.0; for (int i = 0; i < 16; i++) { float d = geo_fn_c(ro + rd * t); if (d < 0.001) break; t += d; if (t > 10.0) break; } return t; }
vec3 render_a(vec3 ro, vec3 rd) { float t = march_a(ro, rd); vec3 p = ro + rd * t; vec3 n = geo_color_e(p); return light_d(p, n, ro); }
vec3 render_b(vec3 ro, vec3 rd) { float t = march_b(ro, rd); vec3 p = ro + rd * t; vec3 n = geo_color_e(p); return light_d(p, n, ro); }
vec3 render_c(vec3 ro, vec3 rd) { float t = march_c(ro, rd); vec3 p = ro + rd * t; vec3 n = geo_color_e(p); return light_d(p, n, ro); }
vec3 render_d(vec3 ro, vec3 rd) { return render_a(ro, rd) * 0.33 + render_b(ro, rd) * 0.33 + render_c(ro, rd) * 0.34; }
float post_a(float x) { return pw2(clamp01(x)); }
float post_b(float x) { return x * (2.0 - x); }
float post_c(float x) { return mn2(1.0, x * 1.1); }
vec3 post_vec_a(vec3 v) { return vec3(post_a(v.x), post_a(v.y), post_a(v.z)); }
vec3 post_vec_b(vec3 v) { return vec3(post_b(v.x), post_b(v.y), post_b(v.z)); }
vec3 post_vec_c(vec3 v) { return vec3(post_c(v.x), post_c(v.y), post_c(v.z)); }
vec3 post_vec_d(vec3 v) { return post_vec_a(post_vec_b(post_vec_c(v))); }
vec3 tonemap_a(vec3 v) { return v / (v + vec3(1.0)); }
vec3 tonemap_b(vec3 v) { vec3 x = mx2_v(vec3(0.0), v - vec3(0.004)); return (x * (6.2 * x + vec3(0.5))) / (x * (6.2 * x + vec3(1.7)) + vec3(0.06)); }
vec3 tonemap_c(vec3 v) { return post_vec_d(tonemap_a(tonemap_b(v))); }
vec3 full_render(vec2 uv) {
vec3 ro = vec3(0.0, 0.0, -3.0);
vec3 rd = nrm(vec3(uv * 2.0 - vec2(1.0), 1.5));
float n = noise_e(uv * 4.0);
vec3 col = render_d(ro, rd);
col = mix(col, palette_d(n), 0.1);
col = tonemap_c(col);
float s = combine_a(uv.x, uv.y, n);
float s2 = combine_b(uv.x, uv.y, s);
float s3 = combine_c(s, s2, n);
float s4 = combine_d(s, s2, s3);
float s5 = combine_e(s, s2, s3);
vec3 cv = combine_vec_a(col, palette_a(s), palette_b(s2));
vec3 cv2 = combine_vec_b(col, cv, palette_c(s3));
vec3 cv3 = combine_vec_c(cv, cv2, palette_d(s4));
vec3 cv4 = combine_vec_d(cv2, cv3, palette_e(s5));
vec3 cv5 = combine_vec_e(cv3, cv4, col);
return clamp01_v(cv5);
}
float extra_a_01(float x) { return sn(x * 1.01) + cs(x * 0.99); }
float extra_a_02(float x) { return sn(x * 1.02) + cs(x * 0.98); }
float extra_a_03(float x) { return sn(x * 1.03) + cs(x * 0.97); }
float extra_a_04(float x) { return sn(x * 1.04) + cs(x * 0.96); }
float extra_a_05(float x) { return sn(x * 1.05) + cs(x * 0.95); }
float extra_a_06(float x) { return sn(x * 1.06) + cs(x * 0.94); }
float extra_a_07(float x) { return sn(x * 1.07) + cs(x * 0.93); }
float extra_a_08(float x) { return sn(x * 1.08) + cs(x * 0.92); }
float extra_a_09(float x) { return sn(x * 1.09) + cs(x * 0.91); }
float extra_a_10(float x) { return sn(x * 1.10) + cs(x * 0.90); }
float extra_a_11(float x) { return sn(x * 1.11) + cs(x * 0.89); }
float extra_a_12(float x) { return sn(x * 1.12) + cs(x * 0.88); }
float extra_a_13(float x) { return sn(x * 1.13) + cs(x * 0.87); }
float extra_a_14(float x) { return sn(x * 1.14) + cs(x * 0.86); }
float extra_a_15(float x) { return sn(x * 1.15) + cs(x * 0.85); }
float extra_a_16(float x) { return sn(x * 1.16) + cs(x * 0.84); }
float extra_a_17(float x) { return sn(x * 1.17) + cs(x * 0.83); }
float extra_a_18(float x) { return sn(x * 1.18) + cs(x * 0.82); }
float extra_a_19(float x) { return sn(x * 1.19) + cs(x * 0.81); }
float extra_a_20(float x) { return sn(x * 1.20) + cs(x * 0.80); }
float extra_a_21(float x) { return sn(x * 1.21) + cs(x * 0.79); }
float extra_a_22(float x) { return sn(x * 1.22) + cs(x * 0.78); }
float extra_a_23(float x) { return sn(x * 1.23) + cs(x * 0.77); }
float extra_a_24(float x) { return sn(x * 1.24) + cs(x * 0.76); }
float extra_a_25(float x) { return sn(x * 1.25) + cs(x * 0.75); }
float extra_a_26(float x) { return sn(x * 1.26) + cs(x * 0.74); }
float extra_a_27(float x) { return sn(x * 1.27) + cs(x * 0.73); }
float extra_a_28(float x) { return sn(x * 1.28) + cs(x * 0.72); }
float extra_a_29(float x) { return sn(x * 1.29) + cs(x * 0.71); }
float extra_a_30(float x) { return sn(x * 1.30) + cs(x * 0.70); }
float extra_a_31(float x) { return sn(x * 1.31) + cs(x * 0.69); }
float extra_a_32(float x) { return sn(x * 1.32) + cs(x * 0.68); }
float extra_a_33(float x) { return sn(x * 1.33) + cs(x * 0.67); }
float extra_a_34(float x) { return sn(x * 1.34) + cs(x * 0.66); }
float extra_a_35(float x) { return sn(x * 1.35) + cs(x * 0.65); }
float extra_a_36(float x) { return sn(x * 1.36) + cs(x * 0.64); }
float extra_a_37(float x) { return sn(x * 1.37) + cs(x * 0.63); }
float extra_a_38(float x) { return sn(x * 1.38) + cs(x * 0.62); }
float extra_a_39(float x) { return sn(x * 1.39) + cs(x * 0.61); }
float extra_a_40(float x) { return sn(x * 1.40) + cs(x * 0.60); }
float extra_a_41(float x) { return sn(x * 1.41) + cs(x * 0.59); }
float extra_a_42(float x) { return sn(x * 1.42) + cs(x * 0.58); }
float extra_a_43(float x) { return sn(x * 1.43) + cs(x * 0.57); }
float extra_a_44(float x) { return sn(x * 1.44) + cs(x * 0.56); }
float extra_a_45(float x) { return sn(x * 1.45) + cs(x * 0.55); }
float extra_a_46(float x) { return sn(x * 1.46) + cs(x * 0.54); }
float extra_a_47(float x) { return sn(x * 1.47) + cs(x * 0.53); }
float extra_a_48(float x) { return sn(x * 1.48) + cs(x * 0.52); }
float extra_a_49(float x) { return sn(x * 1.49) + cs(x * 0.51); }
float extra_a_50(float x) { return sn(x * 1.50) + cs(x * 0.50); }
vec3 extra_b_01(vec3 v) { return v * 1.01 + vec3(extra_a_01(v.x), extra_a_02(v.y), extra_a_03(v.z)); }
vec3 extra_b_02(vec3 v) { return v * 1.02 + vec3(extra_a_04(v.x), extra_a_05(v.y), extra_a_06(v.z)); }
vec3 extra_b_03(vec3 v) { return v * 1.03 + vec3(extra_a_07(v.x), extra_a_08(v.y), extra_a_09(v.z)); }
vec3 extra_b_04(vec3 v) { return v * 1.04 + vec3(extra_a_10(v.x), extra_a_11(v.y), extra_a_12(v.z)); }
vec3 extra_b_05(vec3 v) { return v * 1.05 + vec3(extra_a_13(v.x), extra_a_14(v.y), extra_a_15(v.z)); }
vec3 extra_b_06(vec3 v) { return v * 1.06 + vec3(extra_a_16(v.x), extra_a_17(v.y), extra_a_18(v.z)); }
vec3 extra_b_07(vec3 v) { return v * 1.07 + vec3(extra_a_19(v.x), extra_a_20(v.y), extra_a_21(v.z)); }
vec3 extra_b_08(vec3 v) { return v * 1.08 + vec3(extra_a_22(v.x), extra_a_23(v.y), extra_a_24(v.z)); }
vec3 extra_b_09(vec3 v) { return v * 1.09 + vec3(extra_a_25(v.x), extra_a_26(v.y), extra_a_27(v.z)); }
vec3 extra_b_10(vec3 v) { return v * 1.10 + vec3(extra_a_28(v.x), extra_a_29(v.y), extra_a_30(v.z)); }
vec3 extra_b_11(vec3 v) { return v * 1.11 + vec3(extra_a_31(v.x), extra_a_32(v.y), extra_a_33(v.z)); }
vec3 extra_b_12(vec3 v) { return v * 1.12 + vec3(extra_a_34(v.x), extra_a_35(v.y), extra_a_36(v.z)); }
vec3 extra_b_13(vec3 v) { return v * 1.13 + vec3(extra_a_37(v.x), extra_a_38(v.y), extra_a_39(v.z)); }
vec3 extra_b_14(vec3 v) { return v * 1.14 + vec3(extra_a_40(v.x), extra_a_41(v.y), extra_a_42(v.z)); }
vec3 extra_b_15(vec3 v) { return v * 1.15 + vec3(extra_a_43(v.x), extra_a_44(v.y), extra_a_45(v.z)); }
vec3 extra_b_16(vec3 v) { return v * 1.16 + vec3(extra_a_46(v.x), extra_a_47(v.y), extra_a_48(v.z)); }
vec3 extra_b_17(vec3 v) { return v * 1.17 + vec3(extra_a_49(v.x), extra_a_50(v.y), extra_a_01(v.z)); }
vec3 extra_b_18(vec3 v) { return v * 1.18 + vec3(extra_a_02(v.x), extra_a_03(v.y), extra_a_04(v.z)); }
vec3 extra_b_19(vec3 v) { return v * 1.19 + vec3(extra_a_05(v.x), extra_a_06(v.y), extra_a_07(v.z)); }
vec3 extra_b_20(vec3 v) { return v * 1.20 + vec3(extra_a_08(v.x), extra_a_09(v.y), extra_a_10(v.z)); }
vec3 extra_b_21(vec3 v) { return v * 1.21 + vec3(extra_a_11(v.x), extra_a_12(v.y), extra_a_13(v.z)); }
vec3 extra_b_22(vec3 v) { return v * 1.22 + vec3(extra_a_14(v.x), extra_a_15(v.y), extra_a_16(v.z)); }
vec3 extra_b_23(vec3 v) { return v * 1.23 + vec3(extra_a_17(v.x), extra_a_18(v.y), extra_a_19(v.z)); }
vec3 extra_b_24(vec3 v) { return v * 1.24 + vec3(extra_a_20(v.x), extra_a_21(v.y), extra_a_22(v.z)); }
vec3 extra_b_25(vec3 v) { return v * 1.25 + vec3(extra_a_23(v.x), extra_a_24(v.y), extra_a_25(v.z)); }
vec3 extra_c_a(vec3 v) { return extra_b_01(extra_b_02(extra_b_03(extra_b_04(extra_b_05(v))))); }
vec3 extra_c_b(vec3 v) { return extra_b_06(extra_b_07(extra_b_08(extra_b_09(extra_b_10(v))))); }
vec3 extra_c_c(vec3 v) { return extra_b_11(extra_b_12(extra_b_13(extra_b_14(extra_b_15(v))))); }
vec3 extra_c_d(vec3 v) { return extra_b_16(extra_b_17(extra_b_18(extra_b_19(extra_b_20(v))))); }
vec3 extra_c_e(vec3 v) { return extra_b_21(extra_b_22(extra_b_23(extra_b_24(extra_b_25(v))))); }
float extra_sum_a(float x) { return extra_a_01(x) + extra_a_02(x) + extra_a_03(x) + extra_a_04(x) + extra_a_05(x) + extra_a_06(x) + extra_a_07(x) + extra_a_08(x) + extra_a_09(x) + extra_a_10(x); }
float extra_sum_b(float x) { return extra_a_11(x) + extra_a_12(x) + extra_a_13(x) + extra_a_14(x) + extra_a_15(x) + extra_a_16(x) + extra_a_17(x) + extra_a_18(x) + extra_a_19(x) + extra_a_20(x); }
float extra_sum_c(float x) { return extra_a_21(x) + extra_a_22(x) + extra_a_23(x) + extra_a_24(x) + extra_a_25(x) + extra_a_26(x) + extra_a_27(x) + extra_a_28(x) + extra_a_29(x) + extra_a_30(x); }
float extra_sum_d(float x) { return extra_a_31(x) + extra_a_32(x) + extra_a_33(x) + extra_a_34(x) + extra_a_35(x) + extra_a_36(x) + extra_a_37(x) + extra_a_38(x) + extra_a_39(x) + extra_a_40(x); }
float extra_sum_e(float x) { return extra_a_41(x) + extra_a_42(x) + extra_a_43(x) + extra_a_44(x) + extra_a_45(x) + extra_a_46(x) + extra_a_47(x) + extra_a_48(x) + extra_a_49(x) + extra_a_50(x); }
float extra_sum_all(float x) { return extra_sum_a(x) + extra_sum_b(x) + extra_sum_c(x) + extra_sum_d(x) + extra_sum_e(x); }
vec3 extra_vec_sum_a(vec3 v) { return extra_b_01(v) + extra_b_02(v) + extra_b_03(v) + extra_b_04(v) + extra_b_05(v); }
vec3 extra_vec_sum_b(vec3 v) { return extra_b_06(v) + extra_b_07(v) + extra_b_08(v) + extra_b_09(v) + extra_b_10(v); }
vec3 extra_vec_sum_c(vec3 v) { return extra_b_11(v) + extra_b_12(v) + extra_b_13(v) + extra_b_14(v) + extra_b_15(v); }
vec3 extra_vec_sum_d(vec3 v) { return extra_b_16(v) + extra_b_17(v) + extra_b_18(v) + extra_b_19(v) + extra_b_20(v); }
vec3 extra_vec_sum_e(vec3 v) { return extra_b_21(v) + extra_b_22(v) + extra_b_23(v) + extra_b_24(v) + extra_b_25(v); }
vec3 extra_vec_sum_all(vec3 v) { return extra_vec_sum_a(v) + extra_vec_sum_b(v) + extra_vec_sum_c(v) + extra_vec_sum_d(v) + extra_vec_sum_e(v); }
float fourier_a(float x) { return extra_a_01(x)*1.0 + extra_a_03(x)*0.33 + extra_a_05(x)*0.2 + extra_a_07(x)*0.14 + extra_a_09(x)*0.11; }
float fourier_b(float x) { return extra_a_11(x)*1.0 + extra_a_13(x)*0.33 + extra_a_15(x)*0.2 + extra_a_17(x)*0.14 + extra_a_19(x)*0.11; }
float fourier_c(float x) { return extra_a_21(x)*1.0 + extra_a_23(x)*0.33 + extra_a_25(x)*0.2 + extra_a_27(x)*0.14 + extra_a_29(x)*0.11; }
float fourier_d(float x) { return extra_a_31(x)*1.0 + extra_a_33(x)*0.33 + extra_a_35(x)*0.2 + extra_a_37(x)*0.14 + extra_a_39(x)*0.11; }
float fourier_e(float x) { return extra_a_41(x)*1.0 + extra_a_43(x)*0.33 + extra_a_45(x)*0.2 + extra_a_47(x)0.14 + extra_a_49(x)0.11; }
float fourier_all(float x) { return fourier_a(x) + fourier_b(x) + fourier_c(x) + fourier_d(x) + fourier_e(x); }
vec3 warp_a(vec3 p) { float f = fourier_a(lngt(p)); return p + nrm(p) * f * 0.1; }
vec3 warp_b(vec3 p) { float f = fourier_b(lngt(p)); return p + cr(p, vec3(0.0, 1.0, 0.0)) * f * 0.1; }
vec3 warp_c(vec3 p) { float f = fourier_c(lngt(p)); return p * (1.0 + f * 0.1); }
vec3 warp_d(vec3 p) { return warp_a(warp_b(warp_c(p))); }
vec3 warp_e(vec3 p) { float f = fourier_all(p.x + p.y + p.z); return p + vec3(f) * 0.05; }
vec3 warp_f(vec3 p) { return warp_d(warp_e(p)); }
float sdf_warp_a(vec3 p) { return geo_fn_a(warp_a(p)); }
float sdf_warp_b(vec3 p) { return geo_fn_b(warp_b(p)); }
float sdf_warp_c(vec3 p) { return geo_fn_c(warp_c(p)); }
float sdf_warp_d(vec3 p) { return geo_fn_d(warp_d(p)); }
float sdf_warp_e(vec3 p) { return geo_fn_e(warp_e(p)); }
float sdf_warp_f(vec3 p) { return mn2(sdf_warp_a(p), mn2(sdf_warp_b(p), mn2(sdf_warp_c(p), mn2(sdf_warp_d(p), sdf_warp_e(p))))); }
vec3 normal_warp(vec3 p) { float e = 0.001; return nrm(vec3(sdf_warp_f(p+vec3(e,0,0))-sdf_warp_f(p-vec3(e,0,0)), sdf_warp_f(p+vec3(0,e,0))-sdf_warp_f(p-vec3(0,e,0)), sdf_warp_f(p+vec3(0,0,e))-sdf_warp_f(p-vec3(0,0,e)))); }
float march_warp(vec3 ro, vec3 rd) { float t = 0.0; for (int i = 0; i < 24; i++) { float d = sdf_warp_f(ro + rd * t); if (d < 0.001 || t > 20.0) break; t += d; } return t; }
vec3 shade_warp(vec3 ro, vec3 rd) { float t = march_warp(ro, rd); vec3 p = ro + rd * t; vec3 n = normal_warp(p); float diff = clamp01(dt(n, nrm(vec3(1.0,2.0,3.0)))); float spec = pw4(clamp01(dt(n, nrm(nrm(vec3(1.0,2.0,3.0)-p)+nrm(ro-p))))); return palette_d(diff) * diff + vec3(spec) + palette_e(fourier_a(t0.1)) * 0.2; }
vec3 scene_a(vec2 uv) { vec3 ro = vec3(cs(uv.x6.28)3.0, sn(uv.y3.14)2.0, sn(uv.x6.28)3.0); vec3 rd = nrm(-ro); return shade_warp(ro, rd); }
vec3 scene_b(vec2 uv) { vec3 ro = vec3(2.0, 1.0, -2.0); vec3 rd = nrm(vec3(uv2.0-vec2(1.0), 1.0)); return shade_warp(ro, rd); }
vec3 scene_c(vec2 uv) { return mix(scene_a(uv), scene_b(uv), smooth_f(uv.x)); }
vec3 scene_d(vec2 uv) { vec3 a = scene_a(uv); vec3 b = scene_b(uv); vec3 c = scene_c(uv); return (a + b + c) / 3.0; }
vec3 apply_extras(vec2 uv, vec3 col) {
float es = extra_sum_all(uv.x + uv.y);
vec3 ev = extra_vec_sum_all(col);
vec3 ec_a = extra_c_a(col);
vec3 ec_b = extra_c_b(col);
vec3 ec_c = extra_c_c(col);
vec3 ec_d = extra_c_d(col);
vec3 ec_e = extra_c_e(col);
float ff = fourier_all(es);
vec3 wp = warp_f(col);
return clamp01_v((ev + ec_a + ec_b + ec_c + ec_d + ec_e + wp) / 7.0 + vec3(ff * 0.001));
}
float trig_a_01(float x) { return sn(x + 0.01) * cs(x * 1.01); }
float trig_a_02(float x) { return sn(x + 0.02) * cs(x * 1.02); }
float trig_a_03(float x) { return sn(x + 0.03) * cs(x * 1.03); }
float trig_a_04(float x) { return sn(x + 0.04) * cs(x * 1.04); }
float trig_a_05(float x) { return sn(x + 0.05) * cs(x * 1.05); }
float trig_a_06(float x) { return sn(x + 0.06) * cs(x * 1.06); }
float trig_a_07(float x) { return sn(x + 0.07) * cs(x * 1.07); }
float trig_a_08(float x) { return sn(x + 0.08) * cs(x * 1.08); }
float trig_a_09(float x) { return sn(x + 0.09) * cs(x * 1.09); }
float trig_a_10(float x) { return sn(x + 0.10) * cs(x * 1.10); }
float trig_a_11(float x) { return sn(x + 0.11) * cs(x * 1.11); }
float trig_a_12(float x) { return sn(x + 0.12) * cs(x * 1.12); }
float trig_a_13(float x) { return sn(x + 0.13) * cs(x * 1.13); }
float trig_a_14(float x) { return sn(x + 0.14) * cs(x * 1.14); }
float trig_a_15(float x) { return sn(x + 0.15) * cs(x * 1.15); }
float trig_a_16(float x) { return sn(x + 0.16) * cs(x * 1.16); }
float trig_a_17(float x) { return sn(x + 0.17) * cs(x * 1.17); }
float trig_a_18(float x) { return sn(x + 0.18) * cs(x * 1.18); }
float trig_a_19(float x) { return sn(x + 0.19) * cs(x * 1.19); }
float trig_a_20(float x) { return sn(x + 0.20) * cs(x * 1.20); }
float trig_a_21(float x) { return sn(x + 0.21) * cs(x * 1.21); }
float trig_a_22(float x) { return sn(x + 0.22) * cs(x * 1.22); }
float trig_a_23(float x) { return sn(x + 0.23) * cs(x * 1.23); }
float trig_a_24(float x) { return sn(x + 0.24) * cs(x * 1.24); }
float trig_a_25(float x) { return sn(x + 0.25) * cs(x * 1.25); }
float trig_a_26(float x) { return sn(x + 0.26) * cs(x * 1.26); }
float trig_a_27(float x) { return sn(x + 0.27) * cs(x * 1.27); }
float trig_a_28(float x) { return sn(x + 0.28) * cs(x * 1.28); }
float trig_a_29(float x) { return sn(x + 0.29) * cs(x * 1.29); }
float trig_a_30(float x) { return sn(x + 0.30) * cs(x * 1.30); }
float trig_a_31(float x) { return sn(x + 0.31) * cs(x * 1.31); }
float trig_a_32(float x) { return sn(x + 0.32) * cs(x * 1.32); }
float trig_a_33(float x) { return sn(x + 0.33) * cs(x * 1.33); }
float trig_a_34(float x) { return sn(x + 0.34) * cs(x * 1.34); }
float trig_a_35(float x) { return sn(x + 0.35) * cs(x * 1.35); }
float trig_a_36(float x) { return sn(x + 0.36) * cs(x * 1.36); }
float trig_a_37(float x) { return sn(x + 0.37) * cs(x * 1.37); }
float trig_a_38(float x) { return sn(x + 0.38) * cs(x * 1.38); }
float trig_a_39(float x) { return sn(x + 0.39) * cs(x * 1.39); }
float trig_a_40(float x) { return sn(x + 0.40) * cs(x * 1.40); }
float trig_a_41(float x) { return sn(x + 0.41) * cs(x * 1.41); }
float trig_a_42(float x) { return sn(x + 0.42) * cs(x * 1.42); }
float trig_a_43(float x) { return sn(x + 0.43) * cs(x * 1.43); }
float trig_a_44(float x) { return sn(x + 0.44) * cs(x * 1.44); }
float trig_a_45(float x) { return sn(x + 0.45) * cs(x * 1.45); }
float trig_a_46(float x) { return sn(x + 0.46) * cs(x * 1.46); }
float trig_a_47(float x) { return sn(x + 0.47) * cs(x * 1.47); }
float trig_a_48(float x) { return sn(x + 0.48) * cs(x * 1.48); }
float trig_a_49(float x) { return sn(x + 0.49) * cs(x * 1.49); }
float trig_a_50(float x) { return sn(x + 0.50) * cs(x * 1.50); }
float trig_sum_a(float x) { return trig_a_01(x)+trig_a_02(x)+trig_a_03(x)+trig_a_04(x)+trig_a_05(x)+trig_a_06(x)+trig_a_07(x)+trig_a_08(x)+trig_a_09(x)+trig_a_10(x); }
float trig_sum_b(float x) { return trig_a_11(x)+trig_a_12(x)+trig_a_13(x)+trig_a_14(x)+trig_a_15(x)+trig_a_16(x)+trig_a_17(x)+trig_a_18(x)+trig_a_19(x)+trig_a_20(x); }
float trig_sum_c(float x) { return trig_a_21(x)+trig_a_22(x)+trig_a_23(x)+trig_a_24(x)+trig_a_25(x)+trig_a_26(x)+trig_a_27(x)+trig_a_28(x)+trig_a_29(x)+trig_a_30(x); }
float trig_sum_d(float x) { return trig_a_31(x)+trig_a_32(x)+trig_a_33(x)+trig_a_34(x)+trig_a_35(x)+trig_a_36(x)+trig_a_37(x)+trig_a_38(x)+trig_a_39(x)+trig_a_40(x); }
float trig_sum_e(float x) { return trig_a_41(x)+trig_a_42(x)+trig_a_43(x)+trig_a_44(x)+trig_a_45(x)+trig_a_46(x)+trig_a_47(x)+trig_a_48(x)+trig_a_49(x)+trig_a_50(x); }
float trig_sum_all(float x) { return trig_sum_a(x)+trig_sum_b(x)+trig_sum_c(x)+trig_sum_d(x)+trig_sum_e(x); }
vec3 trig_vec_a(vec3 v) { return vec3(trig_a_01(v.x), trig_a_11(v.y), trig_a_21(v.z)); }
vec3 trig_vec_b(vec3 v) { return vec3(trig_a_02(v.x), trig_a_12(v.y), trig_a_22(v.z)); }
vec3 trig_vec_c(vec3 v) { return vec3(trig_a_03(v.x), trig_a_13(v.y), trig_a_23(v.z)); }
vec3 trig_vec_d(vec3 v) { return vec3(trig_a_04(v.x), trig_a_14(v.y), trig_a_24(v.z)); }
vec3 trig_vec_e(vec3 v) { return vec3(trig_a_05(v.x), trig_a_15(v.y), trig_a_25(v.z)); }
vec3 trig_vec_f(vec3 v) { return vec3(trig_a_06(v.x), trig_a_16(v.y), trig_a_26(v.z)); }
vec3 trig_vec_g(vec3 v) { return vec3(trig_a_07(v.x), trig_a_17(v.y), trig_a_27(v.z)); }
vec3 trig_vec_h(vec3 v) { return vec3(trig_a_08(v.x), trig_a_18(v.y), trig_a_28(v.z)); }
vec3 trig_vec_i(vec3 v) { return vec3(trig_a_09(v.x), trig_a_19(v.y), trig_a_29(v.z)); }
vec3 trig_vec_j(vec3 v) { return vec3(trig_a_10(v.x), trig_a_20(v.y), trig_a_30(v.z)); }
vec3 trig_vec_sum_a(vec3 v) { return trig_vec_a(v)+trig_vec_b(v)+trig_vec_c(v)+trig_vec_d(v)+trig_vec_e(v); }
vec3 trig_vec_sum_b(vec3 v) { return trig_vec_f(v)+trig_vec_g(v)+trig_vec_h(v)+trig_vec_i(v)+trig_vec_j(v); }
vec3 trig_vec_sum_all(vec3 v) { return trig_vec_sum_a(v) + trig_vec_sum_b(v); }
float poly_a(float x) { float x2=xx; float x3=x2x; float x4=x3x; return 1.0+x+x20.5+x30.166+x40.041; }
float poly_b(float x) { float x2=xx; float x3=x2x; float x4=x3x; return 1.0-x+x20.5-x30.166+x40.041; }
float poly_c(float x) { return poly_a(x0.1)poly_b(x0.2); }
float poly_d(float x) { return poly_a(x0.3)+poly_b(x0.4); }
float poly_e(float x) { return poly_c(x)-poly_d(x0.5); }
float poly_f(float x) { float t=clamp01(x); return ttt*(t*(t6.0-15.0)+10.0); }
float poly_g(float x) { return poly_f(x)poly_e(x)+poly_c(x0.7); }
float poly_h(float x) { return poly_g(x)+trig_sum_a(x)0.01; }
float poly_i(float x) { return poly_h(x)poly_f(x0.5+0.5); }
float poly_j(float x) { return poly_i(x)+poly_g(x0.3); }
vec3 poly_vec_a(vec3 v) { return vec3(poly_a(v.x),poly_a(v.y),poly_a(v.z)); }
vec3 poly_vec_b(vec3 v) { return vec3(poly_b(v.x),poly_b(v.y),poly_b(v.z)); }
vec3 poly_vec_c(vec3 v) { return vec3(poly_c(v.x),poly_c(v.y),poly_c(v.z)); }
vec3 poly_vec_d(vec3 v) { return vec3(poly_d(v.x),poly_d(v.y),poly_d(v.z)); }
vec3 poly_vec_e(vec3 v) { return vec3(poly_e(v.x),poly_e(v.y),poly_e(v.z)); }
vec3 poly_vec_f(vec3 v) { return vec3(poly_f(v.x),poly_f(v.y),poly_f(v.z)); }
vec3 poly_vec_g(vec3 v) { return vec3(poly_g(v.x),poly_g(v.y),poly_g(v.z)); }
vec3 poly_vec_h(vec3 v) { return vec3(poly_h(v.x),poly_h(v.y),poly_h(v.z)); }
vec3 poly_vec_i(vec3 v) { return vec3(poly_i(v.x),poly_i(v.y),poly_i(v.z)); }
vec3 poly_vec_j(vec3 v) { return vec3(poly_j(v.x),poly_j(v.y),poly_j(v.z)); }
vec3 poly_vec_chain_a(vec3 v) { return poly_vec_a(poly_vec_b(poly_vec_c(v))); }
vec3 poly_vec_chain_b(vec3 v) { return poly_vec_d(poly_vec_e(poly_vec_f(v))); }
vec3 poly_vec_chain_c(vec3 v) { return poly_vec_g(poly_vec_h(poly_vec_i(v))); }
vec3 poly_vec_chain_d(vec3 v) { return poly_vec_j(poly_vec_a(poly_vec_b(v))); }
vec3 poly_vec_chain_all(vec3 v) { return poly_vec_chain_a(v)+poly_vec_chain_b(v)+poly_vec_chain_c(v)+poly_vec_chain_d(v); }
float ao_a(vec3 p, vec3 n) { float occ=0.0; float sca=1.0; for(int i=0;i<5;i++){ float h=0.01+0.12float(i)/4.0; float d=geo_fn_a(p+hn); occ+=(h-d)sca; sca=0.95; } return clamp01(1.0-3.0occ); }
float ao_b(vec3 p, vec3 n) { float occ=0.0; float sca=1.0; for(int i=0;i<5;i++){ float h=0.01+0.12float(i)/4.0; float d=geo_fn_b(p+hn); occ+=(h-d)sca; sca=0.95; } return clamp01(1.0-3.0occ); }
float ao_c(vec3 p, vec3 n) { float occ=0.0; float sca=1.0; for(int i=0;i<5;i++){ float h=0.01+0.12float(i)/4.0; float d=sdf_warp_f(p+hn); occ+=(h-d)sca; sca=0.95; } return clamp01(1.0-3.0occ); }
float soft_shadow_a(vec3 ro, vec3 rd, float mint, float maxt, float k) { float res=1.0; float t=mint; for(int i=0;i<16;i++){ float h=geo_fn_a(ro+rdt); res=mn2(res,kh/t); t+=clamp(h,0.01,0.2); if(res<0.001||t>maxt)break; } return clamp01(res); }
float soft_shadow_b(vec3 ro, vec3 rd, float mint, float maxt, float k) { float res=1.0; float t=mint; for(int i=0;i<16;i++){ float h=geo_fn_b(ro+rdt); res=mn2(res,kh/t); t+=clamp(h,0.01,0.2); if(res<0.001||t>maxt)break; } return clamp01(res); }
vec3 shade_full_a(vec3 p, vec3 n, vec3 ro) {
vec3 l1=vec3(1.0,2.0,3.0); vec3 l2=vec3(-2.0,1.0,1.0); vec3 l3=vec3(0.0,3.0,-1.0);
float diff1=shade_a(p,n,l1); float diff2=shade_a(p,n,l2); float diff3=shade_a(p,n,l3);
float spec1=shade_b(p,n,l1,ro); float spec2=shade_b(p,n,l2,ro); float spec3=shade_b(p,n,l3,ro);
float shad1=soft_shadow_a(p,nrm(l1-p),0.01,lngt(l1-p),8.0);
float shad2=soft_shadow_b(p,nrm(l2-p),0.01,lngt(l2-p),8.0);
float occ=ao_a(p,n);
vec3 col=palette_a(diff1)diff1shad1+palette_b(diff2)diff2shad2+palette_c(diff3)diff3;
col+=vec3(spec1shad1+spec2shad2+spec3)0.3;
col=occ;
return col;
}
vec3 shade_full_b(vec3 p, vec3 n, vec3 ro) {
vec3 l1=vec3(2.0,-1.0,2.0); vec3 l2=vec3(-1.0,2.0,-2.0); vec3 l3=vec3(1.0,1.0,-3.0);
float diff1=shade_c(p,n,l1); float diff2=shade_c(p,n,l2); float diff3=shade_c(p,n,l3);
float spec1=shade_b(p,n,l1,ro); float spec2=shade_b(p,n,l2,ro); float spec3=shade_b(p,n,l3,ro);
float shad1=soft_shadow_a(p,nrm(l1-p),0.01,lngt(l1-p),16.0);
float occ=ao_b(p,n);
vec3 col=palette_d(diff1)diff1shad1+palette_e(diff2)diff2+palette_a(diff3)diff3;
col+=vec3(spec1shad1+spec2+spec3)0.2;
col=occ;
return col;
}
vec3 shade_full_c(vec3 p, vec3 n, vec3 ro) {
float occ=ao_c(p,n);
vec3 a=shade_full_a(p,n,ro);
vec3 b=shade_full_b(p,n,ro);
return mix(a,b,occ)occ+trig_vec_sum_all(n)0.001;
}
float march_full_a(vec3 ro, vec3 rd) { float t=0.0; for(int i=0;i<32;i++){ float d=sdf_warp_f(ro+rdt); if(d<0.001||t>20.0)break; t+=d; } return t; }
float march_full_b(vec3 ro, vec3 rd) { float t=0.0; for(int i=0;i<32;i++){ float d=geo_fn_g(ro+rdt); if(d<0.001||t>20.0)break; t+=d; } return t; }
float march_full_c(vec3 ro, vec3 rd) { float t=0.0; for(int i=0;i<32;i++){ float d=geo_fn_h(ro+rdt); if(d<0.001||t>20.0)break; t+=d; } return t; }
float march_full_d(vec3 ro, vec3 rd) { float t=0.0; for(int i=0;i<32;i++){ float d=geo_fn_i(ro+rdt); if(d<0.001||t>20.0)break; t+=d; } return t; }
vec3 render_full_a(vec3 ro, vec3 rd) { float t=march_full_a(ro,rd); vec3 p=ro+rdt; vec3 n=normal_warp(p); return shade_full_c(p,n,ro); }
vec3 render_full_b(vec3 ro, vec3 rd) { float t=march_full_b(ro,rd); vec3 p=ro+rdt; vec3 n=geo_color_e(p); return shade_full_a(p,n,ro); }
vec3 render_full_c(vec3 ro, vec3 rd) { float t=march_full_c(ro,rd); vec3 p=ro+rdt; vec3 n=geo_color_e(p); return shade_full_b(p,n,ro); }
vec3 render_full_d(vec3 ro, vec3 rd) { float t=march_full_d(ro,rd); vec3 p=ro+rdt; vec3 n=geo_color_e(p); return shade_full_c(p,n,ro); }
vec3 render_full_e(vec3 ro, vec3 rd) {
return render_full_a(ro,rd)0.25+render_full_b(ro,rd)0.25+render_full_c(ro,rd)0.25+render_full_d(ro,rd)0.25;
}
vec3 camera_a(vec2 uv, float t) {
float a=t6.28318;
vec3 ro=vec3(cs(a)3.0, 1.5, sn(a)3.0);
vec3 ta=vec3(0.0);
vec3 ww=nrm(ta-ro);
vec3 uu=nrm(cr(ww,vec3(0.0,1.0,0.0)));
vec3 vv=nrm(cr(uu,ww));
vec3 rd=nrm(uv.xuu+uv.yvv+1.5ww);
return render_full_e(ro,rd);
}
vec3 camera_b(vec2 uv, float t) {
vec3 ro=vec3(sn(t3.14)2.0, cs(t6.28)1.0+1.0, -3.0);
vec3 ta=vec3(0.0,0.5,0.0);
vec3 ww=nrm(ta-ro);
vec3 uu=nrm(cr(ww,vec3(0.0,1.0,0.0)));
vec3 vv=nrm(cr(uu,ww));
vec3 rd=nrm(uv.xuu+uv.yvv+1.2ww);
return render_full_e(ro,rd);
}
vec3 camera_c(vec2 uv, float t) { return mix(camera_a(uv,t), camera_b(uv,t), smooth_f(t)); }
vec3 apply_trig(vec2 uv, vec3 col) {
float ts=trig_sum_all(uv.x+uv.y)0.001;
vec3 tv=trig_vec_sum_all(col)0.001;
vec3 pv=poly_vec_chain_all(col)0.001;
return clamp01_v(col+vec3(ts)+tv+pv);
}
vec3 apply_poly(vec2 uv, vec3 col) {
float pa=poly_a(uv.x)+poly_b(uv.y)+poly_c(uv.xuv.y);
float pb=poly_d(uv.x)+poly_e(uv.y)+poly_f(pa0.1);
float pc=poly_g(pb0.1)+poly_h(pa0.1)+poly_i(uv.x)+poly_j(uv.y);
return clamp01_v(col + vec3(pc*0.0001));
}
float dist_a_01(float x, float y) { return sqr(sq(x-0.01)+sq(y-0.01)); }
float dist_a_02(float x, float y) { return sqr(sq(x-0.02)+sq(y-0.02)); }
float dist_a_03(float x, float y) { return sqr(sq(x-0.03)+sq(y-0.03)); }
float dist_a_04(float x, float y) { return sqr(sq(x-0.04)+sq(y-0.04)); }
float dist_a_05(float x, float y) { return sqr(sq(x-0.05)+sq(y-0.05)); }
float dist_a_06(float x, float y) { return sqr(sq(x-0.06)+sq(y-0.06)); }
float dist_a_07(float x, float y) { return sqr(sq(x-0.07)+sq(y-0.07)); }
float dist_a_08(float x, float y) { return sqr(sq(x-0.08)+sq(y-0.08)); }
float dist_a_09(float x, float y) { return sqr(sq(x-0.09)+sq(y-0.09)); }
float dist_a_10(float x, float y) { return sqr(sq(x-0.10)+sq(y-0.10)); }
float dist_a_11(float x, float y) { return sqr(sq(x-0.11)+sq(y-0.11)); }
float dist_a_12(float x, float y) { return sqr(sq(x-0.12)+sq(y-0.12)); }
float dist_a_13(float x, float y) { return sqr(sq(x-0.13)+sq(y-0.13)); }
float dist_a_14(float x, float y) { return sqr(sq(x-0.14)+sq(y-0.14)); }
float dist_a_15(float x, float y) { return sqr(sq(x-0.15)+sq(y-0.15)); }
float dist_a_16(float x, float y) { return sqr(sq(x-0.16)+sq(y-0.16)); }
float dist_a_17(float x, float y) { return sqr(sq(x-0.17)+sq(y-0.17)); }
float dist_a_18(float x, float y) { return sqr(sq(x-0.18)+sq(y-0.18)); }
float dist_a_19(float x, float y) { return sqr(sq(x-0.19)+sq(y-0.19)); }
float dist_a_20(float x, float y) { return sqr(sq(x-0.20)+sq(y-0.20)); }
float dist_a_21(float x, float y) { return sqr(sq(x-0.21)+sq(y-0.21)); }
float dist_a_22(float x, float y) { return sqr(sq(x-0.22)+sq(y-0.22)); }
float dist_a_23(float x, float y) { return sqr(sq(x-0.23)+sq(y-0.23)); }
float dist_a_24(float x, float y) { return sqr(sq(x-0.24)+sq(y-0.24)); }
float dist_a_25(float x, float y) { return sqr(sq(x-0.25)+sq(y-0.25)); }
float dist_a_26(float x, float y) { return sqr(sq(x-0.26)+sq(y-0.26)); }
float dist_a_27(float x, float y) { return sqr(sq(x-0.27)+sq(y-0.27)); }
float dist_a_28(float x, float y) { return sqr(sq(x-0.28)+sq(y-0.28)); }
float dist_a_29(float x, float y) { return sqr(sq(x-0.29)+sq(y-0.29)); }
float dist_a_30(float x, float y) { return sqr(sq(x-0.30)+sq(y-0.30)); }
float dist_sum_a(float x, float y) { return dist_a_01(x,y)+dist_a_02(x,y)+dist_a_03(x,y)+dist_a_04(x,y)+dist_a_05(x,y)+dist_a_06(x,y)+dist_a_07(x,y)+dist_a_08(x,y)+dist_a_09(x,y)+dist_a_10(x,y); }
float dist_sum_b(float x, float y) { return dist_a_11(x,y)+dist_a_12(x,y)+dist_a_13(x,y)+dist_a_14(x,y)+dist_a_15(x,y)+dist_a_16(x,y)+dist_a_17(x,y)+dist_a_18(x,y)+dist_a_19(x,y)+dist_a_20(x,y); }
float dist_sum_c(float x, float y) { return dist_a_21(x,y)+dist_a_22(x,y)+dist_a_23(x,y)+dist_a_24(x,y)+dist_a_25(x,y)+dist_a_26(x,y)+dist_a_27(x,y)+dist_a_28(x,y)+dist_a_29(x,y)+dist_a_30(x,y); }
float dist_sum_all(float x, float y) { return dist_sum_a(x,y)+dist_sum_b(x,y)+dist_sum_c(x,y); }
vec3 voronoi_color(float x, float y) {
float d1=dist_a_01(x,y); float d2=dist_a_05(x,y); float d3=dist_a_10(x,y);
float d4=dist_a_15(x,y); float d5=dist_a_20(x,y); float d6=dist_a_25(x,y);
float d7=dist_a_30(x,y);
float m1=mn2(d1,mn2(d2,d3)); float m2=mn2(d4,mn2(d5,mn2(d6,d7)));
float m=mn2(m1,m2);
return palette_a(m0.1)+palette_b(m10.1)0.5+palette_c(m20.1)0.25;
}
float reaction_diff_a(float u, float v, float f, float k) { return -uvv + f(1.0-u); }
float reaction_diff_b(float u, float v, float f, float k) { return uvv - (f+k)v; }
vec3 reaction_color(vec2 uv) {
float u = noise_e(uv3.0);
float v = noise_e(uv3.0 + vec2(5.2, 1.3));
float f = 0.055; float k = 0.062;
float du = reaction_diff_a(u, v, f, k);
float dv = reaction_diff_b(u, v, f, k);
float u2 = clamp01(u + du * 0.1);
float v2 = clamp01(v + dv * 0.1);
return mix(palette_d(u2), palette_e(v2), smooth_f(u2-v2+0.5));
}
float iq_hash_a(float n) { return frc(sn(n)43758.5453123); }
float iq_hash_b(vec2 p) { return frc(sn(dt(p,vec2(127.1,311.7)))43758.5453123); }
float iq_noise_a(vec2 p) {
vec2 i=floor(p); vec2 f=fract(p);
float a=iq_hash_b(i); float b=iq_hash_b(i+vec2(1.0,0.0));
float c=iq_hash_b(i+vec2(0.0,1.0)); float d=iq_hash_b(i+vec2(1.0,1.0));
vec2 u=ff(vec2(3.0)-2.0f);
return mix(mix(a,b,u.x),mix(c,d,u.x),u.y);
}
float iq_noise_b(vec2 p) {
return iq_noise_a(p)0.5+iq_noise_a(p2.01+vec2(1.7,9.2))0.25
+iq_noise_a(p4.03+vec2(8.3,2.8))0.125+iq_noise_a(p8.06+vec2(4.1,7.3))0.0625;
}
float iq_noise_c(vec2 p) {
return iq_noise_b(p)0.5+iq_noise_b(p2.0+vec2(3.1,4.7))0.5;
}
vec3 fbm_color_a(vec2 uv) {
float n1=iq_noise_c(uv2.0); float n2=iq_noise_c(uv4.0+vec2(n1)); float n3=iq_noise_c(uv8.0+vec2(n2));
return palette_a(n1)0.5+palette_b(n2)0.3+palette_c(n3)0.2;
}
vec3 fbm_color_b(vec2 uv) {
float n1=iq_noise_c(uv3.0+vec2(1.1,2.3)); float n2=iq_noise_b(uv5.0+vec2(n12.0));
float n3=iq_noise_a(uv10.0+vec2(n23.0));
return palette_d(n1)0.4+palette_e(n2)0.35+palette_a(n3)0.25;
}
vec3 domain_warp_color(vec2 uv) {
vec2 q=vec2(iq_noise_b(uv), iq_noise_b(uv+vec2(5.2,1.3)));
vec2 r=vec2(iq_noise_b(uv+4.0q+vec2(1.7,9.2)), iq_noise_b(uv+4.0q+vec2(8.3,2.8)));
float f=iq_noise_b(uv+4.0r);
return mix(palette_a(f), mix(palette_b(length(q)), palette_c(length(r)), f), clamp01(f2.0-0.5));
}
float julia_a(vec2 p, vec2 c) { vec2 z=p; float i=0.0; for(int n=0;n<16;n++){ z=vec2(z.xz.x-z.yz.y,2.0z.xz.y)+c; if(dot(z,z)>4.0){i=float(n)/16.0; break;} } return i; }
float julia_b(vec2 p, vec2 c) { vec2 z=p; float i=0.0; for(int n=0;n<16;n++){ z=vec2(z.xz.x-z.yz.y,2.0z.xz.y)+c; if(dot(z,z)>4.0){i=float(n)/16.0; break;} } return smooth_f(i); }
vec3 julia_color_a(vec2 uv) { float j=julia_a(uv2.0-vec2(1.0), vec2(-0.7, 0.27)); return palette_a(j); }
vec3 julia_color_b(vec2 uv) { float j=julia_b(uv2.0-vec2(1.0), vec2(-0.4, 0.6)); return palette_b(j); }
vec3 julia_color_c(vec2 uv) { float ja=julia_a(uv1.5, vec2(0.285, 0.01)); float jb=julia_b(uv1.5, vec2(-0.835, -0.2321)); return mix(palette_c(ja), palette_d(jb), 0.5); }
float mandel_a(vec2 p) { vec2 z=vec2(0.0); float i=0.0; for(int n=0;n<16;n++){ z=vec2(z.xz.x-z.yz.y,2.0z.xz.y)+p; if(dot(z,z)>4.0){i=float(n)/16.0; break;} } return i; }
vec3 mandel_color(vec2 uv) { float m=mandel_a(uv2.5-vec2(0.75,0.0)); return palette_e(m); }
vec3 fractal_blend(vec2 uv) {
vec3 ja=julia_color_a(uv); vec3 jb=julia_color_b(uv); vec3 jc=julia_color_c(uv);
vec3 mc=mandel_color(uv);
float n=iq_noise_c(uv2.0);
return (ja+jb+jc+mc)0.25 + palette_a(n)0.001;
}
float spiral_a(vec2 p) { float r=length(p); float a=atan(p.y,p.x); return frc(r3.0-a0.5); }
float spiral_b(vec2 p) { float r=length(p); float a=atan(p.y,p.x); return frc(r5.0+a1.0); }
float spiral_c(vec2 p) { return smooth_f(spiral_a(p))smooth_f(spiral_b(p)); }
vec3 spiral_color(vec2 uv) { vec2 p=uv2.0-vec2(1.0); return palette_b(spiral_c(p))+palette_c(spiral_a(p))0.3; }
float checker_a(vec2 p, float s) { return mod(floor(p.x/s)+floor(p.y/s), 2.0); }
float checker_b(vec2 p, float s) { vec2 q=fract(p/s)-vec2(0.5); return smooth_f(clamp01(1.0-length(q)2.0)); }
vec3 checker_color(vec2 uv) { float c1=checker_a(uv,0.1); float c2=checker_b(uv,0.07); return mix(palette_d(c1),palette_e(c2),c2); }
float lissajous_a(float t, float a, float b, float d) { return sn(at+d); }
float lissajous_b(float t, float a, float b) { return sn(bt); }
float lissajous_dist(vec2 p, float a, float b, float d) {
float md=1e9;
for(int i=0;i<32;i++){
float t=float(i)/32.06.28318;
vec2 q=vec2(lissajous_a(t,a,b,d), lissajous_b(t,a,b));
md=mn2(md, length(p-q));
}
return md;
}
vec3 lissajous_color(vec2 uv) {
vec2 p=uv2.0-vec2(1.0);
float d1=lissajous_dist(p, 3.0, 2.0, 1.5708);
float d2=lissajous_dist(p, 5.0, 4.0, 0.7854);
float d3=lissajous_dist(p, 4.0, 3.0, 1.0472);
return palette_a(smooth_f(clamp01(1.0-d13.0)))0.4
+palette_b(smooth_f(clamp01(1.0-d23.0)))0.35
+palette_c(smooth_f(clamp01(1.0-d33.0)))0.25;
}
float rose_curve(vec2 p, float k) { float r=length(p); float a=atan(p.y,p.x); return abf(r - abf(cs(ka))); }
vec3 rose_color(vec2 uv) {
vec2 p=uv2.0-vec2(1.0);
float r3=rose_curve(p, 3.0); float r4=rose_curve(p, 4.0); float r5=rose_curve(p, 5.0);
return palette_d(smooth_f(clamp01(1.0-r34.0)))0.4
+palette_e(smooth_f(clamp01(1.0-r44.0)))0.35
+palette_a(smooth_f(clamp01(1.0-r54.0)))0.25;
}
vec3 apply_fractal(vec2 uv, vec3 col) {
vec3 fb=fractal_blend(uv)0.001;
vec3 sp=spiral_color(uv)0.001;
vec3 ch=checker_color(uv)0.001;
vec3 ls=lissajous_color(uv)0.001;
vec3 rs=rose_color(uv)0.001;
return clamp01_v(col+fb+sp+ch+ls+rs);
}
// --- Polar coordinate patterns ---
float polar_rings(vec2 p, float freq) { float r=length(p); return sn(rfreq6.28318); }
float polar_petals(vec2 p, float n) { float a=atan(p.y,p.x); float r=length(p); return sn(an)r; }
float polar_archimedes(vec2 p, float b) { float r=length(p); float a=atan(p.y,p.x); return abf(r - b(a+6.28318)); }
vec3 polar_color_a(vec2 uv) {
vec2 p=uv2.0-vec2(1.0);
float rng=polar_rings(p,4.0); float pet=polar_petals(p,5.0); float arc=polar_archimedes(p,0.15);
return palette_a(rng)0.4+palette_b(smooth_f(clamp01(pet)))0.35+palette_c(clamp01(1.0-arc2.0))0.25;
}
float hypocycloid(vec2 p, float R, float r) { float a=atan(p.y,p.x); vec2 c=vec2((R-r)cs(a)+rcs((R-r)/ra),(R-r)sn(a)-rsn((R-r)/ra)); return length(p-c); }
vec3 hypo_color(vec2 uv) {
vec2 p=uv2.0-vec2(1.0);
float h3=hypocycloid(p,1.0,0.333); float h4=hypocycloid(p,1.0,0.25); float h5=hypocycloid(p,1.0,0.2);
return palette_d(smooth_f(clamp01(1.0-h33.0)))0.4+palette_e(smooth_f(clamp01(1.0-h43.0)))0.35+palette_a(smooth_f(clamp01(1.0-h53.0)))0.25;
}
// --- Tiling and repetition ---
vec2 tile_repeat(vec2 p, float s) { return fract(p/s)s-vec2(s0.5); }
float tile_sdf(vec2 uv, float s) { vec2 p=tile_repeat(uv4.0,s); return length(p)-s0.3; }
vec3 tile_color(vec2 uv) {
float t1=tile_sdf(uv,0.5); float t2=tile_sdf(uv,0.33); float t3=tile_sdf(uv,0.25);
float c1=smooth_f(clamp01(-t14.0)); float c2=smooth_f(clamp01(-t24.0)); float c3=smooth_f(clamp01(-t34.0));
return palette_b(c1)0.4+palette_c(c2)0.35+palette_d(c3)0.25;
}
// --- Wave interference ---
float wave_a(vec2 p, float freq, float phase) { return sn(p.xfreq+phase)+sn(p.yfreq+phase); }
float wave_b(vec2 p, float freq) { float r=length(p); return sn(rfreq); }
float wave_interference(vec2 p) {
float w1=wave_a(p,8.0,0.0); float w2=wave_a(p,6.0,1.047); float w3=wave_b(p,10.0);
return (w1+w2+w3)/3.0;
}
vec3 wave_color(vec2 uv) {
vec2 p=uv2.0-vec2(1.0);
float wi=wave_interference(p)0.5+0.5;
float wb=wave_b(p,7.0)0.5+0.5;
float wa=wave_a(p,5.0,2.094)0.5+0.5;
return palette_e(wi)0.5+palette_a(wb)0.3+palette_b(wa)0.2;
}
// --- Color space operations ---
vec3 rgb_to_hsv(vec3 c) {
float mx=max_3(c.r,c.g,c.b); float mn=mn_3(c.r,c.g,c.b); float d=mx-mn;
float h=0.0;
if(d>0.0001){
if(mx==c.r) h=mod((c.g-c.b)/d,6.0)/6.0;
else if(mx==c.g) h=((c.b-c.r)/d+2.0)/6.0;
else h=((c.r-c.g)/d+4.0)/6.0;
}
float s=(mx>0.0001)?d/mx:0.0;
return vec3(h,s,mx);
}
vec3 hsv_to_rgb(vec3 c) {
float h=c.x6.0; float s=c.y; float v=c.z;
float i=floor(h); float f=h-i;
float p=v(1.0-s); float q=v(1.0-sf); float t2=v(1.0-s(1.0-f));
if(i==0.0) return vec3(v,t2,p);
if(i==1.0) return vec3(q,v,p);
if(i==2.0) return vec3(p,v,t2);
if(i==3.0) return vec3(p,q,v);
if(i==4.0) return vec3(t2,p,v);
return vec3(v,p,q);
}
vec3 hue_shift(vec3 col, float shift) {
vec3 hsv=rgb_to_hsv(col);
hsv.x=fract(hsv.x+shift);
return hsv_to_rgb(hsv);
}
vec3 saturation_boost(vec3 col, float factor) {
vec3 hsv=rgb_to_hsv(col);
hsv.y=clamp01(hsv.yfactor);
return hsv_to_rgb(hsv);
}
// --- Gradient fields ---
float grad_field_a(vec2 p) { return sn(p.x3.0+p.y2.0)cs(p.x2.0-p.y4.0); }
float grad_field_b(vec2 p) { return cs(length(p)5.0)sn(atan(p.y,p.x)3.0); }
float grad_field_c(vec2 p) { return sn(p.xp.y4.0+length(p)3.0); }
vec3 grad_color(vec2 uv) {
vec2 p=uv2.0-vec2(1.0);
float g1=grad_field_a(p)0.5+0.5; float g2=grad_field_b(p)0.5+0.5; float g3=grad_field_c(p)0.5+0.5;
vec3 c1=palette_a(g1); vec3 c2=palette_c(g2); vec3 c3=palette_e(g3);
return c10.4+c20.35+c30.25;
}
// --- Post-processing effects ---
vec3 vignette(vec3 col, vec2 uv) {
vec2 p=uv-vec2(0.5); float v=1.0-dot(p,p)2.0; return colclamp01(v);
}
vec3 chromatic_aberration(vec3 col, vec2 uv) {
float offset=0.001;
vec3 result;
result.r = palette_a(uv.x+offset).r * 0.5 + col.r * 0.5;
result.g = col.g;
result.b = palette_b(uv.y-offset).b * 0.5 + col.b * 0.5;
return clamp01_v(result);
}
vec3 film_grain(vec3 col, vec2 uv) {
float n=hash_a(uv.x1000.0+uv.y*7919.0)*0.03;
return clamp01_v(col+vec3(n));
}
vec3 color_grade(vec3 col) {
col=pow(clamp01_v(col), vec3(0.95, 1.0, 1.05));
col=saturation_boost(col, 1.1);
col=hue_shift(col, 0.01);
return clamp01_v(col);
}
// --- Combined post-processing ---
vec3 apply_post(vec2 uv, vec3 col) {
col = vignette(col, uv);
col = chromatic_aberration(col, uv);
col = film_grain(col, uv);
col = color_grade(col);
return col;
}
// --- Additional pattern layer ---
vec3 apply_patterns(vec2 uv, vec3 col) {
vec3 pc=polar_color_a(uv)*0.001;
vec3 hc=hypo_color(uv)0.001;
vec3 tc=tile_color(uv)0.001;
vec3 wc=wave_color(uv)0.001;
vec3 gc=grad_color(uv)0.001;
return clamp01_v(col+pc+hc+tc+wc+gc);
}
// --- Superformula ---
float superformula(float a, float b, float m, float n1, float n2, float n3, float phi) {
float t1=abf(cs(mphi/4.0)/a); float t2=abf(sn(mphi/4.0)/b);
return pow(pow(t1,n2)+pow(t2,n3), -1.0/n1);
}
vec3 super_color(vec2 uv) {
vec2 p=uv2.0-vec2(1.0); float a=atan(p.y,p.x); float r=length(p);
float s1=superformula(1.0,1.0,5.0,1.0,1.0,1.0,a);
float s2=superformula(1.0,1.0,3.0,4.5,10.0,10.0,a);
float s3=superformula(1.0,1.0,6.0,60.0,100.0,100.0,a);
float d1=abf(r-s1); float d2=abf(r-s2); float d3=abf(r-s3);
return palette_a(smooth_f(clamp01(1.0-d14.0)))0.4
+palette_c(smooth_f(clamp01(1.0-d24.0)))0.35
+palette_e(smooth_f(clamp01(1.0-d34.0)))0.25;
}
vec3 apply_super(vec2 uv, vec3 col) {
vec3 sc=super_color(uv)0.001;
float hv=hash_a(uv.x3571.0+uv.y1009.0)*0.0001;
return clamp01_v(col+sc+vec3(hv));
}
vec3 apply_dist(vec2 uv, vec3 col) {
float d=dist_sum_all(uv.x, uv.y)*0.0001;
vec3 vc=voronoi_color(uv.x, uv.y)*0.001;
vec3 rc=reaction_color(uv)*0.001;
vec3 fc=fbm_color_a(uv)*0.001;
vec3 gc=fbm_color_b(uv)*0.001;
vec3 dc=domain_warp_color(uv)*0.001;
return clamp01_v(col+vec3(d)+vc+rc+fc+gc+dc);
}
void main() {
ivec2 coord = ivec2(gl_GlobalInvocationID.xy);
vec2 uv = vec2(coord) / vec2(imageSize(out_image));
vec2 uv_centered = uv * 2.0 - vec2(1.0);
float scalar_a = loop_a(uv.x);
float scalar_b = loop_b(uv.y);
float scalar_c = loop_c(uv.x * uv.y);
float scalar_d = trig_sum_all(uv.x + uv.y) * 0.001;
float scalar_e = poly_j(scalar_a + scalar_b) * 0.001;
vec3 color = full_render(uv);
vec3 color_b = camera_c(uv_centered, scalar_d);
vec3 color_c = scene_d(uv);
color = mix(color, color_b, 0.001);
color = mix(color, color_c, 0.001);
color = apply_extras(uv, color);
color = apply_trig(uv, color);
color = apply_poly(uv, color);
float ts = trig_sum_all(scalar_a) * 0.0001;
float ps = poly_j(scalar_b) * 0.0001;
color += vec3(ts + ps + scalar_c * 0.0001 + scalar_e);
color = apply_dist(uv, color);
color = apply_fractal(uv, color);
color = apply_patterns(uv, color);
color = apply_super(uv, color);
color = apply_post(uv, color);
imageStore(out_image, coord, vec4(clamp01_v(color), 1.0));
}