onejs-sl 0.8.0 → 0.9.1

package/src/hlsl.ts

@@ -15,8 +15,9 @@
  * next time it is generated.
  */
 
-import { SLError, SL_HASH_VERSION, readsOf, type Program } from "./ir"
+import { SLError, SL_HASH_VERSION, readsOf, reachable, samplingOf, type Program, type TextureSampling } from "./ir"
 import { emitBody, lit, type BodyTarget } from "./body"
+import { SLOP } from "./ops"
 
 /** The property name a uniform gets. Prefixed so it cannot collide with ours. */
 export function uniformProperty(name: string): string {
@@ -49,6 +50,7 @@ export function emitShader(p: Program, options: EmitOptions = {}): string {
     const include = options.include ?? "SLCommon.cginc"
     const body = emitFragmentBody(p)
     const reads = readsOf(p)
+    const use = textureUse(p)
 
     const props: string[] = [
         `        _Secs ("Seconds", Float) = 0`,
@@ -68,7 +70,22 @@ export function emitShader(p: Program, options: EmitOptions = {}): string {
     }
     for (const t of p.textures) {
         props.push(`        _Tex${t.slot} ("${t.name}", 2D) = "white" {}`)
-        decls.push(`            sampler2D _Tex${t.slot};`)
+        // A texture sampled as it is set is the sampler2D it always was, so
+        // every program before IR 6 prints the shader it always did. One the
+        // program sets a sampler for, or fetches from, is a Texture2D: the
+        // inline sampler state or the Load needs the texture on its own.
+        if (!use.object.has(t.slot)) decls.push(`            sampler2D _Tex${t.slot};`)
+        else {
+            decls.push(`            Texture2D _Tex${t.slot};`)
+            // Its own settings, by Unity's naming rule, for a plain sample.
+            if (use.plain.has(t.slot)) decls.push(`            SamplerState sampler_Tex${t.slot};`)
+        }
+        // Unity fills it from the bound texture: (1 / width, 1 / height, width, height).
+        if (use.sized.has(t.slot)) decls.push(`            float4 _Tex${t.slot}_TexelSize;`)
+    }
+    // Unity's inline sampler states: the name says the filter and the wrap.
+    for (const name of [...new Set(p.textures.map(samplingOf).filter((s) => s !== null).map(inlineSampler))].sort()) {
+        decls.push(`            SamplerState ${name};`)
     }
     // 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
@@ -143,6 +160,7 @@ ${body}
  * shader compile, so this target always emits it.
  */
 function unityTarget(p: Program): BodyTarget {
+    const use = textureUse(p)
     return {
         // `_Res` is the TARGET's size, set by the host, not `_ScreenParams`.
         //
@@ -164,8 +182,15 @@ function unityTarget(p: Program): BodyTarget {
             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}))`,
+        sample: (slot, uv) => use.object.has(slot) ? `_Tex${slot}.Sample(sampler_Tex${slot}, ${uv})` : `tex2D(_Tex${slot}, ${uv})`,
+        sampleLevel: (slot, uv, lod) => use.object.has(slot)
+            ? `_Tex${slot}.SampleLevel(sampler_Tex${slot}, ${uv}, ${lod})`
+            : `tex2Dlod(_Tex${slot}, float4(${uv}, 0.0, ${lod}))`,
+        sampleWith: (slot, uv, lod, s) => lod === null
+            ? `_Tex${slot}.Sample(${inlineSampler(s)}, ${uv})`
+            : `_Tex${slot}.SampleLevel(${inlineSampler(s)}, ${uv}, ${lod})`,
+        size: (slot) => `_Tex${slot}_TexelSize.zw`,
+        fetch: (slot, pixel) => `_Tex${slot}.Load(int3(${pixel}, 0))`,
         // 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))`,
@@ -175,6 +200,36 @@ function unityTarget(p: Program): BodyTarget {
     }
 }
 
+/**
+ * An inline sampler state's name. Unity reads the filter and the wrap from the
+ * name itself ("point" or "linear", "clamp", "repeat" or "mirror").
+ */
+function inlineSampler(s: TextureSampling): string {
+    return `sl_sampler_${s.filter}_${s.wrap}`
+}
+
+/**
+ * How the program reaches each texture slot, which decides how the shader
+ * declares it. `object`: declared a Texture2D, because the program sets its
+ * sampler or fetches from it. `plain`: an object sampled with its own
+ * settings, which needs Unity's `sampler_` state. `sized`: reads `_TexelSize`,
+ * as `textureSize` and a fetch's bounds do.
+ */
+function textureUse(p: Program): { object: Set<number>; plain: Set<number>; sized: Set<number> } {
+    const fetched = new Set<number>(), sampled = new Set<number>(), sized = new Set<number>()
+    for (const ref of reachable(p.nodes, p.result)) {
+        const n = p.nodes[ref]!
+        if (n.k !== "call") continue
+        const slot = Math.round(n.imm?.[0] ?? 0)
+        if (n.op === SLOP.SAMPLE || n.op === SLOP.SAMPLE_LOD) sampled.add(slot)
+        else if (n.op === SLOP.TEXTURE_SIZE) sized.add(slot)
+        else if (n.op === SLOP.SAMPLE_FETCH) { fetched.add(slot); sized.add(slot) }
+    }
+    const object = new Set(p.textures.filter((t) => samplingOf(t) !== null || fetched.has(t.slot)).map((t) => t.slot))
+    const plain = new Set([...sampled].filter((slot) => object.has(slot) && samplingOf(p.textures[slot]!) === null))
+    return { object, plain, sized }
+}
+
 /** The straight line body: one local per reachable node, in order. */
 export function emitFragmentBody(p: Program): string {
     return emitBody(p, unityTarget(p)).body

package/src/index.ts

@@ -18,10 +18,10 @@
  */
 export * from "./core"
 export {
-    analyze, classify, diagnose, parse, parseUnit, preludeFunctions, tokenize, PRELUDE_SOURCE, SLParseError,
+    analyze, classify, classifyLine, diagnose, parse, parseUnit, preludeFunctions, tokenize, PRELUDE_SOURCE, SLParseError,
 } from "./lang"
 export type {
-    Checked, Expr, FuncDecl, ParseOptions, Pos, SLClassifiedToken, SLFix, SLTokenClass, Stmt, Token, Unit,
+    Checked, Expr, FuncDecl, ParseOptions, Pos, SLClassifiedToken, SLFix, SLLineState, SLTokenClass, Stmt, Token, Unit,
 } from "./lang"
 export { fromGLSL } from "./lang/glsl"
 export type { FromGLSL } from "./lang/glsl"

package/src/ir.ts

@@ -274,10 +274,45 @@ export function intUniformProblem(type: SLType, value: readonly number[]): strin
     return null
 }
 
+/** How a texture's coordinates outside 0 to 1 read: tiled, held at the edge, or tiled mirrored. */
+export type TextureWrap = "repeat" | "clamp" | "mirror"
+/** How a texture is read between texels: the nearest one, or a blend of the four around. */
+export type TextureFilter = "point" | "linear"
+
+/** The sampler a program sets for a texture, both halves filled in (`samplingOf`). */
+export interface TextureSampling {
+    wrap: TextureWrap
+    filter: TextureFilter
+}
+
+export const TEXTURE_WRAPS: readonly TextureWrap[] = ["repeat", "clamp", "mirror"]
+export const TEXTURE_FILTERS: readonly TextureFilter[] = ["point", "linear"]
+
 export interface TextureDecl {
     name: string
     /** Sampler slot, assigned in declaration order. */
     slot: number
+    /**
+     * How the program samples it, as written: `[Wrap(Repeat)]` and
+     * `[Filter(Point)]` in a `.sl` file, `sl.texture(name, { wrap, filter })`.
+     * Neither set, the texture samples as the texture bound to it is set,
+     * which is what every program did before IR 6. Either set, the program
+     * owns the sampler, and the half it leaves out is clamp or linear
+     * (`samplingOf`). Part of the hash, since the shader differs.
+     */
+    wrap?: TextureWrap
+    filter?: TextureFilter
+}
+
+/**
+ * The sampler a texture's program sets, or null when it samples as the bound
+ * texture is set. A program that names one half gets clamp or linear for the
+ * other, on every host: Unity's inline sampler states and WebGPU's samplers
+ * have no way to take one half from the texture and the other from the shader.
+ */
+export function samplingOf(t: Pick<TextureDecl, "wrap" | "filter">): TextureSampling | null {
+    if (t.wrap === undefined && t.filter === undefined) return null
+    return { wrap: t.wrap ?? "clamp", filter: t.filter ?? "linear" }
 }
 
 export interface Program {
@@ -308,8 +343,9 @@ export function tooManyUniforms(declared: number, source: "file" | "program"): s
 
 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}.`
+        `OneJS binds ${TEXTURE_SLOTS} textures to a program, so this one would have no slot to be ` +
+        `bound in; it is refused here rather than drawn blank. Pack two images into one texture's ` +
+        `channels, or draw in two passes.`
 }
 
 /**
@@ -323,6 +359,17 @@ export function checkCaps(p: Pick<Program, "uniforms" | "textures">): void {
     if (p.textures.length > TEXTURE_SLOTS) throw new SLError(tooManyTextures(p.textures.length, "program"))
 }
 
+/** What is wrong with a texture's sampler, or null. The one check, for the builder and `fromJSON`. */
+export function samplingProblem(s: { wrap?: unknown; filter?: unknown }): string | null {
+    if (s.wrap !== undefined && !TEXTURE_WRAPS.includes(s.wrap as TextureWrap)) {
+        return `a wrap is ${TEXTURE_WRAPS.join(", ")}, and this is ${String(s.wrap)}`
+    }
+    if (s.filter !== undefined && !TEXTURE_FILTERS.includes(s.filter as TextureFilter)) {
+        return `a filter is ${TEXTURE_FILTERS.join(" or ")}, and this is ${String(s.filter)}`
+    }
+    return null
+}
+
 /**
  * The colour as written behind a colour value: the operand of the `TO_LINEAR`
  * that reading a hex or a colour uniform applied, or null for a value computed
@@ -446,14 +493,30 @@ export class Builder {
         return this.add({ k: "uniform", type, slot })
     }
 
-    texture(name: string): number {
+    texture(name: string, sampling: Pick<TextureDecl, "wrap" | "filter"> = {}): number {
+        const problem = samplingProblem(sampling)
+        if (problem !== null) throw new SLError(`texture "${name}": ${problem}`)
         const existing = this.textures.findIndex((t) => t.name === name)
-        if (existing >= 0) return this.textures[existing].slot
+        if (existing >= 0) {
+            // A second use may say nothing about the sampler, or the same thing again.
+            const t = this.textures[existing]!
+            for (const f of ["wrap", "filter"] as const) {
+                if (sampling[f] === undefined) continue
+                if (t[f] !== undefined && t[f] !== sampling[f]) {
+                    throw new SLError(`texture "${name}" is given two different ${f}s, ${t[f]} and ${sampling[f]}`)
+                }
+                t[f] = sampling[f] as never
+            }
+            return t.slot
+        }
         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 })
+        const decl: TextureDecl = { name, slot }
+        if (sampling.wrap !== undefined) decl.wrap = sampling.wrap
+        if (sampling.filter !== undefined) decl.filter = sampling.filter
+        this.textures.push(decl)
         return slot
     }
 }
@@ -687,9 +750,15 @@ export function hashProgram(nodes: SLNode[], result: NodeRef, uniforms: UniformD
     // includes the library's text when it compiles, and none caches a compiled
     // program by hash across a library update, so the new text reaches every
     // shader without a bump.
-    const parts: string[] = [`v${SL_HASH_VERSION}:${programVersion(nodes, result)}`, of(result)]
+    const parts: string[] = [`v${SL_HASH_VERSION}:${programVersion(nodes, result, textures)}`, of(result)]
     for (const u of uniforms) parts.push(`U:${u.name}:${u.type}:${u.value.map(fixed).join(",")}`)
-    for (const t of textures) parts.push(`T:${t.name}:${t.slot}`)
+    // A texture's sampler as the shader has it, so `[Wrap(Clamp)]` and
+    // `[Filter(Linear)]` share a hash, and a texture with neither has the
+    // part it had before IR 6.
+    for (const t of textures) {
+        const s = samplingOf(t)
+        parts.push(`T:${t.name}:${t.slot}${s === null ? "" : `:${s.wrap}:${s.filter}`}`)
+    }
     return fnv1a(parts.join("|"))
 }
 
@@ -751,8 +820,8 @@ export function controlOf(c: UniformControl): UniformControl {
  * int constant a fold used up, say), and they draw nothing. `toJSON` writes
  * only the live ones, so an older reader never meets a dead newer node.
  */
-export function programVersion(nodes: readonly SLNode[], result: NodeRef): number {
-    let v = 2
+export function programVersion(nodes: readonly SLNode[], result: NodeRef, textures: readonly TextureDecl[] = []): number {
+    let v = textures.some((t) => samplingOf(t) !== null) ? 6 : 2
     for (const ref of reachable(nodes as SLNode[], result)) v = Math.max(v, nodeVersion(nodes[ref]!))
     return v
 }
@@ -774,6 +843,9 @@ function nodeVersion(n: SLNode): number {
     if (n.k !== "call") return 2
     if (IR4_OPS.has(n.op)) return 4
     switch (n.op) {
+        case SLOP.TEXTURE_SIZE:
+        case SLOP.SAMPLE_FETCH:
+            return 6
         case SLOP.SAMPLE_PREVIOUS: return 5
         case SLOP.SAMPLE_LOD: return 3
         case SLOP.SDF:
@@ -797,6 +869,8 @@ function nodeVersion(n: SLNode): number {
  *        one immediate
  *   SAMPLE_PREVIOUS  a float4 at a float2, and no immediates: there is one
  *        previous frame, so there is no slot to name
+ *   TEXTURE_SIZE  a float2 of nothing, the slot the one immediate
+ *   SAMPLE_FETCH  a float4 at a float2 pixel, the slot the one immediate
  */
 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(",")
@@ -814,6 +888,12 @@ export function formProblem(n: Extract<SLNode, { k: "call" }>, nodes: readonly S
         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"
+        case SLOP.TEXTURE_SIZE:
+            if (widths === "" && n.type === 2 && n.kind === undefined && n.imm?.length === 1) return null
+            return "a texture's size is a float2, its slot the one immediate"
+        case SLOP.SAMPLE_FETCH:
+            if (widths === "2" && n.type === 4 && n.kind === undefined && n.imm?.length === 1) return null
+            return "a fetch is a float4 read at a float2 pixel, its slot the one immediate"
         default:
             return null
     }
@@ -855,8 +935,9 @@ export const SL_HASH_VERSION = 2
  *      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
+ *   6  TEXTURE_SIZE and SAMPLE_FETCH, and a texture's sampler (`wrap`, `filter`)
  */
-export const SL_IR_VERSION = 5
+export const SL_IR_VERSION = 6
 
 function fnv1a(s: string): string {
     let h = 0x811c9dc5

package/src/lang/README.md

@@ -169,8 +169,8 @@ recorded gap, not an oversight, and each has its own error message rather than
 | `rgb2hsv` | The opcode is numbered and **no backend implements it**; every emitter throws on it. |
 | `fbm`'s simplex base | `sl.fbm(p, octaves, "simplex")` picks the base with a string, and the language has no strings. `fbm(p, octaves)` is the value base, and `turbulence` and `ridged` are the simplex family. |
 
-A `.sl` file and the EDSL are held to the same caps, `UNIFORM_SLOTS` (16) and
-`TEXTURE_SLOTS` (4), reported at the declaration in one wording (`ir.ts`'s
+A `.sl` file and the EDSL are held to the same caps, `UNIFORM_SLOTS` (64) and
+`TEXTURE_SLOTS` (8), reported at the declaration in one wording (`ir.ts`'s
 `tooManyUniforms` and `tooManyTextures`).
 
 ## Attributes
@@ -193,6 +193,16 @@ What they produce is metadata on the uniform (`range`, `toggle`, `options`,
 `header`, `label`, `hide`), which the hash never reads. `[Color]` is the
 exception, because it changes the reads: it is the same as a hex default.
 
+A texture takes two of its own, which are not metadata: `[Wrap(Repeat)]`,
+`[Wrap(Mirror)]` or `[Wrap(Clamp)]`, and `[Filter(Point)]` or `[Filter(Linear)]`,
+read by `readTextureAttributes`. They change the shader (a sampler the program
+owns rather than the bound texture's), so they are in the hash and make a
+program IR 6; the half left out is clamp or linear (`samplingOf`). Unity's
+`Bilinear` and `WrapMode` are offered as fixes, and `Trilinear` and
+`MirrorOnce` are refused with why: no backend's per program sampler blends
+levels, and WebGPU has no mirror once. A uniform's attribute on a texture, or
+a texture's on a uniform, says which one it belongs on.
+
 ## Errors
 
 Every one carries file, line, column, offset and length, and `text`, the
@@ -237,6 +247,13 @@ on the parser's own scanner and word lists, so the highlighting is the parser's.
 It never throws, since it runs on every keystroke. It classifies by spelling,
 not scope: a local named `circle` still reads as a builtin where it is used.
 
+`classifyLine(line, state)` is the same for an editor that colours a line at a
+time, as Monaco does: the line's tokens and the state the next line starts
+from (inside a block comment or not, and the two tokens before it). Every line
+of a file classified that way gives what `classify` gives the whole file, a
+block comment over several lines coming back as one piece per line; the corpus
+holds it to that.
+
 `SL_KEYWORDS` and `SL_TYPES` (`words.ts`) are the lists the parser reads, and a
 name may be neither. `onejs-sl/tables` carries them, and `ATTRIBUTE_NAMES`, with
 a one line description of every builtin, input, attribute and prelude function; a prelude function's is the
@@ -257,7 +274,9 @@ where they were, so the result reads as the shader it came from. What it does:
   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.
+  `log2` become what they compute. `texelFetch(t, p, 0)` is
+  `tex2Dfetch(t, p)` and `textureSize(t, 0)` is `textureSize(t)`; another
+  level gets a note, since both read the full size texture.
 - `mainImage` becomes `float4 main()`, with its colour parameter as a local it
   returns; `void main()` writing `gl_FragColor` or a WebGL2 `out vec4` does the
   same. Shadertoy's `uv = fragCoord / iResolution.xy` line is dropped, since

package/src/lang/ast.ts

@@ -99,7 +99,10 @@ export type AttributeArg =
     | { k: "str"; text: string; pos: Pos; length: number }
     | { k: "ident"; name: string; pos: Pos; length: number }
 
-/** `[Range(0, 2)]` before a uniform: Unity's spelling of what its control is. */
+/**
+ * `[Range(0, 2)]` before a uniform, Unity's spelling of what its control is,
+ * or `[Wrap(Repeat)]` before a texture, of how it is sampled.
+ */
 export interface Attribute {
     name: string
     args: AttributeArg[]
@@ -120,6 +123,8 @@ export interface UniformDecl {
 
 export interface TextureDecl {
     name: string
+    /** `[Wrap(...)]` and `[Filter(...)]`, in the order written. */
+    attrs: Attribute[]
     pos: Pos
 }
 

package/src/lang/attributes.ts

@@ -10,8 +10,8 @@
  * shares.
  */
 
-import type { UniformControl } from "../ir"
-import { TYPE_WIDTH, type Attribute, type AttributeArg, type UniformDecl } from "./ast"
+import { TEXTURE_FILTERS, TEXTURE_WRAPS, type TextureFilter, type TextureWrap, type UniformControl } from "../ir"
+import { TYPE_WIDTH, type Attribute, type AttributeArg, type TextureDecl, type UniformDecl } from "./ast"
 import type { Pos, SLFix } from "./lexer"
 
 export interface AttributeProblem {
@@ -42,6 +42,75 @@ const ALIASES: Record<string, AttributeName> = {
 
 const LIST = "Range, Toggle, Enum, Header, Label, Color and Hide"
 
+/** A texture's attributes (`Specs/SL_NEXT.md` 8): how the program samples it. */
+export const TEXTURE_ATTRIBUTE_NAMES = ["Wrap", "Filter"] as const
+export type TextureAttributeName = (typeof TEXTURE_ATTRIBUTE_NAMES)[number]
+
+/** What each texture attribute takes, as written, from Unity's TextureWrapMode and FilterMode where they agree. */
+const TEXTURE_VALUES: Record<TextureAttributeName, Record<string, TextureWrap | TextureFilter>> = {
+    Wrap: Object.fromEntries(TEXTURE_WRAPS.map((w) => [w[0]!.toUpperCase() + w.slice(1), w])),
+    Filter: Object.fromEntries(TEXTURE_FILTERS.map((f) => [f[0]!.toUpperCase() + f.slice(1), f])),
+}
+
+/** Unity's spellings that mean one of ours, and the ones no host can match, with why. */
+const TEXTURE_VALUE_ALIASES: Record<string, string> = { Bilinear: "Linear", Nearest: "Point" }
+const TEXTURE_VALUE_REFUSED: Record<string, string> = {
+    Trilinear: "a program samples one mip level at a time, so there is no blend between levels to ask for; " +
+        "write [Filter(Linear)], and tex2Dlod with a fractional level blends two levels",
+    MirrorOnce: "WebGPU has no mirror once, so a browser could not draw it; write [Wrap(Mirror)] or [Wrap(Clamp)]",
+}
+
+export interface ReadTextureAttributes {
+    /** What could be read. Neither set, the texture samples as the bound texture is set. */
+    sampling: { wrap?: TextureWrap; filter?: TextureFilter }
+    problems: AttributeProblem[]
+}
+
+/** `[Wrap(Repeat)]` and `[Filter(Point)]` on a `texture2D`, read into its sampler. */
+export function readTextureAttributes(t: TextureDecl): ReadTextureAttributes {
+    const out: ReadTextureAttributes = { sampling: {}, problems: [] }
+    const seen = new Set<string>()
+    const problem = (at: Attribute | AttributeArg, message: string, fix?: SLFix) => {
+        out.problems.push({ message, pos: at.pos, length: at.length, ...(fix === undefined ? {} : { fix }) })
+    }
+    for (const a of t.attrs) {
+        const name = (TEXTURE_ATTRIBUTE_NAMES as readonly string[]).includes(a.name) ? a.name as TextureAttributeName
+            : a.name === "WrapMode" ? "Wrap" : a.name === "FilterMode" ? "Filter" : null
+        if (name === null) {
+            const uniform = (ATTRIBUTE_NAMES as readonly string[]).includes(a.name) || a.name in ALIASES
+            problem(a, uniform
+                ? `[${a.name}] is for a uniform; a texture takes [Wrap(Repeat)], [Wrap(Mirror)], [Wrap(Clamp)] and [Filter(Point)], [Filter(Linear)]`
+                : `"${a.name}" is not an attribute of a texture; a texture takes Wrap and Filter`)
+            continue
+        }
+        if (name !== a.name) {
+            problem(a, `"${a.name}" is ${name} here: [${name}(...)]`, { title: `Replace ${a.name} with ${name}`, replacement: name })
+            continue
+        }
+        if (seen.has(name)) { problem(a, `this texture already has [${name}]`); continue }
+        seen.add(name)
+        const values = TEXTURE_VALUES[name]
+        const listed = Object.keys(values).join(", ")
+        const arg = a.args.length === 1 && a.args[0]!.k === "ident" ? a.args[0]! as Extract<AttributeArg, { k: "ident" }> : null
+        if (arg === null) {
+            problem(a.args[0] ?? a, `[${name}] takes one of ${listed}, as in [${name}(${Object.keys(values)[0]})]`)
+            continue
+        }
+        const v = values[arg.name]
+        if (v !== undefined) {
+            if (name === "Wrap") out.sampling.wrap = v as TextureWrap
+            else out.sampling.filter = v as TextureFilter
+            continue
+        }
+        const refused = TEXTURE_VALUE_REFUSED[arg.name]
+        if (refused !== undefined) { problem(arg, `${name}(${arg.name}) is not offered: ${refused}`); continue }
+        const to = TEXTURE_VALUE_ALIASES[arg.name] ?? Object.keys(values).find((k) => k.toLowerCase() === arg.name.toLowerCase())
+        problem(arg, `${name} takes ${listed}, and this is ${arg.name}${to === undefined ? "" : `. Did you mean ${to}?`}`,
+            to === undefined ? undefined : { title: `Replace ${arg.name} with ${to}`, replacement: to })
+    }
+    return out
+}
+
 export function readAttributes(u: UniformDecl): ReadAttributes {
     const out: ReadAttributes = { control: {}, colour: false, from: {}, problems: [] }
     const seen = new Set<string>()
@@ -62,6 +131,10 @@ export function readAttributes(u: UniformDecl): ReadAttributes {
 
     for (const a of u.attrs) {
         const known = (ATTRIBUTE_NAMES as readonly string[]).includes(a.name)
+        if (!known && ((TEXTURE_ATTRIBUTE_NAMES as readonly string[]).includes(a.name) || a.name === "WrapMode" || a.name === "FilterMode")) {
+            problem(a, `[${a.name}] is for a texture, as in [${a.name.replace("Mode", "")}(${a.name.startsWith("Wrap") ? "Repeat" : "Point"})] texture2D grain;`)
+            continue
+        }
         if (!known) {
             const to = ALIASES[a.name] ?? ATTRIBUTE_NAMES.find((n) => n.toLowerCase() === a.name.toLowerCase())
             const hint = a.name === "IntRange" ? "; a whole number slider is [Range(min, max, 1)]" : ""

package/src/lang/builtins.ts

@@ -137,6 +137,8 @@ function point(fn: string, v: Num): Val {
 
 special(SLOP.SAMPLE, 2, 2)
 special(SLOP.SAMPLE_LOD, 3, 3)
+special(SLOP.TEXTURE_SIZE, 1, 1)
+special(SLOP.SAMPLE_FETCH, 2, 2)
 special(SLOP.SDF, 1, 7)
 special(SLOP.RAMP, 3, 64)
 

package/src/lang/check.ts

@@ -34,7 +34,7 @@ import { SL_GLSL_HINT } from "../ops"
 import { BUILTINS, NOT_YET } from "./builtins"
 import { SL_SDF_SHAPES } from "../shapes"
 import { TYPE_WIDTH, type Expr, type FuncDecl, type Stmt, type Unit } from "./ast"
-import { readAttributes } from "./attributes"
+import { readAttributes, readTextureAttributes } from "./attributes"
 import { SLParseError, type Pos, type SLFix } from "./lexer"
 
 const INPUT_NAMES = new Set(Object.keys(INPUTS))
@@ -68,7 +68,7 @@ const GLSL_RENAMES = new Set([
 ])
 
 /** The builtins whose first argument is a texture, which is not a value anywhere else. */
-const SAMPLES = new Set(["tex2D", "tex2Dlod"])
+const SAMPLES = new Set(["tex2D", "tex2Dlod", "textureSize", "tex2Dfetch"])
 
 const rename = (from: string, to: string): SLFix => ({ title: `Replace ${from} with ${to}`, replacement: to })
 
@@ -188,6 +188,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
             const clash = valueClash(t.name)
             if (clash !== null) fail(`"${t.name}" already names ${clash}`, t.pos, t.name.length)
         })
+        for (const p of readTextureAttributes(t).problems) attempt(() => fail(p.message, p.pos, p.length, p.fix))
         if (!textures.has(t.name)) textures.set(t.name, t)
     }
     attempt(() => {
@@ -512,7 +513,7 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                 if (textures.has(e.name)) {
                     fail(
                         `"${e.name}" is a texture, and a texture is only ever the first argument of ` +
-                        `tex2D or tex2Dlod. Write \`tex2D(${e.name}, uv)\``,
+                        `tex2D, tex2Dlod, tex2Dfetch or textureSize. Write \`tex2D(${e.name}, uv)\``,
                         e.pos, e.name.length,
                     )
                 }
@@ -636,11 +637,18 @@ export function check(unit: Unit, prelude: FuncDecl[], options: CheckOptions = {
                         e.pos,
                     )
                 }
+                if (previous && n === "textureSize") {
+                    fail("previous is the size this program draws at, which is `resolution`", e.pos)
+                }
+                if (previous && n === "tex2Dfetch") {
+                    fail("previous is read at a uv: `tex2D(previous, uv)`, or `tex2D(previous, (pixel + 0.5) / resolution)` for a pixel", e.pos)
+                }
                 if (!previous && (tex === undefined || tex.k !== "ident" || !textures.has(tex.name))) {
-                    const lod = n === "tex2Dlod" ? ", 0" : ""
+                    const rest = n === "tex2Dlod" ? "uv, 0" : n === "textureSize" ? "" : n === "tex2Dfetch" ? "pixel" : "uv"
+                    const verb = n === "textureSize" ? "measures" : n === "tex2Dfetch" ? "reads" : "samples"
                     fail(
-                        `${n} samples a texture declared in this file, as in \`texture2D grain;\` ` +
-                        `then \`${n}(grain, uv${lod})\``,
+                        `${n} ${verb} a texture declared in this file, as in \`texture2D grain;\` ` +
+                        `then \`${n}(grain${rest === "" ? "" : ", " + rest})\``,
                         (tex ?? e).pos,
                     )
                 }

package/src/lang/classify.ts

@@ -46,11 +46,54 @@ const INPUT_NAMES: ReadonlySet<string> = new Set([...Object.keys(SOURCE_INPUTS),
 
 /** The tokens of `source`, comments included, in order, each with its class. */
 export function classify(source: string): SLClassifiedToken[] {
+    return run(source, "", "").tokens
+}
+
+/**
+ * Where a line starts, for `classifyLine`: what the lines before it leave
+ * behind that changes how it reads.
+ */
+export interface SLLineState {
+    /** The line before ended inside a block comment. */
+    readonly comment: boolean
+    /** The last two tokens before the line that were not comments, which decide what a name after a dot or a bracket is. */
+    readonly before: string
+    readonly beforeThat: string
+}
+
+const FIRST_LINE: SLLineState = { comment: false, before: "", beforeThat: "" }
+
+/**
+ * One line of a file, for an editor that colours a line at a time, as Monaco
+ * does: its tokens, with offsets within the line, and the state the next line
+ * starts from. Classifying every line of a file this way, each from the state
+ * the one before ended in, gives exactly what `classify` gives the whole file,
+ * a block comment over several lines coming back as one piece per line.
+ */
+export function classifyLine(line: string, state: SLLineState = FIRST_LINE): { tokens: SLClassifiedToken[]; state: SLLineState } {
+    // A line that starts inside a block comment is read with the comment's
+    // opening put back in front, so the lexer decides where it closes, and
+    // those two characters are taken off the tokens again.
+    const shift = state.comment ? 2 : 0
+    const read = run(state.comment ? "/*" + line : line, state.before, state.beforeThat)
+    const last = read.tokens[read.tokens.length - 1]
+    const comment = last !== undefined && last.kind === "comment" && last.text.startsWith("/*")
+        && !(last.text.length >= 4 && last.text.endsWith("*/"))
+    const tokens: SLClassifiedToken[] = []
+    for (const t of read.tokens) {
+        if (shift === 0) { tokens.push(t); continue }
+        if (t.offset === 0) {
+            if (t.length > shift) tokens.push({ ...t, text: t.text.slice(shift), length: t.length - shift })
+        } else {
+            tokens.push({ ...t, col: t.col - shift, offset: t.offset - shift })
+        }
+    }
+    return { tokens, state: { comment, before: read.before, beforeThat: read.beforeThat } }
+}
+
+function run(source: string, before: string, beforeThat: string): { tokens: SLClassifiedToken[]; before: string; beforeThat: string } {
     const tokens = lex(source, "", true)
     const out: SLClassifiedToken[] = []
-    // The last token that was not a comment, which decides what a name after a dot is.
-    let before = ""
-    let beforeThat = ""
     for (const t of tokens) {
         if (t.kind === "eof") break
         let kind: SLTokenClass
@@ -68,7 +111,8 @@ export function classify(source: string): SLClassifiedToken[] {
             kind = t.kind
         }
         out.push({ kind, text: t.text, line: t.line, col: t.col, offset: t.offset, length: t.length })
+        // The last token that was not a comment, which decides what a name after a dot is.
         if (t.kind !== "comment") { beforeThat = before; before = t.text }
     }
-    return out
+    return { tokens: out, before, beforeThat }
 }

package/src/lang/glsl.ts

@@ -98,10 +98,8 @@ const MISSING: Record<string, string> = {
     iFrameRate: "there is no frame rate",
     iDate: "there is no date",
     iChannelTime: "a texture has no time of its own",
-    iChannelResolution: "a texture's size cannot be read yet",
+    iChannelResolution: "write textureSize(iChannel0) for a channel's width and height",
     iSampleRate: "there is no audio",
-    texelFetch: "a texture cannot be read without filtering yet",
-    textureSize: "a texture's size cannot be read yet",
     dFdx: "there are no derivatives", dFdy: "there are no derivatives", fwidth: "there are no derivatives",
 }
 
@@ -490,6 +488,8 @@ export function fromGLSL(glsl: string, options: { file?: string } = {}): FromGLS
     // ---------- the rewrite ----------
 
     const textures = new Set<string>()
+    /** Channels the shader declares itself, as a WebGL port of a Shadertoy shader does, which need no second declaration. */
+    const declaredChannels = new Set<string>()
     let mouse = false
     let uvDropped = false
 
@@ -530,6 +530,8 @@ export function fromGLSL(glsl: string, options: { file?: string } = {}): FromGLS
                 // `uniform sampler2D tex;` is `texture2D tex;`.
                 out += "texture2D"
                 i = skip(i + 1)
+                const declares = toks[skip(i + 1)]?.text ?? ""
+                if (/^iChannel\d$/.test(declares)) declaredChannels.add(declares)
                 continue
             }
             if (name === "sampler2D") { out += "texture2D"; continue }
@@ -616,6 +618,13 @@ export function fromGLSL(glsl: string, options: { file?: string } = {}): FromGLS
                     call = `pow(2.0, ${a[0]})`
                 } else if (name === "log2" && a.length === 1) {
                     call = `(log(${a[0]}) * 1.4426950408889634)`
+                } else if ((name === "texelFetch" && a.length === 3) || (name === "textureSize" && a.length === 2)) {
+                    // Both read the full size texture here, so the level goes.
+                    const level = a[a.length - 1]!
+                    if (!/^0(\.0*)?$/.test(level)) {
+                        note(t.line, `${name} reads level ${level} in GLSL, and ${name === "texelFetch" ? "tex2Dfetch" : name} reads the full size texture here`)
+                    }
+                    call = name === "texelFetch" ? `tex2Dfetch(${a[0]}, ${a[1]})` : `textureSize(${a[0]})`
                 }
                 if (call !== null) { out += call; i = close; continue }
             }
@@ -683,7 +692,7 @@ export function fromGLSL(glsl: string, options: { file?: string } = {}): FromGLS
         note(at >= 0 ? toks[at]!.line : 1, "the uv line is dropped: fragCoord / resolution is the input uv, y up")
     }
 
-    const declared = [...textures].sort().map((t) => `texture2D ${t};`)
+    const declared = [...textures].filter((t) => !declaredChannels.has(t)).sort().map((t) => `texture2D ${t};`)
     if (mouse) declared.unshift("uniform float4 mouse;")
     const source = (declared.length > 0 ? declared.join("\n") + "\n" : "") + body.replace(/^\n+/, "")
     const lineOf = (n: string) => Number(/^line (\d+)/.exec(n)?.[1] ?? 0)