onejs-sl 0.1.1 → 0.1.2

package/src/lib/hlsl.ts

@@ -0,0 +1,891 @@
+// 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.
+
+/** The HLSL/Metal shared subset, by `LIB_FUNCTIONS` index. A colour dependent function has a text per colour. */
+export const LIB_HLSL: ReadonlyArray<string | { gamma: string; linear: string }> = [
+    `
+float glslMod(float x, float y) {
+    return x - y * floor(x / y);
+}
+`,
+    `
+float ndot(float2 a, float2 b) {
+    return a.x * b.x - a.y * b.y;
+}
+`,
+    `
+float dot2(float2 v) {
+    return dot(v, v);
+}
+`,
+    `
+float sdCircle(float2 p, float r) {
+    return length(p) - r;
+}
+`,
+    `
+float sdRoundedBox(float2 p, float2 b, float4 r) {
+    r.xy = (p.x > 0.0) ? r.xy : r.zw;
+    r.x = (p.y > 0.0) ? r.x : r.y;
+    float2 q = abs(p) - b + r.x;
+    return min(max(q.x, q.y), 0.0) + length(max(q, float2(0.0, 0.0))) - r.x;
+}
+`,
+    `
+float sdBox(float2 p, float2 b) {
+    float2 d = abs(p) - b;
+    return length(max(d, float2(0.0, 0.0))) + min(max(d.x, d.y), 0.0);
+}
+`,
+    `
+float sdOrientedBox(float2 p, float2 a, float2 b, float th) {
+    float l = length(b - a);
+    float2 d = (b - a) / l;
+    float2 q = (p - (a + b) * 0.5);
+    q = float2(q.x * d.x + q.y * d.y, q.x * (-d.y) + q.y * d.x);
+    q = abs(q) - float2(l, th) * 0.5;
+    return length(max(q, float2(0.0, 0.0))) + min(max(q.x, q.y), 0.0);
+}
+`,
+    `
+float sdSegment(float2 p, float2 a, float2 b) {
+    float2 pa = p - a;
+    float2 ba = b - a;
+    float h = clamp(dot(pa, ba) / dot(ba, ba), 0.0, 1.0);
+    return length(pa - ba * h);
+}
+`,
+    `
+float sdRhombus(float2 p, float2 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 * float2(1.0 - h, 1.0 + h));
+    return d * sign(p.x * b.y + p.y * b.x - b.x * b.y);
+}
+`,
+    `
+float sdTrapezoid(float2 p, float r1, float r2, float he) {
+    float2 k1 = float2(r2, he);
+    float2 k2 = float2(r2 - r1, 2.0 * he);
+    p.x = abs(p.x);
+    float2 ca = float2(p.x - min(p.x, (p.y < 0.0) ? r1 : r2), abs(p.y) - he);
+    float2 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(float2 p, float wi, float he, float sk) {
+    float2 e = float2(sk, he);
+    p = (p.y < 0.0) ? -p : p;
+    float2 w = p - e;
+    w.x -= clamp(w.x, -wi, wi);
+    float2 d = float2(dot(w, w), -w.y);
+    float s = p.x * e.y - p.y * e.x;
+    p = (s < 0.0) ? -p : p;
+    float2 v = p - float2(wi, 0.0);
+    v -= e * clamp(dot(v, e) / dot(e, e), -1.0, 1.0);
+    d = min(d, float2(dot(v, v), wi * he - abs(s)));
+    return sqrt(d.x) * sign(-d.y);
+}
+`,
+    `
+float sdEquilateralTriangle(float2 p, float r) {
+    const 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 = float2(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(float2 p, float2 q) {
+    p.x = abs(p.x);
+    float2 a = p - q * clamp(dot(p, q) / dot(q, q), 0.0, 1.0);
+    float2 b = p - q * float2(clamp(p.x / q.x, 0.0, 1.0), 1.0);
+    float s = -sign(q.y);
+    float2 d = min(float2(dot(a, a), s * (p.x * q.y - p.y * q.x)), float2(dot(b, b), s * (p.y - q.y)));
+    return -sqrt(d.x) * sign(d.y);
+}
+`,
+    `
+float sdTriangle(float2 p, float2 p0, float2 p1, float2 p2) {
+    float2 e0 = p1 - p0;
+    float2 e1 = p2 - p1;
+    float2 e2 = p0 - p2;
+    float2 v0 = p - p0;
+    float2 v1 = p - p1;
+    float2 v2 = p - p2;
+    float2 pq0 = v0 - e0 * clamp(dot(v0, e0) / dot(e0, e0), 0.0, 1.0);
+    float2 pq1 = v1 - e1 * clamp(dot(v1, e1) / dot(e1, e1), 0.0, 1.0);
+    float2 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);
+    float2 d = min(min(float2(dot(pq0, pq0), s * (v0.x * e0.y - v0.y * e0.x)), float2(dot(pq1, pq1), s * (v1.x * e1.y - v1.y * e1.x))), float2(dot(pq2, pq2), s * (v2.x * e2.y - v2.y * e2.x)));
+    return -sqrt(d.x) * sign(d.y);
+}
+`,
+    `
+float sdUnevenCapsule(float2 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, float2(-b, a));
+    if (k < 0.0) {
+        return length(p) - r1;
+    }
+    if (k > a * h) {
+        return length(p - float2(0.0, h)) - r2;
+    }
+    return dot(p, float2(a, b)) - r1;
+}
+`,
+    `
+float sdPentagon(float2 p, float r) {
+    const float3 k = float3(0.809016994, 0.587785252, 0.726542528);
+    p.x = abs(p.x);
+    p -= 2.0 * min(dot(float2(-k.x, k.y), p), 0.0) * float2(-k.x, k.y);
+    p -= 2.0 * min(dot(float2(k.x, k.y), p), 0.0) * float2(k.x, k.y);
+    p -= float2(clamp(p.x, -r * k.z, r * k.z), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+float sdHexagon(float2 p, float r) {
+    const float3 k = float3(-0.866025404, 0.5, 0.577350269);
+    p = abs(p);
+    p -= 2.0 * min(dot(k.xy, p), 0.0) * k.xy;
+    p -= float2(clamp(p.x, -k.z * r, k.z * r), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+float sdOctogon(float2 p, float r) {
+    const float3 k = float3(-0.9238795325, 0.3826834323, 0.4142135623);
+    p = abs(p);
+    p -= 2.0 * min(dot(float2(k.x, k.y), p), 0.0) * float2(k.x, k.y);
+    p -= 2.0 * min(dot(float2(-k.x, k.y), p), 0.0) * float2(-k.x, k.y);
+    p -= float2(clamp(p.x, -k.z * r, k.z * r), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+float sdHexagram(float2 p, float r) {
+    const float4 k = float4(-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 -= float2(clamp(p.x, r * k.z, r * k.w), r);
+    return length(p) * sign(p.y);
+}
+`,
+    `
+float sdStar5(float2 p, float r, float rf) {
+    const float2 k1 = float2(0.809016994375, -0.587785252292);
+    const float2 k2 = float2(-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;
+    float2 ba = rf * float2(-k1.y, k1.x) - float2(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(float2 p, float r, int n, float m) {
+    float an = 3.141593 / float(n);
+    float en = 3.141593 / m;
+    float2 acs = float2(cos(an), sin(an));
+    float2 ecs = float2(cos(en), sin(en));
+    float bn = glslMod(atan2(p.x, p.y), 2.0 * an) - an;
+    p = length(p) * float2(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(float2 p, float2 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(float2 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 - float2(w, h));
+}
+`,
+    `
+float sdArc(float2 p, float2 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(float2 p, float2 n, float r, float th) {
+    p.x = abs(p.x);
+    p = float2(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(float2(p.x, max(0.0, abs(r - p.y) - th * 0.5))) * sign(p.x));
+}
+`,
+    `
+float sdHorseshoe(float2 p, float2 c, float r, float2 w) {
+    p.x = abs(p.x);
+    float l = length(p);
+    p = float2(p.x * (-c.x) + p.y * c.y, p.x * c.y + p.y * c.x);
+    p = float2((p.y > 0.0 || p.x > 0.0) ? p.x : l * sign(-c.x), (p.x > 0.0) ? p.y : l);
+    p = float2(p.x, abs(p.y - r)) - w;
+    return length(max(p, float2(0.0, 0.0))) + min(0.0, max(p.x, p.y));
+}
+`,
+    `
+float sdVesica(float2 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 - float2(0.0, b)) : length(p - float2(-d, 0.0)) - r;
+}
+`,
+    `
+float sdOrientedVesica(float2 p, float2 a, float2 b, float w) {
+    float r = 0.5 * length(b - a);
+    float d = 0.5 * (r * r - w * w) / w;
+    float2 v = (b - a) / r;
+    float2 c = (b + a) * 0.5;
+    float2 q = 0.5 * abs(float2((p - c).x * v.y + (p - c).y * (-v.x), (p - c).x * v.x + (p - c).y * v.y));
+    float3 h = (r * q.x < d * (q.y - r)) ? float3(0.0, r, 0.0) : float3(-d, 0.0, d + w);
+    return length(q - h.xy) - h.z;
+}
+`,
+    `
+float sdMoon(float2 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 - float2(a, b));
+    }
+    return max(length(p) - ra, -(length(p - float2(d, 0.0)) - rb));
+}
+`,
+    `
+float sdRoundedCross(float2 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 - float2(1.0, k))) : sqrt(min(dot2(p - float2(0.0, h)), dot2(p - float2(1.0, 0.0))));
+}
+`,
+    `
+float sdEgg(float2 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 + float2(x, y)) - r;
+    }
+    return min(length(p) - ra, length(float2(p.x, p.y - he)) - rb);
+}
+`,
+    `
+float sdHeart(float2 p) {
+    p.x = abs(p.x);
+    if (p.y + p.x > 1.0) {
+        return sqrt(dot(p - float2(0.25, 0.75), p - float2(0.25, 0.75))) - sqrt(2.0) / 4.0;
+    }
+    return sqrt(min(dot(p - float2(0.00, 1.00), p - float2(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(float2 p, float2 b, float r) {
+    p = abs(p);
+    p = (p.y > p.x) ? p.yx : p.xy;
+    float2 q = p - b;
+    float k = max(q.y, q.x);
+    float2 w = (k > 0.0) ? q : float2(b.y - p.x, -k);
+    return sign(k) * length(max(w, float2(0.0, 0.0))) + r;
+}
+`,
+    `
+float sdRoundedX(float2 p, float w, float r) {
+    p = abs(p);
+    return length(p - min(p.x + p.y, w) * 0.5) - r;
+}
+`,
+    `
+float sdEllipse(float2 p, float2 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;
+    }
+    float2 r = ab * float2(co, sqrt(1.0 - co * co));
+    return length(r - p) * sign(p.y - r.y);
+}
+`,
+    `
+float sdParabola(float2 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 - float2(x, k * x * x)) * sign(pos.x - x);
+}
+`,
+    `
+float sdParabolaSegment(float2 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 - float2(x, he - x * x / ik)) * sign(ik * (pos.y - he) + pos.x * pos.x);
+}
+`,
+    `
+float sdBezier(float2 pos, float2 A, float2 B, float2 C) {
+    float2 a = B - A;
+    float2 b = A - 2.0 * B + C;
+    float2 c = a * 2.0;
+    float2 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);
+        float2 x = (float2(h, -h) - q) * 0.5;
+        float2 uv = sign(x) * pow(abs(x), float2(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;
+        float3 t = clamp(float3(m + m, -n - m, n - m) * z - kx, float3(0.0, 0.0, 0.0), float3(1.0, 1.0, 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(float2 pos, float he) {
+    pos = abs(pos);
+    pos = float2(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);
+    float2 z = float2(x, he * (1.0 - 2.0 * x * x)) - pos;
+    return length(z) * sign(z.y);
+}
+`,
+    `
+float sdTunnel(float2 p, float2 wh) {
+    p.x = abs(p.x);
+    p.y = -p.y;
+    float2 q = p - wh;
+    float d1 = dot(float2(max(q.x, 0.0), q.y), float2(max(q.x, 0.0), q.y));
+    q.x = (p.y > 0.0) ? q.x : length(p) - wh.x;
+    float d2 = dot(float2(q.x, max(q.y, 0.0)), float2(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(float2 p, float2 wh, float n) {
+    float2 ba = wh * n;
+    float d = min(dot(p - float2(clamp(p.x, 0.0, ba.x), 0.0), p - float2(clamp(p.x, 0.0, ba.x), 0.0)), dot(p - float2(ba.x, clamp(p.y, 0.0, ba.y)), p - float2(ba.x, clamp(p.y, 0.0, ba.y))));
+    float s = sign(max(-p.y, p.x - ba.x));
+    float dia = length(wh);
+    p = float2(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 = float2(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 - float2(0.0, clamp(p.y, -hh, hh)), p - float2(0.0, clamp(p.y, -hh, hh))));
+    d = min(d, dot(p - float2(clamp(p.x, 0.0, wh.x), hh), p - float2(clamp(p.x, 0.0, wh.x), hh)));
+    return sqrt(d) * s;
+}
+`,
+    `
+float sdQuadraticCircle(float2 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;
+    float2 w = float2(-t, t) + 0.75 - t * t - p;
+    return length(w) * sign(a * a * 0.5 + b - 1.5);
+}
+`,
+    `
+float sdHyberbola(float2 p, float k, float he) {
+    p = abs(p);
+    p = float2(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 - float2(t, k / t)) * sign(p.x * p.y < k ? 1.0 : -1.0);
+}
+`,
+    `
+float sdCoolS(float2 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(float2(six, -p.y) - clamp(0.5 * (six - p.y), 0.0, 0.2));
+    d = min(d, dot2(float2(p.x, -aby) - clamp(0.5 * (p.x - aby), 0.0, 0.4)));
+    d = min(d, dot2(float2(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(float2 p, float tb, float ra) {
+    tb = 3.1415927 * 5.0 / 6.0 * max(tb, 0.0001);
+    float2 co = ra * float2(sin(tb), cos(tb));
+    p.x = abs(glslMod(p.x, co.x * 4.0) - co.x * 2.0);
+    float2 p1 = p;
+    float2 p2 = float2(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(float2 p, float seed) {
+    p = frac(p * float2(123.34, 456.21) + seed * 0.1731);
+    p += dot(p, p + 45.32);
+    return frac(p.x * p.y);
+}
+`,
+    `
+float onejsVNoise(float2 p, float seed) {
+    float2 i = floor(p);
+    float2 f = frac(p);
+    f = f * f * (3.0 - 2.0 * f);
+    float a = onejsHash21(i, seed);
+    float b = onejsHash21(i + float2(1.0, 0.0), seed);
+    float c = onejsHash21(i + float2(0.0, 1.0), seed);
+    float d = onejsHash21(i + float2(1.0, 1.0), seed);
+    return lerp(lerp(a, b, f.x), lerp(c, d, f.x), f.y);
+}
+`,
+    `
+float onejsFbm(float2 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(float2 p, float seed, int octaves) {
+    return onejsFbm(p, seed, octaves, 2.0, 0.5);
+}
+`,
+    `
+float2 onejsMod289(float2 x) {
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+`,
+    `
+float3 onejsMod289(float3 x) {
+    return x - floor(x * (1.0 / 289.0)) * 289.0;
+}
+`,
+    `
+float3 onejsPermute(float3 x) {
+    return onejsMod289(((x * 34.0) + 1.0) * x);
+}
+`,
+    `
+float onejsSimplexRaw(float2 v) {
+    const float4 C = float4(0.211324865405187, 0.366025403784439, -0.577350269189626, 0.024390243902439);
+    float2 i = floor(v + dot(v, C.yy));
+    float2 x0 = v - i + dot(i, C.xx);
+    float2 i1 = (x0.x > x0.y) ? float2(1.0, 0.0) : float2(0.0, 1.0);
+    float4 x12 = x0.xyxy + C.xxzz;
+    x12.xy -= i1;
+    i = onejsMod289(i);
+    float3 p = onejsPermute(onejsPermute(i.y + float3(0.0, i1.y, 1.0)) + i.x + float3(0.0, i1.x, 1.0));
+    float3 m = max(0.5 - float3(dot(x0, x0), dot(x12.xy, x12.xy), dot(x12.zw, x12.zw)), float3(0.0, 0.0, 0.0));
+    m = m * m;
+    m = m * m;
+    float3 x = 2.0 * frac(p * C.www) - 1.0;
+    float3 h = abs(x) - 0.5;
+    float3 ox = floor(x + 0.5);
+    float3 a0 = x - ox;
+    m *= 1.79284291400159 - 0.85373472095314 * (a0 * a0 + h * h);
+    float3 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(float2 p, float seed) {
+    return onejsSimplexRaw(p + seed * 137.13) * 0.5 + 0.5;
+}
+`,
+    `
+float onejsFbmSimplex(float2 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(float2 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(float2 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, float2 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(float2 p) {
+    p = frac(p * float2(123.34, 456.21));
+    p += dot(p, p + 45.32);
+    return frac(p.x * p.y);
+}
+`,
+    `
+float sl_valueNoise(float2 p) {
+    return onejsVNoise(p, 0.0);
+}
+`,
+    `
+float sl_simplex(float2 p) {
+    return onejsSimplex(p, 0.0);
+}
+`,
+    `
+float sl_fbm(float2 p, int octaves, int kind) {
+    return onejsFbmKind(kind, p, 0.0, clamp(octaves, 1, 4), 2.0, 0.5);
+}
+`,
+    `
+float3 sl_hsv2rgb(float3 c) {
+    float4 K = float4(1.0, 2.0 / 3.0, 1.0 / 3.0, 3.0);
+    float3 p = abs(frac(c.xxx + K.xyz) * 6.0 - K.www);
+    return c.z * lerp(K.xxx, saturate(p - K.xxx), float3(c.y, c.y, c.y));
+}
+`,
+    `
+float sl_sdfDistance(int id, float2 p, float4 a, float2 b) {
+    switch (id) {
+        case 0:
+            return sdCircle(p, a.x);
+        case 1:
+            return sdRoundedBox(p, a.xy, float4(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, float2(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(float2 p) {
+    float2 cell = floor(p);
+    float2 f = frac(p);
+    float best = 8.0;
+    for (int y = -1; y <= 1; y++) {
+        for (int x = -1; x <= 1; x++) {
+            float2 o = float2(float(x), float(y));
+            float2 jitter = float2(sl_hash21(cell + o), sl_hash21(cell + o + 37.7));
+            best = min(best, length(o + jitter - f));
+        }
+    }
+    return best;
+}
+`,
+    `
+float sl_luminance(float3 c) {
+    return dot(c, float3(0.2126, 0.7152, 0.0722));
+}
+`,
+    `
+float3 sl_gammaToLinear(float3 c) {
+    return c * (c * (c * 0.305306011 + 0.682171111) + 0.012522878);
+}
+`,
+    {
+        gamma: `
+float sl_toLinear(float c) {
+    return c;
+}
+`,
+        linear: `
+float sl_toLinear(float c) {
+    return sl_gammaToLinear(float3(c, 0.0, 0.0)).x;
+}
+`,
+    },
+    {
+        gamma: `
+float2 sl_toLinear(float2 c) {
+    return c;
+}
+`,
+        linear: `
+float2 sl_toLinear(float2 c) {
+    return sl_gammaToLinear(float3(c, 0.0)).xy;
+}
+`,
+    },
+    {
+        gamma: `
+float3 sl_toLinear(float3 c) {
+    return c;
+}
+`,
+        linear: `
+float3 sl_toLinear(float3 c) {
+    return sl_gammaToLinear(c);
+}
+`,
+    },
+    {
+        gamma: `
+float4 sl_toLinear(float4 c) {
+    return c;
+}
+`,
+        linear: `
+float4 sl_toLinear(float4 c) {
+    return float4(sl_gammaToLinear(c.rgb), c.a);
+}
+`,
+    },
+]