onejs-sl 0.2.0 → 0.2.1

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.2.1
+
+A program built in code or read from JSON is refused past 16 uniforms or 4 textures, as a `.sl` file already was, instead of compiling and then drawing differently on different hosts. A host can read both caps.
+
+### Fixed
+
+- 0.2.0 regression: `compile()` dropped `encode()`'s texture check, so a program built in code with a fifth texture compiled and then sampled nothing in the editor and a native player
+
+### Changed
+
+- `sl.texture` and `sl.uniform` refuse past the caps where they are declared, in the parser's words
+- `compile` and `fromJSON` refuse a program past either cap, however it was made
+- `onejs-sl/core` exports `UNIFORM_SLOTS` (16) and `TEXTURE_SLOTS` (4), which the parser and the builder both read
+- `MAX_TEXTURES` is a deprecated alias of `TEXTURE_SLOTS`, so 4 rather than 15
+- `VM_UNIFORMS` and `VM_TEXTURES` are the same numbers, and go with the VM
+- The parser's cap messages give OneJS's slots as the reason
+
 ## 0.2.0
 
 `compile()` replaces `encode()` for every host that draws compiled: it gives a program's hash, names, defaults and sources with no VM buffer and no budget, so a long program or one with many values at once compiles. Program hashes do not change.

package/README.md

@@ -36,7 +36,7 @@ only what it calls.
 | Entry | Contents |
 |---|---|
 | `onejs-sl` | `parse` and `analyze`, `diagnose` (every error in a file, not just the first), `classify` (every token with its class, comments kept, never throws), `fromGLSL` (a pasted Shadertoy or WebGL shader as a `.sl` file, with notes on what did not carry over), the TypeScript form `sl`, the IR types, `SL_IR_VERSION`, `toJSON`/`fromJSON`, `SLParseError` (file, line, column, offset, length, the bare `text`, and a `fix` where one is certain) |
-| `onejs-sl/core` | the same without the parser: what a game needs at run time |
+| `onejs-sl/core` | the same without the parser: what a game needs at run time. Also the caps on one program, `UNIFORM_SLOTS` (16) and `TEXTURE_SLOTS` (4), which the parser and the builder enforce and a host can read |
 | `onejs-sl/tables` | `BUILTINS`, `SL_HLSL`, `INPUTS`, `SL_SDF_SHAPES`, `SL_SDF_PARAMS`, `SL_KEYWORDS`, `SL_TYPES`, `TYPE_WIDTH`, `PRELUDE_NAMES`: what completion and highlighting read. `BUILTIN_PARAMS`, `SL_SDF_PARAM_NAMES` and `LIB_SIGNATURES` name every parameter, so an editor can show `lerp(x, y, s)`, and `BUILTIN_DOCS`, `INPUT_DOCS` and `PRELUDE_DOCS` give each a line for its tooltip |
 | `onejs-sl/compile` | `compile(program)`: what a host draws a program with. Its hash, its uniform and texture names in slot order, their defaults, and `hlsl`, `wgsl` and `glsl` as lazy getters. No budget |
 | `onejs-sl/limits` | `vmFit(program)`: whether the VM runs it, and why not. The VM's, until it is deleted |

package/goldens/goldens.json

