onejs-sl 0.7.0 → 0.9.0

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)

package/src/lang/index.ts

@@ -33,8 +33,8 @@ export { TYPE_WIDTH } from "./ast"
 export { SLParseError }
 export type { Pos, SLFix, Token } from "./lexer"
 export { tokenize } from "./lexer"
-export { classify } from "./classify"
-export type { SLClassifiedToken, SLTokenClass } from "./classify"
+export { classify, classifyLine } from "./classify"
+export type { SLClassifiedToken, SLLineState, SLTokenClass } from "./classify"
 export { SL_KEYWORDS, SL_TYPES } from "./words"
 export { parseUnit } from "./parser"
 export { PRELUDE_SOURCE, preludeFunctions } from "./prelude"

package/src/lang/lower.ts

@@ -58,7 +58,7 @@ import type { SlSdfKind } from "../shapes"
 import * as sl from "../sl"
 import { Val, type Num } from "../sl"
 import { TYPE_KIND, TYPE_WIDTH, type BinaryOp, type Expr, type FuncDecl, type Stmt, type TypeName } from "./ast"
-import { readAttributes } from "./attributes"
+import { readAttributes, readTextureAttributes } from "./attributes"
 import { BUILTINS } from "./builtins"
 import { terminates, type Checked } from "./check"
 import { SLParseError, type Pos } from "./lexer"
@@ -288,7 +288,10 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
                 global.declare(u.name, { width, kind: TYPE_KIND[u.type], value })
             }
 
-            for (const t of unit.textures) samplers.set(t.name, at(t.pos, () => sl.texture(t.name)))
+            // The checker reported any attribute it could not read; what it could goes in.
+            for (const t of unit.textures) {
+                samplers.set(t.name, at(t.pos, () => sl.texture(t.name, readTextureAttributes(t).sampling)))
+            }
             // Unless the file declared a texture of its own by the name. The
             // checker refuses tex2Dlod on it, and anything else that took the
             // name, before lowering could reach either.
@@ -296,6 +299,8 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
                 samplers.set(PREVIOUS, {
                     sample: (uv) => inputs.previous.sample(uv),
                     sampleLevel: () => { throw new Error("tex2Dlod(previous) reached lowering; the checker refuses it") },
+                    size: () => { throw new Error("textureSize(previous) reached lowering; the checker refuses it") },
+                    fetch: () => { throw new Error("tex2Dfetch(previous) reached lowering; the checker refuses it") },
                 })
             }
 
