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.

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.

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

Pack a linear albedo with a data alpha (0..1) into sRGB rgba8 bytes; the alpha is stored linearly.

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 or flake coverage, A = data).

packNormalXY(n: number, nx: Field, ny: Field) → buffer

Tangent-space normal map straight from per-pixel normal x and y (tilted flakes are facets, not heights); z completes the unit vector. Green = image-up, as M.packNormal writes.

keepSource(name: string) → 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?, keepAlpha: boolean?) → any

Write rgba8 bytes as a texture asset in the package's textures folder, with a PNG source kept. kind: color | normalMap | mask. filter: linear (default) or nearest.

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.