@@ -1,6 +1,6 @@
 {
  "generatedBy": "onejs-sl goldens/run.mjs",
- "package": "0.2.0",
+ "package": "0.2.1",
  "ir": 2,
  "target": "rgba8unorm-srgb: straight alpha, 8 bit, sRGB encoded, the stored bytes of a Linear OneJS game's element",
  "size": [

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "onejs-sl",
-  "version": "0.2.0",
+  "version": "0.2.1",
   "description": "The OneJS shader language: a small typed language for per pixel programs, compiled to a portable IR and emitted as HLSL, WGSL, GLSL ES or a VM buffer",
   "main": "src/index.ts",
   "types": "src/index.ts",

package/src/compile.ts

@@ -12,7 +12,7 @@
  * shader does. `Specs/SL_NEXT.md` section 0.5, step 3.
  */
 
-import type { Program } from "./ir"
+import { checkCaps, type Program } from "./ir"
 import { emitShader } from "./hlsl"
 import { emitGLSL, emitWGSL } from "./web"
 import { uniformDefaults } from "./sl"
@@ -69,6 +69,7 @@ export interface Compiled {
 }
 
 export function compile(program: Program): Compiled {
+    checkCaps(program)
     const compiled = {
         hash: program.hash,
         // Slot order, which is declaration order: Builder.uniform pushes and

package/src/core.ts

@@ -16,7 +16,7 @@ export {
 export type {
     SLType, InputName, NodeRef, SLNode, Program, UniformDecl, UniformControl, TextureDecl,
 } from "./ir"
-export { SLOP, SL_ARITY, SL_NAME, INPUT_ID, isSampling } from "./ops"
+export { SLOP, SL_ARITY, SL_NAME, INPUT_ID, isSampling, UNIFORM_SLOTS, TEXTURE_SLOTS } from "./ops"
 export type { SLOpCode } from "./ops"
 export { SL_SDF_SHAPES, SL_SDF_PARAMS } from "./shapes"
 export type { SlSdfKind } from "./shapes"

package/src/encode.ts

@@ -24,9 +24,9 @@
  */
 
 import {
-    MAX_TEXTURES, SLError, TYPE, reachable, type NodeRef, type Program, type SLNode, type SLType,
+    SLError, TYPE, reachable, type NodeRef, type Program, type SLNode, type SLType,
 } from "./ir"
-import { INPUT_ID, SLOP } from "./ops"
+import { INPUT_ID, SLOP, TEXTURE_SLOTS } from "./ops"
 import { compile, type Compiled } from "./compile"
 
 // Lives in ops.ts with the other wire constants; re-exported so nothing that
@@ -188,7 +188,7 @@ export function checkBudget(program: Program, order: NodeRef[]): void {
         )
     }
     for (const t of program.textures) {
-        if (t.slot >= MAX_TEXTURES) throw new SLError(`texture "${t.name}" is past the sampler budget`)
+        if (t.slot >= TEXTURE_SLOTS) throw new SLError(`texture "${t.name}" is past the sampler budget`)
     }
 }
 

package/src/ir.ts

@@ -26,7 +26,7 @@
  * them, and it is fully testable with no GPU.
  */
 
-import { SLOP, SL_ARITY, SL_NAME, type SLOpCode } from "./ops"
+import { SLOP, SL_ARITY, SL_NAME, TEXTURE_SLOTS, UNIFORM_SLOTS, type SLOpCode } from "./ops"
 
 /** Component count. The only notion of type the IR has. */
 export const TYPE = { FLOAT: 1, VEC2: 2, VEC3: 3, VEC4: 4 } as const
@@ -199,11 +199,38 @@ export interface Program {
 }
 
 /**
- * Sampler slots in a fragment shader on the WebGL2 baseline, minus one for the
- * program texture itself. Exceeding it is refused when the program is written
- * rather than when it is drawn, with a message naming the limit.
+ * @deprecated Use `TEXTURE_SLOTS`. Was 15, the WebGL2 sampler count, which let a
+ * program declare textures no native host binds.
  */
-export const MAX_TEXTURES = 15
+export const MAX_TEXTURES = TEXTURE_SLOTS
+
+/**
+ * The refusals for a program past its caps, worded once for the parser (a
+ * `file`) and the builder (a `program`) so the two cannot drift apart.
+ */
+export function tooManyUniforms(declared: number, source: "file" | "program"): string {
+    return `this ${source} declares ${declared} uniforms and a program may hold ${UNIFORM_SLOTS}. ` +
+        `OneJS keeps a program's uniforms in ${UNIFORM_SLOTS} slots, so this one would have no ` +
+        `slot of its own; it is refused here rather than drawn wrong. Pack related values into ` +
+        `a ${source === "file" ? "float4" : "vec4"}.`
+}
+
+export function tooManyTextures(declared: number, source: "file" | "program"): string {
+    return `this ${source} declares ${declared} textures and a program may sample ${TEXTURE_SLOTS}. ` +
+        `OneJS binds ${TEXTURE_SLOTS} textures to a program in the editor and a native player, so ` +
+        `this one would sample nothing there while a browser drew it: two pictures from one ${source}.`
+}
+
+/**
+ * Refuses a finished program past either cap. The parser and the builder
+ * refuse at the declaration, where the message can point at it; this is for
+ * a program that arrived some other way, stored as JSON or put together by
+ * hand, and `compile` runs it so nothing reaches a host around it.
+ */
+export function checkCaps(p: Pick<Program, "uniforms" | "textures">): void {
+    if (p.uniforms.length > UNIFORM_SLOTS) throw new SLError(tooManyUniforms(p.uniforms.length, "program"))
+    if (p.textures.length > TEXTURE_SLOTS) throw new SLError(tooManyTextures(p.textures.length, "program"))
+}
 
 /** Instructions a single program may hold. Generous; the ceiling that matters is registers. */
 export const MAX_NODES = 4096
@@ -288,6 +315,7 @@ export class Builder {
         const problem = controlProblem(type, value, control)
         if (problem !== null) throw new SLError(`uniform "${name}": ${problem.message}`)
         const slot = this.uniforms.length
+        if (slot >= UNIFORM_SLOTS) throw new SLError(tooManyUniforms(slot + 1, "program"))
         const decl: UniformDecl = { name, type, value: value.slice() }
         if (colour) decl.colour = true
         Object.assign(decl, controlOf(control))
@@ -298,12 +326,8 @@ export class Builder {
     texture(name: string): number {
         const existing = this.textures.findIndex((t) => t.name === name)
         if (existing >= 0) return this.textures[existing].slot
-        if (this.textures.length >= MAX_TEXTURES) {
-            throw new SLError(
-                `a program may sample at most ${MAX_TEXTURES} textures, and this one asks for ` +
-                `${this.textures.length + 1}. That ceiling is the fragment shader's sampler slots ` +
-                `on the WebGL2 baseline, so it cannot be widened.`,
-            )
+        if (this.textures.length >= TEXTURE_SLOTS) {
+            throw new SLError(tooManyTextures(this.textures.length + 1, "program"))
         }
         const slot = this.textures.length
         this.textures.push({ name, slot })

package/src/lang/check.ts

@@ -28,8 +28,8 @@
  * is refused with the reason.
  */
 
-import { DERIVED_INPUTS, INPUTS } from "../ir"
-import { VM_TEXTURES, VM_UNIFORMS } from "../ops"
+import { DERIVED_INPUTS, INPUTS, tooManyTextures, tooManyUniforms } from "../ir"
+import { TEXTURE_SLOTS, UNIFORM_SLOTS } from "../ops"
 import { SL_GLSL_HINT } from "../ops"
 import { BUILTINS, NOT_YET } from "./builtins"
 import { SL_SDF_SHAPES } from "../shapes"
@@ -161,15 +161,9 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         if (!uniforms.has(u.name)) uniforms.set(u.name, u)
     }
     attempt(() => {
-        if (uniforms.size <= VM_UNIFORMS) return
-        const over = unit.uniforms[VM_UNIFORMS]!
-        fail(
-            `this file declares ${uniforms.size} uniforms and a program may hold ${VM_UNIFORMS}. ` +
-            `That is the size of the VM's uniform array; past it a slot reads the last one instead ` +
-            `of its own, so it is refused here rather than rendered wrong. Pack related values into ` +
-            `a float4.`,
-            over.pos, over.name.length,
-        )
+        if (uniforms.size <= UNIFORM_SLOTS) return
+        const over = unit.uniforms[UNIFORM_SLOTS]!
+        fail(tooManyUniforms(uniforms.size, "file"), over.pos, over.name.length)
     })
 
     for (const t of unit.textures) {
@@ -180,14 +174,9 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         if (!textures.has(t.name)) textures.set(t.name, t)
     }
     attempt(() => {
-        if (textures.size <= VM_TEXTURES) return
-        const over = unit.textures[VM_TEXTURES]!
-        fail(
-            `this file declares ${textures.size} textures and a program may sample ${VM_TEXTURES}. ` +
-            `The VM shader declares four samplers; a fifth would sample the fourth in the browser ` +
-            `and its own after an eject, which is two different pictures from one file.`,
-            over.pos, over.name.length,
-        )
+        if (textures.size <= TEXTURE_SLOTS) return
+        const over = unit.textures[TEXTURE_SLOTS]!
+        fail(tooManyTextures(textures.size, "file"), over.pos, over.name.length)
     })
 
     for (const c of unit.consts) {

package/src/ops.ts

@@ -35,17 +35,24 @@
 export const SL_WIRE_VERSION = 2
 
 /**
- * What the VM shader actually declares, and therefore what a program may use.
+ * How many uniforms and textures one program may declare: the language's caps,
+ * for a host to read.
  *
- * `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.
+ * They are what OneJS draws a program with. It keeps a program's uniforms in
+ * 16 slots in the editor, a native player and a browser alike
+ * (`SLProgramBridge.MaxUniforms`, the web frame's `sl_U`), and binds four
+ * textures in the editor and a native player (`_Tex0` to `_Tex3`). A program
+ * past either has something with no slot of its own, which one host would drop
+ * and another would draw, so the parser and the builder both refuse it at the
+ * declaration, the parser with a file and a line. `Specs/SL_NEXT.md` section 8
+ * proposes raising both.
  */
-export const VM_UNIFORMS = 16
-export const VM_TEXTURES = 4
+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. */
 export const INPUT_ID: Record<string, number> = {

package/src/serial.ts

@@ -9,7 +9,7 @@
  * older one is migrated to this one and rehashed under it.
  */
 import {
-    INPUTS, SLError, SL_IR_VERSION, TYPE, controlOf, controlProblem, hashProgram,
+    INPUTS, SLError, SL_IR_VERSION, TYPE, checkCaps, controlOf, controlProblem, hashProgram,
     type NodeRef, type Program, type SLNode, type SLType, type TextureDecl, type UniformDecl,
 } from "./ir"
 import { SL_ARITY, SL_NAME } from "./ops"
@@ -44,6 +44,7 @@ export function fromJSON(json: unknown): Program {
     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)
+    checkCaps({ uniforms, textures })
     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`)
     }

package/src/web.ts

@@ -29,12 +29,12 @@ import { SLError, TYPE, type Program, type SLNode, type SLType } from "./ir"
 import { libClosure, libIndex, LIB_FUNCTIONS, SDF_CALLS } from "./lib"
 import { LIB_GLSL } from "./lib/glsl"
 import { LIB_WGSL } from "./lib/wgsl"
-import { INPUT_ID, SLOP, VM_UNIFORMS } from "./ops"
+import { INPUT_ID, SLOP, UNIFORM_SLOTS } from "./ops"
 
 export type WebLanguage = "glsl" | "wgsl"
 
 /** Uniform slots the host always provides, so every program shares one layout. */
-export const WEB_UNIFORM_SLOTS = VM_UNIFORMS
+export const WEB_UNIFORM_SLOTS = UNIFORM_SLOTS
 
 export function emitGLSL(p: Program): string {
     return emitWeb(p, "glsl")