onejs-sl 0.1.8 → 0.1.10

package/src/sl.ts

@@ -25,7 +25,7 @@
 import { parseColor as parseHex } from "./color"
 import {
     Builder, INPUTS, SLError, SL_IR_VERSION, TYPE, hashProgram, widthName,
-    type InputName, type NodeRef, type Program, type SLNode, type SLType,
+    type InputName, type NodeRef, type Program, type SLNode, type SLType, type UniformControl,
 } from "./ir"
 import { SLOP, type SLOpCode } from "./ops"
 import { SL_SDF_PARAMS, SL_SDF_SHAPES, type SlSdfKind } from "./shapes"
@@ -254,6 +254,10 @@ export interface ProgramInputs {
     resolution: Vec2
     time: Float
     aspect: Float
+    /** One pixel, in uv: `1 / resolution`. Recorded only if read. */
+    texel: Vec2
+    /** `(uv - 0.5) * vec2(aspect, 1)`: 0 at the centre, and a circle stays round. Recorded only if read. */
+    centered: Vec2
 }
 
 /**
@@ -271,6 +275,12 @@ export function program(fn: (inputs: ProgramInputs) => Vec4): Program {
             const ref = b.add({ k: "input", type: width as SLType, name: name as InputName })
             ;(inputs as any)[name] = mk(b, ref, width as SLType)
         }
+        // Getters, so a program that never reads one records nothing for it
+        // (DERIVED_INPUTS in ir.ts). A second read is hash consed to the first.
+        Object.defineProperties(inputs, {
+            texel: { enumerable: true, get: () => vec2(1, 1).div(inputs.resolution) },
+            centered: { enumerable: true, get: () => inputs.uv.sub(0.5).mul(vec2(inputs.aspect, 1)) },
+        })
         const out = fn(inputs)
         if (!(out instanceof Val)) throw new SLError("a program must return an sl value, not " + typeof out)
         if (out.width !== TYPE.VEC4) {
@@ -655,40 +665,49 @@ export function voronoi(p: Vec2): Float {
     return mk(p.owner, p.owner.call(SLOP.VORONOI, TYPE.FLOAT, [p.ref]), TYPE.FLOAT)
 }
 
+/**
+ * A uniform: a value the host sets by name, with the default the program
+ * starts from. The last argument says how a host presents it, a slider, a
+ * checkbox, a dropdown, a heading or a label, and is what `[Range(0, 2)]` and
+ * the other attributes write in a `.sl` file. It never changes the hash.
+ *
+ *     sl.uniform.float("warp", 1, { range: { min: 0, max: 2 } })
+ */
 export const uniform = {
-    float(name: string, value = 0): Float {
+    float(name: string, value = 0, control: UniformControl = {}): Float {
         const b = ctx()
-        return mk(b, b.uniform(name, TYPE.FLOAT, [value]), TYPE.FLOAT)
+        return mk(b, b.uniform(name, TYPE.FLOAT, [value], false, control), TYPE.FLOAT)
     },
-    vec2(name: string, value: [number, number] = [0, 0]): Vec2 {
+    vec2(name: string, value: [number, number] = [0, 0], control: UniformControl = {}): Vec2 {
         const b = ctx()
-        return mk(b, b.uniform(name, TYPE.VEC2, value), TYPE.VEC2)
+        return mk(b, b.uniform(name, TYPE.VEC2, value, false, control), TYPE.VEC2)
     },
-    vec3(name: string, value: [number, number, number] = [0, 0, 0]): Vec3 {
+    vec3(name: string, value: [number, number, number] = [0, 0, 0], control: UniformControl = {}): Vec3 {
         const b = ctx()
-        return mk(b, b.uniform(name, TYPE.VEC3, value), TYPE.VEC3)
+        return mk(b, b.uniform(name, TYPE.VEC3, value, false, control), TYPE.VEC3)
     },
-    vec4(name: string, value: [number, number, number, number] = [0, 0, 0, 1]): Vec4 {
+    vec4(name: string, value: [number, number, number, number] = [0, 0, 0, 1], control: UniformControl = {}): Vec4 {
         const b = ctx()
-        return mk(b, b.uniform(name, TYPE.VEC4, value), TYPE.VEC4)
+        return mk(b, b.uniform(name, TYPE.VEC4, value, false, control), TYPE.VEC4)
     },
     /**
-     * A colour, defaulting to `hex` as written (sRGB, the way CSS reads it).
-     * Returns it converted to linear, as a hex literal is, and marks the
-     * declaration `colour` so a host can offer a colour picker for it. Three
-     * components when `width` is 3, dropping the alpha.
+     * A colour, defaulting to `hex` as written (sRGB, the way CSS reads it), or
+     * to components written the same way. Returns it converted to linear, as a
+     * hex literal is, and marks the declaration `colour` so a host can offer a
+     * colour picker for it. Three components when `width` is 3, dropping the
+     * alpha.
      */
-    colour: ((name: string, hex: string, width: 3 | 4 = 4): Vec3 | Vec4 => {
+    colour: ((name: string, hex: string | readonly number[], width: 3 | 4 = 4, control: UniformControl = {}): Vec3 | Vec4 => {
         const b = ctx()
-        const c = parseHex(hex)
+        const c = typeof hex === "string" ? parseHex(hex) : [hex[0] ?? 0, hex[1] ?? 0, hex[2] ?? 0, hex[3] ?? 1]
         const type = width === 3 ? TYPE.VEC3 : TYPE.VEC4
-        const raw = mk(b, b.uniform(name, type, c.slice(0, width), true), type)
+        const raw = mk(b, b.uniform(name, type, c.slice(0, width), true, control), type)
         return toLinear(raw) as Vec3 | Vec4
     }) as {
-        (name: string, hex: string): Vec4
-        (name: string, hex: string, width: 3): Vec3
-        (name: string, hex: string, width: 4): Vec4
-        (name: string, hex: string, width: 3 | 4): Vec3 | Vec4
+        (name: string, hex: string | readonly number[]): Vec4
+        (name: string, hex: string | readonly number[], width: 3, control?: UniformControl): Vec3
+        (name: string, hex: string | readonly number[], width: 4, control?: UniformControl): Vec4
+        (name: string, hex: string | readonly number[], width: 3 | 4, control?: UniformControl): Vec3 | Vec4
     },
 }
 

package/src/tables.ts

@@ -13,9 +13,12 @@ export {
     SLOP, SL_ARITY, SL_NAME, SL_HLSL, SL_CALL_NAMES, SL_GLSL_HINT, SL_UNIMPLEMENTED,
 } from "./ops"
 export type { SLSurface } from "./ops"
-export { INPUTS } from "./ir"
+export { DERIVED_INPUTS, INPUTS, SOURCE_INPUTS } from "./ir"
+export type { DerivedInputName, InputName, SourceInputName } from "./ir"
 export { SL_SDF_SHAPES, SL_SDF_PARAMS } from "./shapes"
-export { BUILTIN_DOCS, BUILTIN_PARAMS, INPUT_DOCS, LIB_SIGNATURES, SL_SDF_PARAM_NAMES } from "./params"
+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 { PRELUDE_DOCS, PRELUDE_NAMES } from "./lang/prelude-source"
 export { SL_KEYWORDS, SL_TYPES } from "./lang/words"
 export { TYPE_WIDTH } from "./lang/ast"