onejs-sl 0.2.1 → 0.3.0

package/src/lang/parser.ts

@@ -344,8 +344,8 @@ class Parser {
         if (t.text === "for") return this.parseFor()
         if (t.text === "while" || t.text === "do") {
             this.fail(
-                `there is no ${t.text} loop: the VM has no branches, so a loop has to unroll, and ` +
-                `only a for loop with constant bounds can. See a for loop`,
+                `there is no ${t.text} loop: a loop unrolls at build time, and only a for loop ` +
+                `with constant bounds can. See a for loop`,
                 t,
             )
         }

package/src/lang/prelude.ts

@@ -7,8 +7,8 @@
  *
  * ADDING TO IT COSTS A FUNCTION AND A TEST, NOT AN OPCODE IN THREE PLACES. That
  * is the whole argument for having a text language with inlining functions: a
- * library entry is source, so it lands in the VM, in generated HLSL and in the
- * hash by being ordinary code, and neither backend learns anything new.
+ * library entry is source, so it lands in every emitter's output and in the
+ * hash by being ordinary code, and no backend learns anything new.
  *
  * WHY THE SOURCE IS A STRING AND NOT A FILE. `onejs-sl` ships raw TypeScript
  * and runs inside a browser worker on play.onejs.com, where

package/src/ops.ts

@@ -1,10 +1,9 @@
 /**
  * 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.
+ * Phase 1 of `Specs/SHADER_LANG.md`. The numbers are in every program's hash
+ * and in its JSON, so an opcode keeps its number for good, and one that goes
+ * leaves its number unused.
  *
  * Numbered in families with gaps, the convention `fx/ops.ts` set, so a reader
  * can tell what an opcode is from its value:
@@ -22,18 +21,6 @@
  * 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
-
 /**
  * How many uniforms and textures one program may declare: the language's caps,
  * for a host to read.
@@ -50,11 +37,7 @@ export const SL_WIRE_VERSION = 2
 export const UNIFORM_SLOTS = 16
 export const TEXTURE_SLOTS = 4
 
-/** The VM's names for the same two caps, which go when the VM does. */
-export const VM_UNIFORMS = UNIFORM_SLOTS
-export const VM_TEXTURES = TEXTURE_SLOTS
-
-/** Input ids, fixed here because the shader switches on them. */
+/** Input ids, which the web emitter switches on. */
 export const INPUT_ID: Record<string, number> = {
     uv: 0, fragCoord: 1, resolution: 2, time: 3, aspect: 4,
 }
@@ -136,10 +119,7 @@ export const SLOP = {
     // 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,
+    // 135 was SDF_WIDE, the VM's form of an SDF with more than four parameters.
 
     // Sampling
     SAMPLE: 144,
@@ -149,7 +129,7 @@ export const SLOP = {
 export type SLOpCode = (typeof SLOP)[keyof typeof SLOP]
 
 /**
- * How many arguments each op takes, for validation and for the encoder.
+ * How many arguments each op takes, for validation.
  *
  * -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
@@ -177,7 +157,7 @@ export const SL_ARITY: Record<number, number> = {
     [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.VORONOI]: 1, [SLOP.TURBULENCE]: 1, [SLOP.RIDGED]: 1,
 
     [SLOP.SAMPLE]: 1, [SLOP.SAMPLE_LOD]: 2,
 }
@@ -187,18 +167,10 @@ 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
+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.
+ * Ops that read a texture.
  */
 export function isSampling(op: number): boolean {
     return op >= FIRST_SAMPLING
@@ -292,7 +264,6 @@ export const SL_HLSL: Record<number, SLSurface> = {
     [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" },
@@ -303,16 +274,15 @@ export const SL_HLSL: Record<number, SLSurface> = {
  *
  * 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.
+ * nothing: the emitters have no case for them. 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.RGB2HSV]: "no backend has a case for it yet",
+    [SLOP.SAMPLE_LOD]: "no backend samples at an explicit LOD yet; use tex2D",
     [SLOP.REMAP]: "the surface form is a macro over arithmetic, so the opcode is unused",
 }
 

package/src/serial.ts

@@ -55,7 +55,7 @@ export function fromJSON(json: unknown): Program {
     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: [] }
+    return { version: SL_IR_VERSION, nodes, result: result!, uniforms, textures, hash }
 }
 
 function node(n: unknown, i: number): SLNode {

package/src/sl.ts

@@ -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.
@@ -294,7 +294,6 @@ export function program(fn: (inputs: ProgramInputs) => Vec4): Program {
             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.
@@ -597,13 +585,9 @@ export function parseColor(hex: string): [number, number, number, number] {
 export function ramp(t: Num, stops: Array<string | [number, number, number, number]>): 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.
+    // 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 v = typeof stops[i] === "string" ? parseColor(stops[i] as string) : (stops[i] as number[])
         return vec4(v[0], v[1], v[2], v[3])
@@ -733,34 +717,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,
@@ -159,7 +158,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])
@@ -182,7 +181,7 @@ function emitWeb(p: Program, lang: WebLanguage): string {
             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.`,
                 )
         }