onejs-sl 0.5.0 → 0.7.0

package/src/compile.ts

@@ -11,7 +11,7 @@
  * are the only refusal (`checkCaps`).
  */
 
-import { checkCaps, type Program } from "./ir"
+import { checkCaps, readsOf, type Program, type SLReads } from "./ir"
 import { emitShader } from "./hlsl"
 import { emitGLSL, emitWGSL } from "./web"
 import { uniformDefaults } from "./sl"
@@ -46,6 +46,15 @@ export interface Compiled {
      * Setting a material property called `grain` bound nothing, silently.
      */
     textures: string[]
+    /**
+     * What the program needs its host to keep from one frame to the next: the
+     * previous frame, the frame count, the step (`Specs/SL_NEXT.md` 4). A host
+     * keeps a history pair only for a program that reads `previous`, and one
+     * that cannot provide something here refuses the program rather than
+     * drawing it as if nothing came before. A host that carries a compiled
+     * program elsewhere, as OneJS's `.sl` import does, has to carry this too.
+     */
+    reads: SLReads
     /**
      * The program as HLSL, for a host that can compile it.
      *
@@ -76,6 +85,7 @@ export function compile(program: Program): Compiled {
         uniforms: program.uniforms.map((u) => u.name),
         defaults: uniformDefaults(program),
         textures: program.textures.map((t) => t.name),
+        reads: readsOf(program),
     } as Compiled
     let hlsl: string | undefined
     let wgsl: string | undefined

package/src/core.ts

@@ -8,13 +8,13 @@
  * game never executes.
  */
 export * as sl from "./sl"
-export type { Float, Vec2, Vec3, Vec4, Num, ProgramInputs, Texture } from "./sl"
+export type { Float, Vec2, Vec3, Vec4, Num, ProgramInputs, PreviousFrame, Texture } from "./sl"
 export {
-    TYPE, INPUTS, MAX_NODES, SLError, hashProgram, widthName, SL_IR_VERSION, SL_HASH_VERSION, inputsUsed,
-    CONTROL_FIELDS, controlProblem,
+    TYPE, INPUTS, STEP_INPUTS, PREVIOUS, MAX_NODES, SLError, hashProgram, widthName, SL_IR_VERSION, SL_HASH_VERSION,
+    inputsUsed, readsOf, CONTROL_FIELDS, controlProblem,
 } from "./ir"
 export type {
-    SLType, InputName, NodeRef, SLNode, Program, UniformDecl, UniformControl, TextureDecl,
+    SLType, InputName, StepInputName, HostInputName, SLReads, NodeRef, SLNode, Program, UniformDecl, UniformControl, TextureDecl,
 } from "./ir"
 export { SLOP, SL_ARITY, SL_NAME, INPUT_ID, isSampling, UNIFORM_SLOTS, TEXTURE_SLOTS } from "./ops"
 export type { SLOpCode } from "./ops"

package/src/hlsl.ts

@@ -15,7 +15,7 @@
  * next time it is generated.
  */
 
-import { SLError, SL_HASH_VERSION, type Program } from "./ir"
+import { SLError, SL_HASH_VERSION, readsOf, type Program } from "./ir"
 import { emitBody, lit, type BodyTarget } from "./body"
 
 /** The property name a uniform gets. Prefixed so it cannot collide with ours. */
@@ -48,6 +48,7 @@ export function emitShader(p: Program, options: EmitOptions = {}): string {
     const name = options.name ?? `Hidden/SLGenerated/${p.hash}`
     const include = options.include ?? "SLCommon.cginc"
     const body = emitFragmentBody(p)
+    const reads = readsOf(p)
 
     const props: string[] = [
         `        _Secs ("Seconds", Float) = 0`,
@@ -69,6 +70,16 @@ export function emitShader(p: Program, options: EmitOptions = {}): string {
         props.push(`        _Tex${t.slot} ("${t.name}", 2D) = "white" {}`)
         decls.push(`            sampler2D _Tex${t.slot};`)
     }
+    // Only for a program that samples it, so every other program's shader is
+    // the text it always was. Transparent black is the previous frame's clear
+    // value, so a host that binds nothing draws the first frame.
+    if (reads.previous) {
+        props.push(`        _Prev ("Previous frame", 2D) = "black" {}`)
+        decls.push(`            sampler2D _Prev;`)
+    }
+    // What the program returns is the next frame's previous, kept at 16 bits
+    // a channel, so it leaves at full precision rather than as a fixed4.
+    const out = reads.previous ? "float4" : "fixed4"
 
     return `// GENERATED from a shader language program. Do not edit.
 //
@@ -112,7 +123,7 @@ ${decls.join("\n")}
                 return o;
             }
 
-            fixed4 frag(v2f i) : SV_Target
+            ${out} frag(v2f i) : SV_Target
             {
 ${body}
             }
@@ -125,7 +136,9 @@ ${body}
 
 /**
  * The frame's side of the body: OneJS's names for the inputs, a uniform's
- * material property, and `tex2D` and `tex2Dlod` on the slot's sampler. `sl_toLinear` stays a
+ * material property, and `tex2D` and `tex2Dlod` on the slot's sampler. The
+ * host puts the frame count and the step in `_Res`'s spare zw, and binds the
+ * previous frame as `_Prev`. `sl_toLinear` stays a
  * call because `SLCommon.cginc` decides Gamma or Linear per project, at the
  * shader compile, so this target always emits it.
  */
@@ -147,10 +160,15 @@ function unityTarget(p: Program): BodyTarget {
             resolution: "_Res.xy",
             time: "_Secs",
             aspect: "(_Res.x / max(_Res.y, 1.0))",
+            frame: "_Res.z",
+            deltaTime: "_Res.w",
         },
         uniform: (slot) => uniformProperty(p.uniforms[slot]!.name),
         sample: (slot, uv) => `tex2D(_Tex${slot}, ${uv})`,
         sampleLevel: (slot, uv, lod) => `tex2Dlod(_Tex${slot}, float4(${uv}, 0.0, ${lod}))`,
+        // Flipped as this frame flipped the uv it wrote at, so a read at a
+        // pixel's own uv is that pixel whichever way the host's target runs.
+        previous: (uv) => `tex2Dlod(_Prev, float4(${uv} * float2(1.0, 1.0 - 2.0 * _FlipY) + float2(0.0, _FlipY), 0.0, 0.0))`,
         colour: "linear",
         indent: "                ",
         loopAttribute: "[loop]",

package/src/ir.ts

@@ -57,9 +57,35 @@ export const DERIVED_INPUTS = {
 } as const
 export type DerivedInputName = keyof typeof DERIVED_INPUTS
 
+/**
+ * Inputs the host hands over only to a program that reads one (IR 5,
+ * `Specs/SL_NEXT.md` 4). They are not recorded up front as `INPUTS` are, so a
+ * program that never names one holds no node for it and keeps its IR version,
+ * its hash and its bytes. `compile(p).reads` says which a program reads.
+ *
+ *   frame      frames drawn since the previous frame was last cleared, from 0.
+ *              An int in the language; the host hands over a float holding it
+ *              exactly, and the program converts
+ *   deltaTime  seconds from the frame before to this one; 0 on a frame that
+ *              redraws the same time
+ *
+ * The previous frame itself is SLOP.SAMPLE_PREVIOUS, an op rather than an input.
+ */
+export const STEP_INPUTS = {
+    frame: TYPE.FLOAT,
+    deltaTime: TYPE.FLOAT,
+} as const
+export type StepInputName = keyof typeof STEP_INPUTS
+
+/** The name `.sl` reads the previous frame by, as a texture: `tex2D(previous, uv)`. */
+export const PREVIOUS = "previous"
+
+/** Every input a host hands over: the ones every program has, then the ones a program asks for. */
+export type HostInputName = InputName | StepInputName
+
 /** Every input a program can name: the host's, then the derived ones. */
-export type SourceInputName = InputName | DerivedInputName
-export const SOURCE_INPUTS: Readonly<Record<SourceInputName, SLType>> = { ...INPUTS, ...DERIVED_INPUTS }
+export type SourceInputName = HostInputName | DerivedInputName
+export const SOURCE_INPUTS: Readonly<Record<SourceInputName, SLType>> = { ...INPUTS, ...STEP_INPUTS, ...DERIVED_INPUTS }
 
 /** Index into `Program.nodes`. Always refers backwards. */
 export type NodeRef = number
@@ -77,7 +103,7 @@ export type SLKind = "int" | "uint" | "bool"
  */
 export type ValueNode =
     | { k: "const"; type: SLType; kind?: SLKind; v: number[] }
-    | { k: "input"; type: SLType; kind?: undefined; name: InputName }
+    | { k: "input"; type: SLType; kind?: undefined; name: HostInputName }
     | { k: "uniform"; type: SLType; kind?: undefined; slot: number }
     | { k: "swizzle"; type: SLType; kind?: SLKind; src: NodeRef; chans: number[] }
     | { k: "call"; type: SLType; kind?: SLKind; op: SLOpCode; args: NodeRef[]; imm?: number[] }
@@ -225,6 +251,27 @@ export interface UniformDecl extends UniformControl {
      * conversion is already in the graph, so it is not part of the hash.
      */
     colour?: true
+    /**
+     * An int: `value` is a whole number and the program reads it as one, so a
+     * host shows a whole number field rather than a float's. The slot is a
+     * float, as every host binds it, and `type` is FLOAT. Set by `uniform int`
+     * in a `.sl` file or `sl.uniform.int`. Metadata for a host like `colour`:
+     * the reads' conversion to an int is already in the graph, so it is not
+     * part of the hash. A float uniform has none.
+     */
+    kind?: "int"
+}
+
+/** What is wrong with an int uniform of `type` and default `value`, or null. The one check, for the builder and `fromJSON`. */
+export function intUniformProblem(type: SLType, value: readonly number[]): string | null {
+    if (type !== TYPE.FLOAT) return `an int uniform is one number, and this is a ${widthName(type)}`
+    const v = value[0]!
+    // Its slot is a float, and a read is held to INT_BOUNDS: a default the
+    // program would read as another number is refused rather than shown.
+    if (!Number.isInteger(v) || Math.fround(v) !== v || v < INT_BOUNDS.int[0] || v > INT_BOUNDS.int[1]) {
+        return `an int uniform's default is a whole number its float slot holds exactly, and this is ${v}`
+    }
+    return null
 }
 
 export interface TextureDecl {
@@ -358,7 +405,7 @@ export class Builder {
         return this.add(node)
     }
 
-    uniform(name: string, type: SLType, value: number[], colour = false, control: UniformControl = {}): NodeRef {
+    uniform(name: string, type: SLType, value: number[], colour = false, control: UniformControl = {}, kind?: "int"): NodeRef {
         const existing = this.uniforms.findIndex((u) => u.name === name)
         if (existing >= 0) {
             const u = this.uniforms[existing]
@@ -368,6 +415,9 @@ export class Builder {
             if ((u.colour === true) !== colour) {
                 throw new SLError(`uniform "${name}" is declared both as a colour and as plain numbers`)
             }
+            if (u.kind !== kind) {
+                throw new SLError(`uniform "${name}" is declared as both an int and a float`)
+            }
             // A second read may say nothing about the control, or the same thing again.
             const merged = { ...controlOf(u) }
             for (const f of CONTROL_FIELDS) {
@@ -384,10 +434,13 @@ export class Builder {
         }
         const problem = controlProblem(type, value, control)
         if (problem !== null) throw new SLError(`uniform "${name}": ${problem.message}`)
+        const kindProblem = kind === undefined ? null : intUniformProblem(type, value)
+        if (kindProblem !== null) throw new SLError(`uniform "${name}": ${kindProblem}`)
         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
+        if (kind !== undefined) decl.kind = kind
         Object.assign(decl, controlOf(control))
         this.uniforms.push(decl)
         return this.add({ k: "uniform", type, slot })
@@ -427,17 +480,43 @@ export function reachable(nodes: SLNode[], result: NodeRef): NodeRef[] {
 }
 
 /**
- * The inputs a program reads, in `INPUTS` order. Dead nodes do not count: a
- * value computed and never used is not in the picture, so a program that does
- * that with `time` is still not animated.
+ * The inputs a program reads, in `INPUTS` order and then `STEP_INPUTS` order.
+ * Dead nodes do not count: a value computed and never used is not in the
+ * picture, so a program that does that with `time` is still not animated.
  */
-export function inputsUsed(p: Program): InputName[] {
-    const read = new Set<InputName>()
+export function inputsUsed(p: Program): HostInputName[] {
+    const read = new Set<HostInputName>()
     for (const ref of reachable(p.nodes, p.result)) {
         const n = p.nodes[ref]
         if (n.k === "input") read.add(n.name)
     }
-    return (Object.keys(INPUTS) as InputName[]).filter((name) => read.has(name))
+    return ([...Object.keys(INPUTS), ...Object.keys(STEP_INPUTS)] as HostInputName[]).filter((name) => read.has(name))
+}
+
+/**
+ * What a program needs its host to keep from one frame to the next
+ * (`Specs/SL_NEXT.md` 4). A host that draws a program reading any of these
+ * has to hand it over, or refuse the program: nothing here has a value that
+ * would pass for right.
+ *
+ *   previous   the host keeps what the program drew last and binds it
+ *   frame      frames drawn since `previous` was last cleared
+ *   deltaTime  seconds since the frame before
+ */
+export interface SLReads {
+    previous: boolean
+    frame: boolean
+    deltaTime: boolean
+}
+
+export function readsOf(p: Program): SLReads {
+    const out: SLReads = { previous: false, frame: false, deltaTime: false }
+    for (const ref of reachable(p.nodes, p.result)) {
+        const n = p.nodes[ref]!
+        if (n.k === "call" && n.op === SLOP.SAMPLE_PREVIOUS) out.previous = true
+        else if (n.k === "input" && n.name in STEP_INPUTS) out[n.name as StepInputName] = true
+    }
+    return out
 }
 
 /** Structural key for hash consing. Order matters and is fixed by the node shape. */
@@ -654,10 +733,12 @@ const IR4_OPS = new Set<number>([
  * holds, and `fromJSON` moves it to the form IR 3 has.
  */
 function nodeVersion(n: SLNode): number {
+    if (n.k === "input" && n.name in STEP_INPUTS) return 5
     if (n.k === "if" || n.k === "loop" || n.k === "param" || n.k === "proj" || n.kind !== undefined) return 4
     if (n.k !== "call") return 2
     if (IR4_OPS.has(n.op)) return 4
     switch (n.op) {
+        case SLOP.SAMPLE_PREVIOUS: return 5
         case SLOP.SAMPLE_LOD: return 3
         case SLOP.SDF:
         case SLOP.FBM:
@@ -678,6 +759,8 @@ function nodeVersion(n: SLNode): number {
  *        the shape id the one immediate
  *   FBM, TURBULENCE, RIDGED  the point and the octave count, FBM's kind the
  *        one immediate
+ *   SAMPLE_PREVIOUS  a float4 at a float2, and no immediates: there is one
+ *        previous frame, so there is no slot to name
  */
 export function formProblem(n: Extract<SLNode, { k: "call" }>, nodes: readonly SLNode[]): string | null {
     const widths = n.args.map((a) => { const v = nodes[a]!; return v.k === "if" || v.k === "loop" ? "control" : v.type }).join(",")
@@ -692,6 +775,9 @@ export function formProblem(n: Extract<SLNode, { k: "call" }>, nodes: readonly S
             if (widths === "2,1" && (n.imm?.length ?? 0) === rest) return null
             return `${SL_NAME[n.op]} takes a float2 and its octave count, a float`
         }
+        case SLOP.SAMPLE_PREVIOUS:
+            if (widths === "2" && n.type === 4 && n.kind === undefined && (n.imm?.length ?? 0) === 0) return null
+            return "the previous frame is a float4 read at a float2"
         default:
             return null
     }
@@ -732,8 +818,9 @@ export const SL_HASH_VERSION = 2
  *   3  SAMPLE_LOD; an SDF's shape parameters and a noise's octave count are
  *      operands, where they were immediates
  *   4  control flow (if, loop, their params and projs), ints, uints and bools
+ *   5  the previous frame (SAMPLE_PREVIOUS), and the frame and deltaTime inputs
  */
-export const SL_IR_VERSION = 4
+export const SL_IR_VERSION = 5
 
 function fnv1a(s: string): string {
     let h = 0x811c9dc5

package/src/lang/README.md

@@ -245,7 +245,8 @@ It rewrites tokens and keeps everything else: comments, layout and names stay
 where they were, so the result reads as the shader it came from. What it does:
 
 - The spellings that mean the same (`vec3`, `mix`, `fract`, `texture`,
-  `iTime`, `gl_FragCoord`) become the HLSL ones. So do the calls that need an
+  `iTime`, `iFrame`, `iTimeDelta`, `gl_FragCoord`) become the HLSL ones and
+  the inputs. So do the calls that need an
   expression: `mod` floors (`a - b * floor(a / b)`, never `%`, which
   truncates), and `atan`, `inversesqrt`, `radians`, `degrees`, `exp2` and
   `log2` become what they compute.
@@ -269,8 +270,8 @@ where they were, so the result reads as the shader it came from. What it does:
   becomes a const; any other directive is kept as a comment, with a note.
 - A name the language already means something by gets a `_` suffix, and an
   `int` becomes a float (a for-loop counter stays an int), each with a note.
-- What has no counterpart (`iFrame`, `textureLod`, `dFdx`, a function returning
-  nothing) is left in place with a note, for `errors` to point at.
+- What has no counterpart (`iFrameRate`, `texelFetch`, `dFdx`, a function
+  returning nothing) is left in place with a note, for `errors` to point at.
 
 It is not a GLSL parser, and is not meant to be: a shader it cannot follow comes
 out with errors on the lines to look at, which is where a person pasting one

package/src/lang/check.ts

@@ -28,7 +28,7 @@
  * is refused with the reason.
  */
 
-import { DERIVED_INPUTS, INPUTS, tooManyTextures, tooManyUniforms } from "../ir"
+import { DERIVED_INPUTS, INPUTS, PREVIOUS, STEP_INPUTS, tooManyTextures, tooManyUniforms } from "../ir"
 import { TEXTURE_SLOTS, UNIFORM_SLOTS } from "../ops"
 import { SL_GLSL_HINT } from "../ops"
 import { BUILTINS, NOT_YET } from "./builtins"
@@ -44,6 +44,17 @@ const INPUT_NAMES = new Set(Object.keys(INPUTS))
  * long before the language had one, and that must keep compiling.
  */
 const DERIVED_NAMES = new Set(Object.keys(DERIVED_INPUTS))
+/**
+ * `frame` and `deltaTime`, and `previous`, the texture that is the frame drawn
+ * before (IR 5). The language had none of them before 0.7.0, so a program may
+ * already use the name for its own value, texture or function, and keeps it.
+ * A function by the name is called by it; the bare name is still the input.
+ */
+const STEP_NAMES = new Set(Object.keys(STEP_INPUTS))
+/** What a declaration may take the name of, with the words for it. */
+const SHADOWABLE = new Set(["a builtin", "a derived input", "a built in input", "the previous frame"])
+/** What a function may take the name of: only the names that came after files could have used them. */
+const FUNCTION_MAY_TAKE = new Set(["a built in input", "the previous frame"])
 
 /**
  * The GLSL spellings whose HLSL name means the same wherever it is written, so
@@ -145,13 +156,15 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         if (textures.has(n)) return "a texture"
         if (consts.has(n)) return "a const"
         if (DERIVED_NAMES.has(n)) return "a derived input"
+        if (STEP_NAMES.has(n)) return "a built in input"
+        if (n === PREVIOUS) return "the previous frame"
         return null
     }
 
     /** What a value may not be called: anything spoken for, except a builtin's or a prelude function's name. */
     const valueClash = (n: string): string | null => {
         const why = taken(n)
-        if (why !== null && why !== "a builtin" && why !== "a derived input") return why
+        if (why !== null && !SHADOWABLE.has(why)) return why
         const fn = funcs.get(n)
         return fn !== undefined && !fn.prelude ? "a function" : null
     }
@@ -194,7 +207,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
     for (const fn of unit.funcs) {
         attempt(() => {
             const clash = taken(fn.name)
-            if (clash !== null) fail(`"${fn.name}" already names ${clash}`, fn.pos, fn.name.length)
+            if (clash !== null && !FUNCTION_MAY_TAKE.has(clash)) fail(`"${fn.name}" already names ${clash}`, fn.pos, fn.name.length)
             if (unit.funcs.filter((f) => f.name === fn.name).length > 1) {
                 fail(
                     `this file declares ${fn.name} more than once. There is no overloading: a function ` +
@@ -222,7 +235,8 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
         if (main.params.length > 0) {
             fail(
                 "main takes no parameters: what a program is given are the free identifiers uv, " +
-                "fragCoord, resolution, time, aspect, texel and centered",
+                "fragCoord, resolution, time, aspect, texel, centered, frame and deltaTime, and the " +
+                "texture previous",
                 main.params[0]!.pos,
             )
         }
@@ -486,7 +500,15 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
             case "bool":
                 return
             case "ident": {
-                if (scope.has(e.name) || INPUT_NAMES.has(e.name) || DERIVED_NAMES.has(e.name) || uniforms.has(e.name) || consts.has(e.name)) return
+                if (scope.has(e.name) || INPUT_NAMES.has(e.name) || DERIVED_NAMES.has(e.name) || STEP_NAMES.has(e.name) ||
+                    uniforms.has(e.name) || consts.has(e.name)) return
+                if (e.name === PREVIOUS && !textures.has(e.name)) {
+                    fail(
+                        "previous is the frame this program drew before, a texture, and a texture is only " +
+                        "ever the first argument of tex2D. Write `tex2D(previous, uv)`",
+                        e.pos, e.name.length,
+                    )
+                }
                 if (textures.has(e.name)) {
                     fail(
                         `"${e.name}" is a texture, and a texture is only ever the first argument of ` +
@@ -604,7 +626,17 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                     )
                 }
                 arity(e, n, builtin.min, builtin.max)
-                if (tex === undefined || tex.k !== "ident" || !textures.has(tex.name)) {
+                // The previous frame, unless something in this file took its name.
+                const previous = tex?.k === "ident" && tex.name === PREVIOUS && !textures.has(PREVIOUS) &&
+                    !scope.has(PREVIOUS) && !uniforms.has(PREVIOUS) && !consts.has(PREVIOUS)
+                if (previous && n === "tex2Dlod") {
+                    fail(
+                        "previous has one level, the frame as drawn, so there is no mip level to pick. " +
+                        "Read it with `tex2D(previous, uv)`",
+                        e.pos,
+                    )
+                }
+                if (!previous && (tex === undefined || tex.k !== "ident" || !textures.has(tex.name))) {
                     const lod = n === "tex2Dlod" ? ", 0" : ""
                     fail(
                         `${n} samples a texture declared in this file, as in \`texture2D grain;\` ` +
@@ -654,7 +686,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
     /** Refuses a name nothing declares, offering the nearest one spelled almost like it. */
     function unknown(n: string, scope: Set<string>, pos: Pos): never {
         const near = nearest(n, [
-            ...scope, ...INPUT_NAMES, ...DERIVED_NAMES, ...uniforms.keys(), ...textures.keys(), ...consts.keys(),
+            ...scope, ...INPUT_NAMES, ...DERIVED_NAMES, ...STEP_NAMES, ...uniforms.keys(), ...textures.keys(), ...consts.keys(),
             ...funcs.keys(), ...Object.keys(BUILTINS),
         ])
         if (near === null) fail(`"${n}" is not declared`, pos, n.length)

package/src/lang/classify.ts

@@ -13,7 +13,7 @@
  * wants that should ask it.
  */
 
-import { SOURCE_INPUTS } from "../ir"
+import { PREVIOUS, SOURCE_INPUTS } from "../ir"
 import { BUILTINS } from "./builtins"
 import { lex } from "./lexer"
 import { PRELUDE_NAMES } from "./prelude-source"
@@ -42,7 +42,7 @@ export interface SLClassifiedToken {
     length: number
 }
 
-const INPUT_NAMES: ReadonlySet<string> = new Set(Object.keys(SOURCE_INPUTS))
+const INPUT_NAMES: ReadonlySet<string> = new Set([...Object.keys(SOURCE_INPUTS), PREVIOUS])
 
 /** The tokens of `source`, comments included, in order, each with its class. */
 export function classify(source: string): SLClassifiedToken[] {

package/src/lang/glsl.ts

@@ -76,6 +76,7 @@ const GLSL_TYPES = new Set(["float", "int", "uint", "bool", "vec2", "vec3", "vec
 const RENAME: Record<string, string> = {
     vec2: "float2", vec3: "float3", vec4: "float4", mix: "lerp", fract: "frac",
     texture: "tex2D", texture2D: "tex2D", textureLod: "tex2Dlod", iTime: "time", iGlobalTime: "time", gl_FragCoord: "fragCoord",
+    iFrame: "frame", iTimeDelta: "deltaTime",
 }
 
 /**
@@ -94,8 +95,6 @@ const NARROW: Record<string, [string, string]> = {
 
 /** Shadertoy's inputs with no counterpart yet, and why. */
 const MISSING: Record<string, string> = {
-    iFrame: "there is no frame counter yet",
-    iTimeDelta: "there is no delta time yet",
     iFrameRate: "there is no frame rate",
     iDate: "there is no date",
     iChannelTime: "a texture has no time of its own",
@@ -115,6 +114,7 @@ const MISSING: Record<string, string> = {
 const HOST_UNIFORMS: Record<string, string> = {
     u_time: "time", u_resolution: "resolution", time: "time", resolution: "resolution",
     iTime: "time", iGlobalTime: "time", iResolution: "resolution", iMouse: "mouse",
+    iFrame: "frame", iTimeDelta: "deltaTime",
 }
 
 const QUALIFIERS = new Set(["highp", "mediump", "lowp"])