listOf(kind: string) → void

Every lookup enumerates a literal asset type, which is what a published world records, rather than resolving a computed name.

findAsset(kind: string, suffix: string) → any

shaderAt(path: string) → any

setClock(fn: (() → void

Drive the stack's clock (seconds) from a function, or nil to return to the shared clock.

sharedTime( ) → number

Wall-clock UTC in seconds with sub-second precision, the same on every machine whose clock is set right, or nil until it is known. `os.time()` gives whole UTC seconds; the moment it ticks over is caught against the engine's smooth real time, so from then on UTC is real time plus that offset, good to about a frame.

invalidateShaders( ) → void

Forget the shader index, so the next lookup reads the engine's list afresh (called when a block registers or is removed).

tier( ) → string

forceTier(tier: string?) → void

start( ) → void

Feature lifecycle

noteCpu(ms: number) → void

shaderAt(path: string) → any

The shader asset at a VFS path, found by listing (no computed resolve).

status( ) → void

timings( ) → void

freeTargets( ) → void

Targets and programs

targetsLost( ) → boolean

ensureTargets(ctx: any, tier: string) → void

rt(name: string, fmt: string, space: string, scale: number) → any

lazyTarget(name: string) → any

ensurePrograms( ) → boolean

hexToRgb(s: string) → void

Effects: one per entry (and one per published field)

toValue(v: any, kind: string?) → any

encode(v: any) → string

bindShared(name: string, T: any, writes: string?) → void

A field pass must not read the target it writes (a texture cannot be a colour target and a sampled resource in one pass), so it reads a small dummy in place of its own field.

ensureEffect(name: string, shaderPath: string) → boolean

resolvedSettings(block: any, entry: any, tier: string, schema: { any }) → void

schemaOf(shaderPath: string) → void

applySettings(name: string, values: { [string]: any }) → void

skyDistance( ) → number

Where the sky lies for a depth mask: the on-screen camera's far distance, read about once a second (a component read every frame would cost more than it is worth).

maskUniforms(mask: any, skyDist: number?) → void

setFrameUniforms(name: string, entry: any, layerMode: number, F: any) → void

Each call into the engine costs CPU time, many times more on the web, so an effect's uniforms are written only when what they hold has changed: the frame key covers the stack's revision (any edit of an entry, here or on another machine), the tier and the shared frame inputs; the clock is written when the held step moves (8 times a second by default).

settingsFor(name: string, block: any, entry: any, tier: string, shaderPath: string, F: any) → void

A block's settings, resolved and written only when the frame key moves.

schemaHas(shaderPath: string, prop: string) → boolean

The scene's sun (direction toward it, w 1 when there is a sun with light) for a block whose shader declares `sk_sun`, written when it changes.

sunFor(name: string, shaderPath: string, F: any) → void

sceneSun(force: boolean) → void

Read every 4 frames (a sun crossing the sky moves a raking light by a hair between reads, where once a second stepped it visibly), at once when `force` (the stack changed: a new look, a new scene's stack), and every frame while someone drives the clock (the Lookbook, a recording), so a run never draws with the light of what came before it and repeats exactly.

bindExtras(name: string, soft: boolean, pigments: boolean, rendered: boolean, paper: boolean?) → void

The extra inputs a block declares after the shared header: the soft field and the scene's pigment palette, bound once per effect (and again whenever the images behind them are made anew).

ensurePalette(opts: any) → void

The scene's pigment set as a 16 x 1 float image, rewritten only when the set (or the sets installed) change.

softField(src: string, T: any, F: any, opts: any, order: number, q: (any) → void

The soft field: one direction across, then down, at half the chain's resolution, weighted by depth so far surfaces never take colour from near ones in front of them. Returns the next free pass order.

retire(used: { [string]: boolean }) → void

releaseAll( ) → void

With no live block the stack leaves nothing of its own behind: every block effect and internal effect is removed, the targets, buffer and mask materials are freed and the render feature itself is torn down. The next block registers them afresh.

holdsAnything( ) → boolean

Whether the runtime holds anything at all (effects, targets, programs or its render feature).

idle( ) → void

resolveEntry(v: any) → void

An exclude or group entry names entities by id or by name. A name is what a scene should store: an id written into a field's value is not carried over when the scene is saved and loaded again (the entity comes back under a new id), a name is. `{ id = ... }` and `{ name = ... }` tables work too.

objectGroups(opts: any) → void

Returns the groups and whether some entry found nothing yet (an entity that arrives later, or a scene still loading), so the caller can look again.

add(ch: number, list: any) → void

render(ctx: any, ordered: { any }, opts: any, registry: { [string]: any }, _revision: number) → void

q(spec: any) → void

layeredField(passes: { any }, prop: string, final: any, second: string, neutral: string, writes: string) → boolean

Several passes into one shared field: each later one reads the one before as `prop` and mixes itself over it, ping-ponging between two images so the last lands in `final`.