onejs-sl 0.1.0 → 0.1.2

package/src/lib/glsl.ts

@@ -0,0 +1,899 @@
+// 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.
+
+/** GLSL ES 3.00, by `LIB_FUNCTIONS` index. */
+export const LIB_GLSL: ReadonlyArray<string> = [
+    `
+float glslMod(float x, float y) {
+    return x - y * floor(x / y);
+}
+`,
+    `
+float ndot(vec2 a, vec2 b) {
+    return a.x * b.x - a.y * b.y;
+}
+`,
+    `
+float dot2(vec2 v) {
+    return dot(v, v);
+}
+`,
+    `
+float sdCircle(vec2 p, float r) {
+    return length(p) - r;
+}
+`,
+    `
+float sdRoundedBox(vec2 p, vec2 b, vec4 r) {
+    r.xy = (p.x > 0.0) ? r.xy : r.zw;
+    r.x = (p.y > 0.0) ? r.x : r.y;
+    vec2 q = abs(p) - b + r.x;
+    return min(max(q.x, q.y), 0.0) + length(max(q, vec2(0.0))) - r.x;
+}
+`,
+    `
+float sdBox(vec2 p, vec2 b) {
+    vec2 d = abs(p) - b;
+    return length(max(d, vec2(0.0))) + min(max(d.x, d.y), 0.0);
+}
+`,
+    `
+float sdOrientedBox(vec2 p, vec2 a, vec2 b, float th) {
+    float l = length(b - a);
+    vec2 d = (b - a) / l;
+    vec2 q = (p - (a + b) * 0.5);
+    q = vec2(q.x * d.x + q.y * d.y, q.x * (-d.y) + q.y * d.x);
+    q = abs(q) - vec2(l, th) * 0.5;
+    return length(max(q, vec2(0.0))) + min(max(q.x, q.y), 0.0);
+}
+`,
+    `
+float sdSegment(vec2 p, vec2 a, vec2 b) {
+    vec2 pa = p - a;
+    vec2 ba = b - a;
+    float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+    return length(pa - ba * h);
+}
+`,
+    `
+float sdRhombus(vec2 p, vec2 b) {
+    p = abs(p);
+    float h = clamp(ndot(b - 2.0 * p, b) / dot(b, b), -1.0, 1.0);
+    float d = length(p - 0.5 * b * vec2(1.0 - h, 1.0 + h));
+    return d * sign(p.x * b.y + p.y * b.x - b.x * b.y);
+}
+`,
+    `
+float sdTrapezoid(vec2 p, float r1, float r2, float he) {
+    vec2 k1 = vec2(r2, he);
+    vec2 k2 = vec2(r2 - r1, 2.0 * he);
+    p.x = abs(p.x);
+    vec2 ca = vec2(p.x - min(p.x, (p.y < 0.0) ? r1 : r2), abs(p.y) - he);
+    vec2 cb = p - k1 + k2 * clamp(dot(k1 - p, k2) / dot2(k2), 0.0, 1.0);
+    float s = (cb.x < 0.0 && ca.y < 0.0) ? -1.0 : 1.0;
+    return s * sqrt(min(dot2(ca), dot2(cb)));
+}
+`,
+    `
+float sdParallelogram(vec2 p, float wi, float he, float sk) {
+    vec2 e = vec2(sk, he);
+    p = (p.y < 0.0) ? -p : p;
+    vec2 w = p - e;
+    w.x -= clamp(w.x, -wi, wi);
+    vec2 d = vec2(dot(w, w), -w.y);
+    float s = p.x * e.y - p.y * e.x;
+    p = (s < 0.0) ? -p : p;
+    vec2 v = p - vec2(wi, 0.0);
+    v -= e * clamp(dot(v, e) / dot(e, e), -1.0, 1.0);
+    d = min(d, vec2(dot(v, v), wi * he - abs(s)));
+    return sqrt(d.x) * sign(-d.y);
+}
+`,
+    `
+float sdEquilateralTriangle(vec2 p, float r) {
+    float k = sqrt(3.0);
+    p.x = abs(p.x) - r;
+    p.y = p.y + r / k;
+    if (p.x + k * p.y > 0.0) {
+        p = vec2(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);
+}
+`,
+    `
+float sdTriangleIsosceles(vec2 p, vec2 q) {
+    p.x = abs(p.x);
+    vec2 a = p - q * clamp(dot(p, q) / dot(q, q), 0.0, 1.0);
+    vec2 b = p - q * vec2(clamp(p.x / q.x, 0.0, 1.0), 1.0);
+    float s = -sign(q.y);
+    vec2 d = min(vec2(dot(a, a), s * (p.x * q.y - p.y * q.x)), vec2(dot(b, b), s * (p.y - q.y)));
+    return -sqrt(d.x) * sign(d.y);
+}
+`,
+    `
+float sdTriangle(vec2 p, vec2 p0, vec2 p1, vec2 p2) {
+    vec2 e0 = p1 - p0;
+    vec2 e1 = p2 - p1;
+    vec2 e2 = p0 - p2;
+    vec2 v0 = p - p0;
+    vec2 v1 = p - p1;
+    vec2 v2 = p - p2;
+    vec2 pq0 = v0 - e0 * clamp(dot(v0, e0) / dot(e0, e0), 0.0, 1.0);
+    vec2 pq1 = v1 - e1 * clamp(dot(v1, e1) / dot(e1, e1), 0.0, 1.0);
+    vec2 pq2 = v2 - e2 * clamp(dot(v2, e2) / dot(e2, e2), 0.0, 1.0);
+    float s = sign(e0.x * e2.y - e0.y * e2.x);
+    vec2 d = min(min(vec2(dot(pq0, pq0), s * (v0.x * e0.y - v0.y * e0.x)), vec2(dot(pq1, pq1), s * (v1.x * e1.y - v1.y * e1.x))), vec2(dot(pq2, pq2), s * (v2.x * e2.y - v2.y * e2.x)));
+    return -sqrt(d.x) * sign(d.y);
+}
+`,
+    `
+float sdUnevenCapsule(vec2 p, float r1, float r2, float h) {
+    p.x = abs(p.x);
+    float b = (r1 - r2) / h;
+    float a = sqrt(1.0 - b * b);
+    float k = dot(p, vec2(-b, a));
+    if (k < 0.0) {
+        return length(p) - r1;
+    }
+    if (k > a * h) {
+        return length(p - vec2(0.0, h)) - r2;
+    }
+    return dot(p, vec2(a, b)) - r1;
+}
+`,
+    `
+float sdPentagon(vec2 p, float r) {
+    vec3 k = vec3(0.809016994, 0.587785252, 0.726542528);
+    p.x = abs(p.x);
+    p -= 2.0 * min(dot(vec2(-k.x, k.y), p), 0.0) * vec2(-k.x, k.y);
+    p -= 2.0 * min(dot(vec2(k.x, k.y), p), 0.0) * vec2(k.x, k.y);
+    p -= vec2(clamp(p.x, -r * k.z, r * k.z), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+float sdHexagon(vec2 p, float r) {
+    vec3 k = vec3(-0.866025404, 0.5, 0.577350269);
+    p = abs(p);
+    p -= 2.0 * min(dot(k.xy, p), 0.0) * k.xy;
+    p -= vec2(clamp(p.x, -k.z * r, k.z * r), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+float sdOctogon(vec2 p, float r) {
+    vec3 k = vec3(-0.9238795325, 0.3826834323, 0.4142135623);
+    p = abs(p);
+    p -= 2.0 * min(dot(vec2(k.x, k.y), p), 0.0) * vec2(k.x, k.y);
+    p -= 2.0 * min(dot(vec2(-k.x, k.y), p), 0.0) * vec2(-k.x, k.y);
+    p -= vec2(clamp(p.x, -k.z * r, k.z * r), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+float sdHexagram(vec2 p, float r) {
+    vec4 k = vec4(-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 -= vec2(clamp(p.x, r * k.z, r * k.w), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+float sdStar5(vec2 p, float r, float rf) {
+    vec2 k1 = vec2(0.809016994375, -0.587785252292);
+    vec2 k2 = vec2(-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;
+    vec2 ba = rf * vec2(-k1.y, k1.x) - vec2(0.0, 1.0);
+    float h = clamp(dot(p, ba) / dot(ba, ba), 0.0, r);
+    return length(p - ba * h) * sign(p.y * ba.x - p.x * ba.y);
+}
+`,
+    `
+float sdStar(vec2 p, float r, int n, float m) {
+    float an = 3.141593 / float(n);
+    float en = 3.141593 / m;
+    vec2 acs = vec2(cos(an), sin(an));
+    vec2 ecs = vec2(cos(en), sin(en));
+    float bn = glslMod(atan(p.x, p.y), 2.0 * an) - an;
+    p = length(p) * vec2(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);
+}
+`,
+    `
+float sdPie(vec2 p, vec2 c, float r) {
+    p.x = abs(p.x);
+    float l = length(p) - r;
+    float m = length(p - c * clamp(dot(p, c), 0.0, r));
+    return max(l, m * sign(c.y * p.x - c.x * p.y));
+}
+`,
+    `
+float sdCutDisk(vec2 p, float r, float h) {
+    float w = sqrt(r * r - h * h);
+    p.x = abs(p.x);
+    float s = max((h - r) * p.x * p.x + w * w * (h + r - 2.0 * p.y), h * p.x - w * p.y);
+    return (s < 0.0) ? length(p) - r : (p.x < w) ? h - p.y : length(p - vec2(w, h));
+}
+`,
+    `
+float sdArc(vec2 p, vec2 sc, float ra, float rb) {
+    p.x = abs(p.x);
+    return ((sc.y * p.x > sc.x * p.y) ? length(p - sc * ra) : abs(length(p) - ra)) - rb;
+}
+`,
+    `
+float sdRing(vec2 p, vec2 n, float r, float th) {
+    p.x = abs(p.x);
+    p = vec2(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(vec2(p.x, max(0.0, abs(r - p.y) - th * 0.5))) * sign(p.x));
+}
+`,
+    `
+float sdHorseshoe(vec2 p, vec2 c, float r, vec2 w) {
+    p.x = abs(p.x);
+    float l = length(p);
+    p = vec2(p.x * (-c.x) + p.y * c.y, p.x * c.y + p.y * c.x);
+    p = vec2((p.y > 0.0 || p.x > 0.0) ? p.x : l * sign(-c.x), (p.x > 0.0) ? p.y : l);
+    p = vec2(p.x, abs(p.y - r)) - w;
+    return length(max(p, vec2(0.0))) + min(0.0, max(p.x, p.y));
+}
+`,
+    `
+float sdVesica(vec2 p, float r, float d) {
+    p = abs(p);
+    float b = sqrt(r * r - d * d);
+    return ((p.y - b) * d > p.x * b) ? length(p - vec2(0.0, b)) : length(p - vec2(-d, 0.0)) - r;
+}
+`,
+    `
+float sdOrientedVesica(vec2 p, vec2 a, vec2 b, float w) {
+    float r = 0.5 * length(b - a);
+    float d = 0.5 * (r * r - w * w) / w;
+    vec2 v = (b - a) / r;
+    vec2 c = (b + a) * 0.5;
+    vec2 q = 0.5 * abs(vec2((p - c).x * v.y + (p - c).y * (-v.x), (p - c).x * v.x + (p - c).y * v.y));
+    vec3 h = (r * q.x < d * (q.y - r)) ? vec3(0.0, r, 0.0) : vec3(-d, 0.0, d + w);
+    return length(q - h.xy) - h.z;
+}
+`,
+    `
+float sdMoon(vec2 p, float d, float ra, float rb) {
+    p.y = abs(p.y);
+    float a = (ra * ra - rb * rb + d * d) / (2.0 * d);
+    float b = 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 - vec2(a, b));
+    }
+    return max(length(p) - ra, -(length(p - vec2(d, 0.0)) - rb));
+}
+`,
+    `
+float sdRoundedCross(vec2 p, float h) {
+    float k = 0.5 * (h + 1.0 / h);
+    p = abs(p);
+    return (p.x < 1.0 && p.y < p.x * (k - h) + h) ? k - sqrt(dot2(p - vec2(1.0, k))) : sqrt(min(dot2(p - vec2(0.0, h)), dot2(p - vec2(1.0, 0.0))));
+}
+`,
+    `
+float sdEgg(vec2 p, float he, float ra, float rb, float bu) {
+    float r = 0.5 * (he + ra + rb) / bu;
+    float da = r - ra;
+    float db = r - rb;
+    float y = (db * db - da * da - he * he) / (2.0 * he);
+    float x = sqrt(max(da * da - y * y, 0.0));
+    p.x = abs(p.x);
+    p.y += 0.5 * (he + rb - ra);
+    float k = p.y * x - p.x * y;
+    if (k > 0.0 && k < he * (p.x + x)) {
+        return length(p + vec2(x, y)) - r;
+    }
+    return min(length(p) - ra, length(vec2(p.x, p.y - he)) - rb);
+}
+`,
+    `
+float sdHeart(vec2 p) {
+    p.x = abs(p.x);
+    if (p.y + p.x > 1.0) {
+        return sqrt(dot(p - vec2(0.25, 0.75), p - vec2(0.25, 0.75))) - sqrt(2.0) / 4.0;
+    }
+    return sqrt(min(dot(p - vec2(0.00, 1.00), p - vec2(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);
+}
+`,
+    `
+float sdCross(vec2 p, vec2 b, float r) {
+    p = abs(p);
+    p = (p.y > p.x) ? p.yx : p.xy;
+    vec2 q = p - b;
+    float k = max(q.y, q.x);
+    vec2 w = (k > 0.0) ? q : vec2(b.y - p.x, -k);
+    return sign(k) * length(max(w, vec2(0.0))) + r;
+}
+`,
+    `
+float sdRoundedX(vec2 p, float w, float r) {
+    p = abs(p);
+    return length(p - min(p.x + p.y, w) * 0.5) - r;
+}
+`,
+    `
+float sdEllipse(vec2 p, vec2 ab) {
+    p = abs(p);
+    if (p.x > p.y) {
+        p = p.yx;
+        ab = ab.yx;
+    }
+    float l = ab.y * ab.y - ab.x * ab.x;
+    float m = ab.x * p.x / l;
+    float m2 = m * m;
+    float n = ab.y * p.y / l;
+    float n2 = n * n;
+    float c = (m2 + n2 - 1.0) / 3.0;
+    float c3 = c * c * c;
+    float q = c3 + m2 * n2 * 2.0;
+    float d = c3 + m2 * n2;
+    float g = m + m * n2;
+    float co;
+    if (d < 0.0) {
+        float h = acos(q / c3) / 3.0;
+        float s = cos(h);
+        float t = sin(h) * sqrt(3.0);
+        float rx = sqrt(-c * (s + t + 2.0) + m2);
+        float ry = sqrt(-c * (s - t + 2.0) + m2);
+        co = (ry + sign(l) * rx + abs(g) / (rx * ry) - m) / 2.0;
+    } else {
+        float h = 2.0 * m * n * sqrt(d);
+        float s = sign(q + h) * pow(abs(q + h), 1.0 / 3.0);
+        float u = sign(q - h) * pow(abs(q - h), 1.0 / 3.0);
+        float rx = -s - u - c * 4.0 + 2.0 * m2;
+        float ry = (s - u) * sqrt(3.0);
+        float rm = sqrt(rx * rx + ry * ry);
+        co = (ry / sqrt(rm - rx) + 2.0 * g / rm - m) / 2.0;
+    }
+    vec2 r = ab * vec2(co, sqrt(1.0 - co * co));
+    return length(r - p) * sign(p.y - r.y);
+}
+`,
+    `
+float sdParabola(vec2 pos, float k) {
+    pos.x = abs(pos.x);
+    float ik = 1.0 / k;
+    float p = ik * (pos.y - 0.5 * ik) / 3.0;
+    float q = 0.25 * ik * ik * pos.x;
+    float h = q * q - p * p * p;
+    float r = sqrt(abs(h));
+    float x = (h > 0.0) ? pow(q + r, 1.0 / 3.0) - pow(abs(q - r), 1.0 / 3.0) * sign(r - q) : 2.0 * cos(atan(r / q) / 3.0) * sqrt(p);
+    return length(pos - vec2(x, k * x * x)) * sign(pos.x - x);
+}
+`,
+    `
+float sdParabolaSegment(vec2 pos, float wi, float he) {
+    pos.x = abs(pos.x);
+    float ik = wi * wi / he;
+    float p = ik * (he - pos.y - 0.5 * ik) / 3.0;
+    float q = pos.x * ik * ik * 0.25;
+    float h = q * q - p * p * p;
+    float r = sqrt(abs(h));
+    float x = (h > 0.0) ? pow(q + r, 1.0 / 3.0) - pow(abs(q - r), 1.0 / 3.0) * sign(r - q) : 2.0 * cos(atan(r / q) / 3.0) * sqrt(p);
+    x = min(x, wi);
+    return length(pos - vec2(x, he - x * x / ik)) * sign(ik * (pos.y - he) + pos.x * pos.x);
+}
+`,
+    `
+float sdBezier(vec2 pos, vec2 A, vec2 B, vec2 C) {
+    vec2 a = B - A;
+    vec2 b = A - 2.0 * B + C;
+    vec2 c = a * 2.0;
+    vec2 d = A - pos;
+    float kk = 1.0 / dot(b, b);
+    float kx = kk * dot(a, b);
+    float ky = kk * (2.0 * dot(a, a) + dot(d, b)) / 3.0;
+    float kz = kk * dot(d, a);
+    float res = 0.0;
+    float p = ky - kx * kx;
+    float p3 = p * p * p;
+    float q = kx * (2.0 * kx * kx - 3.0 * ky) + kz;
+    float h = q * q + 4.0 * p3;
+    if (h >= 0.0) {
+        h = sqrt(h);
+        vec2 x = (vec2(h, -h) - q) * 0.5;
+        vec2 uv = sign(x) * pow(abs(x), vec2(1.0 / 3.0, 1.0 / 3.0));
+        float t = clamp(uv.x + uv.y - kx, 0.0, 1.0);
+        res = dot(d + (c + b * t) * t, d + (c + b * t) * t);
+    } else {
+        float z = sqrt(-p);
+        float v = acos(q / (p * z * 2.0)) / 3.0;
+        float m = cos(v);
+        float n = sin(v) * 1.732050808;
+        vec3 t = clamp(vec3(m + m, -n - m, n - m) * z - kx, vec3(0.0), vec3(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);
+}
+`,
+    `
+float sdBlobbyCross(vec2 pos, float he) {
+    pos = abs(pos);
+    pos = vec2(abs(pos.x - pos.y), 1.0 - pos.x - pos.y) / sqrt(2.0);
+    float p = (he - pos.y - 0.25 / he) / (6.0 * he);
+    float q = pos.x / (he * he * 16.0);
+    float h = q * q - p * p * p;
+    float x;
+    if (h > 0.0) {
+        float r = sqrt(h);
+        x = pow(q + r, 1.0 / 3.0) - pow(abs(q - r), 1.0 / 3.0) * sign(r - q);
+    } else {
+        float r = sqrt(p);
+        x = 2.0 * r * cos(acos(q / (p * r)) / 3.0);
+    }
+    x = min(x, sqrt(2.0) / 2.0);
+    vec2 z = vec2(x, he * (1.0 - 2.0 * x * x)) - pos;
+    return length(z) * sign(z.y);
+}
+`,
+    `
+float sdTunnel(vec2 p, vec2 wh) {
+    p.x = abs(p.x);
+    p.y = -p.y;
+    vec2 q = p - wh;
+    float d1 = dot(vec2(max(q.x, 0.0), q.y), vec2(max(q.x, 0.0), q.y));
+    q.x = (p.y > 0.0) ? q.x : length(p) - wh.x;
+    float d2 = dot(vec2(q.x, max(q.y, 0.0)), vec2(q.x, max(q.y, 0.0)));
+    float d = sqrt(min(d1, d2));
+    return (max(q.x, q.y) < 0.0) ? -d : d;
+}
+`,
+    `
+float sdStairs(vec2 p, vec2 wh, float n) {
+    vec2 ba = wh * n;
+    float d = min(dot(p - vec2(clamp(p.x, 0.0, ba.x), 0.0), p - vec2(clamp(p.x, 0.0, ba.x), 0.0)), dot(p - vec2(ba.x, clamp(p.y, 0.0, ba.y)), p - vec2(ba.x, clamp(p.y, 0.0, ba.y))));
+    float s = sign(max(-p.y, p.x - ba.x));
+    float dia = length(wh);
+    p = vec2(p.x * wh.x + p.y * wh.y, p.x * (-wh.y) + p.y * wh.x) / dia;
+    float id = clamp(round(p.x / dia), 0.0, n - 1.0);
+    p.x = p.x - id * dia;
+    p = vec2(p.x * wh.x + p.y * (-wh.y), p.x * wh.y + p.y * wh.x) / dia;
+    float hh = wh.y / 2.0;
+    p.y -= hh;
+    if (p.y > hh * sign(p.x)) {
+        s = 1.0;
+    }
+    p = (id < 0.5 || p.x > 0.0) ? p : -p;
+    d = min(d, dot(p - vec2(0.0, clamp(p.y, -hh, hh)), p - vec2(0.0, clamp(p.y, -hh, hh))));
+    d = min(d, dot(p - vec2(clamp(p.x, 0.0, wh.x), hh), p - vec2(clamp(p.x, 0.0, wh.x), hh)));
+    return sqrt(d) * s;
+}
+`,
+    `
+float sdQuadraticCircle(vec2 p) {
+    p = abs(p);
+    if (p.y > p.x) {
+        p = p.yx;
+    }
+    float a = p.x - p.y;
+    float b = p.x + p.y;
+    float c = (2.0 * b - 1.0) / 3.0;
+    float h = a * a + c * c * c;
+    float t;
+    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 {
+        float z = sqrt(-c);
+        float v = acos(a / (c * z)) / 3.0;
+        t = -z * (cos(v) + sin(v) * 1.732050808);
+    }
+    t *= 0.5;
+    vec2 w = vec2(-t, t) + 0.75 - t * t - p;
+    return length(w) * sign(a * a * 0.5 + b - 1.5);
+}
+`,
+    `
+float sdHyberbola(vec2 p, float k, float he) {
+    p = abs(p);
+    p = vec2(p.x - p.y, p.x + p.y) / sqrt(2.0);
+    float x2 = p.x * p.x / 16.0;
+    float y2 = p.y * p.y / 16.0;
+    float r = k * (4.0 * k - p.x * p.y) / 12.0;
+    float q = (x2 - y2) * k * k;
+    float h = q * q + r * r * r;
+    float u;
+    if (h < 0.0) {
+        float m = sqrt(-r);
+        u = m * cos(acos(q / (r * m)) / 3.0);
+    } else {
+        float m = pow(sqrt(h) - q, 1.0 / 3.0);
+        u = (m - r / m) / 2.0;
+    }
+    float w = sqrt(u + x2);
+    float b = k * p.y - x2 * p.x * 2.0;
+    float t = 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 - vec2(t, k / t)) * sign(p.x * p.y < k ? 1.0 : -1.0);
+}
+`,
+    `
+float sdCoolS(vec2 p) {
+    float six = (p.y < 0.0) ? -p.x : p.x;
+    p.x = abs(p.x);
+    p.y = abs(p.y) - 0.2;
+    float rex = p.x - min(round(p.x / 0.4), 0.4);
+    float aby = abs(p.y - 0.2) - 0.6;
+    float d = dot2(vec2(six, -p.y) - clamp(0.5 * (six - p.y), 0.0, 0.2));
+    d = min(d, dot2(vec2(p.x, -aby) - clamp(0.5 * (p.x - aby), 0.0, 0.4)));
+    d = min(d, dot2(vec2(rex, p.y - clamp(p.y, 0.0, 0.4))));
+    float s = 2.0 * p.x + aby + abs(aby + 0.4) - 0.4;
+    return sqrt(d) * sign(s);
+}
+`,
+    `
+float sdCircleWave(vec2 p, float tb, float ra) {
+    tb = 3.1415927 * 5.0 / 6.0 * max(tb, 0.0001);
+    vec2 co = ra * vec2(sin(tb), cos(tb));
+    p.x = abs(glslMod(p.x, co.x * 4.0) - co.x * 2.0);
+    vec2 p1 = p;
+    vec2 p2 = vec2(abs(p.x - 2.0 * co.x), -p.y + 2.0 * co.y);
+    float d1 = ((co.y * p1.x > co.x * p1.y) ? length(p1 - co) : abs(length(p1) - ra));
+    float d2 = ((co.y * p2.x > co.x * p2.y) ? length(p2 - co) : abs(length(p2) - ra));
+    return min(d1, d2);
+}
+`,
+    `
+float onejsHash21(vec2 p, float seed) {
+    p = fract(p * vec2(123.34, 456.21) + seed * 0.1731);
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+}
+`,
+    `
+float onejsVNoise(vec2 p, float seed) {
+    vec2 i = floor(p);
+    vec2 f = fract(p);
+    f = f * f * (3.0 - 2.0 * f);
+    float a = onejsHash21(i, seed);
+    float b = onejsHash21(i + vec2(1.0, 0.0), seed);
+    float c = onejsHash21(i + vec2(0.0, 1.0), seed);
+    float d = onejsHash21(i + vec2(1.0, 1.0), seed);
+    return mix(mix(a, b, f.x), mix(c, d, f.x), f.y);
+}
+`,
+    `
+float onejsFbm(vec2 p, float seed, int octaves, float lacunarity, float gain) {
+    float sum = 0.0;
+    float amp = 0.5;
+    float norm = 0.0;
+    for (int o = 0; o < 4; o++) {
+        if (o >= octaves) {
+            break;
+        }
+        sum += onejsVNoise(p, seed + float(o) * 19.0) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+`,
+    `
+float onejsFbm(vec2 p, float seed, int octaves) {
+    return onejsFbm(p, seed, octaves, 2.0, 0.5);
+}
+`,
+    `
+vec2 onejsMod289(vec2 x) {
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+`,
+    `
+vec3 onejsMod289(vec3 x) {
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+`,
+    `
+vec3 onejsPermute(vec3 x) {
+    return onejsMod289(((x * 34.0) + 1.0) * x);
+}
+`,
+    `
+float onejsSimplexRaw(vec2 v) {
+    vec4 C = vec4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
+    vec2 i = floor(v + dot(v, C.yy));
+    vec2 x0 = v - i + dot(i, C.xx);
+    vec2 i1 = (x0.x > x0.y) ? vec2(1.0, 0.0) : vec2(0.0, 1.0);
+    vec4 x12 = x0.xyxy + C.xxzz;
+    x12.xy -= i1;
+    i = onejsMod289(i);
+    vec3 p = onejsPermute(onejsPermute(i.y + vec3(0.0, i1.y, 1.0)) + i.x + vec3(0.0, i1.x, 1.0));
+    vec3 m = max(0.5 - vec3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), vec3(0.0));
+    m = m * m;
+    m = m * m;
+    vec3 x = 2.0 * fract(p * C.www) - 1.0;
+    vec3 h = abs(x) - 0.5;
+    vec3 ox = floor(x + 0.5);
+    vec3 a0 = x - ox;
+    m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+    vec3 g;
+    g.x = a0.x * x0.x + h.x * x0.y;
+    g.yz = a0.yz * x12.xz + h.yz * x12.yw;
+    return 130.0 * dot(m, g);
+}
+`,
+    `
+float onejsSimplex(vec2 p, float seed) {
+    return onejsSimplexRaw(p + seed * 137.13) * 0.5 + 0.5;
+}
+`,
+    `
+float onejsFbmSimplex(vec2 p, float seed, int octaves, float lacunarity, float gain) {
+    float sum = 0.0;
+    float amp = 0.5;
+    float norm = 0.0;
+    for (int o = 0; o < 4; o++) {
+        if (o >= octaves) {
+            break;
+        }
+        sum += onejsSimplex(p, seed + float(o) * 19.0) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+`,
+    `
+float onejsTurbulence(vec2 p, float seed, int octaves, float lacunarity, float gain) {
+    float sum = 0.0;
+    float amp = 0.5;
+    float norm = 0.0;
+    for (int o = 0; o < 4; o++) {
+        if (o >= octaves) {
+            break;
+        }
+        sum += abs(onejsSimplexRaw(p + (seed + float(o) * 19.0) * 137.13)) * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+`,
+    `
+float onejsRidged(vec2 p, float seed, int octaves, float lacunarity, float gain) {
+    float sum = 0.0;
+    float amp = 0.5;
+    float norm = 0.0;
+    for (int o = 0; o < 4; o++) {
+        if (o >= octaves) {
+            break;
+        }
+        float r = 1.0 - abs(onejsSimplexRaw(p + (seed + float(o) * 19.0) * 137.13));
+        sum += r * r * amp;
+        norm += amp;
+        p *= lacunarity;
+        amp *= gain;
+    }
+    return sum / max(norm, 1e-4);
+}
+`,
+    `
+float onejsFbmKind(int kind, vec2 p, float seed, int octaves, float lacunarity, float gain) {
+    if (kind == 2) {
+        return onejsTurbulence(p, seed, octaves, lacunarity, gain);
+    }
+    if (kind == 3) {
+        return onejsRidged(p, seed, octaves, lacunarity, gain);
+    }
+    return kind == 1 ? onejsFbmSimplex(p, seed, octaves, lacunarity, gain) : onejsFbm(p, seed, octaves, lacunarity, gain);
+}
+`,
+    `
+float sl_hash21(vec2 p) {
+    p = fract(p * vec2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return fract(p.x * p.y);
+}
+`,
+    `
+float sl_valueNoise(vec2 p) {
+    return onejsVNoise(p, 0.0);
+}
+`,
+    `
+float sl_simplex(vec2 p) {
+    return onejsSimplex(p, 0.0);
+}
+`,
+    `
+float sl_fbm(vec2 p, int octaves, int kind) {
+    return onejsFbmKind(kind, p, 0.0, clamp(octaves, 1, 4), 2.0, 0.5);
+}
+`,
+    `
+vec3 sl_hsv2rgb(vec3 c) {
+    vec4 K = vec4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    vec3 p = abs(fract(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * mix(K.xxx, clamp(p - K.xxx, vec3(0.0), vec3(1.0)), vec3(c.y));
+}
+`,
+    `
+float sl_sdfDistance(int id, vec2 p, vec4 a, vec2 b) {
+    switch (id) {
+        case 0:
+            return sdCircle(p, a.x);
+        case 1:
+            return sdRoundedBox(p, a.xy, vec4(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, int(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, vec2(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;
+    }
+}
+`,
+    `
+float sl_voronoi(vec2 p) {
+    vec2 cell = floor(p);
+    vec2 f = fract(p);
+    float best = 8.0;
+    for (int y = -1; y <= 1; y++) {
+        for (int x = -1; x <= 1; x++) {
+            vec2 o = vec2(float(x), float(y));
+            vec2 jitter = vec2(sl_hash21(cell + o), sl_hash21(cell + o + 37.7));
+            best = min(best, length(o + jitter - f));
+        }
+    }
+    return best;
+}
+`,
+    `
+float sl_luminance(vec3 c) {
+    return dot(c, vec3(0.2126, 0.7152, 0.0722));
+}
+`,
+    `
+vec3 sl_gammaToLinear(vec3 c) {
+    return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
+}
+`,
+    `
+float sl_toLinear_gamma(float c) {
+    return c;
+}
+float sl_toLinear_linear(float c) {
+    return sl_gammaToLinear(vec3(c, 0.0, 0.0)).x;
+}
+float sl_toLinear(float c) {
+    if (sl_Opt.x > 0.5) {
+        return sl_toLinear_linear(c);
+    }
+    return sl_toLinear_gamma(c);
+}
+`,
+    `
+vec2 sl_toLinear_gamma(vec2 c) {
+    return c;
+}
+vec2 sl_toLinear_linear(vec2 c) {
+    return sl_gammaToLinear(vec3(c, 0.0)).xy;
+}
+vec2 sl_toLinear(vec2 c) {
+    if (sl_Opt.x > 0.5) {
+        return sl_toLinear_linear(c);
+    }
+    return sl_toLinear_gamma(c);
+}
+`,
+    `
+vec3 sl_toLinear_gamma(vec3 c) {
+    return c;
+}
+vec3 sl_toLinear_linear(vec3 c) {
+    return sl_gammaToLinear(c);
+}
+vec3 sl_toLinear(vec3 c) {
+    if (sl_Opt.x > 0.5) {
+        return sl_toLinear_linear(c);
+    }
+    return sl_toLinear_gamma(c);
+}
+`,
+    `
+vec4 sl_toLinear_gamma(vec4 c) {
+    return c;
+}
+vec4 sl_toLinear_linear(vec4 c) {
+    return vec4(sl_gammaToLinear(c.rgb), c.a);
+}
+vec4 sl_toLinear(vec4 c) {
+    if (sl_Opt.x > 0.5) {
+        return sl_toLinear_linear(c);
+    }
+    return sl_toLinear_gamma(c);
+}
+`,
+]