onejs-sl 0.1.0

package/src/ops.ts

@@ -0,0 +1,346 @@
+/**
+ * The shader language opcode table.
+ *
+ * Phase 1 of `Specs/SHADER_LANG.md`. This is the contract three things will
+ * share: the encoder that packs a program into a texture, the VM shader that
+ * evaluates it, and the HLSL emitter that prints it. Two of those do not exist
+ * yet, which is exactly why the numbering is fixed now rather than later.
+ *
+ * Numbered in families with gaps, the convention `fx/ops.ts` set, so a reader
+ * can tell what an opcode is from its value:
+ *
+ *     0..15    construct and swizzle
+ *    16..47    arithmetic
+ *    48..79    maths
+ *    80..95    geometry
+ *    96..111   interpolate
+ *   112..127   colour
+ *   128..143   procedural
+ *   144..159   sampling
+ *
+ * Leave the gaps. A later opcode landing in the right family is worth more than
+ * a dense table.
+ */
+
+/**
+ * The newest VM encoding this encoder writes. The VM accepts 1..its own and
+ * refuses newer, where there is a VM: a WebGL player draws compiled and never
+ * reads the buffer.
+ *
+ * A payload records the LOWEST version that can run it (`Encoded.wire`), not
+ * this: a program that uses nothing new stays 1, so a new bundle still runs on
+ * an older Play container, and only a program that needs a newer instruction
+ * is refused by an older one rather than drawn wrong.
+ */
+export const SL_WIRE_VERSION = 2
+
+/**
+ * What the VM shader actually declares, and therefore what a program may use.
+ *
+ * `FxProgram.shader` has `float4 _Uniforms[16]` and four `sampler2D`s, and
+ * `SLProgramBridge.cs` fills exactly those. Past either ceiling the VM does not
+ * fail, it clamps: uniform 17 reads slot 15 and texture slot 4 samples `_Tex3`,
+ * while the generated HLSL would declare both correctly. That is a silent
+ * disagreement between the backends, so the text form reports it at the
+ * declaration with a file and a line. See `Specs/SL_TEXT.md` 3.7.
+ */
+export const VM_UNIFORMS = 16
+export const VM_TEXTURES = 4
+
+/** Input ids, fixed here because the shader switches on them. */
+export const INPUT_ID: Record<string, number> = {
+    uv: 0, fragCoord: 1, resolution: 2, time: 3, aspect: 4,
+}
+
+export const SLOP = {
+    // Construct and swizzle
+    CONST: 0,
+    INPUT: 1,
+    UNIFORM: 2,
+    COMPOSE: 3,   // build a wider value from narrower parts
+    SWIZZLE: 4,
+
+    // Arithmetic
+    ADD: 16,
+    SUB: 17,
+    MUL: 18,
+    DIV: 19,
+    MOD: 20,
+    POW: 21,
+    NEG: 22,
+    RECIP: 23,
+
+    // Maths
+    SIN: 48,
+    COS: 49,
+    TAN: 50,
+    ASIN: 51,
+    ACOS: 52,
+    ATAN2: 53,
+    EXP: 54,
+    LOG: 55,
+    SQRT: 56,
+    ABS: 57,
+    SIGN: 58,
+    FLOOR: 59,
+    CEIL: 60,
+    ROUND: 61,
+    FRACT: 62,
+    MIN: 63,
+    MAX: 64,
+    CLAMP: 65,
+    SATURATE: 66,
+
+    // Geometry
+    LENGTH: 80,
+    DISTANCE: 81,
+    DOT: 82,
+    CROSS: 83,
+    NORMALIZE: 84,
+    REFLECT: 85,
+
+    // Interpolate
+    MIX: 96,
+    STEP: 97,
+    SMOOTHSTEP: 98,
+    SELECT: 99,
+    REMAP: 100,
+
+    // Colour
+    RAMP: 112,
+    HSV2RGB: 113,
+    RGB2HSV: 114,
+    LUMINANCE: 115,
+    // A colour as written (sRGB, like CSS) to the working space the target
+    // holds. Gamma-aware in both backends; alpha is left alone.
+    TO_LINEAR: 116,
+
+    // Procedural. These are SUPERINSTRUCTIONS: one opcode expanding to a
+    // substantial block in the shader, the way SOURCE_NOISE and SOURCE_SDF
+    // already do in FxSources. Making an author build fbm out of thirty
+    // primitives would be slower to run and worse to write, and we already own
+    // the HLSL.
+    NOISE: 128,
+    SIMPLEX: 129,
+    FBM: 130,
+    SDF: 131,
+    VORONOI: 132,
+    // Same field family as fx noise: |simplex| octaves summed, and the crease
+    // made bright. imm.x carries the octave count, as FBM does.
+    TURBULENCE: 133,
+    RIDGED: 134,
+    // VM only: an SDF given a fifth or sixth parameter, which one instruction's
+    // four immediates and id cannot hold. The encoder makes it (`forVm`); the
+    // IR and every compiled backend only ever see SDF.
+    SDF_WIDE: 135,
+
+    // Sampling
+    SAMPLE: 144,
+    SAMPLE_LOD: 145,
+} as const
+
+export type SLOpCode = (typeof SLOP)[keyof typeof SLOP]
+
+/**
+ * How many arguments each op takes, for validation and for the encoder.
+ *
+ * -1 means variadic: COMPOSE takes however many parts add up to its width, RAMP
+ * takes a value plus its stops. Everything else is fixed, and a mismatch is a
+ * bug in the builder rather than something an author can cause.
+ */
+export const SL_ARITY: Record<number, number> = {
+    [SLOP.CONST]: 0, [SLOP.INPUT]: 0, [SLOP.UNIFORM]: 0,
+    [SLOP.COMPOSE]: -1, [SLOP.SWIZZLE]: 1,
+
+    [SLOP.ADD]: 2, [SLOP.SUB]: 2, [SLOP.MUL]: 2, [SLOP.DIV]: 2,
+    [SLOP.MOD]: 2, [SLOP.POW]: 2, [SLOP.NEG]: 1, [SLOP.RECIP]: 1,
+
+    [SLOP.SIN]: 1, [SLOP.COS]: 1, [SLOP.TAN]: 1, [SLOP.ASIN]: 1, [SLOP.ACOS]: 1,
+    [SLOP.ATAN2]: 2, [SLOP.EXP]: 1, [SLOP.LOG]: 1, [SLOP.SQRT]: 1, [SLOP.ABS]: 1,
+    [SLOP.SIGN]: 1, [SLOP.FLOOR]: 1, [SLOP.CEIL]: 1, [SLOP.ROUND]: 1,
+    [SLOP.FRACT]: 1, [SLOP.MIN]: 2, [SLOP.MAX]: 2, [SLOP.CLAMP]: 3,
+    [SLOP.SATURATE]: 1,
+
+    [SLOP.LENGTH]: 1, [SLOP.DISTANCE]: 2, [SLOP.DOT]: 2, [SLOP.CROSS]: 2,
+    [SLOP.NORMALIZE]: 1, [SLOP.REFLECT]: 2,
+
+    [SLOP.MIX]: 3, [SLOP.STEP]: 2, [SLOP.SMOOTHSTEP]: 3, [SLOP.SELECT]: 3,
+    [SLOP.REMAP]: 5,
+
+    [SLOP.RAMP]: -1, [SLOP.HSV2RGB]: 1, [SLOP.RGB2HSV]: 1, [SLOP.LUMINANCE]: 1, [SLOP.TO_LINEAR]: 1,
+
+    [SLOP.NOISE]: 1, [SLOP.SIMPLEX]: 1, [SLOP.FBM]: 1, [SLOP.SDF]: 1,
+    [SLOP.VORONOI]: 1, [SLOP.TURBULENCE]: 1, [SLOP.RIDGED]: 1, [SLOP.SDF_WIDE]: 2,
+
+    [SLOP.SAMPLE]: 1, [SLOP.SAMPLE_LOD]: 2,
+}
+
+/** Name per opcode, for error messages and for the HLSL emitter's comments. */
+export const SL_NAME: Record<number, string> = Object.fromEntries(
+    Object.entries(SLOP).map(([name, code]) => [code, name.toLowerCase()]),
+)
+
+export const FIRST_ARITHMETIC = 16
+export const FIRST_MATHS = 48
+export const FIRST_GEOMETRY = 80
+export const FIRST_INTERPOLATE = 96
+export const FIRST_COLOUR = 112
+export const FIRST_PROCEDURAL = 128
+export const FIRST_SAMPLING = 144
+
+/**
+ * Ops that read a texture. Sampler slots are the one resource ceiling neither
+ * backend can widen (16 in a fragment shader on WebGL2), so these are counted
+ * at record time.
+ */
+export function isSampling(op: number): boolean {
+    return op >= FIRST_SAMPLING
+}
+
+/**
+ * How each opcode is written in the text form, `Specs/SL_TEXT.md` 3.4.
+ *
+ * ONE COLUMN, READ BY BOTH SURFACES. The EDSL's names and the parser's names
+ * are the same set by construction rather than by two lists that have to be
+ * kept level; `lang/builtins.ts` attaches a lowering to each `call` entry here
+ * and a contract test refuses an opcode that has neither a spelling nor a
+ * reason to lack one.
+ *
+ * `call` is a name an author writes as a function. `syntax` is everything the
+ * language produces from a form instead: an operator, a constructor, a swizzle,
+ * the conditional. An opcode has exactly one of the two.
+ */
+export interface SLSurface {
+    call?: string
+    syntax?: string
+    /**
+     * Set when the surface form does not emit this opcode at all: it expands
+     * into ops both backends already have. `ramp` and `remap` are macros for
+     * the same reason `sl.ramp` is, and the opcode number stays reserved.
+     */
+    macro?: true
+}
+
+export const SL_HLSL: Record<number, SLSurface> = {
+    [SLOP.CONST]: { syntax: "a number literal" },
+    [SLOP.INPUT]: { syntax: "uv, fragCoord, resolution, time, aspect" },
+    [SLOP.UNIFORM]: { syntax: "uniform <type> name = <default>;" },
+    [SLOP.COMPOSE]: { syntax: "float2(), float3(), float4()" },
+    [SLOP.SWIZZLE]: { syntax: ".xyzw / .rgba" },
+
+    [SLOP.ADD]: { syntax: "+" },
+    [SLOP.SUB]: { syntax: "-" },
+    [SLOP.MUL]: { syntax: "*" },
+    [SLOP.DIV]: { syntax: "/" },
+    [SLOP.MOD]: { syntax: "%" },
+    [SLOP.POW]: { call: "pow" },
+    [SLOP.NEG]: { syntax: "unary -" },
+    [SLOP.RECIP]: { call: "rcp" },
+
+    [SLOP.SIN]: { call: "sin" },
+    [SLOP.COS]: { call: "cos" },
+    [SLOP.TAN]: { call: "tan" },
+    [SLOP.ASIN]: { call: "asin" },
+    [SLOP.ACOS]: { call: "acos" },
+    [SLOP.ATAN2]: { call: "atan2" },
+    [SLOP.EXP]: { call: "exp" },
+    [SLOP.LOG]: { call: "log" },
+    [SLOP.SQRT]: { call: "sqrt" },
+    [SLOP.ABS]: { call: "abs" },
+    [SLOP.SIGN]: { call: "sign" },
+    [SLOP.FLOOR]: { call: "floor" },
+    [SLOP.CEIL]: { call: "ceil" },
+    [SLOP.ROUND]: { call: "round" },
+    [SLOP.FRACT]: { call: "frac" },
+    [SLOP.MIN]: { call: "min" },
+    [SLOP.MAX]: { call: "max" },
+    [SLOP.CLAMP]: { call: "clamp" },
+    [SLOP.SATURATE]: { call: "saturate" },
+
+    [SLOP.LENGTH]: { call: "length" },
+    [SLOP.DISTANCE]: { call: "distance" },
+    [SLOP.DOT]: { call: "dot" },
+    [SLOP.CROSS]: { call: "cross" },
+    [SLOP.NORMALIZE]: { call: "normalize" },
+    [SLOP.REFLECT]: { call: "reflect" },
+
+    [SLOP.MIX]: { call: "lerp" },
+    [SLOP.STEP]: { call: "step" },
+    [SLOP.SMOOTHSTEP]: { call: "smoothstep" },
+    // `select` exists as a name too, because `sl.select` does and a contract
+    // test holds the two surfaces level, but `?:` is how anyone writes it.
+    [SLOP.SELECT]: { syntax: "?:" },
+    [SLOP.REMAP]: { call: "remap", macro: true },
+
+    [SLOP.RAMP]: { call: "ramp", macro: true },
+    [SLOP.HSV2RGB]: { call: "hsv2rgb" },
+    [SLOP.RGB2HSV]: { call: "rgb2hsv" },
+    [SLOP.LUMINANCE]: { call: "luminance" },
+    [SLOP.TO_LINEAR]: { call: "toLinear" },
+
+    [SLOP.NOISE]: { call: "noise" },
+    [SLOP.SIMPLEX]: { call: "simplex" },
+    [SLOP.FBM]: { call: "fbm" },
+    [SLOP.SDF]: { call: "sdf" },
+    [SLOP.VORONOI]: { call: "voronoi" },
+    [SLOP.TURBULENCE]: { call: "turbulence" },
+    [SLOP.RIDGED]: { call: "ridged" },
+    [SLOP.SDF_WIDE]: { syntax: "sdf.<shape>(p, ...) given a fifth or sixth parameter" },
+
+    [SLOP.SAMPLE]: { call: "tex2D" },
+    [SLOP.SAMPLE_LOD]: { call: "tex2Dlod" },
+}
+
+/**
+ * Opcodes no backend implements.
+ *
+ * Numbered so the families stay in order, and refused at the surface until
+ * somebody writes both halves. A program reaching one would render as whatever
+ * the VM's dispatch falls through to and fail outright in the HLSL emitter,
+ * which is the silent-disagreement failure this design exists to prevent, so
+ * the parser names them rather than treating them as unknown identifiers.
+ *
+ * `REMAP` is here because the opcode is unimplemented; the SURFACE `remap` is a
+ * macro over arithmetic and works everywhere.
+ */
+export const SL_UNIMPLEMENTED: Record<number, string> = {
+    [SLOP.RGB2HSV]: "neither the VM shader nor the HLSL emitter has a case for it",
+    [SLOP.SAMPLE_LOD]: "the VM samples without an explicit LOD; use tex2D",
+    [SLOP.REMAP]: "the surface form is a macro over arithmetic, so the opcode is unused",
+}
+
+/**
+ * GLSL spellings, recognised only so they can be refused by their HLSL name.
+ *
+ * Accepting both would be two ways to write everything and a table that has to
+ * stay complete in two columns forever (`Specs/SL_TEXT.md` 9.1). Recognising
+ * them costs one entry each and turns "unknown identifier mix" into the answer.
+ */
+export const SL_GLSL_HINT: Record<string, string> = {
+    mix: "lerp",
+    fract: "frac",
+    mod: "%",
+    texture: "tex2D",
+    textureLod: "tex2Dlod",
+    vec2: "float2",
+    vec3: "float3",
+    vec4: "float4",
+    ivec2: "float2",
+    ivec3: "float3",
+    ivec4: "float4",
+    inversesqrt: "1 / sqrt(x); there is no rsqrt opcode",
+    atan: "atan2",
+    sampler2D: "texture2D",
+    gl_FragCoord: "fragCoord",
+    gl_FragColor: "the value main returns",
+    iTime: "time",
+    iResolution: "resolution",
+    iMouse: "a uniform you declare",
+}
+
+/** Every opcode that an author can write as a call, by the name they write. */
+export const SL_CALL_NAMES: Record<string, number> = Object.fromEntries(
+    Object.entries(SL_HLSL)
+        .filter(([, s]) => s.call !== undefined)
+        .map(([code, s]) => [s.call!, Number(code)]),
+)

