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.

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?, lossless: 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.

readTexture(ref: string, n: number?) → void

Read a texture asset's pixels as fields (0..1 per channel, raw bytes / 255) at its own size, resampled to n when n is given. Returns n, r, g, b.

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

Resample a NON-periodic n x n field to m x m (box-filtered down, bilinear up, edges clamped). Used on source pictures before they are made to tile.

shiftField(n: number, f: Field, dx: number, dy: number) → Field

minCut(n: number, cost: (number, number) → void

A minimum-error vertical cut (top to bottom) through cost columns [c0, c1] (inclusive, may wrap past n), returned as the column (in band coordinates, 0 = c0) per row. The path moves at most one column per row and comes back to its own start at the bottom, so the cut is continuous across the row wrap too.

makePeriodic(n: number, layers: { Field }, costIdx: { number }?, bandFrac: number?) → void

Make a set of aligned square pictures (same n: a photo's colour channels and the maps read off it) tile with no seam. Each axis in turn: a band around the picture's edge is replaced by the same picture shifted half a repeat (continuous across the edge), joined to the rest along minimum-difference cuts with a narrow feather. The cuts are chosen on the layers listed in `costIdx` (default the first three) and applied to every layer alike, so the maps stay aligned. Returns new fields in the same order.

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

pass 2 reads the picture transposed so the same vertical cut serves

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

seamRatio(n: number, f: Field) → number

How well a field tiles: the mean absolute jump across its wrap edges divided by the mean jump between neighbouring pixels inside it (1 = indistinguishable, above ~1.5 a seam shows).

srgbToLinear(c: number) → number

Linear value of an sRGB channel given 0..1.

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

Pack four 0..1 fields into rgba8 bytes (the terrain mask: R metallic, G AO, B height, A smoothness).