breathe( ) → void

Yield a frame once a bake has held the engine for 50 ms, so a long bake never freezes the editor.

mul32(a: number, b: number) → number

rng(seed: number) → void

A deterministic random stream: rng() returns [0, 1).

hash(a: number, b: number?, c: number?) → number

A stable 0..1 hash of up to three integers (cell ids, blocks).

field(n: number, v: number?) → Field

value2(n: number, fx: number, fy: number, seed: number, out: Field?, amp: number?) → Field

One octave of periodic value noise, fx cells across and fy cells along (integers), added into out scaled by amp.

fbm2(n: number, fx: number, fy: number, octaves: number, seed: number, gain: number?) → Field

Periodic fractal noise 0..1, octaves doubling from (fx, fy) cells; anisotropic when fx ~= fy.

fbm(n: number, f: number, octaves: number, seed: number, gain: number?) → Field

ridged(n: number, fx: number, fy: number, octaves: number, seed: number, sharp: number?) → Field

Periodic ridged noise 0..1 (1 on the ridge lines): 1 - |2·fbm - 1|, sharpened by `sharp` (a power).

worley2(n: number, cx: number, cy: number, seed: number, jitter: number?) → void

Periodic Worley cells, cx across by cy along (anisotropic cells). Returns F1, F2 (in cell units) and a 0..1 id per nearest cell.

poisson(tile: number, tileY: number, minDist: number, seed: number, maxPoints: number?, wRange: { number }?) → void

Periodic dart-throwing point set over a tile x tileY metre repeat: points at least `minDist` apart (wrapping), optional per-point radius range for power cells. Each point: { x, y (metres), w (weight radius, metres), id (0..1) }.

cells(n: number, tile: number, tileY: number, pts: { Point }, aspect: number?) → Cells

Periodic (power) Voronoi cells of a point set over a tile x tileY metre repeat, sampled on an n x n grid. Each point's `w` (metres) grows its cell (power distance d^2 - w^2), so stones of different sizes pack. `aspect` stretches distances along y (1 = isotropic). Returns the true distance to the cell border, the distance to the site, ids and site offsets.

courses(tile: number, tileY: number, rows: number, lenRange: { number }, hJitter: number, seed: number) → void

A periodic coursed layout over a tile x tileY metre repeat: `rows` courses (heights jittered by `hJitter`, summing to tileY), each cut into blocks of length between lenRange[1] and lenRange[2] metres with the cut positions wrapping across x. Returns the blocks; use M.blockField to rasterise.

blockField(n: number, tile: number, tileY: number, blocks: { Block }) → BlockMap

Rasterise a periodic block layout (M.courses) onto an n x n grid: distance to the block's own border, its id, and the pixel's position within it.

blur(n: number, src: Field, r: number, passes: number?) → Field

Periodic separable box blur of radius r texels (passes times, ~gaussian at 3).

normalize(n: number, f: Field, p: number?, q: number?) → Field

Remap a field so its p-th and q-th percentiles land at 0 and 1 (clamped).

sample(n: number, f: Field, x: number, y: number) → number

Bilinear sample of a periodic field at fractional texel coordinates (x across, y along), wrapping.

warp(n: number, f: Field, wx: Field, wy: Field, amount: number) → Field

Domain warp: resample a periodic field with each pixel displaced by (wx, wy) fields (0..1, centred at 0.5) times `amount` texels.

resize(n: number, f: Field, m: number) → Field

Resample a periodic field to size m (box-filtered down, bilinear up).

smoothstep(a: number, b: number, x: number) → number

lerp(a: number, b: number, t: number) → number

lin(s: number) → number

Linear value of an sRGB 0..255 colour channel, for writing palettes the way they are measured.

rgb(r: number, g: number, b: number) → void

A linear RGB triple from an sRGB triple (0..255).

mix(a: { number }, b: { number }, t: number) → void

Linear interpolation between two linear RGB triples.

newMaps(n: number, tile: number) → Maps

A blank set of maps: mid-grey albedo, flat height, open AO, roughness 0.85.

aoFromHeight(m: Maps, radius: number, depth: number, strength: number) → void

Fill a stone's AO from its height: cavities `depth` metres below the local average (blur `radius` texels) go dark by `strength`.

percentile(f: Field, p: number) → number

The p-th percentile (0..1) of a field, from a sample of about 2048 values.