package/src/serial.ts

@@ -0,0 +1,137 @@
+/**
+ * The IR as JSON, for a host that stores or ships a program rather than its
+ * source (`Specs/SL_PACKAGE.md` section 2).
+ *
+ * `toJSON` writes the version beside the graph. `fromJSON` is the only way
+ * back in, and it checks everything an emitter relies on, because an emitter
+ * handed a malformed graph does not fail: it prints a shader that computes
+ * something else. A newer version is refused with a message naming both; an
+ * older one is migrated to this one and rehashed under it.
+ */
+import {
+    INPUTS, SLError, SL_IR_VERSION, TYPE, hashProgram,
+    type NodeRef, type Program, type SLNode, type SLType, type TextureDecl, type UniformDecl,
+} from "./ir"
+import { SL_ARITY, SL_NAME } from "./ops"
+
+export interface ProgramJSON {
+    /** `SL_IR_VERSION` of the writer. Absent means 1. */
+    v: number
+    nodes: SLNode[]
+    result: NodeRef
+    uniforms: UniformDecl[]
+    textures: TextureDecl[]
+    hash: string
+}
+
+export function toJSON(p: Program): ProgramJSON {
+    return { v: p.version, nodes: p.nodes, result: p.result, uniforms: p.uniforms, textures: p.textures, hash: p.hash }
+}
+
+export function fromJSON(json: unknown): Program {
+    if (typeof json !== "object" || json === null) fail("a program must be an object")
+    const j = json as Partial<ProgramJSON>
+    const v = j.v ?? 1
+    if (!Number.isInteger(v) || v < 1) fail(`its version must be a whole number from 1, got ${String(j.v)}`)
+    if (v > SL_IR_VERSION) {
+        fail(`it is IR version ${v}, and this compiler reads up to ${SL_IR_VERSION}. ` +
+            `Update onejs-sl to read it, or rebuild it from its .sl source.`)
+    }
+    if (!Array.isArray(j.nodes) || j.nodes.length === 0) fail("it has no nodes")
+    const nodes = j.nodes.map((n, i) => node(n, i))
+    const result = j.result
+    if (!Number.isInteger(result) || result! < 0 || result! >= nodes.length) fail(`its result ${String(result)} is not a node`)
+    if (nodes[result!]!.type !== TYPE.VEC4) fail("its result is not a float4")
+    const uniforms = (j.uniforms ?? []).map(uniform)
+    const textures = (j.textures ?? []).map(texture)
+    for (const n of nodes) {
+        if (n.k === "uniform" && n.slot >= uniforms.length) fail(`a node reads uniform slot ${n.slot}, which is not declared`)
+    }
+    const hash = hashProgram(nodes, result!, uniforms, textures)
+    // Same version, so the same maths and the same hash; a different one means
+    // the file was edited or damaged, and its cached shader belongs to
+    // something else. An older version is rehashed under this one on purpose.
+    if (v === SL_IR_VERSION && j.hash !== undefined && j.hash !== hash) {
+        fail(`its hash ${j.hash} does not match its nodes (${hash}); it was changed after it was written`)
+    }
+    return { version: SL_IR_VERSION, nodes, result: result!, uniforms, textures, hash, loops: [] }
+}
+
+function node(n: unknown, i: number): SLNode {
+    if (typeof n !== "object" || n === null) fail(`node ${i} is not an object`)
+    const x = n as Record<string, unknown>
+    const type = x.type
+    if (type !== 1 && type !== 2 && type !== 3 && type !== 4) fail(`node ${i} has no width 1 to 4`)
+    const t = type as SLType
+    const ref = (r: unknown, what: string): NodeRef => {
+        if (!Number.isInteger(r) || (r as number) < 0 || (r as number) >= i) {
+            fail(`node ${i}'s ${what} ${String(r)} does not refer to an earlier node`)
+        }
+        return r as number
+    }
+    const nums = (a: unknown, what: string): number[] => {
+        if (!Array.isArray(a) || !a.every((e) => typeof e === "number" && Number.isFinite(e))) {
+            fail(`node ${i}'s ${what} must be finite numbers`)
+        }
+        return a as number[]
+    }
+    switch (x.k) {
+        case "const": {
+            const v = nums(x.v, "value")
+            if (v.length !== t) fail(`node ${i} is a float${t === 1 ? "" : t} constant with ${v.length} values`)
+            return { k: "const", type: t, v }
+        }
+        case "input": {
+            const name = x.name as keyof typeof INPUTS
+            if (!(name in INPUTS) || INPUTS[name] !== t) fail(`node ${i} reads an input "${String(x.name)}" that does not exist at that width`)
+            return { k: "input", type: t, name }
+        }
+        case "uniform": {
+            if (!Number.isInteger(x.slot) || (x.slot as number) < 0) fail(`node ${i} has no uniform slot`)
+            return { k: "uniform", type: t, slot: x.slot as number }
+        }
+        case "swizzle": {
+            const chans = nums(x.chans, "channels")
+            if (chans.length !== t || !chans.every((c) => Number.isInteger(c) && c >= 0 && c <= 3)) {
+                fail(`node ${i}'s swizzle does not pick ${t} channels`)
+            }
+            return { k: "swizzle", type: t, src: ref(x.src, "source"), chans }
+        }
+        case "call": {
+            const op = x.op as number
+            if (SL_NAME[op] === undefined) {
+                fail(`node ${i} calls opcode ${String(x.op)}, which this compiler does not know. ` +
+                    `A newer compiler wrote it; its version says otherwise, so the file is damaged.`)
+            }
+            if (!Array.isArray(x.args)) fail(`node ${i} has no arguments list`)
+            const args = (x.args as unknown[]).map((a) => ref(a, "argument"))
+            const arity = SL_ARITY[op]
+            if (arity !== undefined && arity >= 0 && args.length !== arity) {
+                fail(`node ${i} calls ${SL_NAME[op]} with ${args.length} arguments; it takes ${arity}`)
+            }
+            const out: SLNode = { k: "call", type: t, op: op as never, args }
+            if (x.imm !== undefined) out.imm = nums(x.imm, "immediates")
+            return out
+        }
+        default:
+            fail(`node ${i} is a "${String(x.k)}", which is not a kind of node`)
+    }
+}
+
+function uniform(u: unknown, i: number): UniformDecl {
+    const x = (u ?? {}) as Partial<UniformDecl>
+    if (typeof x.name !== "string" || ![1, 2, 3, 4].includes(x.type as number) || !Array.isArray(x.value)) {
+        fail(`uniform ${i} needs a name, a width and a value`)
+    }
+    return { name: x.name!, type: x.type as SLType, value: x.value!.slice() }
+}
+
+function texture(t: unknown, i: number): TextureDecl {
+    const x = (t ?? {}) as Partial<TextureDecl>
+    if (typeof x.name !== "string" || x.slot !== i) fail(`texture ${i} needs a name and slot ${i}`)
+    return { name: x.name!, slot: i }
+}
+
+function fail(why: string): never {
+    throw new SLError(`this program's IR cannot be read: ${why}.`)
+}