@@ -1160,6 +1165,16 @@ export function lower(checked: Checked, errors?: SLParseError[]): Program {
         if (n === "int" || n === "uint" || n === "bool") return convert(n, e, scope)
         if (n in TYPE_WIDTH) return construct(n as TypeName, floats(e.args), e.pos)
 
+        if (n === "textureSize" || n === "tex2Dfetch") {
+            const tex = samplers.get((e.args[0] as Extract<Expr, { k: "ident" }>).name)!
+            if (n === "textureSize") return at(e.pos, () => tex.size() as unknown as Val)
+            const pixel = toFloat(lowerExpr(e.args[1]!, scope), e.args[1]!.pos)
+            if (typeof pixel === "number" || pixel.width !== 2) {
+                fail("tex2Dfetch reads at a float2 pixel, as in tex2Dfetch(t, fragCoord)", e.args[1]!.pos)
+            }
+            return at(e.pos, () => tex.fetch(pixel as never) as unknown as Val)
+        }
+
         if (n === "tex2D" || n === "tex2Dlod") {
             const texName = (e.args[0] as Extract<Expr, { k: "ident" }>).name
             const tex = samplers.get(texName)!

package/src/lang/parser.ts

@@ -212,17 +212,18 @@ class Parser {
 
         if (t.text === "[") {
             const attrs = this.parseAttributes()
+            if (this.at("texture2D")) { unit.textures.push(this.parseTexture(attrs)); return }
             if (!this.at("uniform")) {
                 this.fail(
-                    `an attribute belongs on a uniform, as in \`[Range(0, 1)] uniform float amount = 0.5;\`, ` +
-                    `and this one is followed by ${describe(this.peek())}`, t,
+                    `an attribute belongs on a uniform or a texture, as in \`[Range(0, 1)] uniform float amount = 0.5;\` ` +
+                    `or \`[Wrap(Repeat)] texture2D grain;\`, and this one is followed by ${describe(this.peek())}`, t,
                 )
             }
             unit.uniforms.push(this.parseUniform(attrs))
             return
         }
         if (t.text === "uniform") { unit.uniforms.push(this.parseUniform([])); return }
-        if (t.text === "texture2D") { unit.textures.push(this.parseTexture()); return }
+        if (t.text === "texture2D") { unit.textures.push(this.parseTexture([])); return }
         if (t.text === "const") { unit.consts.push(this.parseConst()); return }
         if (t.kind === "ident") {
             const fn = this.parseFunction()
@@ -277,7 +278,7 @@ class Parser {
         this.fail(`expected a number, a word or a "string" as an attribute's argument, got ${describe(t)}`, t)
     }
 
-    private parseTexture(): TextureDecl {
+    private parseTexture(attrs: Attribute[]): TextureDecl {
         const kw = this.next()
         const name = this.expectName("a texture name")
         if (this.at("=")) {
@@ -287,7 +288,7 @@ class Parser {
             )
         }
         this.expect(";", "after a texture declaration")
-        return { name: name.text, pos: kw }
+        return { name: name.text, attrs, pos: kw }
     }
 
     private parseConst(): Extract<Stmt, { k: "const" }> {

package/src/ops.ts

@@ -26,16 +26,21 @@
  * for a host to read.
  *
  * 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.
+ * 64 slots in the editor, a native player and a browser alike
+ * (`SLProgramBridge.MaxUniforms`, the web frame's `sl_U`), and binds eight
+ * textures everywhere (`_Tex0` to `_Tex7`). 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.
+ *
+ * Both sit inside every backend's minimum (`Specs/SL_NEXT.md` 8). Eight
+ * textures and the previous frame are nine sampled textures and at most nine
+ * samplers, where WebGPU, WebGL2, OpenGL ES 3 and Direct3D 11 all guarantee 16
+ * a fragment stage. 64 float4s are 1 KB of uniforms, where WebGL2 and OpenGL
+ * ES 3 guarantee 224 vectors and WebGPU 64 KB.
  */
-export const UNIFORM_SLOTS = 16
-export const TEXTURE_SLOTS = 4
+export const UNIFORM_SLOTS = 64
+export const TEXTURE_SLOTS = 8
 
 /** Input ids, which the web emitter switches on. */
 export const INPUT_ID: Record<string, number> = {
@@ -149,6 +154,11 @@ export const SLOP = {
     // What this program drew the frame before, at a uv (IR 5). No slot: the
     // host keeps it, and a program that never reads it has none.
     SAMPLE_PREVIOUS: 146,
+    // IR 6. A texture's size in pixels, a float2, its slot the one immediate.
+    TEXTURE_SIZE: 147,
+    // IR 6. One texel, unfiltered, at a float2 pixel: floored and held inside
+    // the texture, so every backend reads the same texel at every pixel.
+    SAMPLE_FETCH: 148,
 } as const
 
 export type SLOpCode = (typeof SLOP)[keyof typeof SLOP]
@@ -191,6 +201,7 @@ export const SL_ARITY: Record<number, number> = {
     [SLOP.VORONOI]: 1, [SLOP.TURBULENCE]: -1, [SLOP.RIDGED]: -1,
 
     [SLOP.SAMPLE]: 1, [SLOP.SAMPLE_LOD]: 2, [SLOP.SAMPLE_PREVIOUS]: 1,
+    [SLOP.TEXTURE_SIZE]: 0, [SLOP.SAMPLE_FETCH]: 1,
 }
 
 /** Name per opcode, for error messages and for the HLSL emitter's comments. */
@@ -316,6 +327,8 @@ export const SL_HLSL: Record<number, SLSurface> = {
     [SLOP.SAMPLE]: { call: "tex2D" },
     [SLOP.SAMPLE_LOD]: { call: "tex2Dlod" },
     [SLOP.SAMPLE_PREVIOUS]: { syntax: "tex2D(previous, uv)" },
+    [SLOP.TEXTURE_SIZE]: { call: "textureSize" },
+    [SLOP.SAMPLE_FETCH]: { call: "tex2Dfetch" },
 }
 
 /**
@@ -347,6 +360,7 @@ export const SL_GLSL_HINT: Record<string, string> = {
     mod: "%",
     texture: "tex2D",
     textureLod: "tex2Dlod",
+    texelFetch: "tex2Dfetch",
     vec2: "float2",
     vec3: "float3",
     vec4: "float4",

package/src/params.ts

@@ -21,7 +21,7 @@ import { LIB_FUNCTIONS, SDF_CALLS } from "./lib/table"
 import { LIB_PARAM_NAMES } from "./lib/names"
 import { SL_SDF_PARAMS, SL_SDF_SHAPES, type SlSdfKind } from "./shapes"
 import type { PREVIOUS, SourceInputName } from "./ir"
-import type { AttributeName } from "./lang/attributes"
+import type { AttributeName, TextureAttributeName } from "./lang/attributes"
 
 /** One function of the helper library, as its source declares it. */
 export interface LibSignature {
@@ -55,6 +55,8 @@ const INTRINSIC: Record<string, readonly string[]> = {
     lerp: ["x", "y", "s"], step: ["y", "x"], smoothstep: ["min", "max", "x"],
     tex2D: ["s", "t"],
     tex2Dlod: ["s", "t", "lod"],
+    textureSize: ["s"],
+    tex2Dfetch: ["s", "pixel"],
 }
 
 /**
@@ -162,7 +164,9 @@ export const BUILTIN_DOCS: Readonly<Record<string, string>> = {
     turbulence: "Simplex creases layered in octaves, 1 to 4: fire, smoke, marble.",
     ridged: "Turbulence made bright at its creases: ridges, lightning, cracks.",
     tex2D: "The colour of texture s at the uv t, with straight alpha.",
-    tex2Dlod: "The colour of texture s at the uv t from mip level lod: 0 is the full size, 1 half, and so on.",
+    tex2Dlod: "Texture s at uv t from mip level lod: 0 is full size, 1 half, and a fraction blends the two.",
+    textureSize: "The width and height of texture s in pixels, at full size, as a float2.",
+    tex2Dfetch: "One texel of texture s at pixel, unfiltered; a pixel past an edge reads the edge.",
     sdf: "The signed distance from p to a shape, negative inside: `sdf.circle(p, r)`.",
     ramp: "t mapped through evenly spaced colour stops, from the first at 0 to the last at 1.",
 }
@@ -181,6 +185,12 @@ export const ATTRIBUTE_DOCS: Readonly<Record<AttributeName, string>> = {
     Hide: "No control: the host sets this uniform from code.",
 }
 
+/** One line on each texture attribute, for the same tooltips. */
+export const TEXTURE_ATTRIBUTE_DOCS: Readonly<Record<TextureAttributeName, string>> = {
+    Wrap: "How uv outside 0 to 1 reads: [Wrap(Repeat)] tiles, [Wrap(Mirror)] tiles mirrored, [Wrap(Clamp)] holds the edge.",
+    Filter: "How the texture reads between texels: [Filter(Point)] the nearest, [Filter(Linear)] a blend of four.",
+}
+
 /**
  * One line on each input, for the same tooltips. In the words of no one host:
  * the output is a UI element in OneJS and an image on a Magerie board, and the

package/src/serial.ts

@@ -10,10 +10,13 @@
  */
 import {
     INPUTS, STEP_INPUTS, SLError, SL_HASH_VERSION, SL_IR_VERSION, TYPE, checkCaps, controlOf, controlProblem, formProblem, hashProgram, intUniformProblem,
-    programVersion, type HostInputName, type NodeRef, type Program, type SLNode, type SLType, type TextureDecl, type UniformDecl,
+    programVersion, samplingProblem, type HostInputName, type NodeRef, type Program, type SLNode, type SLType, type TextureDecl, type UniformDecl,
 } from "./ir"
 import { SLOP, SL_ARITY, SL_NAME } from "./ops"
 
+/** The ops that name a texture slot in their first immediate. */
+const TEXTURE_OPS = new Set<number>([SLOP.SAMPLE, SLOP.SAMPLE_LOD, SLOP.TEXTURE_SIZE, SLOP.SAMPLE_FETCH])
+
 const HOST_INPUTS: Readonly<Record<HostInputName, SLType>> = { ...INPUTS, ...STEP_INPUTS }
 
 export interface ProgramJSON {
@@ -54,7 +57,8 @@ export function fromJSON(json: unknown): Program {
     // as they are) or was edited. One that claims less than its nodes need
     // holds something its version never had, and a version 1 file has
     // nothing IR 3 added.
-    const needs = programVersion(written, j.result!)
+    const textures = (j.textures ?? []).map(texture)
+    const needs = programVersion(written, j.result!, textures)
     if (v < needs && (v >= 2 || needs >= 3)) fail(`it says IR version ${v} and holds nodes version ${needs} added; it was changed after it was written`)
     const { nodes, result } = v < 3 ? toOperands(written, j.result!) : { nodes: written, result: j.result! }
     nodes.forEach((n, i) => {
@@ -64,12 +68,14 @@ export function fromJSON(json: unknown): Program {
     const out = nodes[result]!
     if (out.k === "if" || out.k === "loop" || out.type !== TYPE.VEC4 || out.kind !== undefined) 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`)
+        if (n.k === "call" && TEXTURE_OPS.has(n.op) && !(n.imm !== undefined && n.imm[0]! < textures.length)) {
+            fail(`a node reads texture slot ${String(n.imm?.[0])}, which is not declared`)
+        }
     }
-    const version = programVersion(nodes, result)
+    const version = programVersion(nodes, result, textures)
     const hash = hashProgram(nodes, result, uniforms, textures)
     // The same IR version and hash scheme, so the same hash; a different one
     // means the file was edited or damaged, and its cached shader belongs to
@@ -245,7 +251,12 @@ function uniform(u: unknown, i: number): UniformDecl {
 function texture(t: unknown, i: number): TextureDecl {
     const x = (t ?? {}) as Partial<TextureDecl>
     if (typeof x.name !== "string" || x.slot !== i) fail(`texture ${i} needs a name and slot ${i}`)
-    return { name: x.name!, slot: i }
+    const problem = samplingProblem(x)
+    if (problem !== null) fail(`texture ${i}: ${problem}`)
+    const out: TextureDecl = { name: x.name!, slot: i }
+    if (x.wrap !== undefined) out.wrap = x.wrap
+    if (x.filter !== undefined) out.filter = x.filter
+    return out
 }
 
 function fail(why: string): never {

package/src/sl.ts

@@ -25,7 +25,8 @@
 import { parseColor as parseHex } from "./color"
 import {
     Builder, INPUTS, RAMP_STOP_COMPUTED, STEP_INPUTS, SLError, TYPE, hashProgram, programVersion, truncateHeld, widthName, writtenColour,
-    type HostInputName, type InputName, type NodeRef, type Program, type SLKind, type SLNode, type SLType, type UniformControl,
+    type HostInputName, type InputName, type NodeRef, type Program, type SLKind, type SLNode, type SLType, type TextureFilter,
+    type TextureWrap, type UniformControl,
 } from "./ir"
 import { SLOP, SL_HLSL, SL_NAME, type SLOpCode } from "./ops"
 import { SL_SDF_PARAMS, SL_SDF_SHAPES, type SlSdfKind } from "./shapes"
@@ -561,7 +562,7 @@ export function program(fn: (inputs: ProgramInputs) => Vec4): Program {
         }
         const nodes: SLNode[] = b.nodes.slice()
         return {
-            version: programVersion(nodes, out.ref),
+            version: programVersion(nodes, out.ref, b.textures),
             nodes,
             result: out.ref,
             uniforms: b.uniforms.slice(),
@@ -1033,19 +1034,42 @@ export const uniform = {
 }
 
 export interface Texture {
-    /** The colour at `uv`, filtered as the texture's own settings say. */
+    /**
+     * The colour at `uv`, filtered and wrapped as the texture's own settings
+     * say, or as `sl.texture`'s sampling says when it was given one.
+     */
     sample(uv: Vec2): Vec4
     /**
      * The colour at `uv` from mip level `lod`: 0 is the full size texture, 1
-     * half, and a fraction blends two levels where the texture's filter does.
-     * A texture with no mips has only level 0.
+     * half, and a fraction blends the two levels either side, whatever the
+     * texture's filter mode. A texture with no mips has only level 0.
      */
     sampleLevel(uv: Vec2, lod: Num): Vec4
+    /** The texture's width and height in pixels, at full size. `textureSize(t)` in a `.sl` file. */
+    size(): Vec2
+    /**
+     * One texel, unfiltered, at a pixel: (0, 0) is the texel `uv` (0, 0)
+     * samples. The pixel is floored and held inside the texture, so a pixel
+     * past an edge reads the edge on every host. Full size only, and the
+     * sampling settings do not apply. `tex2Dfetch(t, pixel)` in a `.sl` file.
+     */
+    fetch(pixel: Vec2): Vec4
 }
 
-export function texture(name: string): Texture {
+/**
+ * How a program samples a texture, when it should not follow the bound
+ * texture's own settings. Either half set, the program owns the sampler and
+ * the other half is clamp or linear. `[Wrap(Repeat)]` and `[Filter(Point)]`
+ * in a `.sl` file.
+ */
+export interface TextureSamplingOptions {
+    wrap?: TextureWrap
+    filter?: TextureFilter
+}
+
+export function texture(name: string, sampling: TextureSamplingOptions = {}): Texture {
     const b = ctx()
-    const slot = b.texture(name)
+    const slot = b.texture(name, sampling)
     return {
         sample(uv: Vec2): Vec4 {
             if (uv.owner !== b) throw new SLError("a value from another program cannot be used in this one")
@@ -1060,6 +1084,16 @@ export function texture(name: string): Texture {
             }
             return mk(b, b.call(SLOP.SAMPLE_LOD, TYPE.VEC4, [uv.ref, typeof level === "number" ? level : level.ref], [slot]), TYPE.VEC4)
         },
+        size(): Vec2 {
+            return mk(b, b.call(SLOP.TEXTURE_SIZE, TYPE.VEC2, [], [slot]), TYPE.VEC2)
+        },
+        fetch(pixel: Vec2): Vec4 {
+            if (pixel.owner !== b) throw new SLError("a value from another program cannot be used in this one")
+            if (pixel.width !== TYPE.VEC2 || pixel.kind !== undefined) {
+                throw new SLError(`a texel is fetched at a float2 pixel, and this is ${pixel.kind === undefined ? `a ${widthName(pixel.width)}` : `an ${pixel.kind}`}`)
+            }
+            return mk(b, b.call(SLOP.SAMPLE_FETCH, TYPE.VEC4, [pixel.ref], [slot]), TYPE.VEC4)
+        },
     }
 }
 

package/src/tables.ts

@@ -16,9 +16,11 @@ export type { SLSurface } from "./ops"
 export { DERIVED_INPUTS, INPUTS, PREVIOUS, SOURCE_INPUTS, STEP_INPUTS } from "./ir"
 export type { DerivedInputName, HostInputName, InputName, SourceInputName, StepInputName } from "./ir"
 export { SL_SDF_SHAPES, SL_SDF_PARAMS } from "./shapes"
-export { ATTRIBUTE_DOCS, BUILTIN_DOCS, BUILTIN_PARAMS, INPUT_DOCS, LIB_SIGNATURES, SL_SDF_PARAM_NAMES } from "./params"
-export { ATTRIBUTE_NAMES } from "./lang/attributes"
-export type { AttributeName } from "./lang/attributes"
+export {
+    ATTRIBUTE_DOCS, BUILTIN_DOCS, BUILTIN_PARAMS, INPUT_DOCS, LIB_SIGNATURES, SL_SDF_PARAM_NAMES, TEXTURE_ATTRIBUTE_DOCS,
+} from "./params"
+export { ATTRIBUTE_NAMES, TEXTURE_ATTRIBUTE_NAMES } from "./lang/attributes"
+export type { AttributeName, TextureAttributeName } from "./lang/attributes"
 export { PRELUDE_DOCS, PRELUDE_NAMES } from "./lang/prelude-source"
 export { SL_KEYWORDS, SL_TYPES } from "./lang/words"
 export { TYPE_WIDTH } from "./lang/ast"