onejs-sl 0.2.1 → 0.4.0

package/src/sl.ts

@@ -24,7 +24,7 @@
 
 import { parseColor as parseHex } from "./color"
 import {
-    Builder, INPUTS, SLError, SL_IR_VERSION, TYPE, hashProgram, widthName,
+    Builder, INPUTS, RAMP_STOP_COMPUTED, SLError, TYPE, hashProgram, programVersion, widthName, writtenColour,
     type InputName, type NodeRef, type Program, type SLNode, type SLType, type UniformControl,
 } from "./ir"
 import { SLOP, type SLOpCode } from "./ops"
@@ -207,7 +207,7 @@ function align2(a: Val, o: Num): [NodeRef, NodeRef] {
  * right for two operands because `bin` takes the max itself; the three and four
  * operand ops used to take the width from one chosen operand, so
  * `mix(0, aVec3, t)` produced a node typed float that held three components.
- * The VM keeps every value in a float4 register and never noticed, while the
+ * The VM, which kept every value in a float4 register, never noticed, while the
  * HLSL emitter declared `float` and truncated, so the two backends rendered
  * different pictures from one program. Anything component wise with more than
  * two operands goes through here.
@@ -288,13 +288,12 @@ export function program(fn: (inputs: ProgramInputs) => Vec4): Program {
         }
         const nodes: SLNode[] = b.nodes.slice()
         return {
-            version: SL_IR_VERSION,
+            version: programVersion(nodes),
             nodes,
             result: out.ref,
             uniforms: b.uniforms.slice(),
             textures: b.textures.slice(),
             hash: hashProgram(nodes, out.ref, b.uniforms, b.textures),
-            loops: b.loops.slice(),
         }
     } finally {
         current = null
@@ -312,23 +311,14 @@ function compose(width: SLType, parts: Num[]): Val {
     // Wide parts are SPLIT into their components here, so COMPOSE only ever
     // sees scalars.
     //
-    // The VM keeps every value in a float4 register and took the x of each
-    // operand, which silently dropped everything after the first component:
-    // vec4(uv, 0, 1) rendered (uv.x, 0, 1, 0) instead of (uv.x, uv.y, 0, 1).
-    // Teaching the shader each part's width would need widths in an encoding
-    // that has no room for them, and would put the complexity in the half that
-    // is hardest to test. Splitting at record time costs a few extra swizzle
-    // nodes, which the register allocator reclaims immediately, and leaves the
-    // VM's COMPOSE trivially correct.
+    // The VM (removed in 0.3.0) took the x of each operand, which dropped
+    // everything after the first component: vec4(uv, 0, 1) rendered
+    // (uv.x, 0, 1, 0). Splitting at record time costs a few extra swizzle
+    // nodes and keeps every emitter's COMPOSE trivial.
     // A constructor of literals is ONE constant, not a COMPOSE of four.
     //
-    // `vec4(0.1, 0.2, 0.3, 0.4)` was five instructions holding four registers
-    // at once, because every part became its own CONST and COMPOSE kept them
-    // all live. The IR has always been able to say it in one node: a const
-    // carries up to four components. A two stop `ramp` used five of the eight
-    // registers on nothing but its own stop colours, which put the language's
-    // headline colour tool within one or two registers of unusable in any
-    // program that also did something.
+    // Every part as its own CONST, joined by a COMPOSE, is five nodes where the
+    // IR can say it in one: a const carries up to four components.
     if (parts.length === width && parts.every((p) => typeof p === "number")) {
         return mk(b, b.constant(parts as number[]), width)
     }
@@ -425,9 +415,8 @@ export function hsv2rgb(c: Vec3): Vec3 {
 /**
  * Cross and reflect, both vec3 only.
  *
- * The VM evaluates them as `cross(a.xyz, b.xyz)`, so a vec2 or vec4 would mean
- * one thing in a compiled build and another in the interpreter. Refusing the
- * other widths here is what keeps the two honest.
+ * Refusing the other widths here keeps every backend drawing the same thing,
+ * rather than each deciding what a vec2 or vec4 cross product means.
  */
 export function cross(a: Vec3, b: Vec3): Vec3 {
     if (a.width !== TYPE.VEC3 || b.width !== TYPE.VEC3) {
@@ -452,7 +441,7 @@ export function reflect(incident: Vec3, normal: Vec3): Vec3 {
  *
  * A MACRO, like `ramp`, and for the same reason: it expands into arithmetic
  * both backends already have, so it needs no opcode, no second implementation
- * in the emitter and no VM case. `SLOP.REMAP` stays a reserved number.
+ * in the emitters. `SLOP.REMAP` stays a reserved number.
  *
  * Unclamped on purpose, which is what HLSL authors expect of the one liner they
  * would otherwise write; wrap it in `saturate` when the ends matter.
@@ -495,11 +484,10 @@ export function select(cond: Num, whenTrue: Num, whenFalse: Num): Val {
     const t = typeof whenTrue === "number" ? float(whenTrue) : whenTrue
     const f = typeof whenFalse === "number" ? float(whenFalse) : whenFalse
     // The condition is widened with the branches, not left at its own width.
-    // A register is a float4 whatever it holds, so a scalar condition sits
-    // there as (c, 0, 0, 0) and the VM's `step(0.5, cond)` answered 0 for
-    // components y, z and w, while the HLSL backend broadcasts a scalar
-    // itself. The two DISAGREED on every vector valued select, which is the one
-    // failure this design cannot tolerate.
+    // The VM (removed in 0.3.0) held a scalar condition as (c, 0, 0, 0) and
+    // answered 0 for components y, z and w, while HLSL broadcasts a scalar
+    // itself; the two disagreed on every vector valued select. Widening here
+    // keeps every emitter's SELECT the same simple form.
     const { refs, width } = alignN([c, t, f])
     return mk(b, b.call(SLOP.SELECT, width, refs), width)
 }
@@ -507,8 +495,8 @@ export function select(cond: Num, whenTrue: Num, whenFalse: Num): Val {
 /**
  * The interpolant is broadcast to the operand width before it crosses.
  *
- * A register is a float4 whatever it holds, so a scalar `t` sits there as
- * (t, 0, 0, 0) and the shader's lerp ran per component against those zeros:
+ * The VM (removed in 0.3.0) held a scalar `t` as (t, 0, 0, 0) and its lerp
+ * ran per component against those zeros:
  * a black to white ramp at its midpoint rendered (0.5, 0, 0, 1) instead of
  * grey. Broadcasting here rather than in the shader keeps `t` free to be a
  * genuine per component vector when an author wants one.
@@ -545,6 +533,10 @@ export function uniformDefaults(p: Program): number[] {
  * fields `fx.noise` draws: a value or simplex base, layered as fBm, or the
  * turbulence and ridged variants built on simplex. A program has no seed;
  * offset the input for a different field. Octaves are 1 to 4, as in fx.
+ *
+ * The octave count may be a value, a uniform say, rounded to the nearest whole
+ * number and held to 1 to 4 where it is read. It is an operand either way
+ * (IR 3); a constant one is checked here, and prints as the number it is.
  */
 export function noise(p: Vec2): Float {
     return mk(p.owner, p.owner.call(SLOP.NOISE, TYPE.FLOAT, [p.ref]), TYPE.FLOAT)
@@ -552,24 +544,31 @@ export function noise(p: Vec2): Float {
 export function simplex(p: Vec2): Float {
     return mk(p.owner, p.owner.call(SLOP.SIMPLEX, TYPE.FLOAT, [p.ref]), TYPE.FLOAT)
 }
-function octaveCount(name: string, octaves: number): number {
-    if (!Number.isInteger(octaves) || octaves < 1 || octaves > 4) {
-        throw new SLError(`${name} octaves must be a whole number from 1 to 4, got ${octaves}`)
+/**
+ * An octave op: the point and the count as operands, with `rest` (fbm's kind)
+ * the immediates. A constant count is checked here.
+ */
+function octaves(op: SLOpCode, name: string, p: Vec2, count: Num, rest: number[]): Float {
+    const c = components(p.owner, count)
+    if (c.length !== 1) throw new SLError(`${name}'s octave count is one number, and this is a ${widthName(c.length as SLType)}`)
+    const n = c[0]!
+    if (typeof n === "number" && (!Number.isInteger(n) || n < 1 || n > 4)) {
+        throw new SLError(`${name} octaves must be a whole number from 1 to 4, got ${n}`)
     }
-    return octaves
+    const v = typeof n === "number" ? float(n) : n
+    return mk(p.owner, p.owner.call(op, TYPE.FLOAT, [p.ref, v.ref], rest), TYPE.FLOAT)
 }
 /** Layered noise. `base` picks the grid ("value", the default) or triangles ("simplex"). */
-export function fbm(p: Vec2, octaves = 3, base: "value" | "simplex" = "value"): Float {
-    const kind = base === "simplex" ? 1 : 0
-    return mk(p.owner, p.owner.call(SLOP.FBM, TYPE.FLOAT, [p.ref], [octaveCount("fbm", octaves), kind]), TYPE.FLOAT)
+export function fbm(p: Vec2, octaveCount: Num = 3, base: "value" | "simplex" = "value"): Float {
+    return octaves(SLOP.FBM, "fbm", p, octaveCount, [base === "simplex" ? 1 : 0])
 }
 /** Sum of |simplex| octaves: creases that stack into veins and licks. Fire, smoke, marble. */
-export function turbulence(p: Vec2, octaves = 3): Float {
-    return mk(p.owner, p.owner.call(SLOP.TURBULENCE, TYPE.FLOAT, [p.ref], [octaveCount("turbulence", octaves)]), TYPE.FLOAT)
+export function turbulence(p: Vec2, octaveCount: Num = 3): Float {
+    return octaves(SLOP.TURBULENCE, "turbulence", p, octaveCount, [])
 }
 /** The turbulence crease made bright and squared: ridges, lightning, cracks. */
-export function ridged(p: Vec2, octaves = 3): Float {
-    return mk(p.owner, p.owner.call(SLOP.RIDGED, TYPE.FLOAT, [p.ref], [octaveCount("ridged", octaves)]), TYPE.FLOAT)
+export function ridged(p: Vec2, octaveCount: Num = 3): Float {
+    return octaves(SLOP.RIDGED, "ridged", p, octaveCount, [])
 }
 
 /** "#rgb", "#rrggbb" or "#rrggbbaa" to 0..1 components. Shared with fx. */
@@ -593,18 +592,23 @@ export function parseColor(hex: string): [number, number, number, number] {
  *
  * This is the argument for the EDSL in miniature. A library function that
  * composes from primitives costs one function here and nothing anywhere else.
+ *
+ * A stop is a colour as written: a hex, four numbers, or a value that is a
+ * colour as written, which is one `color`, `sl.uniform.colour` or a hex
+ * literal made (a colour uniform, say). The ramp blends the colours as
+ * written, so a value computed any other way, already in the working space,
+ * has nothing it could blend, and is refused.
  */
-export function ramp(t: Num, stops: Array<string | [number, number, number, number]>): Vec4 {
+export function ramp(t: Num, stops: Array<string | [number, number, number, number] | Vec3 | Vec4>): Vec4 {
     if (stops.length < 2) throw new SLError(`a ramp needs at least 2 stops, got ${stops.length}`)
     const tv = (typeof t === "number" ? float(t) : t).saturate()
-    // Each stop is built IMMEDIATELY BEFORE the mix that consumes it, not all
-    // of them up front. The graph is identical either way and so is the hash,
-    // which is a Merkle hash over the shape and not over storage order, but the
-    // register allocator walks the array: built up front, every stop stayed
-    // live until the last mix, and a four stop ramp reserved four of the VM's
-    // eight registers before the program did anything. That put the language's
-    // headline colour tool a couple of registers from unusable.
+    const written = stops.map((s) => (s instanceof Val ? asWritten(s) : null))
+    // Each stop is built immediately before the mix that consumes it. The graph
+    // and the hash are the same either way (the hash is over the shape, not the
+    // storage order); the order only mattered to the VM's register allocator.
     const colourAt = (i: number) => {
+        const w = written[i]
+        if (w !== null && w !== undefined) return w
         const v = typeof stops[i] === "string" ? parseColor(stops[i] as string) : (stops[i] as number[])
         return vec4(v[0], v[1], v[2], v[3])
     }
@@ -622,6 +626,18 @@ export function ramp(t: Num, stops: Array<string | [number, number, number, numb
     return toLinear(out)
 }
 
+/**
+ * A colour value as it was written, a float4: the operand of the `toLinear`
+ * that reading it as a colour applied, with alpha 1 when it has three
+ * components. Anything else was computed in the working space.
+ */
+function asWritten(v: Vec3 | Vec4): Vec4 {
+    const ref = writtenColour(v.owner.nodes, v.ref)
+    if (ref === null) throw new SLError(RAMP_STOP_COMPUTED)
+    const raw = mk(v.owner, ref, v.width) as Val
+    return v.width === TYPE.VEC4 ? (raw as Vec4) : vec4(raw, 1)
+}
+
 /**
  * Signed distance to a shape, positive outside and negative inside.
  *
@@ -637,27 +653,45 @@ export function ramp(t: Num, stops: Array<string | [number, number, number, numb
  *
  * A shape takes up to `SL_SDF_PARAMS[kind]` parameters, six at most. Fewer
  * fills zeros, which is all a program could pass before six shapes grew their
- * fifth and sixth.
+ * fifth and sixth. A vector parameter counts as its components, so a box's
+ * half extents can be one float2.
  *
  * Which parameters a shape takes is the shape's own business; `circle` wants a
  * radius, `roundedBox` wants half extents and a corner. See `lib/sdf2d.hlsl`.
+ *
+ * A parameter may be any value, a uniform or one computed per pixel. The six
+ * are operands either way (IR 3), a float4 and a float2, and constant ones
+ * print as the numbers they are.
  */
-export function sdf(kind: SlSdfKind, p: Vec2, params: number[] = []): Float {
+export function sdf(kind: SlSdfKind, p: Vec2, params: Num[] = []): Float {
     const id = SL_SDF_SHAPES[kind]
     if (id === undefined) throw new SLError(`"${kind}" is not a shape; see SL_SDF_SHAPES for the 42 names`)
+    const c = params.flatMap((v) => components(p.owner, v))
     // At least four, so a program that passed a shape more than it reads, which
     // was harmless when every shape took four, still builds.
     const most = Math.max(4, SL_SDF_PARAMS[kind])
-    if (params.length > most) {
-        throw new SLError(`sl.sdf("${kind}") takes at most ${most} parameters and was given ${params.length}`)
+    if (c.length > most) {
+        throw new SLError(`sl.sdf("${kind}") takes at most ${most} parameters and was given ${c.length}`)
     }
-    for (const v of params) {
-        if (!Number.isFinite(v)) throw new SLError(`sl.sdf parameters must be finite, got ${v}`)
+    for (const v of c) {
+        if (typeof v === "number" && !Number.isFinite(v)) throw new SLError(`sl.sdf parameters must be finite, got ${v}`)
     }
-    // Four always, as before, and a fifth and sixth only when given: a program
-    // using four or fewer is the same node, and hashes the same, as it was.
-    const imm = [params[0] ?? 0, params[1] ?? 0, params[2] ?? 0, params[3] ?? 0, ...params.slice(4)]
-    return mk(p.owner, p.owner.call(SLOP.SDF, TYPE.FLOAT, [p.ref], [id, ...imm]), TYPE.FLOAT)
+    const q = vec4(c[0] ?? 0, c[1] ?? 0, c[2] ?? 0, c[3] ?? 0)
+    const r = vec2(c[4] ?? 0, c[5] ?? 0)
+    return mk(p.owner, p.owner.call(SLOP.SDF, TYPE.FLOAT, [p.ref, q.ref, r.ref], [id]), TYPE.FLOAT)
+}
+
+/**
+ * A value as its components: numbers for a constant, which is what it would
+ * have been written as, and a float per component otherwise.
+ */
+function components(b: Builder, v: Num): Num[] {
+    if (typeof v === "number") return [v]
+    if (v.owner !== b) throw new SLError("a value from another program cannot be used in this one")
+    const n = b.nodes[v.ref]!
+    if (n.k === "const") return n.v.slice()
+    if (v.width === 1) return [v]
+    return Array.from({ length: v.width }, (_, i) => v.swz("xyzw"[i] as "x"))
 }
 
 /** Distance to the nearest point of a jittered lattice. Cells, cracks, scales. */
@@ -712,7 +746,14 @@ export const uniform = {
 }
 
 export interface Texture {
+    /** The colour at `uv`, filtered as the texture's own settings say. */
     sample(uv: Vec2): Vec4
+    /**
+     * The colour at `uv` from mip level `lod`: 0 is the full size texture, 1
+     * half, and a fraction blends two levels where the texture's filter does.
+     * A texture with no mips has only level 0.
+     */
+    sampleLevel(uv: Vec2, lod: Num): Vec4
 }
 
 export function texture(name: string): Texture {
@@ -723,6 +764,15 @@ export function texture(name: string): Texture {
             if (uv.owner !== b) throw new SLError("a value from another program cannot be used in this one")
             return mk(b, b.call(SLOP.SAMPLE, TYPE.VEC4, [uv.ref], [slot]), TYPE.VEC4)
         },
+        sampleLevel(uv: Vec2, lod: Num): Vec4 {
+            if (uv.owner !== b) throw new SLError("a value from another program cannot be used in this one")
+            const level = typeof lod === "number" ? b.constant([lod]) : lod
+            if (typeof level !== "number") {
+                if (level.owner !== b) throw new SLError("a value from another program cannot be used in this one")
+                if (level.width !== 1) throw new SLError(`a mip level is one number, and this is a ${widthName(level.width)}`)
+            }
+            return mk(b, b.call(SLOP.SAMPLE_LOD, TYPE.VEC4, [uv.ref, typeof level === "number" ? level : level.ref], [slot]), TYPE.VEC4)
+        },
     }
 }
 
@@ -733,34 +783,13 @@ export function texture(name: string): Texture {
  *
  * Honest about what it is: a macro, not a loop. It covers fbm, layered noise and
  * small iterated distance fields, which is most of what 2D shaders loop for. A
- * data dependent loop is out of scope, because in the VM it would need a nested
- * bounded loop with a dynamic trip count while codegen would handle it fine, and
- * the two backends agreeing is the property this whole design protects.
+ * loop with a runtime count is `Specs/SL_NEXT.md` proposal 3b.
  */
 export function repeat<T extends Val>(n: number, body: (i: number, acc: T) => T, seed: T): T {
     if (!Number.isInteger(n) || n < 0 || n > 64) {
         throw new SLError(`repeat count must be a whole number from 0 to 64, got ${n}`)
     }
-    return unrolled(n, () => {
-        let acc = seed
-        for (let i = 0; i < n; i++) acc = body(i, acc)
-        return acc
-    })
-}
-
-/**
- * Records the nodes a body produced as one unrolled span.
- *
- * Diagnostic only: the instruction ceiling error uses the span to say which
- * loop spent the budget, so the fix reads as "lower this count" rather than
- * "fewer instructions". `repeat` is the EDSL's form of it and the text
- * language's `for` is the other, and neither should be reaching into the
- * Builder to push a span itself.
- */
-export function unrolled<T>(count: number, body: () => T): T {
-    const b = ctx()
-    const start = b.nodes.length
-    const out = body()
-    b.loops.push({ count, start, end: b.nodes.length })
-    return out
+    let acc = seed
+    for (let i = 0; i < n; i++) acc = body(i, acc)
+    return acc
 }

package/src/web.ts

@@ -2,11 +2,10 @@
  * The web backends: prints a program as GLSL ES 3.00 or WGSL, for a browser to
  * compile at runtime on Unity's own graphics device.
  *
- * Unity cannot compile a shader in a built game, which is why the VM exists.
- * A browser can, and the Play container runs on WebGPU with WebGL2 behind it,
- * so a program becomes WGSL on one and GLSL ES on the other and runs compiled:
- * no register budget, no interpreter, and on the spike's measurements 100 to
- * 600 times cheaper per pixel. The host that compiles and draws these lives in
+ * Unity cannot compile a shader in a built game, so a native build ships the
+ * shaders the editor generated. A browser can compile, and the Play container
+ * runs on WebGPU with WebGL2 behind it, so a program becomes WGSL on one and
+ * GLSL ES on the other. The host that compiles and draws these lives in
  * OneJS (`Plugins/WebGL/OneJSSLWeb.jslib`); this file only prints them.
  *
  * Structurally the HLSL emitter again: one local per reachable node, in order,
@@ -53,6 +52,11 @@ function emitWeb(p: Program, lang: WebLanguage): string {
     const emitted = new Set<number>()
     const T = (t: SLType) => (W ? (t === 1 ? "f32" : `vec${t}f`) : t === 1 ? "float" : `vec${t}`)
     const typeOf = (ref: number) => p.nodes[ref].type
+    /** A constant node's value, or null for anything computed. */
+    const constantOf = (ref: number): number[] | null => {
+        const c = p.nodes[ref]!
+        return c.k === "const" ? c.v : null
+    }
 
     /** A node's value widened to `t` when it is a scalar and `t` is not. */
     const splat = (ref: number, t: SLType) => (typeOf(ref) === 1 && t > 1 ? `${T(t)}(n${ref})` : `n${ref}`)
@@ -159,7 +163,7 @@ function emitWeb(p: Program, lang: WebLanguage): string {
             case SLOP.MIX: return `mix(${s[0]}, ${s[1]}, ${s[2]})`
             case SLOP.STEP: return `step(${s[0]}, ${s[1]})`
             case SLOP.SMOOTHSTEP: smoothsteps.add(t); return `sl_smoothstep${t}(${s[0]}, ${s[1]}, ${s[2]})`
-            // As the VM and the HLSL emitter do it: branchless, so every
+            // As the HLSL emitter does it: branchless, so every
             // backend agrees on the edge value.
             case SLOP.SELECT: {
                 const c = typeOf(n.args[0])
@@ -169,44 +173,72 @@ function emitWeb(p: Program, lang: WebLanguage): string {
             case SLOP.HSV2RGB: return `${lib("sl_hsv2rgb")}(${a[0]})`
             case SLOP.NOISE: return `${lib("sl_valueNoise")}(${a[0]})`
             case SLOP.SIMPLEX: return `${lib("sl_simplex")}(${a[0]})`
-            case SLOP.FBM: return octaveCall(Math.round(imm[1] ?? 0), a[0], imm[0])
-            case SLOP.TURBULENCE: return octaveCall(2, a[0], imm[0])
-            case SLOP.RIDGED: return octaveCall(3, a[0], imm[0])
+            case SLOP.FBM: return octaveCall(Math.round((n.args.length > 1 ? imm[0] : imm[1]) ?? 0), a[0])
+            case SLOP.TURBULENCE: return octaveCall(2, a[0])
+            case SLOP.RIDGED: return octaveCall(3, a[0])
             case SLOP.VORONOI: return `${lib("sl_voronoi")}(${a[0]})`
-            case SLOP.SDF: return sdfCall(Math.round(imm[0] ?? 0), a[0], imm)
+            case SLOP.SDF: return sdfCall(Math.round(imm[0] ?? 0), a[0], sdfParams())
             case SLOP.SAMPLE: {
                 const slot = Math.round(imm[0] ?? 0)
                 sampled.add(slot)
                 return W ? `textureSample(sl_tex${slot}, sl_samp${slot}, ${a[0]})` : `texture(sl_Tex${slot}, ${a[0]})`
             }
+            case SLOP.SAMPLE_LOD: {
+                const slot = Math.round(imm[0] ?? 0)
+                sampled.add(slot)
+                return W
+                    ? `textureSampleLevel(sl_tex${slot}, sl_samp${slot}, ${a[0]}, ${a[1]})`
+                    : `textureLod(sl_Tex${slot}, ${a[0]}, ${a[1]})`
+            }
             default:
                 throw new SLError(
                     `the ${lang.toUpperCase()} emitter has no case for opcode ${n.op}. A program using it would ` +
-                    `differ between the VM and a compiled build, which is the one failure this design cannot tolerate.`,
+                    `differ between a browser and a Unity build, which is the one failure this design cannot tolerate.`,
                 )
         }
 
         /**
          * The library's onejsFbmKind, resolved here since the kind is a
          * constant: calling the dispatcher would print a WGSL `select` that
-         * runs two of the four fields to keep one.
+         * runs two of the four fields to keep one. The count is a literal when
+         * it is a constant, and otherwise rounded and held to 1 to 4 as
+         * `sl_fbm` holds it.
          */
-        function octaveCall(kind: number, pt: string, octaves: number | undefined): string {
-            const o = Math.min(4, Math.max(1, Math.round(octaves ?? 3)))
+        function octaveCall(kind: number, pt: string): string {
+            const c = constantOf(n.args[1]!)
+            const o = c !== null
+                ? String(Math.min(4, Math.max(1, Math.round(c[0]!))))
+                : `clamp(${W ? "i32" : "int"}(floor(${a[1]} + 0.5)), 1, 4)`
             const fn = kind === 2 ? "onejsTurbulence" : kind === 3 ? "onejsRidged" : kind === 1 ? "onejsFbmSimplex" : "onejsFbm"
             return `${lib(fn, ["float2", "float", "int", "float", "float"])}(${pt}, 0.0, ${o}, 2.0, 0.5)`
         }
 
+        /**
+         * The six shape parameters, each as a float expression and, when it
+         * is a constant, its number: literals from a constant float4 or
+         * float2, and their components otherwise.
+         */
+        function sdfParams(): Array<{ text: string; value?: number }> {
+            const part = (ref: number, chans: string[]) => {
+                const c = constantOf(ref)
+                return chans.map((ch, i) => c !== null ? { text: lit(c[i]!), value: c[i]! } : { text: `${a[n.args.indexOf(ref)]}.${ch}` })
+            }
+            return [...part(n.args[1]!, ["x", "y", "z", "w"]), ...part(n.args[2]!, ["x", "y"])]
+        }
+
         /** The shape is a constant, so this calls it directly instead of sl_sdfDistance's switch. */
-        function sdfCall(id: number, pt: string, im: number[]): string {
+        function sdfCall(id: number, pt: string, v: Array<{ text: string; value?: number }>): string {
             const shape = SDF_CALLS[id]
             // sl_sdfDistance returns 1e6 for an id it does not know.
             if (shape === undefined) return lit(1e6)
             const fn = lib(shape.fn)
-            const v = [im[1] ?? 0, im[2] ?? 0, im[3] ?? 0, im[4] ?? 0, im[5] ?? 0, im[6] ?? 0]
             const args = shape.args.map((arg) => {
-                if ("int" in arg) return String(Math.trunc(v[arg.int]))
-                const parts = arg.map((i) => lit(v[i]))
+                // Truncated toward zero, as HLSL's int() of the float4 does.
+                if ("int" in arg) {
+                    const p = v[arg.int]!
+                    return p.value !== undefined ? String(Math.trunc(p.value)) : W ? `i32(${p.text})` : `int(${p.text})`
+                }
+                const parts = arg.map((i) => v[i]!.text)
                 return parts.length === 1 ? parts[0] : `${T(parts.length as SLType)}(${parts.join(", ")})`
             })
             return `${fn}(${[pt, ...args].join(", ")})`