paint(m: Maps, col: (number) → void

Set each pixel's albedo from a linear RGB palette lookup: col(i) returns {r,g,b} for pixel i.

toSrgb8(c: number) → number

packAlbedo(n: number, r: Field, g: Field, b: Field) → buffer

Pack an albedo from three linear-colour fields into sRGB rgba8 bytes.

packAlbedoA(n: number, r: Field, g: Field, b: Field, a: Field) → buffer

Pack an albedo with coverage: three linear-colour fields and an alpha field (0..1) into sRGB rgba8 bytes. Fully transparent texels take the colour of the nearest opaque texel (M.bleed) before packing, so mip levels and filtering never pull a white or black fringe into a card's edge.

bleed(n: number, r: Field, g: Field, b: Field, a: Field, passes: number?) → void

Fill the colour of transparent texels (alpha < 0.5) outward from the opaque ones, a few texels per pass, so a card's edge filters to its own colour. Mutates r, g, b in place.

packMask(n: number, r: Field, g: Field, b: Field) → buffer

Pack three linear 0..1 fields into rgba8 bytes (R = AO, G = roughness, B = metallic).

packNormal(n: number, h: Field, tile: number, strength: number?) → buffer

Tangent-space normal map from a height field in METRES over a tile of `tile` metres. Raised areas face outward, so a sunk mortar joint or gap reads as a groove; green = image-up (OpenGL / glTF), the convention the engine reads.

cavity(n: number, h: Field, radius: number, depth: number, strength: number?) → Field

Cavity occlusion from height: 1 on tops, darker in pits and grooves. depth in metres for full dark.

keepSource(name: string, lossless: boolean?) → any

Re-create a baked texture with a source image beside its GPU data, so tools that read the source image (materialLibraryKit's texture-memory measure) see its real size. Colour and normal maps of 512 px and up keep a JPEG source (quality 95: about a third of the PNG's download, within ~2 code values of it); masks keep a lossless PNG, because they pack independent channels and metallic must stay exactly 0, and so do small and nearest-filtered (pixel, toon) textures. Settings are kept.

save(name: string, n: number, bytes: buffer, kind: string, filter: string?, clamp: boolean?, lossless: boolean?) → any

Write rgba8 bytes as a texture asset in the package's textures folder, with a source image kept (PNG for a card's albedo, whose alpha a JPEG would lose). kind: color | normalMap | mask. filter: linear (default) or nearest. `clamp` keeps a card from wrapping its edge into the opposite one.

rects(n: number, tile: number, rects: { Rect }) → RectMap

Rasterise a periodic layout of axis-aligned rectangles (metres, may run past the repeat and wrap) onto an n x n grid over a tile x tile repeat: which rectangle covers each pixel, the distance to its border and the pixel's position within it. Pixels no rectangle covers (the joints) get idx 0.

boxes(n: number, tile: number, boxes: { Box }) → RectMap

Rasterise periodic rotated rectangles (centre, half sizes and angle in radians; metres) onto an n x n grid over a tile x tile repeat, like M.rects: index, distance to the border, and the position within the box along its own long (u) and short (v) axes.

packMaskA(n: number, r: Field, g: Field, b: Field, a: Field) → buffer

Pack four linear 0..1 fields into rgba8 bytes: R = AO, G = roughness, B = metallic, A = a fourth linear channel (the glow materials' pulse phase along a trace, 0..1).

wrapd(d: number, tile: number) → number

The shortest signed offset from 0 to d on a loop of length `tile` (wraps a distance across a repeat).

sdBox(dx: number, dy: number, hw: number, hh: number, r: number?) → number

Signed distance (metres, negative inside) from offset (dx, dy) to a rounded box of half sizes hw, hh and corner radius r.

cover(d: number, aa: number) → number

Anti-aliased coverage 0..1 of a signed distance d (negative inside), smoothed over `aa` metres (one texel is tile / n).

around(n: number, tile: number, cx: number, cy: number, reachX: number, reachY: number, fn: (number, number, number) → void

Call fn(i, dx, dy) for every texel within `reach` metres of (cx, cy) on a periodic n x n grid over `tile` metres; dx, dy are the texel's wrapped offset from the centre.

text(field: Field, n: number, tile: number, text: string, x: number, y: number, h: number, stencil: boolean?) → number

Draw `text` in the 5 x 7 block font into `field` (max-blended coverage 0..1) on a periodic n x n grid over `tile` metres. (x, y) is the text's top-left corner in metres, image axes (y grows down the image); `h` is the cap height, each glyph 5/7 h wide with a 1/7 h gap. `stencil` leaves bridge gaps between the cells of a stroke, the look of a cut stencil. Returns the text's width in metres.