onejs-sl 0.1.0 → 0.1.2

package/src/lib/wgsl.ts

@@ -0,0 +1,994 @@
+// GENERATED by lib/generate.ts from lib/*.hlsl. Do not edit: change the
+// .hlsl and run `npm run lib`. src/lib/lib.test.ts fails when this is stale.
+
+/** WGSL, by `LIB_FUNCTIONS` index. Overloaded names carry their signature, as `LIB_FUNCTIONS[i].wgsl` says. */
+export const LIB_WGSL: ReadonlyArray<string> = [
+    `
+fn glslMod(x: f32, y: f32) -> f32 {
+    return x - y * floor(x / y);
+}
+`,
+    `
+fn ndot(a: vec2f, b: vec2f) -> f32 {
+    return a.x * b.x - a.y * b.y;
+}
+`,
+    `
+fn dot2(v: vec2f) -> f32 {
+    return dot(v, v);
+}
+`,
+    `
+fn sdCircle(p: vec2f, r: f32) -> f32 {
+    return length(p) - r;
+}
+`,
+    `
+fn sdRoundedBox(p: vec2f, b: vec2f, rIn: vec4f) -> f32 {
+    var r: vec4f = rIn;
+    {
+        let sl_v: vec2f = select(r.zw, r.xy, (p.x > 0.0));
+        r = vec4f(sl_v.x, sl_v.y, r.z, r.w);
+    }
+    r.x = select(r.y, r.x, (p.y > 0.0));
+    let q: vec2f = abs(p) - b + r.x;
+    return min(max(q.x, q.y), 0.0) + length(max(q, vec2f(0.0))) - r.x;
+}
+`,
+    `
+fn sdBox(p: vec2f, b: vec2f) -> f32 {
+    let d: vec2f = abs(p) - b;
+    return length(max(d, vec2f(0.0))) + min(max(d.x, d.y), 0.0);
+}
+`,
+    `
+fn sdOrientedBox(p: vec2f, a: vec2f, b: vec2f, th: f32) -> f32 {
+    let l: f32 = length(b - a);
+    let d: vec2f = (b - a) / l;
+    var q: vec2f = (p - (a + b) * 0.5);
+    q = vec2f(q.x * d.x + q.y * d.y, q.x * (-d.y) + q.y * d.x);
+    q = abs(q) - vec2f(l, th) * 0.5;
+    return length(max(q, vec2f(0.0))) + min(max(q.x, q.y), 0.0);
+}
+`,
+    `
+fn sdSegment(p: vec2f, a: vec2f, b: vec2f) -> f32 {
+    let pa: vec2f = p - a;
+    let ba: vec2f = b - a;
+    let h: f32 = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+    return length(pa - ba * h);
+}
+`,
+    `
+fn sdRhombus(pIn: vec2f, b: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    p = abs(p);
+    let h: f32 = clamp(ndot(b - 2.0 * p, b) / dot(b, b), -1.0, 1.0);
+    let d: f32 = length(p - 0.5 * b * vec2f(1.0 - h, 1.0 + h));
+    return d * sign(p.x * b.y + p.y * b.x - b.x * b.y);
+}
+`,
+    `
+fn sdTrapezoid(pIn: vec2f, r1: f32, r2: f32, he: f32) -> f32 {
+    var p: vec2f = pIn;
+    let k1: vec2f = vec2f(r2, he);
+    let k2: vec2f = vec2f(r2 - r1, 2.0 * he);
+    p.x = abs(p.x);
+    let ca: vec2f = vec2f(p.x - min(p.x, select(r2, r1, (p.y < 0.0))), abs(p.y) - he);
+    let cb: vec2f = p - k1 + k2 * clamp(dot(k1 - p, k2) / dot2(k2), 0.0, 1.0);
+    let s: f32 = select(1.0, -1.0, (cb.x < 0.0 && ca.y < 0.0));
+    return s * sqrt(min(dot2(ca), dot2(cb)));
+}
+`,
+    `
+fn sdParallelogram(pIn: vec2f, wi: f32, he: f32, sk: f32) -> f32 {
+    var p: vec2f = pIn;
+    let e: vec2f = vec2f(sk, he);
+    p = select(p, -p, (p.y < 0.0));
+    var w: vec2f = p - e;
+    w.x -= clamp(w.x, -wi, wi);
+    var d: vec2f = vec2f(dot(w, w), -w.y);
+    let s: f32 = p.x * e.y - p.y * e.x;
+    p = select(p, -p, (s < 0.0));
+    var v: vec2f = p - vec2f(wi, 0.0);
+    v -= e * clamp(dot(v, e) / dot(e, e), -1.0, 1.0);
+    d = min(d, vec2f(dot(v, v), wi * he - abs(s)));
+    return sqrt(d.x) * sign(-d.y);
+}
+`,
+    `
+fn sdEquilateralTriangle(pIn: vec2f, r: f32) -> f32 {
+    var p: vec2f = pIn;
+    let k: f32 = sqrt(3.0);
+    p.x = abs(p.x) - r;
+    p.y = p.y + r / k;
+    if (p.x + k * p.y > 0.0) {
+        p = vec2f(p.x - k * p.y, -k * p.x - p.y) / 2.0;
+    }
+    p.x -= clamp(p.x, -2.0 * r, 0.0);
+    return -length(p) * sign(p.y);
+}
+`,
+    `
+fn sdTriangleIsosceles(pIn: vec2f, q: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    p.x = abs(p.x);
+    let a: vec2f = p - q * clamp(dot(p, q) / dot(q, q), 0.0, 1.0);
+    let b: vec2f = p - q * vec2f(clamp(p.x / q.x, 0.0, 1.0), 1.0);
+    let s: f32 = -sign(q.y);
+    let d: vec2f = min(vec2f(dot(a, a), s * (p.x * q.y - p.y * q.x)), vec2f(dot(b, b), s * (p.y - q.y)));
+    return -sqrt(d.x) * sign(d.y);
+}
+`,
+    `
+fn sdTriangle(p: vec2f, p0: vec2f, p1: vec2f, p2: vec2f) -> f32 {
+    let e0: vec2f = p1 - p0;
+    let e1: vec2f = p2 - p1;
+    let e2: vec2f = p0 - p2;
+    let v0: vec2f = p - p0;
+    let v1: vec2f = p - p1;
+    let v2: vec2f = p - p2;
+    let pq0: vec2f = v0 - e0 * clamp(dot(v0, e0) / dot(e0, e0), 0.0, 1.0);
+    let pq1: vec2f = v1 - e1 * clamp(dot(v1, e1) / dot(e1, e1), 0.0, 1.0);
+    let pq2: vec2f = v2 - e2 * clamp(dot(v2, e2) / dot(e2, e2), 0.0, 1.0);
+    let s: f32 = sign(e0.x * e2.y - e0.y * e2.x);
+    let d: vec2f = min(min(vec2f(dot(pq0, pq0), s * (v0.x * e0.y - v0.y * e0.x)), vec2f(dot(pq1, pq1), s * (v1.x * e1.y - v1.y * e1.x))), vec2f(dot(pq2, pq2), s * (v2.x * e2.y - v2.y * e2.x)));
+    return -sqrt(d.x) * sign(d.y);
+}
+`,
+    `
+fn sdUnevenCapsule(pIn: vec2f, r1: f32, r2: f32, h: f32) -> f32 {
+    var p: vec2f = pIn;
+    p.x = abs(p.x);
+    let b: f32 = (r1 - r2) / h;
+    let a: f32 = sqrt(1.0 - b * b);
+    let k: f32 = dot(p, vec2f(-b, a));
+    if (k < 0.0) {
+        return length(p) - r1;
+    }
+    if (k > a * h) {
+        return length(p - vec2f(0.0, h)) - r2;
+    }
+    return dot(p, vec2f(a, b)) - r1;
+}
+`,
+    `
+fn sdPentagon(pIn: vec2f, r: f32) -> f32 {
+    var p: vec2f = pIn;
+    let k: vec3f = vec3f(0.809016994, 0.587785252, 0.726542528);
+    p.x = abs(p.x);
+    p -= 2.0 * min(dot(vec2f(-k.x, k.y), p), 0.0) * vec2f(-k.x, k.y);
+    p -= 2.0 * min(dot(vec2f(k.x, k.y), p), 0.0) * vec2f(k.x, k.y);
+    p -= vec2f(clamp(p.x, -r * k.z, r * k.z), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+fn sdHexagon(pIn: vec2f, r: f32) -> f32 {
+    var p: vec2f = pIn;
+    let k: vec3f = vec3f(-0.866025404, 0.5, 0.577350269);
+    p = abs(p);
+    p -= 2.0 * min(dot(k.xy, p), 0.0) * k.xy;
+    p -= vec2f(clamp(p.x, -k.z * r, k.z * r), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+fn sdOctogon(pIn: vec2f, r: f32) -> f32 {
+    var p: vec2f = pIn;
+    let k: vec3f = vec3f(-0.9238795325, 0.3826834323, 0.4142135623);
+    p = abs(p);
+    p -= 2.0 * min(dot(vec2f(k.x, k.y), p), 0.0) * vec2f(k.x, k.y);
+    p -= 2.0 * min(dot(vec2f(-k.x, k.y), p), 0.0) * vec2f(-k.x, k.y);
+    p -= vec2f(clamp(p.x, -k.z * r, k.z * r), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+fn sdHexagram(pIn: vec2f, r: f32) -> f32 {
+    var p: vec2f = pIn;
+    let k: vec4f = vec4f(-0.5, 0.8660254038, 0.5773502692, 1.7320508076);
+    p = abs(p);
+    p -= 2.0 * min(dot(k.xy, p), 0.0) * k.xy;
+    p -= 2.0 * min(dot(k.yx, p), 0.0) * k.yx;
+    p -= vec2f(clamp(p.x, r * k.z, r * k.w), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+fn sdStar5(pIn: vec2f, r: f32, rf: f32) -> f32 {
+    var p: vec2f = pIn;
+    let k1: vec2f = vec2f(0.809016994375, -0.587785252292);
+    let k2: vec2f = vec2f(-k1.x, k1.y);
+    p.x = abs(p.x);
+    p -= 2.0 * max(dot(k1, p), 0.0) * k1;
+    p -= 2.0 * max(dot(k2, p), 0.0) * k2;
+    p.x = abs(p.x);
+    p.y -= r;
+    let ba: vec2f = rf * vec2f(-k1.y, k1.x) - vec2f(0.0, 1.0);
+    let h: f32 = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);
+    return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);
+}
+`,
+    `
+fn sdStar(pIn: vec2f, r: f32, n: i32, m: f32) -> f32 {
+    var p: vec2f = pIn;
+    let an: f32 = 3.141593 / f32(n);
+    let en: f32 = 3.141593 / m;
+    let acs: vec2f = vec2f(cos(an), sin(an));
+    let ecs: vec2f = vec2f(cos(en), sin(en));
+    let bn: f32 = glslMod(atan2(p.x, p.y), 2.0 * an) - an;
+    p = length(p) * vec2f(cos(bn), abs(sin(bn)));
+    p -= r * acs;
+    p += ecs * clamp(-dot(p, ecs), 0.0, r * acs.y / ecs.y);
+    return length(p) * sign(p.x);
+}
+`,
+    `
+fn sdPie(pIn: vec2f, c: vec2f, r: f32) -> f32 {
+    var p: vec2f = pIn;
+    p.x = abs(p.x);
+    let l: f32 = length(p) - r;
+    let m: f32 = length(p - c * clamp(dot(p, c), 0.0, r));
+    return max(l, m * sign(c.y * p.x - c.x * p.y));
+}
+`,
+    `
+fn sdCutDisk(pIn: vec2f, r: f32, h: f32) -> f32 {
+    var p: vec2f = pIn;
+    let w: f32 = sqrt(r * r - h * h);
+    p.x = abs(p.x);
+    let s: f32 = max((h - r) * p.x * p.x + w * w * (h + r - 2.0 * p.y), h * p.x - w * p.y);
+    return select(select(length(p - vec2f(w, h)), h - p.y, (p.x < w)), length(p) - r, (s < 0.0));
+}
+`,
+    `
+fn sdArc(pIn: vec2f, sc: vec2f, ra: f32, rb: f32) -> f32 {
+    var p: vec2f = pIn;
+    p.x = abs(p.x);
+    return (select(abs(length(p) - ra), length(p - sc * ra), (sc.y * p.x > sc.x * p.y))) - rb;
+}
+`,
+    `
+fn sdRing(pIn: vec2f, n: vec2f, r: f32, th: f32) -> f32 {
+    var p: vec2f = pIn;
+    p.x = abs(p.x);
+    p = vec2f(p.x * n.x + p.y * (-n.y), p.x * n.y + p.y * n.x);
+    return max(abs(length(p) - r) - th * 0.5, length(vec2f(p.x, max(0.0, abs(r - p.y) - th * 0.5))) * sign(p.x));
+}
+`,
+    `
+fn sdHorseshoe(pIn: vec2f, c: vec2f, r: f32, w: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    p.x = abs(p.x);
+    let l: f32 = length(p);
+    p = vec2f(p.x * (-c.x) + p.y * c.y, p.x * c.y + p.y * c.x);
+    p = vec2f(select(l * sign(-c.x), p.x, (p.y > 0.0 || p.x > 0.0)), select(l, p.y, (p.x > 0.0)));
+    p = vec2f(p.x, abs(p.y - r)) - w;
+    return length(max(p, vec2f(0.0))) + min(0.0, max(p.x, p.y));
+}
+`,
+    `
+fn sdVesica(pIn: vec2f, r: f32, d: f32) -> f32 {
+    var p: vec2f = pIn;
+    p = abs(p);
+    let b: f32 = sqrt(r * r - d * d);
+    return select(length(p - vec2f(-d, 0.0)) - r, length(p - vec2f(0.0, b)), ((p.y - b) * d > p.x * b));
+}
+`,
+    `
+fn sdOrientedVesica(p: vec2f, a: vec2f, b: vec2f, w: f32) -> f32 {
+    let r: f32 = 0.5 * length(b - a);
+    let d: f32 = 0.5 * (r * r - w * w) / w;
+    let v: vec2f = (b - a) / r;
+    let c: vec2f = (b + a) * 0.5;
+    let q: vec2f = 0.5 * abs(vec2f((p - c).x * v.y + (p - c).y * (-v.x), (p - c).x * v.x + (p - c).y * v.y));
+    let h: vec3f = select(vec3f(-d, 0.0, d + w), vec3f(0.0, r, 0.0), (r * q.x < d * (q.y - r)));
+    return length(q - h.xy) - h.z;
+}
+`,
+    `
+fn sdMoon(pIn: vec2f, d: f32, ra: f32, rb: f32) -> f32 {
+    var p: vec2f = pIn;
+    p.y = abs(p.y);
+    let a: f32 = (ra * ra - rb * rb + d * d) / (2.0 * d);
+    let b: f32 = sqrt(max(ra * ra - a * a, 0.0));
+    if (d * (p.x * b - p.y * a) > d * d * max(b - p.y, 0.0)) {
+        return length(p - vec2f(a, b));
+    }
+    return max(length(p) - ra, -(length(p - vec2f(d, 0.0)) - rb));
+}
+`,
+    `
+fn sdRoundedCross(pIn: vec2f, h: f32) -> f32 {
+    var p: vec2f = pIn;
+    let k: f32 = 0.5 * (h + 1.0 / h);
+    p = abs(p);
+    return select(sqrt(min(dot2(p - vec2f(0.0, h)), dot2(p - vec2f(1.0, 0.0)))), k - sqrt(dot2(p - vec2f(1.0, k))), (p.x < 1.0 && p.y < p.x * (k - h) + h));
+}
+`,
+    `
+fn sdEgg(pIn: vec2f, he: f32, ra: f32, rb: f32, bu: f32) -> f32 {
+    var p: vec2f = pIn;
+    let r: f32 = 0.5 * (he + ra + rb) / bu;
+    let da: f32 = r - ra;
+    let db: f32 = r - rb;
+    let y: f32 = (db * db - da * da - he * he) / (2.0 * he);
+    let x: f32 = sqrt(max(da * da - y * y, 0.0));
+    p.x = abs(p.x);
+    p.y += 0.5 * (he + rb - ra);
+    let k: f32 = p.y * x - p.x * y;
+    if (k > 0.0 && k < he * (p.x + x)) {
+        return length(p + vec2f(x, y)) - r;
+    }
+    return min(length(p) - ra, length(vec2f(p.x, p.y - he)) - rb);
+}
+`,
+    `
+fn sdHeart(pIn: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    p.x = abs(p.x);
+    if (p.y + p.x > 1.0) {
+        return sqrt(dot(p - vec2f(0.25, 0.75), p - vec2f(0.25, 0.75))) - sqrt(2.0) / 4.0;
+    }
+    return sqrt(min(dot(p - vec2f(0.00, 1.00), p - vec2f(0.00, 1.00)), dot(p - 0.5 * max(p.x + p.y, 0.0), p - 0.5 * max(p.x + p.y, 0.0)))) * sign(p.x - p.y);
+}
+`,
+    `
+fn sdCross(pIn: vec2f, b: vec2f, r: f32) -> f32 {
+    var p: vec2f = pIn;
+    p = abs(p);
+    p = select(p.xy, p.yx, (p.y > p.x));
+    let q: vec2f = p - b;
+    let k: f32 = max(q.y, q.x);
+    let w: vec2f = select(vec2f(b.y - p.x, -k), q, (k > 0.0));
+    return sign(k) * length(max(w, vec2f(0.0))) + r;
+}
+`,
+    `
+fn sdRoundedX(pIn: vec2f, w: f32, r: f32) -> f32 {
+    var p: vec2f = pIn;
+    p = abs(p);
+    return length(p - min(p.x + p.y, w) * 0.5) - r;
+}
+`,
+    `
+fn sdEllipse(pIn: vec2f, abIn: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    var ab: vec2f = abIn;
+    p = abs(p);
+    if (p.x > p.y) {
+        p = p.yx;
+        ab = ab.yx;
+    }
+    let l: f32 = ab.y * ab.y - ab.x * ab.x;
+    let m: f32 = ab.x * p.x / l;
+    let m2: f32 = m * m;
+    let n: f32 = ab.y * p.y / l;
+    let n2: f32 = n * n;
+    let c: f32 = (m2 + n2 - 1.0) / 3.0;
+    let c3: f32 = c * c * c;
+    let q: f32 = c3 + m2 * n2 * 2.0;
+    let d: f32 = c3 + m2 * n2;
+    let g: f32 = m + m * n2;
+    var co: f32;
+    if (d < 0.0) {
+        let h: f32 = acos(q / c3) / 3.0;
+        let s: f32 = cos(h);
+        let t: f32 = sin(h) * sqrt(3.0);
+        let rx: f32 = sqrt(-c * (s + t + 2.0) + m2);
+        let ry: f32 = sqrt(-c * (s - t + 2.0) + m2);
+        co = (ry + sign(l) * rx + abs(g) / (rx * ry) - m) / 2.0;
+    } else {
+        let h: f32 = 2.0 * m * n * sqrt(d);
+        let s: f32 = sign(q + h) * pow(abs(q + h), 1.0 / 3.0);
+        let u: f32 = sign(q - h) * pow(abs(q - h), 1.0 / 3.0);
+        let rx: f32 = -s - u - c * 4.0 + 2.0 * m2;
+        let ry: f32 = (s - u) * sqrt(3.0);
+        let rm: f32 = sqrt(rx * rx + ry * ry);
+        co = (ry / sqrt(rm - rx) + 2.0 * g / rm - m) / 2.0;
+    }
+    let r: vec2f = ab * vec2f(co, sqrt(1.0 - co * co));
+    return length(r - p) * sign(p.y - r.y);
+}
+`,
+    `
+fn sdParabola(posIn: vec2f, k: f32) -> f32 {
+    var pos: vec2f = posIn;
+    pos.x = abs(pos.x);
+    let ik: f32 = 1.0 / k;
+    let p: f32 = ik * (pos.y - 0.5 * ik) / 3.0;
+    let q: f32 = 0.25 * ik * ik * pos.x;
+    let h: f32 = q * q - p * p * p;
+    let r: f32 = sqrt(abs(h));
+    let x: f32 = select(2.0 * cos(atan(r / q) / 3.0) * sqrt(p), pow(q + r, 1.0 / 3.0) - pow(abs(q - r), 1.0 / 3.0) * sign(r - q), (h > 0.0));
+    return length(pos - vec2f(x, k * x * x)) * sign(pos.x - x);
+}
+`,
+    `
+fn sdParabolaSegment(posIn: vec2f, wi: f32, he: f32) -> f32 {
+    var pos: vec2f = posIn;
+    pos.x = abs(pos.x);
+    let ik: f32 = wi * wi / he;
+    let p: f32 = ik * (he - pos.y - 0.5 * ik) / 3.0;
+    let q: f32 = pos.x * ik * ik * 0.25;
+    let h: f32 = q * q - p * p * p;
+    let r: f32 = sqrt(abs(h));
+    var x: f32 = select(2.0 * cos(atan(r / q) / 3.0) * sqrt(p), pow(q + r, 1.0 / 3.0) - pow(abs(q - r), 1.0 / 3.0) * sign(r - q), (h > 0.0));
+    x = min(x, wi);
+    return length(pos - vec2f(x, he - x * x / ik)) * sign(ik * (pos.y - he) + pos.x * pos.x);
+}
+`,
+    `
+fn sdBezier(pos: vec2f, A: vec2f, B: vec2f, C: vec2f) -> f32 {
+    let a: vec2f = B - A;
+    let b: vec2f = A - 2.0 * B + C;
+    let c: vec2f = a * 2.0;
+    let d: vec2f = A - pos;
+    let kk: f32 = 1.0 / dot(b, b);
+    let kx: f32 = kk * dot(a, b);
+    let ky: f32 = kk * (2.0 * dot(a, a) + dot(d, b)) / 3.0;
+    let kz: f32 = kk * dot(d, a);
+    var res: f32 = 0.0;
+    let p: f32 = ky - kx * kx;
+    let p3: f32 = p * p * p;
+    let q: f32 = kx * (2.0 * kx * kx - 3.0 * ky) + kz;
+    var h: f32 = q * q + 4.0 * p3;
+    if (h >= 0.0) {
+        h = sqrt(h);
+        let x: vec2f = (vec2f(h, -h) - q) * 0.5;
+        let uv: vec2f = sign(x) * pow(abs(x), vec2f(1.0 / 3.0, 1.0 / 3.0));
+        let t: f32 = clamp(uv.x + uv.y - kx, 0.0, 1.0);
+        res = dot(d + (c + b * t) * t, d + (c + b * t) * t);
+    } else {
+        let z: f32 = sqrt(-p);
+        let v: f32 = acos(q / (p * z * 2.0)) / 3.0;
+        let m: f32 = cos(v);
+        let n: f32 = sin(v) * 1.732050808;
+        let t: vec3f = clamp(vec3f(m + m, -n - m, n - m) * z - kx, vec3f(0.0), vec3f(1.0));
+        res = min(dot(d + (c + b * t.x) * t.x, d + (c + b * t.x) * t.x), dot(d + (c + b * t.y) * t.y, d + (c + b * t.y) * t.y));
+    }
+    return sqrt(res);
+}
+`,
+    `
+fn sdBlobbyCross(posIn: vec2f, he: f32) -> f32 {
+    var pos: vec2f = posIn;
+    pos = abs(pos);
+    pos = vec2f(abs(pos.x - pos.y), 1.0 - pos.x - pos.y) / sqrt(2.0);
+    let p: f32 = (he - pos.y - 0.25 / he) / (6.0 * he);
+    let q: f32 = pos.x / (he * he * 16.0);
+    let h: f32 = q * q - p * p * p;
+    var x: f32;
+    if (h > 0.0) {
+        let r: f32 = sqrt(h);
+        x = pow(q + r, 1.0 / 3.0) - pow(abs(q - r), 1.0 / 3.0) * sign(r - q);
+    } else {
+        let r: f32 = sqrt(p);
+        x = 2.0 * r * cos(acos(q / (p * r)) / 3.0);
+    }
+    x = min(x, sqrt(2.0) / 2.0);
+    let z: vec2f = vec2f(x, he * (1.0 - 2.0 * x * x)) - pos;
+    return length(z) * sign(z.y);
+}
+`,
+    `
+fn sdTunnel(pIn: vec2f, wh: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    p.x = abs(p.x);
+    p.y = -p.y;
+    var q: vec2f = p - wh;
+    let d1: f32 = dot(vec2f(max(q.x, 0.0), q.y), vec2f(max(q.x, 0.0), q.y));
+    q.x = select(length(p) - wh.x, q.x, (p.y > 0.0));
+    let d2: f32 = dot(vec2f(q.x, max(q.y, 0.0)), vec2f(q.x, max(q.y, 0.0)));
+    let d: f32 = sqrt(min(d1, d2));
+    return select(d, -d, (max(q.x, q.y) < 0.0));
+}
+`,
+    `
+fn sdStairs(pIn: vec2f, wh: vec2f, n: f32) -> f32 {
+    var p: vec2f = pIn;
+    let ba: vec2f = wh * n;
+    var d: f32 = min(dot(p - vec2f(clamp(p.x, 0.0, ba.x), 0.0), p - vec2f(clamp(p.x, 0.0, ba.x), 0.0)), dot(p - vec2f(ba.x, clamp(p.y, 0.0, ba.y)), p - vec2f(ba.x, clamp(p.y, 0.0, ba.y))));
+    var s: f32 = sign(max(-p.y, p.x - ba.x));
+    let dia: f32 = length(wh);
+    p = vec2f(p.x * wh.x + p.y * wh.y, p.x * (-wh.y) + p.y * wh.x) / dia;
+    let id: f32 = clamp(round(p.x / dia), 0.0, n - 1.0);
+    p.x = p.x - id * dia;
+    p = vec2f(p.x * wh.x + p.y * (-wh.y), p.x * wh.y + p.y * wh.x) / dia;
+    let hh: f32 = wh.y / 2.0;
+    p.y -= hh;
+    if (p.y > hh * sign(p.x)) {
+        s = 1.0;
+    }
+    p = select(-p, p, (id < 0.5 || p.x > 0.0));
+    d = min(d, dot(p - vec2f(0.0, clamp(p.y, -hh, hh)), p - vec2f(0.0, clamp(p.y, -hh, hh))));
+    d = min(d, dot(p - vec2f(clamp(p.x, 0.0, wh.x), hh), p - vec2f(clamp(p.x, 0.0, wh.x), hh)));
+    return sqrt(d) * s;
+}
+`,
+    `
+fn sdQuadraticCircle(pIn: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    p = abs(p);
+    if (p.y > p.x) {
+        p = p.yx;
+    }
+    let a: f32 = p.x - p.y;
+    let b: f32 = p.x + p.y;
+    let c: f32 = (2.0 * b - 1.0) / 3.0;
+    var h: f32 = a * a + c * c * c;
+    var t: f32;
+    if (h >= 0.0) {
+        h = sqrt(h);
+        t = sign(h - a) * pow(abs(h - a), 1.0 / 3.0) - pow(h + a, 1.0 / 3.0);
+    } else {
+        let z: f32 = sqrt(-c);
+        let v: f32 = acos(a / (c * z)) / 3.0;
+        t = -z * (cos(v) + sin(v) * 1.732050808);
+    }
+    t *= 0.5;
+    let w: vec2f = vec2f(-t, t) + 0.75 - t * t - p;
+    return length(w) * sign(a * a * 0.5 + b - 1.5);
+}
+`,
+    `
+fn sdHyberbola(pIn: vec2f, k: f32, he: f32) -> f32 {
+    var p: vec2f = pIn;
+    p = abs(p);
+    p = vec2f(p.x - p.y, p.x + p.y) / sqrt(2.0);
+    let x2: f32 = p.x * p.x / 16.0;
+    let y2: f32 = p.y * p.y / 16.0;
+    let r: f32 = k * (4.0 * k - p.x * p.y) / 12.0;
+    let q: f32 = (x2 - y2) * k * k;
+    let h: f32 = q * q + r * r * r;
+    var u: f32;
+    if (h < 0.0) {
+        let m: f32 = sqrt(-r);
+        u = m * cos(acos(q / (r * m)) / 3.0);
+    } else {
+        let m: f32 = pow(sqrt(h) - q, 1.0 / 3.0);
+        u = (m - r / m) / 2.0;
+    }
+    let w: f32 = sqrt(u + x2);
+    let b: f32 = k * p.y - x2 * p.x * 2.0;
+    var t: f32 = p.x / 4.0 - w + sqrt(2.0 * x2 - u + b / w / 4.0);
+    t = max(t, sqrt(he * he * 0.5 + k) - he / sqrt(2.0));
+    return length(p - vec2f(t, k / t)) * sign(select(-1.0, 1.0, p.x * p.y < k));
+}
+`,
+    `
+fn sdCoolS(pIn: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    let six: f32 = select(p.x, -p.x, (p.y < 0.0));
+    p.x = abs(p.x);
+    p.y = abs(p.y) - 0.2;
+    let rex: f32 = p.x - min(round(p.x / 0.4), 0.4);
+    let aby: f32 = abs(p.y - 0.2) - 0.6;
+    var d: f32 = dot2(vec2f(six, -p.y) - clamp(0.5 * (six - p.y), 0.0, 0.2));
+    d = min(d, dot2(vec2f(p.x, -aby) - clamp(0.5 * (p.x - aby), 0.0, 0.4)));
+    d = min(d, dot2(vec2f(rex, p.y - clamp(p.y, 0.0, 0.4))));
+    let s: f32 = 2.0 * p.x + aby + abs(aby + 0.4) - 0.4;
+    return sqrt(d) * sign(s);
+}
+`,
+    `
+fn sdCircleWave(pIn: vec2f, tbIn: f32, ra: f32) -> f32 {
+    var p: vec2f = pIn;
+    var tb: f32 = tbIn;
+    tb = 3.1415927 * 5.0 / 6.0 * max(tb, 0.0001);
+    let co: vec2f = ra * vec2f(sin(tb), cos(tb));
+    p.x = abs(glslMod(p.x, co.x * 4.0) - co.x * 2.0);
+    let p1: vec2f = p;
+    let p2: vec2f = vec2f(abs(p.x - 2.0 * co.x), -p.y + 2.0 * co.y);
+    let d1: f32 = (select(abs(length(p1) - ra), length(p1 - co), (co.y * p1.x > co.x * p1.y)));
+    let d2: f32 = (select(abs(length(p2) - ra), length(p2 - co), (co.y * p2.x > co.x * p2.y)));
+    return min(d1, d2);
+}
+`,
+    `
+fn onejsHash21(pIn: vec2f, seed: f32) -> f32 {
+    var p: vec2f = pIn;
+    p = fract(p * vec2f(123.34, 456.21) + seed * 0.1731);
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+}
+`,
+    `
+fn onejsVNoise(p: vec2f, seed: f32) -> f32 {
+    let i: vec2f = floor(p);
+    var f: vec2f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    let a: f32 = onejsHash21(i, seed);
+    let b: f32 = onejsHash21(i + vec2f(1.0, 0.0), seed);
+    let c: f32 = onejsHash21(i + vec2f(0.0, 1.0), seed);
+    let d: f32 = onejsHash21(i + vec2f(1.0, 1.0), seed);
+    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+`,
+    `
+fn onejsFbm_f2_f_i_f_f(pIn: vec2f, seed: f32, octaves: i32, lacunarity: f32, gain: f32) -> f32 {
+    var p: vec2f = pIn;
+    var sum: f32 = 0.0;
+    var amp: f32 = 0.5;
+    var norm: f32 = 0.0;
+    for (var o: i32 = 0; o < 4; o++) {
+        if (o >= octaves) {
+            break;
+        }
+        sum += onejsVNoise(p, seed + f32(o) * 19.0) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+`,
+    `
+fn onejsFbm_f2_f_i(p: vec2f, seed: f32, octaves: i32) -> f32 {
+    return onejsFbm_f2_f_i_f_f(p, seed, octaves, 2.0, 0.5);
+}
+`,
+    `
+fn onejsMod289_f2(x: vec2f) -> vec2f {
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+`,
+    `
+fn onejsMod289_f3(x: vec3f) -> vec3f {
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+`,
+    `
+fn onejsPermute(x: vec3f) -> vec3f {
+    return onejsMod289_f3(((x * 34.0) + 1.0) * x);
+}
+`,
+    `
+fn onejsSimplexRaw(v: vec2f) -> f32 {
+    let C: vec4f = vec4f(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
+    var i: vec2f = floor(v + dot(v, C.yy));
+    let x0: vec2f = v - i + dot(i, C.xx);
+    let i1: vec2f = select(vec2f(0.0, 1.0), vec2f(1.0, 0.0), (x0.x > x0.y));
+    var x12: vec4f = x0.xyxy + C.xxzz;
+    {
+        let sl_v: vec2f = x12.xy - i1;
+        x12 = vec4f(sl_v.x, sl_v.y, x12.z, x12.w);
+    }
+    i = onejsMod289_f2(i);
+    let p: vec3f = onejsPermute(onejsPermute(i.y + vec3f(0.0, i1.y, 1.0)) + i.x + vec3f(0.0, i1.x, 1.0));
+    var m: vec3f = max(0.5 - vec3f(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), vec3f(0.0));
+    m = m * m;
+    m = m * m;
+    let x: vec3f = 2.0 * fract(p * C.www) - 1.0;
+    let h: vec3f = abs(x) - 0.5;
+    let ox: vec3f = floor(x + 0.5);
+    let a0: vec3f = x - ox;
+    m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+    var g: vec3f;
+    g.x = a0.x * x0.x + h.x * x0.y;
+    {
+        let sl_v: vec2f = a0.yz * x12.xz + h.yz * x12.yw;
+        g = vec3f(g.x, sl_v.x, sl_v.y);
+    }
+    return 130.0 * dot(m, g);
+}
+`,
+    `
+fn onejsSimplex(p: vec2f, seed: f32) -> f32 {
+    return onejsSimplexRaw(p + seed * 137.13) * 0.5 + 0.5;
+}
+`,
+    `
+fn onejsFbmSimplex(pIn: vec2f, seed: f32, octaves: i32, lacunarity: f32, gain: f32) -> f32 {
+    var p: vec2f = pIn;
+    var sum: f32 = 0.0;
+    var amp: f32 = 0.5;
+    var norm: f32 = 0.0;
+    for (var o: i32 = 0; o < 4; o++) {
+        if (o >= octaves) {
+            break;
+        }
+        sum += onejsSimplex(p, seed + f32(o) * 19.0) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+`,
+    `
+fn onejsTurbulence(pIn: vec2f, seed: f32, octaves: i32, lacunarity: f32, gain: f32) -> f32 {
+    var p: vec2f = pIn;
+    var sum: f32 = 0.0;
+    var amp: f32 = 0.5;
+    var norm: f32 = 0.0;
+    for (var o: i32 = 0; o < 4; o++) {
+        if (o >= octaves) {
+            break;
+        }
+        sum += abs(onejsSimplexRaw(p + (seed + f32(o) * 19.0) * 137.13)) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+`,
+    `
+fn onejsRidged(pIn: vec2f, seed: f32, octaves: i32, lacunarity: f32, gain: f32) -> f32 {
+    var p: vec2f = pIn;
+    var sum: f32 = 0.0;
+    var amp: f32 = 0.5;
+    var norm: f32 = 0.0;
+    for (var o: i32 = 0; o < 4; o++) {
+        if (o >= octaves) {
+            break;
+        }
+        let r: f32 = 1.0 - abs(onejsSimplexRaw(p + (seed + f32(o) * 19.0) * 137.13));
+        sum += r * r * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+`,
+    `
+fn onejsFbmKind(kind: i32, p: vec2f, seed: f32, octaves: i32, lacunarity: f32, gain: f32) -> f32 {
+    if (kind == 2) {
+        return onejsTurbulence(p, seed, octaves, lacunarity, gain);
+    }
+    if (kind == 3) {
+        return onejsRidged(p, seed, octaves, lacunarity, gain);
+    }
+    return select(onejsFbm_f2_f_i_f_f(p, seed, octaves, lacunarity, gain), onejsFbmSimplex(p, seed, octaves, lacunarity, gain), kind == 1);
+}
+`,
+    `
+fn sl_hash21(pIn: vec2f) -> f32 {
+    var p: vec2f = pIn;
+    p = fract(p * vec2f(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+}
+`,
+    `
+fn sl_valueNoise(p: vec2f) -> f32 {
+    return onejsVNoise(p, 0.0);
+}
+`,
+    `
+fn sl_simplex(p: vec2f) -> f32 {
+    return onejsSimplex(p, 0.0);
+}
+`,
+    `
+fn sl_fbm(p: vec2f, octaves: i32, kind: i32) -> f32 {
+    return onejsFbmKind(kind, p, 0.0, clamp(octaves, 1, 4), 2.0, 0.5);
+}
+`,
+    `
+fn sl_hsv2rgb(c: vec3f) -> vec3f {
+    let K: vec4f = vec4f(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    let p: vec3f = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * mix(K.xxx, saturate(p - K.xxx), vec3f(c.y));
+}
+`,
+    `
+fn sl_sdfDistance(id: i32, p: vec2f, a: vec4f, b: vec2f) -> f32 {
+    switch (id) {
+        case 0: {
+            return sdCircle(p, a.x);
+        }
+        case 1: {
+            return sdRoundedBox(p, a.xy, vec4f(a.z, a.w, b.x, b.y));
+        }
+        case 2: {
+            return sdBox(p, a.xy);
+        }
+        case 3: {
+            return sdOrientedBox(p, a.xy, a.zw, b.x);
+        }
+        case 4: {
+            return sdSegment(p, a.xy, a.zw);
+        }
+        case 5: {
+            return sdRhombus(p, a.xy);
+        }
+        case 6: {
+            return sdTrapezoid(p, a.x, a.y, a.z);
+        }
+        case 7: {
+            return sdParallelogram(p, a.x, a.y, a.z);
+        }
+        case 8: {
+            return sdEquilateralTriangle(p, a.x);
+        }
+        case 9: {
+            return sdTriangleIsosceles(p, a.xy);
+        }
+        case 10: {
+            return sdTriangle(p, a.xy, a.zw, b.xy);
+        }
+        case 11: {
+            return sdUnevenCapsule(p, a.x, a.y, a.z);
+        }
+        case 12: {
+            return sdPentagon(p, a.x);
+        }
+        case 13: {
+            return sdHexagon(p, a.x);
+        }
+        case 14: {
+            return sdOctogon(p, a.x);
+        }
+        case 15: {
+            return sdHexagram(p, a.x);
+        }
+        case 16: {
+            return sdStar5(p, a.x, a.y);
+        }
+        case 17: {
+            return sdStar(p, a.x, i32(a.y), a.z);
+        }
+        case 18: {
+            return sdPie(p, a.xy, a.z);
+        }
+        case 19: {
+            return sdCutDisk(p, a.x, a.y);
+        }
+        case 20: {
+            return sdArc(p, a.xy, a.z, a.w);
+        }
+        case 21: {
+            return sdRing(p, a.xy, a.z, a.w);
+        }
+        case 22: {
+            return sdHorseshoe(p, a.xy, a.z, vec2f(a.w, b.x));
+        }
+        case 23: {
+            return sdVesica(p, a.x, a.y);
+        }
+        case 24: {
+            return sdOrientedVesica(p, a.xy, a.zw, b.x);
+        }
+        case 25: {
+            return sdMoon(p, a.x, a.y, a.z);
+        }
+        case 26: {
+            return sdRoundedCross(p, a.x);
+        }
+        case 27: {
+            return sdEgg(p, a.x, a.y, a.z, a.w);
+        }
+        case 28: {
+            return sdHeart(p);
+        }
+        case 29: {
+            return sdCross(p, a.xy, a.z);
+        }
+        case 30: {
+            return sdRoundedX(p, a.x, a.y);
+        }
+        case 31: {
+            return sdEllipse(p, a.xy);
+        }
+        case 32: {
+            return sdParabola(p, a.x);
+        }
+        case 33: {
+            return sdParabolaSegment(p, a.x, a.y);
+        }
+        case 34: {
+            return sdBezier(p, a.xy, a.zw, b.xy);
+        }
+        case 35: {
+            return sdBlobbyCross(p, a.x);
+        }
+        case 36: {
+            return sdTunnel(p, a.xy);
+        }
+        case 37: {
+            return sdStairs(p, a.xy, a.z);
+        }
+        case 38: {
+            return sdQuadraticCircle(p);
+        }
+        case 39: {
+            return sdHyberbola(p, a.x, a.y);
+        }
+        case 40: {
+            return sdCoolS(p);
+        }
+        case 41: {
+            return sdCircleWave(p, a.x, a.y);
+        }
+        default: {
+            return 1e6;
+        }
+    }
+}
+`,
+    `
+fn sl_voronoi(p: vec2f) -> f32 {
+    let cell: vec2f = floor(p);
+    let f: vec2f = fract(p);
+    var best: f32 = 8.0;
+    for (var y: i32 = -1; y <= 1; y++) {
+        for (var x: i32 = -1; x <= 1; x++) {
+            let o: vec2f = vec2f(f32(x), f32(y));
+            let jitter: vec2f = vec2f(sl_hash21(cell + o), sl_hash21(cell + o + 37.7));
+            best = min(best, length(o + jitter - f));
+        }
+    }
+    return best;
+}
+`,
+    `
+fn sl_luminance(c: vec3f) -> f32 {
+    return dot(c, vec3f(0.2126, 0.7152, 0.0722));
+}
+`,
+    `
+fn sl_gammaToLinear(c: vec3f) -> vec3f {
+    return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
+}
+`,
+    `
+fn sl_toLinear_f_gamma(c: f32) -> f32 {
+    return c;
+}
+fn sl_toLinear_f_linear(c: f32) -> f32 {
+    return sl_gammaToLinear(vec3f(c, 0.0, 0.0)).x;
+}
+fn sl_toLinear_f(c: f32) -> f32 {
+    if (sl.opt.x > 0.5) {
+        return sl_toLinear_f_linear(c);
+    }
+    return sl_toLinear_f_gamma(c);
+}
+`,
+    `
+fn sl_toLinear_f2_gamma(c: vec2f) -> vec2f {
+    return c;
+}
+fn sl_toLinear_f2_linear(c: vec2f) -> vec2f {
+    return sl_gammaToLinear(vec3f(c, 0.0)).xy;
+}
+fn sl_toLinear_f2(c: vec2f) -> vec2f {
+    if (sl.opt.x > 0.5) {
+        return sl_toLinear_f2_linear(c);
+    }
+    return sl_toLinear_f2_gamma(c);
+}
+`,
+    `
+fn sl_toLinear_f3_gamma(c: vec3f) -> vec3f {
+    return c;
+}
+fn sl_toLinear_f3_linear(c: vec3f) -> vec3f {
+    return sl_gammaToLinear(c);
+}
+fn sl_toLinear_f3(c: vec3f) -> vec3f {
+    if (sl.opt.x > 0.5) {
+        return sl_toLinear_f3_linear(c);
+    }
+    return sl_toLinear_f3_gamma(c);
+}
+`,
+    `
+fn sl_toLinear_f4_gamma(c: vec4f) -> vec4f {
+    return c;
+}
+fn sl_toLinear_f4_linear(c: vec4f) -> vec4f {
+    return vec4f(sl_gammaToLinear(c.rgb), c.a);
+}
+fn sl_toLinear_f4(c: vec4f) -> vec4f {
+    if (sl.opt.x > 0.5) {
+        return sl_toLinear_f4_linear(c);
+    }
+    return sl_toLinear_f4_gamma(c);
+}
+`,
+]