package/src/shapes.ts

@@ -0,0 +1,49 @@
+/**
+ * Shape names and ids for `sl.sdf`.
+ *
+ * A SECOND COPY of `fx/sdf.ts`'s table, deliberately, and guarded by a test
+ * that compares the two.
+ *
+ * `fx` lives in onejs-unity and this package has no Unity in it, so the table
+ * cannot be imported from there. It was a copy before the move too: OneJS's
+ * Play eject scaffold vendors each module into its own folder and does not
+ * rewrite relative paths across modules. onejs-unity's `sl/shapes.test.ts`
+ * compares the two.
+ *
+ * Duplicating and pinning is the trade this repository already makes for the
+ * painter and particle opcode tables, and for the SDF dispatcher that exists in
+ * both FxSources and SLCommon. The ids are a contract with SDF2D.cginc either
+ * way; what matters is that a test fails when they drift, not that there is
+ * only one copy.
+ */
+export const SL_SDF_SHAPES = {
+    circle: 0, roundedBox: 1, box: 2, orientedBox: 3, segment: 4, rhombus: 5,
+    trapezoid: 6, parallelogram: 7, equilateralTriangle: 8, triangleIsosceles: 9,
+    triangle: 10, unevenCapsule: 11, pentagon: 12, hexagon: 13, octagon: 14,
+    hexagram: 15, star5: 16, star: 17, pie: 18, cutDisk: 19, arc: 20, ring: 21,
+    horseshoe: 22, vesica: 23, orientedVesica: 24, moon: 25, roundedCross: 26,
+    egg: 27, heart: 28, cross: 29, roundedX: 30, ellipse: 31, parabola: 32,
+    parabolaSegment: 33, bezier: 34, blobbyCross: 35, tunnel: 36, stairs: 37,
+    quadraticCircle: 38, hyperbola: 39, coolS: 40, circleWave: 41,
+} as const
+
+export type SlSdfKind = keyof typeof SL_SDF_SHAPES
+
+/**
+ * How many parameters each shape reads, in the order SDF2D.cginc takes them
+ * (its `a` then `b`). Six shapes take more than four: roundedBox's last two
+ * corner radii, orientedBox's thickness, triangle's third vertex, horseshoe's
+ * second width, orientedVesica's width and bezier's end point. `sl.sdf` takes
+ * up to this many, and a test derives the same counts from the web emitters'
+ * call table, so the two cannot drift.
+ */
+export const SL_SDF_PARAMS: Record<SlSdfKind, number> = {
+    circle: 1, roundedBox: 6, box: 2, orientedBox: 5, segment: 4, rhombus: 2,
+    trapezoid: 3, parallelogram: 3, equilateralTriangle: 1, triangleIsosceles: 2,
+    triangle: 6, unevenCapsule: 3, pentagon: 1, hexagon: 1, octagon: 1,
+    hexagram: 1, star5: 2, star: 3, pie: 3, cutDisk: 2, arc: 4, ring: 4,
+    horseshoe: 5, vesica: 2, orientedVesica: 5, moon: 3, roundedCross: 1,
+    egg: 4, heart: 0, cross: 3, roundedX: 2, ellipse: 2, parabola: 1,
+    parabolaSegment: 2, bezier: 6, blobbyCross: 1, tunnel: 2, stairs: 3,
+    quadraticCircle: 0, hyperbola: 2, coolS: 0, circleWave: 2,
+}