onejs-sl 0.4.0 → 0.5.0

package/src/sl.ts

@@ -24,10 +24,10 @@
 
 import { parseColor as parseHex } from "./color"
 import {
-    Builder, INPUTS, RAMP_STOP_COMPUTED, SLError, TYPE, hashProgram, programVersion, widthName, writtenColour,
-    type InputName, type NodeRef, type Program, type SLNode, type SLType, type UniformControl,
+    Builder, INPUTS, RAMP_STOP_COMPUTED, SLError, TYPE, hashProgram, programVersion, truncateHeld, widthName, writtenColour,
+    type InputName, type NodeRef, type Program, type SLKind, type SLNode, type SLType, type UniformControl,
 } from "./ir"
-import { SLOP, type SLOpCode } from "./ops"
+import { SLOP, SL_HLSL, SL_NAME, type SLOpCode } from "./ops"
 import { SL_SDF_PARAMS, SL_SDF_SHAPES, type SlSdfKind } from "./shapes"
 
 // MARK: values
@@ -55,7 +55,8 @@ export type Num = Val | number
 // point rather than a hazard; see the comment above that loop.
 // eslint-disable-next-line @typescript-eslint/no-unsafe-declaration-merging
 export class Val {
-    constructor(readonly owner: Builder, readonly ref: NodeRef, readonly width: SLType) {}
+    /** `kind` is what the value holds beside its width: an int, a uint or a bool. None means floats. */
+    constructor(readonly owner: Builder, readonly ref: NodeRef, readonly width: SLType, readonly kind?: SLKind) {}
 
     // Arithmetic. Mixing a vector with a Float broadcasts, as in HLSL.
     add(o: Num): this { return bin(SLOP.ADD, this, o) as this }
@@ -73,6 +74,11 @@ export class Val {
     min(o: Num): this { return bin(SLOP.MIN, this, o) as this }
     max(o: Num): this { return bin(SLOP.MAX, this, o) as this }
     clamp(lo: Num, hi: Num): this {
+        if ([this, lo, hi].some((v) => typeof v !== "number" && v.kind !== undefined)) {
+            const u = unify([this, lo, hi])
+            if (u.kind !== undefined) return mk(u.owner, u.owner.call(SLOP.CLAMP, u.width, u.refs, undefined, u.kind), u.width, u.kind) as this
+            return (mk(u.owner, u.refs[0]!, u.width) as Val).clamp(mk(u.owner, u.refs[1]!, u.width) as Val, mk(u.owner, u.refs[2]!, u.width) as Val) as this
+        }
         const { refs, width } = alignN([this, lo, hi])
         return mk(this.owner, this.owner.call(SLOP.CLAMP, width, refs), width) as this
     }
@@ -89,6 +95,27 @@ export class Val {
     }
     normalize(): this { return un(SLOP.NORMALIZE, this) as this }
 
+    // Comparisons give a bool per component; an int meeting a float is compared as a float.
+    lt(o: Num): Bool { return compare(SLOP.LT, this, o) }
+    le(o: Num): Bool { return compare(SLOP.LE, this, o) }
+    gt(o: Num): Bool { return compare(SLOP.GT, this, o) }
+    ge(o: Num): Bool { return compare(SLOP.GE, this, o) }
+    eq(o: Num): Bool { return compare(SLOP.EQ, this, o) }
+    ne(o: Num): Bool { return compare(SLOP.NE, this, o) }
+
+    // Logic, on bools.
+    and(o: Val | boolean): Bool { return logic(SLOP.AND, this, o) }
+    or(o: Val | boolean): Bool { return logic(SLOP.OR, this, o) }
+    not(): Bool { return logic(SLOP.NOT, this) }
+
+    // Bits, on ints and uints. A shift takes its count modulo 32 on every backend.
+    band(o: Num): this { return bits(SLOP.BIT_AND, this, o) as this }
+    bor(o: Num): this { return bits(SLOP.BIT_OR, this, o) as this }
+    bxor(o: Num): this { return bits(SLOP.BIT_XOR, this, o) as this }
+    shl(o: Num): this { return bits(SLOP.SHL, this, o) as this }
+    shr(o: Num): this { return bits(SLOP.SHR, this, o) as this }
+    bnot(): this { return bits(SLOP.BIT_NOT, this) as this }
+
     /**
      * Arbitrary swizzle. The common single and full width ones are also getters
      * (`p.x`, `c.rgb`); this covers everything else and is typed by its argument,
@@ -106,7 +133,7 @@ export class Val {
             chans.push(c)
         }
         const t = chans.length as SLType
-        return mk(this.owner, this.owner.add({ k: "swizzle", type: t, src: this.ref, chans }), t) as Widen<S>
+        return mk(this.owner, this.owner.add(withKind({ k: "swizzle", type: t, src: this.ref, chans }, this.kind)), t, this.kind) as Widen<S>
     }
 
     get x(): Float { return this.swz("x") }
@@ -160,9 +187,18 @@ export interface Float extends Val { readonly width: 1 }
 export interface Vec2 extends Val { readonly width: 2 }
 export interface Vec3 extends Val { readonly width: 3 }
 export interface Vec4 extends Val { readonly width: 4 }
+/** A value holding a bool, an int or a uint rather than floats. */
+export interface Bool extends Val { readonly width: 1; readonly kind: "bool" }
+export interface Int extends Val { readonly width: 1; readonly kind: "int" }
+export interface UInt extends Val { readonly width: 1; readonly kind: "uint" }
 
-function mk(b: Builder, ref: NodeRef, width: SLType): any {
-    return new Val(b, ref, width)
+function mk(b: Builder, ref: NodeRef, width: SLType, kind?: SLKind): any {
+    return new Val(b, ref, width, kind)
+}
+
+/** A node with its kind, which a float node leaves out so it keys and hashes as it always did. */
+function withKind<T extends SLNode>(n: T, kind: SLKind | undefined): T {
+    return kind === undefined ? n : { ...n, kind }
 }
 
 // MARK: recording context
@@ -233,19 +269,222 @@ function alignN(vs: Num[]): { refs: NodeRef[]; width: SLType } {
 
 /** float -> vecN by repeating the component. */
 function broadcast(v: Val, width: SLType): NodeRef {
-    return v.owner.add({ k: "swizzle", type: width, src: v.ref, chans: new Array(width).fill(0) })
+    return v.owner.add(withKind({ k: "swizzle", type: width, src: v.ref, chans: new Array(width).fill(0) }, v.kind))
 }
 
 function bin(op: SLOpCode, a: Val, o: Num): Val {
+    if (a.kind !== undefined || (typeof o !== "number" && o.kind !== undefined)) return kindedBin(op, a, o)
     const [x, y] = align2(a, o)
     const width = typeof o === "number" ? a.width : (Math.max(a.width, o.width) as SLType)
     return mk(a.owner, a.owner.call(op, width, [x, y]), width)
 }
 
 function un(op: SLOpCode, a: Val): Val {
+    if (a.kind !== undefined) {
+        if ((op === SLOP.NEG || op === SLOP.ABS) && a.kind === "int") return mk(a.owner, a.owner.call(op, a.width, [a.ref], undefined, a.kind), a.width, a.kind)
+        a = toFloat(a)
+    }
     return mk(a.owner, a.owner.call(op, a.width, [a.ref]), a.width)
 }
 
+// MARK: kinds (IR 4)
+
+/** The ops an int or a uint keeps its kind through. Anything else takes it as a float. */
+const INT_OPS = new Set<number>([SLOP.ADD, SLOP.SUB, SLOP.MUL, SLOP.DIV, SLOP.MOD, SLOP.MIN, SLOP.MAX, SLOP.CLAMP])
+
+/** A value as floats: itself when it already is, a conversion otherwise (a bool is 0 or 1). */
+export function toFloat(v: Val): Val {
+    if (v.kind === undefined) return v
+    return mk(v.owner, v.owner.call(SLOP.CAST, v.width, [v.ref]), v.width)
+}
+
+/**
+ * The operands of an op brought to one kind and one width.
+ *
+ * Two ints stay ints, and a whole number beside one is an int too. Anything
+ * else meeting a float, a bool among them, becomes a float, as HLSL converts
+ * it. An int and a uint are refused, since which one wins is a guess.
+ */
+function unify(vs: Num[]): { refs: NodeRef[]; width: SLType; kind: SLKind | undefined; owner: Builder } {
+    let owner: Builder | null = null
+    const kinds = new Set<SLKind | undefined>()
+    let width: SLType = 1
+    for (const v of vs) {
+        if (typeof v === "number") continue
+        if (owner === null) owner = v.owner
+        else if (v.owner !== owner) throw new SLError("a value from another program cannot be used in this one")
+        kinds.add(v.kind)
+        if (v.width > width) width = v.width
+    }
+    const b = owner ?? ctx()
+    if (kinds.has("int") && kinds.has("uint")) {
+        throw new SLError("cannot combine an int with a uint; convert one with int(...) or uint(...)")
+    }
+    let kind = kinds.size === 1 ? [...kinds][0] : undefined
+    if (kind === "bool") kind = undefined
+    if (kind !== undefined && vs.some((v) => typeof v === "number" && !Number.isInteger(v))) kind = undefined
+    const refs = vs.map((v) => {
+        if (typeof v === "number") return b.constant(new Array(width).fill(v), kind)
+        const x = kind === undefined ? toFloat(v) : v
+        if (x.width === width) return x.ref
+        if (x.width === 1) return broadcast(x, width)
+        throw new SLError(`cannot combine a ${widthName(x.width)} with a ${widthName(width)}`)
+    })
+    return { refs, width, kind, owner: b }
+}
+
+function kindedBin(op: SLOpCode, a: Val, o: Num): Val {
+    const { refs, width, kind, owner } = unify([a, o])
+    if (kind === undefined || !INT_OPS.has(op)) {
+        const x = mk(owner, refs[0]!, width) as Val
+        return bin(op, x, mk(owner, refs[1]!, width) as Val)
+    }
+    return mk(owner, owner.call(op, width, refs, undefined, kind), width, kind)
+}
+
+function compare(op: SLOpCode, a: Val, o: Num): Bool {
+    const { refs, width, kind, owner } = unify([a, o])
+    void kind
+    return mk(owner, owner.call(op, width, refs, undefined, "bool"), width, "bool")
+}
+
+/** A bool operand, a JS boolean made a constant. */
+function asBool(b: Builder, v: Val | boolean, what: string): Val {
+    if (typeof v === "boolean") return mk(b, b.constant([v ? 1 : 0], "bool"), 1, "bool")
+    if (v.kind !== "bool") throw new SLError(`${what} takes bools, and this is ${v.kind === undefined ? `a ${widthName(v.width)}` : `an ${v.kind}`}; compare it, as in x > 0`)
+    return v
+}
+
+function logic(op: SLOpCode, a: Val, o?: Val | boolean): Bool {
+    const name = op === SLOP.AND ? "&&" : op === SLOP.OR ? "||" : "!"
+    const x = asBool(a.owner, a, name)
+    if (o === undefined) return mk(a.owner, a.owner.call(op, x.width, [x.ref], undefined, "bool"), x.width, "bool")
+    const y = asBool(a.owner, o, name)
+    if (x.width !== y.width) throw new SLError(`cannot combine a bool${x.width} with a bool${y.width}`)
+    return mk(a.owner, a.owner.call(op, x.width, [x.ref, y.ref], undefined, "bool"), x.width, "bool")
+}
+
+function bits(op: SLOpCode, a: Val, o?: Num): Val {
+    const word = SL_HLSL[op]?.syntax ?? SL_NAME[op]
+    const intOnly = (v: Num) => {
+        if (typeof v === "number" ? !Number.isInteger(v) : v.kind !== "int" && v.kind !== "uint") {
+            throw new SLError(`${word} works on the bits of an int or a uint, and this is ${typeof v === "number" ? "a fraction" : v.kind === "bool" ? "a bool; use && or ||" : `a ${widthName(v.width)}`}`)
+        }
+    }
+    intOnly(a)
+    if (o === undefined) return mk(a.owner, a.owner.call(op, a.width, [a.ref], undefined, a.kind), a.width, a.kind)
+    intOnly(o)
+    // A shift's count is its own kind; the value shifted keeps its own.
+    if (op === SLOP.SHL || op === SLOP.SHR) {
+        const count = typeof o === "number" ? a.owner.constant([o], a.kind) : o.ref
+        return mk(a.owner, a.owner.call(op, a.width, [a.ref, count], undefined, a.kind), a.width, a.kind)
+    }
+    const { refs, width, kind, owner } = unify([a, o])
+    return mk(owner, owner.call(op, width, refs, undefined, kind), width, kind)
+}
+
+/** A conversion to `kind`, or to floats when it is undefined. A float to an int truncates toward zero, held to the int's range. */
+function convert(v: Num | boolean, kind: SLKind | undefined): Val {
+    const b = typeof v === "object" ? v.owner : ctx()
+    if (typeof v === "boolean") v = mk(b, b.constant([v ? 1 : 0], "bool"), 1, "bool") as Val
+    if (typeof v === "number") {
+        if (kind === undefined) return mk(b, b.constant([v]), 1)
+        if (kind === "bool") return mk(b, b.constant([v !== 0 ? 1 : 0], "bool"), 1, "bool")
+        // A whole number the kind holds is that number exactly (`747796405u`);
+        // anything else is a float converted, as the GPU would.
+        const exact = Number.isInteger(v) && (kind === "int" ? v >= -2147483648 && v <= 2147483647 : v >= 0 && v <= 4294967295)
+        return mk(b, b.constant([exact ? v : truncateHeld(v, kind)], kind), 1, kind)
+    }
+    if (v.kind === kind) return v
+    return mk(b, b.call(SLOP.CAST, v.width, [v.ref], undefined, kind), v.width, kind)
+}
+
+/** An int: a whole number, or a value converted, a float truncating toward zero. */
+export function int(v: Num | boolean): Int { return convert(v, "int") as Int }
+export function uint(v: Num | boolean): UInt { return convert(v, "uint") as UInt }
+/** A bool: true or false, or a value converted, where anything but zero is true. */
+export function bool(v: Num | boolean): Bool { return convert(v, "bool") as Bool }
+
+function choose(b: Builder, cond: Num | boolean, whenTrue: Num, whenFalse: Num): Val {
+    if (typeof cond === "boolean") return convertTo(cond ? whenTrue : whenFalse, whenTrue, whenFalse)
+    // What SELECT reads a float condition as, so the two agree.
+    const c = typeof cond === "number" ? asBool(b, cond >= 0.5, "a choice")
+        : cond.kind === "bool" ? cond : cond.kind === undefined ? cond.ge(0.5) : cond.ne(0)
+    if (c.width !== 1) throw new SLError("a choice takes one bool, and this is several; combine them with && or ||")
+    const { refs, width, kind, owner } = unify([whenTrue, whenFalse])
+    return mk(owner, owner.call(SLOP.CHOOSE, width, [c.ref, ...refs], undefined, kind), width, kind)
+}
+
+/** `v` as the type the two would unify to, for a choice whose condition is known. */
+function convertTo(v: Num, a: Num, c: Num): Val {
+    const { refs, width, kind, owner } = unify([a, c])
+    return mk(owner, v === a ? refs[0]! : refs[1]!, width, kind)
+}
+
+/**
+ * A real branch: only the side `cond` picks runs, and its results come back.
+ * Both sides give the same number of results, pairwise of one type; a plain
+ * number takes its partner's. A value only one side needs is computed only when
+ * that side runs.
+ */
+export function branch(cond: Val | boolean, whenTrue: () => Num[], whenFalse: () => Num[]): Val[] {
+    const b = ctx()
+    if (typeof cond === "boolean") return (cond ? whenTrue() : whenFalse()).map((v) => (typeof v === "number" ? float(v) : v))
+    const c = asBool(b, cond, "a branch")
+    if (c.width !== 1) throw new SLError("a branch takes one bool, and this is several; combine them with && or ||")
+    const t = whenTrue()
+    const f = whenFalse()
+    if (t.length !== f.length) throw new SLError(`a branch's sides give ${t.length} and ${f.length} results; they must give the same`)
+    const types = t.map((x, i) => pairType(x, f[i]!, i))
+    if (types.length === 0) return []
+    const node = b.add({ k: "if", cond: c.ref, then: t.map((v, i) => typed(b, v, types[i]!)), else: f.map((v, i) => typed(b, v, types[i]!)) })
+    return types.map((ty, i) => mk(b, b.add(withKind({ k: "proj", type: ty.width, src: node, index: i }, ty.kind)), ty.width, ty.kind))
+}
+
+/**
+ * A real loop. The values start as `init`; while `cond` of them holds, and
+ * fewer than `max` turns have run, they become `body` of them. What comes back
+ * is the values when it stops. `max` is what guarantees it stops: a loop that
+ * reaches it leaves as if its condition had failed.
+ */
+export function loop(init: Num[], cond: (v: Val[]) => Val | boolean, body: (v: Val[]) => Num[], max = 1024): Val[] {
+    const b = ctx()
+    if (!Number.isInteger(max) || max < 1) throw new SLError(`a loop's turn limit is a whole number from 1, got ${max}`)
+    const start = init.map((v) => (typeof v === "number" ? (float(v) as Val) : v))
+    const id = b.newLoop()
+    const params = start.map((v, i) => mk(b, b.add(withKind({ k: "param", type: v.width, loop: id, index: i }, v.kind)), v.width, v.kind) as Val)
+    const c = asBool(b, cond(params), "a loop's condition")
+    if (c.width !== 1) throw new SLError("a loop's condition is one bool, and this is several; combine them with && or ||")
+    const next = body(params)
+    if (next.length !== params.length) throw new SLError(`a loop carries ${params.length} values and its body gave ${next.length}`)
+    const ty = params.map((p) => ({ width: p.width, kind: p.kind }))
+    const node = b.add({
+        k: "loop", id, init: start.map((v) => v.ref), cond: c.ref,
+        next: next.map((v, i) => { pairType(params[i]!, v, i); return typed(b, v, ty[i]!) }), max,
+    })
+    return ty.map((t, i) => mk(b, b.add(withKind({ k: "proj", type: t.width, src: node, index: i }, t.kind)), t.width, t.kind))
+}
+
+interface ValType { width: SLType; kind: SLKind | undefined }
+
+/** The one type two results share, or why they do not. */
+function pairType(a: Num, c: Num, i: number): ValType {
+    if (typeof a === "number" && typeof c === "number") return { width: 1, kind: undefined }
+    if (typeof a === "number") return { width: (c as Val).width, kind: (c as Val).kind }
+    if (typeof c === "number") return { width: a.width, kind: a.kind }
+    if (a.width !== c.width || a.kind !== c.kind) {
+        const name = (v: Val) => (v.kind === undefined ? widthName(v.width) : v.width === 1 ? v.kind : `${v.kind}${v.width}`)
+        throw new SLError(`result ${i} is a ${name(a)} one way and a ${name(c)} the other`)
+    }
+    return { width: a.width, kind: a.kind }
+}
+
+/** A result as a node of its type, a plain number becoming a constant. */
+function typed(b: Builder, v: Num, t: ValType): NodeRef {
+    if (typeof v === "number") return b.constant(new Array(t.width).fill(v), t.kind)
+    return v.ref
+}
+
 // MARK: the public surface
 
 export interface ProgramInputs {
@@ -288,7 +527,7 @@ export function program(fn: (inputs: ProgramInputs) => Vec4): Program {
         }
         const nodes: SLNode[] = b.nodes.slice()
         return {
-            version: programVersion(nodes),
+            version: programVersion(nodes, out.ref),
             nodes,
             result: out.ref,
             uniforms: b.uniforms.slice(),
@@ -302,7 +541,8 @@ export function program(fn: (inputs: ProgramInputs) => Vec4): Program {
 
 export function float(v: Num): Float {
     const b = ctx()
-    return typeof v === "number" ? mk(b, b.constant([v]), TYPE.FLOAT) : (v as Float)
+    if (typeof v !== "number") return (v.kind === undefined ? v : toFloat(v)) as Float
+    return mk(b, b.constant([v]), TYPE.FLOAT)
 }
 
 /** Builds a wider value from narrower parts, which must add up exactly. */
@@ -478,8 +718,12 @@ export function atan2(y: Num, x: Num): Float {
  * rather than an `if`: a real branch would have to survive both backends
  * identically, and this does not.
  */
-export function select(cond: Num, whenTrue: Num, whenFalse: Num): Val {
+export function select(cond: Num | boolean, whenTrue: Num, whenFalse: Num): Val {
     const b = ctx()
+    const kinded = (v: Num | boolean) => typeof v === "object" && v.kind !== undefined
+    // A bool condition, or results that are not floats: a choice, which carries
+    // any kind, where SELECT's arithmetic carries only floats (IR 4).
+    if (typeof cond === "boolean" || kinded(cond) || kinded(whenTrue) || kinded(whenFalse)) return choose(b, cond, whenTrue, whenFalse)
     const c = typeof cond === "number" ? float(cond) : cond
     const t = typeof whenTrue === "number" ? float(whenTrue) : whenTrue
     const f = typeof whenFalse === "number" ? float(whenFalse) : whenFalse

package/src/structure.ts

@@ -0,0 +1,285 @@
+/**
+ * Where each node of a program is computed: the region tree an emitter prints.
+ *
+ * The IR is a graph, and an `if` or a `loop` (IR 4) is a node whose regions are
+ * the parts of the graph it runs (`ir.ts`, `ControlNode`). A node belongs to no
+ * region by itself; this places it in the innermost one that every use of it is
+ * inside. So a value only a branch needs is computed only when that branch
+ * runs, one a loop's body needs is computed each turn, and one that is also
+ * needed outside is computed once, before either. Nothing is hoisted out of the
+ * region it is used in, which is what an author who wrote it there expects.
+ *
+ * It also says which regions run in control flow that differs from one pixel
+ * to the next. A texture sample there has no neighbours to take its mip level
+ * from (WGSL refuses one outright), so every emitter samples at level 0 in such
+ * a region, and every backend draws the same picture.
+ */
+
+import { INPUTS, operands, reachable, type NodeRef, type Program, type SLNode } from "./ir"
+import { SLOP } from "./ops"
+
+export interface Region {
+    id: number
+    /** The region this one is inside; null for the root, the whole function. */
+    parent: number | null
+    /** The `if` or `loop` whose region this is; null for the root. */
+    owner: NodeRef | null
+    role: "root" | "then" | "else" | "cond" | "body"
+    depth: number
+    /** Runs in control flow that differs between pixels. */
+    varying: boolean
+    /**
+     * The nodes placed here, each after what it reads: depth first from the
+     * result, operands in order, which is the order a program with no control
+     * flow has always been printed in.
+     */
+    nodes: NodeRef[]
+}
+
+export interface Structure {
+    regions: Region[]
+    /** The region each reachable node is placed in. */
+    placed: Map<NodeRef, number>
+    /** An `if`'s then and else regions; a `loop`'s cond and body regions (the body inside the cond). */
+    children: Map<NodeRef, [number, number]>
+    /** The values that can differ from one pixel to the next. */
+    varying: Set<NodeRef>
+}
+
+/** Inputs that differ per pixel. The others are one value for the whole draw. */
+const PER_PIXEL = new Set<string>(["uv", "fragCoord"] satisfies Array<keyof typeof INPUTS>)
+
+export function structure(p: Program): Structure {
+    const nodes = p.nodes
+    const reach = reachable(nodes, p.result)
+    const regions: Region[] = []
+    const placed = new Map<NodeRef, number>()
+    const children = new Map<NodeRef, [number, number]>()
+    const uses = new Map<NodeRef, number[]>()
+
+    const region = (parent: number | null, owner: NodeRef | null, role: Region["role"]): number => {
+        const id = regions.length
+        regions.push({ id, parent, owner, role, depth: parent === null ? 0 : regions[parent]!.depth + 1, varying: false, nodes: [] })
+        return id
+    }
+    const use = (ref: NodeRef, at: number) => {
+        const list = uses.get(ref)
+        if (list === undefined) uses.set(ref, [at])
+        else list.push(at)
+    }
+    const lca = (a: number, b: number): number => {
+        let x = a, y = b
+        while (regions[x]!.depth > regions[y]!.depth) x = regions[x]!.parent!
+        while (regions[y]!.depth > regions[x]!.depth) y = regions[y]!.parent!
+        while (x !== y) { x = regions[x]!.parent!; y = regions[y]!.parent! }
+        return x
+    }
+    const inside = (inner: number, outer: number): boolean => {
+        let r: number | null = inner
+        while (r !== null) { if (r === outer) return true; r = regions[r]!.parent }
+        return false
+    }
+
+    const root = region(null, null, "root")
+    use(p.result, root)
+    const loopRegion = new Map<number, number>()
+
+    // Latest first: every use of a node is a later node, so it is placed by then.
+    for (let i = reach.length - 1; i >= 0; i--) {
+        const ref = reach[i]!
+        const n = nodes[ref]!
+        let at: number
+        if (n.k === "param") {
+            const cond = loopRegion.get(n.loop)
+            if (cond === undefined) throw new Error(`node ${ref} is a param of loop ${n.loop}, which nothing reaches`)
+            at = cond
+            for (const u of uses.get(ref) ?? []) {
+                if (!inside(u, cond)) throw new Error(`node ${ref}, a param of loop ${n.loop}, is read outside that loop`)
+            }
+        } else {
+            const list = uses.get(ref)
+            if (list === undefined) throw new Error(`node ${ref} is reachable and has no use`)
+            at = list.reduce(lca)
+        }
+        placed.set(ref, at)
+        regions[at]!.nodes.push(ref)
+        if (n.k === "if") {
+            const then = region(at, ref, "then")
+            const otherwise = region(at, ref, "else")
+            children.set(ref, [then, otherwise])
+            use(n.cond, at)
+            for (const r of n.then) use(r, then)
+            for (const r of n.else) use(r, otherwise)
+        } else if (n.k === "loop") {
+            const cond = region(at, ref, "cond")
+            const body = region(cond, ref, "body")
+            children.set(ref, [cond, body])
+            loopRegion.set(n.id, cond)
+            for (const r of n.init) use(r, at)
+            use(n.cond, cond)
+            for (const r of n.next) use(r, body)
+        } else {
+            for (const a of operands(n)) use(a, at)
+        }
+    }
+    const order = postOrder(nodes, p.result)
+    for (const r of regions) r.nodes.sort((x, y) => order.get(x)! - order.get(y)!)
+
+    const varying = varyingValues(nodes, reach)
+    // A region varies if the one it is in does, or if its own condition does.
+    for (const r of regions) {
+        if (r.parent === null) continue
+        const owner = nodes[r.owner!]!
+        const cond = owner.k === "if" || owner.k === "loop" ? owner.cond : -1
+        r.varying = regions[r.parent]!.varying || varying.has(cond)
+    }
+    return { regions, placed, children, varying }
+}
+
+/** Each reachable node's place in a depth first walk from the result, operands in order, each after its operands. */
+function postOrder(nodes: readonly SLNode[], result: NodeRef): Map<NodeRef, number> {
+    const order = new Map<NodeRef, number>()
+    let next = 0
+    const walk = (ref: NodeRef): void => {
+        if (order.has(ref)) return
+        order.set(ref, -1)
+        for (const a of operands(nodes[ref]!)) walk(a)
+        order.set(ref, next++)
+    }
+    walk(result)
+    return order
+}
+
+/**
+ * The values that can differ between pixels: the per pixel inputs, texture
+ * samples, and anything computed from one. A loop's params differ when their
+ * start, their next value or the loop's condition does, which depends on the
+ * params, so it is found by going round until nothing changes.
+ */
+function varyingValues(nodes: readonly SLNode[], reach: NodeRef[]): Set<NodeRef> {
+    const out = new Set<NodeRef>()
+    const params = new Map<number, NodeRef[]>()
+    for (const ref of reach) {
+        const n = nodes[ref]!
+        if (n.k === "param") params.set(n.loop, [...(params.get(n.loop) ?? []), ref])
+    }
+    for (let changed = true; changed;) {
+        changed = false
+        const mark = (ref: NodeRef) => { if (!out.has(ref)) { out.add(ref); changed = true } }
+        for (const ref of reach) {
+            const n = nodes[ref]!
+            switch (n.k) {
+                case "input": if (PER_PIXEL.has(n.name)) mark(ref); break
+                case "call":
+                    if (n.op === SLOP.SAMPLE || n.op === SLOP.SAMPLE_LOD || n.args.some((a) => out.has(a))) mark(ref)
+                    break
+                case "swizzle": if (out.has(n.src)) mark(ref); break
+                case "proj": {
+                    const src = nodes[n.src]!
+                    if (src.k === "if" && (out.has(src.cond) || out.has(src.then[n.index]!) || out.has(src.else[n.index]!))) mark(ref)
+                    if (src.k === "loop") {
+                        const param = (params.get(src.id) ?? []).find((q) => (nodes[q] as { index: number }).index === n.index)
+                        if (out.has(src.cond) || out.has(src.init[n.index]!) || out.has(src.next[n.index]!) || (param !== undefined && out.has(param))) mark(ref)
+                    }
+                    break
+                }
+                case "loop":
+                    for (const q of params.get(n.id) ?? []) {
+                        const i = (nodes[q] as { index: number }).index
+                        if (out.has(n.cond) || out.has(n.init[i]!) || out.has(n.next[i]!)) mark(q)
+                    }
+                    break
+                default: break
+            }
+        }
+    }
+    return out
+}
+
+/**
+ * How a language spells the statements a structured body is printed with. The
+ * expressions are the emitter's own; this is only the frame around them.
+ */
+export interface Syntax {
+    /** A value node's local, initialised: `float n3 = expr;` */
+    value(ref: NodeRef, expr: string): string
+    /** A local that is assigned later, typed as `like` is: an if's or a loop's result. */
+    mutable(name: string, like: NodeRef, init?: string): string
+    /** A loop's turn counter, from 0. */
+    counter(name: string): string
+    assign(name: string, value: string): string
+    increment(name: string): string
+    ifOpen(cond: string): string
+    elseOpen: string
+    close: string
+    loopOpen: string
+    /** Leaves the loop unless `cond` holds and `turns` is under `max`. */
+    breakUnless(cond: string, turns: string, max: number): string
+}
+
+/** A node's local. */
+export const local = (ref: NodeRef): string => `n${ref}`
+
+/**
+ * Prints the body: every placed node in its region, each `if` and `loop` with
+ * its regions inside it. `expr` prints a value node's expression; the result is
+ * `local(p.result)` for the caller to return.
+ */
+export function printBody(p: Program, s: Structure, syntax: Syntax, expr: (ref: NodeRef) => string, indent: string): string[] {
+    const lines: string[] = []
+    const loopRef = new Map<number, NodeRef>()
+    for (const [ref, n] of p.nodes.entries()) if (n.k === "loop") loopRef.set(n.id, ref)
+    const result = (ref: NodeRef, i: number) => `r${ref}_${i}`
+    const carried = (ref: NodeRef, i: number) => `l${ref}_${i}`
+
+    const region = (id: number, ind: string): void => {
+        for (const ref of s.regions[id]!.nodes) {
+            const n = p.nodes[ref]!
+            switch (n.k) {
+                case "if": {
+                    const [then, otherwise] = s.children.get(ref)!
+                    n.then.forEach((r, i) => lines.push(ind + syntax.mutable(result(ref, i), r)))
+                    lines.push(ind + syntax.ifOpen(local(n.cond)))
+                    region(then, ind + "    ")
+                    n.then.forEach((r, i) => lines.push(ind + "    " + syntax.assign(result(ref, i), local(r))))
+                    lines.push(ind + syntax.elseOpen)
+                    region(otherwise, ind + "    ")
+                    n.else.forEach((r, i) => lines.push(ind + "    " + syntax.assign(result(ref, i), local(r))))
+                    lines.push(ind + syntax.close)
+                    break
+                }
+                case "loop": {
+                    const [cond, body] = s.children.get(ref)!
+                    const turns = `l${ref}_turns`
+                    n.init.forEach((r, i) => lines.push(ind + syntax.mutable(carried(ref, i), r, local(r))))
+                    lines.push(ind + syntax.counter(turns))
+                    lines.push(ind + syntax.loopOpen)
+                    region(cond, ind + "    ")
+                    lines.push(ind + "    " + syntax.breakUnless(local(n.cond), turns, n.max))
+                    lines.push(ind + "    " + syntax.increment(turns))
+                    region(body, ind + "    ")
+                    n.next.forEach((r, i) => lines.push(ind + "    " + syntax.assign(carried(ref, i), local(r))))
+                    lines.push(ind + syntax.close)
+                    break
+                }
+                case "param":
+                    lines.push(ind + syntax.value(ref, carried(loopRef.get(n.loop)!, n.index)))
+                    break
+                case "proj": {
+                    const src = p.nodes[n.src]!
+                    lines.push(ind + syntax.value(ref, src.k === "loop" ? carried(n.src, n.index) : result(n.src, n.index)))
+                    break
+                }
+                default:
+                    lines.push(ind + syntax.value(ref, expr(ref)))
+            }
+        }
+    }
+    region(0, indent)
+    return lines
+}
+
+/** Whether a node is computed where a sample has no neighbours to take a mip level from. */
+export function inVaryingFlow(s: Structure, ref: NodeRef): boolean {
+    return s.regions[s.placed.get(ref)!]!.varying
+}