`@bendyline/molen-worldgen/kernel`

ref

string

outer

readonly Vec2[]

holes

readonly readonly Vec2[][]

heightOf

(p) => number

n

uvOf

(p) => Vec2

color

RGB

Returns

boolean

addConvexPolygon()

addConvexPolygon(
   slot, 
   ref, 
   points, 
   n, 
   uvOf, 
   color
): void;

Fan-triangulate a convex polygon (used for gable pentagons).

Parameters

slot

ref

string

points

readonly Vec3[]

n

uvOf

(p) => Vec2

color

RGB

Returns

void

addQuad()

addQuad(
   slot, 
   ref, 
   p, 
   n, 
   uv, 
   color
): void;

Parameters

slot

ref

string

Returns

void

addTriangle()

addTriangle(
   slot, 
   ref, 
   p, 
   n, 
   uv, 
   color
): void;

Parameters

slot

ref

string

p

readonly [Vec3, Vec3, Vec3]

n

uv

readonly [Vec2, Vec2, Vec2]

color

RGB

Returns

void

append()

append(source): void;

Merge already generated geometry, preserving per-building UVs and vertex colors.

Parameters

source

MeshBufferBuilder

Returns

void

bytes()

bytes(): number;

Approximate GPU bytes for the current content.

Returns

number

finalize()

finalize(): MeshBuffers;

Returns

groupCount()

groupCount(): number;

Returns

number

isEmpty()

isEmpty(): boolean;

Returns

boolean

mark()

mark(): BuilderMark;

Returns

materialKeys()

materialKeys(): string[];

Returns

string[]

maxYSince()

maxYSince(mark): number;

Highest vertex emitted since a mark, without inspecting earlier buildings.

Parameters

mark

Returns

number

rollback()

rollback(mark): void;

Parameters

mark

Returns

void

setUvScale()

setUvScale(
   slot, 
   ref, 
   scale
): void;

Meters per texture repeat applied to every UV emitted for (slot, ref) from now on; set it before emitting a building's faces so each texture repeats at its authored scale.

Parameters

slot

ref

string

scale

[number, number] | undefined

Returns

void

transformYSince()

transformYSince(
   mark, 
   origin, 
   target, 
   scale
): void;

Fit recently emitted geometry vertically; normals use the inverse scale.

Parameters

mark

origin

number

target

number

scale

number

Returns

void

triangleCount()

triangleCount(): number;

Returns

number

vertexCount()

vertexCount(): number;

Returns

number

Interfaces

ArchApplicability

Properties

areaMax?

optional areaMax?: number;

areaMin?

optional areaMin?: number;

classes

classes: string[];

contextClasses?

optional contextClasses?: string[];

notes?

optional notes?: string;

ArchFacade

Properties

bands

bands: object;

base

base: object;

base.height

height: NumberRange;

cornice?

optional cornice?: object;

cornice.height

height: number;

floorLines

floorLines: boolean;

bays

bays: object;

cornerMargin

cornerMargin: number;

width

width: NumberRange;

details?

optional details?: ArchFacadeDetails;

windows

windows: object;

groundFloor

groundFloor: "none" | "same" | "storefront";

height

height: NumberRange;

probabilityPerBay

probabilityPerBay: number;

sill

sill: NumberRange;

style

style: "punched" | "ribbon" | "grid" | "none";

width

width: NumberRange;

ArchFacadeDetails

Metric facade ornament, fitted to actual bays and omitted when facade-bands is dropped.

Properties

awnings?

optional awnings?: object;

depth

depth: number;

balconies?

optional balconies?: object;

depth

depth: number;

every

every: number;

railing

railing: "open" | "solid";

framing?

optional framing?: object;

style

style: "timber" | "pilasters";

width

width: number;

shutters?

optional shutters?: boolean;

veranda?

optional veranda?: object;

columns

columns: boolean;

depth

depth: number;

ArchHeightRule

Properties

height?

optional height?: NumberRange;

levels?

optional levels?: NumberRange;

when?

optional when?: SelectionWhen;

ArchLodTier

Properties

keep

keep: ArchLodFeature[];

minTier

minTier: number;

ArchMassing

Properties

floorHeight

floorHeight: NumberRange;

foundation

foundation: object;

exposeOnSlope

exposeOnSlope: boolean;

height

height: NumberRange;

groundFit

groundFit: "platform-average" | "platform-max" | "platform-min";

groundFloorHeight?

optional groundFloorHeight?: NumberRange;

heightFallback

heightFallback: ArchHeightRule[];

Used only when a request has neither height nor levels; ordered; last rule is a catch-all.

respectMinHeight

respectMinHeight: boolean;

setbacks

setbacks: object[];

aboveHeight

aboveHeight: number;

inset

inset: number;

wings

wings: object;

maxWingSpan

maxWingSpan: number;

minWingArea

minWingArea: number;

secondaryHeightScale

secondaryHeightScale: NumberRange;

split

split: "none" | "rectangles";

ArchMaterialChoice

Properties

ref

ref: string;

weight

weight: number;

ArchMaterialSpec

Properties

choices

choices: ArchMaterialChoice[];

palette?

optional palette?: string;

Key of palettes used to tint this part.

tint

tint: "none" | "multiply";

uv

uv: "meters" | "cell";

uvMirror

uvMirror: boolean;

uvOffset

uvOffset: "none" | "meters" | "cell";

uvScale?

optional uvScale?: [number, number];

Meters per texture repeat [u, v] when uv is meters.

ArchPalette

Properties

entries

entries: ArchPaletteEntry[];

jitter

jitter: object;

hue

hue: number;

lightness

lightness: number;

saturation

saturation: number;

ArchPaletteEntry

Properties

color

color: string;

name?

optional name?: string;

weight

weight: number;

ArchProp

Properties

anchor

anchor: ArchPropAnchor;

count

count: NumberRange;

id

id: string;

lodTier

lodTier: number;

margin

margin: number;

model

model: string;

perAreaM2?

optional perAreaM2?: number;

probability

probability: number;

roof?

optional roof?: ArchRoofType[];

scale

scale: NumberRange;

spacing

spacing: number;

tintPalette?

optional tintPalette?: string;

when?

optional when?: SelectionWhen;

yaw

yaw: "align-wall" | "random" | "fixed";

ArchRoof

Properties

choices

choices: ArchRoofChoice[];

complexFootprint

complexFootprint: "flat" | "wings";

fallback

fallback: "flat";

features?

optional features?: ArchRoofFeatures;

overhang

overhang: NumberRange;

perWing

perWing: boolean;

ridge

ridge: "long-axis" | "short-axis";

ArchRoofChoice

Properties

lowerPitchDeg?

optional lowerPitchDeg?: NumberRange;

overhang?

optional overhang?: NumberRange;

parapet?

optional parapet?: object;

height

height: NumberRange;

thickness

thickness: number;

pitchDeg?

optional pitchDeg?: NumberRange;

ridge?

optional ridge?: "long-axis" | "short-axis";

shedDirection?

optional shedDirection?: "random" | "long-axis" | "downhill";

type

type: ArchRoofType;

weight

weight: number;

when?

optional when?: SelectionWhen;

ArchRoofFeatures

Properties

dormers?

optional dormers?: object;

perRidgeMeters

perRidgeMeters: number;

probability

probability: number;

style

style: "gable" | "shed";

when?

optional when?: SelectionWhen;

ArchStyleDoc

Properties

applicability

applicability: ArchApplicability;

doc?

optional doc?: string;

facade

facade: ArchFacade;

format

format: "molen/archstyle@1";

id

id: string;

lod

lod: object;

tiers

tiers: ArchLodTier[];

massing

massing: ArchMassing;

materials

materials: object;

foundation

foundation: ArchMaterialSpec;

roof

roof: ArchMaterialSpec;

trim

trim: ArchMaterialSpec;

wall

wall: ArchMaterialSpec;

window?

optional window?: ArchMaterialSpec;

palettes

palettes: Record<string, ArchPalette>;

props

props: ArchProp[];

roof

roof: ArchRoof;

title

title: string;

version

version: number;

Bump to re-roll every building using this style.

BoxLandmarkDoc

Extends

LandmarkBase

Properties

format

format: "molen/landmark@1";

Inherited from

LandmarkBase.format

generator

generator: "boxes";

id

id: string;

Inherited from

LandmarkBase.id

parts

parts: LandmarkBoxPart[];

title

title: string;

Inherited from

LandmarkBase.title

version

version: number;

Inherited from

LandmarkBase.version

BoxPlacement

Properties

color

color: RGB;

roof?

optional roof?: "gable";

gable: a pitched building's stand-in, the builtin:box.gable model (walls to GABLE_BOX_EAVE of its height, then a roof ridged along local x, the longer side).

sx

sx: number;

sy

sy: number;

sz

sz: number;

x

x: number;

y

y: number;

yaw

yaw: number;

three.js rotation about +y.

z

z: number;

BuilderMark

Properties

lengths

lengths: Map<string, [number, number]>;

BuildingAppearance

Properties

trim?

optional trim?: string;

wall?

optional wall?: string;

BuildingGenerateInput

Properties

analysis?

optional analysis?: FootprintAnalysis;

Precomputed analysis (the batch generator analyzes once for sorting).

collapseMaterials?

optional collapseMaterials?: boolean;

Render textured materials as vertex colors only (fewer mesh groups).

footprintOptions?

optional footprintOptions?: FootprintOptions;

ground

ground: HeightSampler;

interiors?

optional interiors?: InteriorCatalogDoc;

Generate real openings and storey metadata for lazy interiors laid out by this catalog.

pack

pack: PackIdentity;

request

request: BuildingRequest;

simplified?

optional simplified?: boolean;

Budget fallback: retain roof shape and bounded facades; collapseMaterials defaults true.

style

style: ArchStyleDoc;

tier

tier: number;

0 = full detail; higher tiers drop detail; beyond the style tiers a box is emitted.

BuildingHit

Properties

distance

distance: number;

Distance from the query point to the record centroid.

record

record: BuildingRecord;

BuildingMetrics

What rules evaluate against.

Properties

areaM2

areaM2: number;

context?

optional context?: string;

elongation

elongation: number;

hasHoles

hasHoles: boolean;

height?

optional height?: number;

labels

labels: string[];

levels?

optional levels?: number;

perimeterM

perimeterM: number;

rectangularity

rectangularity: number;

vertexCount

vertexCount: number;

wings?

optional wings?: number;

BuildingOpening

Distances along one canonical ring edge and absolute heights.

Properties

bottom

bottom: number;

edge

edge: number;

end

end: number;

kind

kind: "window" | "door";

start

start: number;

top

top: number;

BuildingRecipe

Properties

bayWidth

bayWidth: number;

box

box: boolean;

Beyond the last declared tier: render as a tinted box.

cornerMargin

cornerMargin: number;

exposeFoundation

exposeFoundation: boolean;

facade

facade: object;

bands

bands: FacadeBands | undefined;

details?

optional details?: ArchFacadeDetails;

windows

windows: FacadeWindows | undefined;

floorHeight

floorHeight: number;

floors

floors: number;

foundationHeight

foundationHeight: number;

groundFit

groundFit: "platform-average" | "platform-max" | "platform-min";

groundFloorHeight

groundFloorHeight: number;

heightSource

heightSource: "height" | "levels" | "fallback";

lodKeep

lodKeep: ArchLodFeature[];

maxWingSpan

maxWingSpan: number;

minHeight

minHeight: number;

minWingArea

minWingArea: number;

parts

parts: object;

foundation

foundation: RecipePart;

roof

roof: RecipePart;

trim

trim: RecipePart;

wall

wall: RecipePart;

window

window: RecipePart;

props

props: RecipeProp[];

roof

roof: RecipeRoof;

secondaryHeightScale

secondaryHeightScale: number;

seed

seed: string;

styleId

styleId: string;

styleVersion

styleVersion: number;

totalHeight

totalHeight: number;

Wall height above the platform, meters.

wingSplit

wingSplit: boolean;

BuildingRecord

Properties

area

area: number;

base

base: number;

bounds

bounds: [number, number, number, number];

centroid

centroid: Vec2;

footprintKind

footprintKind: string;

height

height: number;

identity

identity: string;

interior?

optional interior?: InteriorSite;

Structural access metadata only; plans and furnishings are generated on demand.

roof

roof: string;

styleId

styleId: string;

tier

tier: number;

BuildingRequest

Properties

appearance?

optional appearance?: BuildingAppearance;

Optional identity palette; explicit structural measurements still win.

clipped?

optional clipped?: boolean;

The outline is a cut piece of a larger shape: flat roof, seam walls, no ownership choices.

context?

optional context?: string;

Opaque surrounding label (e.g. the land class the outline sits in).

groundOutline?

optional groundOutline?: Vec2[];

Shared ground-fitting footprint for related parts, in local meters.

height?

optional height?: number;

Known total height above the base, in meters.

holes?

optional holes?: Vec2[][];

identity

identity: string;

Caller-owned stable identity, e.g. f:123456 or room:hall-1; seeds every look choice.

interiorLabels?

optional interiorLabels?: string[];

Confirmed ground-floor use, independent of the exterior building classification.

labels

labels: string[];

Opaque category labels, most specific first (e.g. ['house', 'building']).

levels?

optional levels?: number;

Known floor count.

minHeight?

optional minHeight?: number;

Height of the lowest floor above the base (skyways, cantilevers).

outline

outline: Vec2[];

Local meters, any orientation; the analysis canonicalizes it.

seamEdges?

optional seamEdges?: number[];

Outline edge indices that lie on a cut boundary.

storefronts?

optional storefronts?: StorefrontRequest[];

style?

optional style?: string;

Bypass style rules with an explicit style id.

BuildingResult

Properties

analysis

analysis: FootprintAnalysis;

box?

optional box?: BoxPlacement;

facade?

optional facade?: FacadeStats;

props?

optional props?: PropPlacement[];

Prop instances attached to the building (roof props); empty for boxes.

recipe?

optional recipe?: BuildingRecipe;

record?

optional record?: BuildingRecord;

skipped?

optional skipped?: "degenerate" | "roof";

FacadeBands

Properties

baseHeight

baseHeight: number;

Base band height in meters; 0 disables.

corniceHeight

corniceHeight: number;

Cornice height in meters; 0 disables.

floorLines

floorLines: boolean;

FacadeStats

Properties

bands

bands: number;

storefronts

storefronts: number;

windows

windows: number;

FacadeWindows

Properties

groundFloor

groundFloor: "none" | "same" | "storefront";

height

height: number;

Window height in meters (clamped to the floor).

probabilityPerBay

probabilityPerBay: number;

sill

sill: number;

Sill height above the floor in meters.

style

style: "punched" | "ribbon" | "grid" | "none";

width

width: number;

Window width in meters (clamped to the bay).

FootprintAnalysis

Properties

area

area: number;

axisStrength

axisStrength: number;

bounds

bounds: Bounds2;

centroid

centroid: Vec2;

depth

depth: number;

elongation

elongation: number;

width / depth, always >= 1.

frame

frame: Frame;

holeNotices?

optional holeNotices?: string[];

One message per input hole that was dropped as unusable (outside the outline, crossing it, or overlapping a hole already kept). Absent when every hole was kept. A broken ring is dropped rather than thrown on: one bad inner ring must not cost the whole building.

holes

holes: Vec2[][];

kind

kind: FootprintKind;

localHoles

localHoles: Vec2[][];

localOutline

localOutline: Vec2[];

Outline in the frame; snapped when rectilinear.

outline

outline: Vec2[];

Cleaned outline in the caller coordinates (positive orientation).

perimeter

perimeter: number;

rectangularity

rectangularity: number;

area / (width * depth) in 0..1.

rectilinear

rectilinear: boolean;

reflexCount

reflexCount: number;

vertexCount

vertexCount: number;

width

width: number;

wings

wings: Wing[];

FootprintOptions

Properties

angleTolerance

angleTolerance: number;

tan of the maximum edge angle from an axis that still snaps (default tan 10°).

maxVertices

maxVertices: number;

maxWings

maxWings: number;

minArea

minArea: number;

Outlines below this area (m²) are degenerate.

minAxisStrength

minAxisStrength: number;

Below this axis strength (0..1) an outline has no dominant orientation.

snapTolerance

snapTolerance: number;

Absolute off-axis tolerance in meters (absorbs source quantization).

Frame

Rigid frame: local = R(world - origin) with R = [[c, s], [-s, c]].

Properties

c

c: number;

ox

ox: number;

oz

oz: number;

s

s: number;

GlbMaterialMeta

Properties

alphaCutoff?

optional alphaCutoff?: number;

Cutoff for MASK materials, default glTF value 0.5.

alphaMode?

optional alphaMode?: "OPAQUE" | "MASK" | "BLEND";

Standard glTF alpha handling; defaults to OPAQUE for existing generated assets.

baseColorFactor?

optional baseColorFactor?: [number, number, number, number];

Base color factor multiplied by COLOR_0; default white.

doubleSided?

optional doubleSided?: boolean;

Thin glass panels may need both sides; defaults to false.

metallic?

optional metallic?: number;

name

name: string;

roughness?

optional roughness?: number;

sharedSurface?

optional sharedSurface?: GlbSharedSurface;

GlbSharedSurface

Opt-in shared surface. UVs must already be in texture repeats; fallback PBR stays portable.

Properties

ref

ref: string;

slot

slot: MaterialSlot;

uv

uv: "repeats";

HeightGrid

Properties

cols

cols: number;

heights

heights: Float32Array;

Row-major heights in meters, cols * rows entries.

originX

originX: number;

Local coordinate of sample (0, 0).

originZ

originZ: number;

rows

rows: number;

sizeX

sizeX: number;

Extent covered by the grid, meters.

sizeZ

sizeZ: number;

HeightSampler

Ground queries in local meters. A terrain Heightfield satisfies it structurally.

Methods

normalAt()

normalAt(x, z): Vec3;

Parameters

x

number

z

number

Returns

sampleHeight()

sampleHeight(x, z): number;

Parameters

x

number

z

number

Returns

number

slopeAt()

slopeAt(x, z): number;

Slope 0..1 (0 = flat, 1 = vertical).

Parameters

x

number

z

number

Returns

number

InteriorCatalogDoc

Properties

fallback

fallback: string;

format

format: "molen/interior-catalog@1";

profiles

profiles: InteriorProfile[];

InteriorFixture

Properties

bounds

bounds: Bounds2;

Interior frame: X runs along the entrance, Z runs inward.

id

id: string;

kind

kind: InteriorFurniture;

level?

optional level?: number;

variant?

optional variant?: number;

InteriorGenerateOptions

Extended by

InteriorStreamingOptions

Properties

catalog

catalog: InteriorCatalogDoc;

The interior catalog, usually the style pack's interiors.

maxCandidates?

optional maxCandidates?: number;

maxFixtures?

optional maxFixtures?: number;

InteriorGeometry

Properties

bytes

bytes: number;

collision

collision: MeshBuffers;

furniture

furniture: MeshBuffers;

glass

glass: MeshBuffers;

steps

steps: MeshBuffers;

Visible step geometry is decorative; use this smooth solid proxy for character collision.

structure

structure: MeshBuffers;

InteriorPlan

Properties

circulation

circulation: Bounds2[];

Reserved routes in the entrance frame; furniture cannot occupy these cells.

fixtures

fixtures: InteriorFixture[];

identity

identity: string;

profile

profile: string;

rooms

rooms: InteriorRoom[];

seed

seed: string;

site

site: InteriorSite;

stairs

stairs: InteriorStair[];

stats

stats: object;

candidates

candidates: number;

rejected

rejected: number;

truncated

truncated: boolean;

storeys

storeys: InteriorStorey[];

InteriorProfile

JSON authoring surface. Labels are opaque; geographic adapters supply their vocabulary.

Properties

aisleWidth

aisleWidth: number;

algorithm

algorithm: InteriorAlgorithm;

density

density: number;

furnishing

furnishing: InteriorFurniture;

id

id: string;

labels

labels: string[];

moduleDepth

moduleDepth: number;

moduleWidth

moduleWidth: number;

palette

palette: object;

accent

accent: string;

floor

floor: string;

wall

wall: string;

wood

wood: string;

residential?

optional residential?: object;

Residential topology; upper floors are generated only when both envelope and stairs fit.

minRoomWidth

minRoomWidth: number;

runPerRise

runPerRise: number;

stairWidth

stairWidth: number;

upstairs

upstairs: boolean;

version

version: number;

InteriorRoom

Properties

bounds

bounds: Bounds2;

door?

optional door?: object;

Side facing the shared hallway; distance along Z to the center of its open doorway.

at

at: number;

side

side: "left" | "right";

id

id: string;

level?

optional level?: number;

program?

optional program?: InteriorRoomUse;

use

use: InteriorFurniture;

InteriorSite

Cheap structural descriptor; contains no generated floor plan or furniture.

Properties

access

access: Vec3[];

Four ramp corners: threshold left/right, outside right/left.

bounds

bounds: Bounds2;

ceiling

ceiling: number;

entrance

entrance: Vec2;

floor

floor: number;

holes

holes: Vec2[][];

identity

identity: string;

inward

inward: Vec2;

labels

labels: string[];

openings

openings: BuildingOpening[];

outline

outline: Vec2[];

storeys?

optional storeys?: InteriorStorey[];

Available storeys inferred from the exterior envelope; layouts may use fewer.

InteriorStair

Properties

bounds

bounds: Bounds2;

Local rectangle, ascending along +Z. The whole run is a slab opening above.

lower

lower: number;

steps

steps: number;

upper

upper: number;

InteriorStorey

Properties

ceiling

ceiling: number;

floor

floor: number;

LandmarkBoxPart

Properties

center

center: Vec3;

color

color: string;

size

size: Vec3;

tiers?

optional tiers?: (0 | 1 | 2)[];

yaw?

optional yaw?: number;

LandmarkDocs

Landmark documents as loaded: the catalog and its model documents by catalog key.

Properties

catalog

catalog: unknown;

models

models: Readonly<Record<string, unknown>>;

LandmarkLibrary

Properties

catalog

readonly catalog: LandmarkCatalogDoc;

definitions

readonly definitions: LandmarkDefinitions;

hash

readonly hash: string;

Hash over the catalog and every model document; a cache key for generated models.

signDesigns

readonly signDesigns: Readonly<Record<string, SignDesign>>;

Sign designs by short name (sign.grocery is grocery).

version

readonly version: number;

The catalog's version; model caches key on it.

Methods

get()

get(id): LandmarkDoc | undefined;

Parameters

id

string

Returns

LandmarkDoc | undefined

MeshBuffers

Properties

bytes

bytes: number;

colors

colors: Uint8Array;

8-bit linear RGB triplets.

groups

groups: MeshGroup[];

indices

indices: Uint32Array;

normals

normals: Float32Array;

positions

positions: Float32Array;

triangleCount

triangleCount: number;

uvs

uvs: Float32Array;

Per-slot UV convention: walls in meters or (bay, floor) cells, roofs in meters.

vertexCount

vertexCount: number;

MeshGroup

Properties

count

count: number;

Number of indices in the group.

materialRef

materialRef: string;

materialRef string (palette:#rrggbb, matgraph:<id>, pixelgrid:<id>).

slot

slot: MaterialSlot;

start

start: number;

Offset into indices of the group's first index.

ModelPlacementRequest

Properties

at

at: Vec2;

identity

identity: string;

model

model: string;

scale?

optional scale?: Vec3;

yaw?

optional yaw?: number;

NumberRange

Properties

max

max: number;

min

min: number;

PackIdentity

Properties

name

name: string;

version

version: string;

PlacementSet

Properties

count

count: number;

data

data: Float32Array;

PLACEMENT_STRIDE floats per instance; x/z local meters, y absolute, yaw in radians.

modelRef

modelRef: string;

Asset id or builtin:<name>.

setId

setId: string;

PreparedBuildingCell

Properties

bounds

bounds: [number, number, number, number, number, number];

center

center: [number, number, number];

Cell center in the batch's coordinates.

colors

colors: Uint8Array;

Normalized RGB, (r, g, b, pad) per vertex.

groups

groups: MeshGroup[];

indices

indices: Uint32Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike>;

key

key: string;

normals

normals: Int8Array;

Unit normals as normalized signed bytes, (x, y, z, pad) per vertex.

positions

positions: Int16Array;

Normalized offsets from center, (x, y, z, pad) per vertex, in units of positionScale.

positionScale

positionScale: number;

Meters per normalized unit (uniform on every axis): the object scale a renderer applies.

structuralIndices

structuralIndices: Uint32Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike>;

uvs

uvs: Float32Array;

PropHit

Properties

distance

distance: number;

index

index: number;

modelRef

modelRef: string;

scale

scale: number;

setId

setId: string;

x

x: number;

y

y: number;

yaw

yaw: number;

z

z: number;

PropPlacement

Properties

color

color: RGB;

model

model: string;

scale

scale: number;

x

x: number;

y

y: number;

yaw

yaw: number;

three.js rotation about +y.

z

z: number;

QueuedBuilding

Properties

analysis

analysis: FootprintAnalysis;

order

order: number;

request

request: BuildingRequest;

styleId

styleId: string;

RecipePart

Properties

color

color: RGB;

mirror

mirror: boolean;

offsetU

offsetU: number;

offsetV

offsetV: number;

ref

ref: string;

Material reference; palette refs are baked into color and become WHITE_REF.

tint

tint: "none" | "multiply";

uv

uv: "meters" | "cell";

uvScale

uvScale: [number, number] | undefined;

RecipeProp

Properties

anchor

anchor: ArchPropAnchor;

color

color: RGB;

Instance tint from tintPalette; white without one.

count

count: number;

id

id: string;

lodTier

lodTier: number;

margin

margin: number;

model

model: string;

roof?

optional roof?: ArchRoofType[];

scale

scale: number;

spacing

spacing: number;

yaw

yaw: "align-wall" | "random" | "fixed";

RecipeRoof

Properties

complexFootprint

complexFootprint: "flat" | "wings";

dormers?

optional dormers?: object;

perRidgeMeters

perRidgeMeters: number;

style

style: "gable" | "shed";

lowerRise

lowerRise: number;

overhang

overhang: number;

parapet?

optional parapet?: object;

height

height: number;

thickness

thickness: number;

perWing

perWing: boolean;

ridge

ridge: "long-axis" | "short-axis";

rise

rise: number;

Rise per meter of run.

shedDirection

shedDirection: -1 | 1;

shedDownhill

shedDownhill: boolean;

type

type: ArchRoofType;

ResolvedStylePack

Properties

archstyles

archstyles: Readonly<Record<string, ArchStyleDoc>>;

assets

assets: Readonly<Record<string, string>>;

Asset id to pack-relative sidecar path.

hash

hash: string;

Content hash over every document; part of cache keys.

id

id: string;

interiors?

optional interiors?: InteriorCatalogDoc;

Layouts for enterable buildings; undefined when the pack has none.

materials

materials: Readonly<Record<string, "matgraph" | "pixelgrid">>;

Material id to document kind.

root

root: StylePackDoc;

scatters

scatters: Readonly<Record<string, ScatterDoc>>;

version

version: string;

warnings

warnings: string[];

ScatterAltitude

Properties

max?

optional max?: number;

min?

optional min?: number;

ScatterAvoid

Properties

buildings

buildings: number;

roads

roads: number;

water

water: number;

ScatterClustering

Properties

contrast

contrast: number;

Steepness of the density ramp above the threshold.

scale

scale: number;

Noise wavelength in meters.

seedOffset

seedOffset: number;

threshold

threshold: number;

Noise value below which density is zero.

ScatterDoc

Properties

defaults

defaults: object;

avoid

avoid: ScatterAvoid;

lod

lod: ScatterLod;

slopeMax

slopeMax: number;

doc?

optional doc?: string;

format

format: "molen/scatter@1";

id

id: string;

rules

rules: ScatterRule[];

surface

surface: object;

colors

colors: Record<string, string>;

default

default: string;

title

title: string;

version

version: number;

Bump to re-roll every placement of this rule set.

ScatterExclusion

Properties

kind?

optional kind?: "roads" | "buildings" | "water";

Which avoidance radius from the scatter rules applies (roads, buildings, water).

polyline?

optional polyline?: Vec2[];

radius

radius: number;

Extra clearance in meters around the ring or polyline.

ring?

optional ring?: Vec2[];

width?

optional width?: number;

Polyline width in meters (the exclusion covers width / 2 + radius on each side).

ScatterFrame

Properties

originX

originX: number;

Local coordinate of the global anchor origin; cells are laid out relative to it.

originZ

originZ: number;

unitsPerMeter

unitsPerMeter: number;

Frame units per meter (1 for metric frames).

ScatterLod

Properties

keepByTier

keepByTier: number[];

Keep fraction per detail tier (index 0 = full detail); non-increasing.

maxInstancesPerBatch

maxInstancesPerBatch: number;

ScatterPolygon

Properties

density?

optional density?: number;

Density multiplier for this polygon (default 1).

holes?

optional holes?: Vec2[][];

label

label: string;

ring

ring: Vec2[];

seed?

optional seed?: number;

Optional owner seed for acceptance and appearance; the shared placement grid stays fixed.

ScatterPopulation

Properties

align

align: "up" | "normal";

altitude?

optional altitude?: ScatterAltitude;

model

model: string;

Asset id (pack or imported namespace) or builtin:<name>.

scale

scale: NumberRange;

slopeMax?

optional slopeMax?: number;

tint?

optional tint?: ScatterTint;

weight

weight: number;

widthScale?

optional widthScale?: NumberRange;

Independent multiplier of X/Z scale (crown width/bushiness); defaults to 1.

yaw

yaw: "none" | "random";

ScatterRequest

Properties

emitBounds

emitBounds: [number, number, number, number];

Only candidates inside this local rectangle are emitted.

exclusions

exclusions: ScatterExclusion[];

frame

frame: ScatterFrame;

keep

keep: number;

Detail keep fraction in (0, 1]; smaller values yield nested subsets.

polygons

polygons: ScatterPolygon[];

ScatterRule

Properties

altitude?

optional altitude?: ScatterAltitude;

avoid?

optional avoid?: Partial<ScatterAvoid>;

classes

classes: string[];

clustering?

optional clustering?: ScatterClustering;

densityPerHectare

densityPerHectare: number;

id

id: string;

lod?

optional lod?: Partial<ScatterLod>;

minSpacing

minSpacing: number;

notClasses?

optional notClasses?: string[];

populations

populations: ScatterPopulation[];

slopeMax?

optional slopeMax?: number;

ScatterTint

Properties

hue

hue: number;

lightness

lightness: number;

saturation

saturation: number;

SelectionWhen

Properties

areaMax?

optional areaMax?: number;

areaMin?

optional areaMin?: number;

Footprint area bounds in m².

class?

optional class?: string[];

Match when any label equals or contains one of these words.

contextClass?

optional contextClass?: string[];

Match the surrounding label; the word none matches an absent context.

elongationMax?

optional elongationMax?: number;

elongationMin?

optional elongationMin?: number;

Long/short axis ratio of the oriented bounding box, >= 1.

hasHeight?

optional hasHeight?: boolean;

Require (true) or forbid (false) a known height.

heightMax?

optional heightMax?: number;

heightMin?

optional heightMin?: number;

Known-height bounds in meters; a rule with height bounds never matches an unknown height.

holes?

optional holes?: boolean;

levelsMax?

optional levelsMax?: number;

levelsMin?

optional levelsMin?: number;

notClass?

optional notClass?: string[];

notContextClass?

optional notContextClass?: string[];

rectangularityMax?

optional rectangularityMax?: number;

rectangularityMin?

optional rectangularityMin?: number;

area / (width * depth), 0..1.

verticesMax?

optional verticesMax?: number;

wingsMax?

optional wingsMax?: number;

wingsMin?

optional wingsMin?: number;

Roof wing count after decomposition (archstyle rules only).

SignDesign

Properties

background

background: string;

foreground

foreground: string;

letters?

optional letters?: string;

mark

mark: string;

symbol

symbol: 
  | "arches"
  | "spark"
  | "disc"
  | "target"
  | "cross"
  | "letters"
  | "cup"
  | "tag"
  | "roofline"
  | "star"
  | "burger"
  | "bell"
  | "bucket"
  | "domino";

text

text: string;

SignLandmarkDoc

Extends

LandmarkBase

Properties

appearance

appearance: object;

accent

accent: string;

wall

wall: string;

format

format: "molen/landmark@1";

Inherited from

LandmarkBase.format

generator

generator: "sign";

id

id: string;

Inherited from

LandmarkBase.id

sign

sign: SignDesign;

storefront

storefront: object;

sharedWidth

sharedWidth: number;

style?

optional style?: string;

width

width: number;

title

title: string;

Inherited from

LandmarkBase.title

version

version: number;

Inherited from

LandmarkBase.version

StorefrontRequest

Properties

accent

accent: string;

at

at: Vec2;

Desired frontage anchor in local meters, projected onto an exterior edge.

identity

identity: string;

signModel

signModel: string;

signSize?

optional signSize?: Vec2;

Native sign width/height; default 4 x 1.35 meters, base Y=0, front +Z.

width?

optional width?: number;

StylePackAttribution

Properties

license

license: string;

licenseUrl?

optional licenseUrl?: string;

sourceUrl?

optional sourceUrl?: string;

text

text: string;

StylePackDefaults

Properties

rules

rules: StyleRule[];

Ordered style rules evaluated after any world binding rules.

scatter?

optional scatter?: string;

Scatter rule set used when a binding does not name one.

style

style: string;

Archstyle used when no rule matches.

StylePackDoc

Properties

assets

assets: Record<string, string>;

Asset id to pack-relative molen/asset@1 sidecar path.

attribution

attribution: StylePackAttribution[];

defaults

defaults: StylePackDefaults;

doc?

optional doc?: string;

format

format: "molen/stylepack@1";

imports

imports: StylePackImport[];

interiors?

optional interiors?: string;

Pack-relative molen/interior-catalog@1 path; without one the pack has no interiors.

materials

materials: Record<string, string>;

Material id to pack-relative matgraph/pixelgrid document path.

name

name: string;

namespace

namespace: string;

Every style, scatter, material, and asset id must live under this namespace.

scatter

scatter: Record<string, string>;

Scatter id to pack-relative document path.

styles

styles: Record<string, string>;

Archstyle id to pack-relative document path.

title?

optional title?: string;

version

version: string;

Participates in every seed; bump to re-roll the world.

StylePackImport

Properties

namespace

namespace: string;

External asset namespace the pack may reference, e.g. molen.entities.

note?

optional note?: string;

package?

optional package?: string;

StyleRule

Properties

style

style: string;

Archstyle id to use when the rule matches.

variants?

optional variants?: object[];

Stable identity selects one weighted regional variant; style is the identity-free fallback.

style

style: string;

weight

weight: number;

when?

optional when?: SelectionWhen;

StyleSelection

Properties

ruleIndex

ruleIndex: number;

Index of the matching rule, or -1 when the fallback was used.

style

style: string;

VersionedId

Properties

id

id: string;

version

version: number;

Wing

Properties

endOnOutline

endOnOutline: [boolean, boolean];

Whether the start and end of the long axis reach the outline (gable ends visible).

longAxis

longAxis: "u" | "v";

priority

priority: number;

0 = dominant wing (highest ridge).

u0

u0: number;

u1

u1: number;

v0

v0: number;

v1

v1: number;

WorldgenBatchDoc

Properties

buildings

buildings: BuildingRequest[];

fallbackStyle?

optional fallbackStyle?: string;

format

format: "molen/worldgen-batch@1";

ground

ground: WorldgenBatchGround;

interiors?

optional interiors?: boolean;

name

name: string;

props?

optional props?: ModelPlacementRequest[];

rules?

optional rules?: StyleRule[];

scatter?

optional scatter?: ScatterRequest;

scatterId?

optional scatterId?: string;

tier

tier: number;

Detail tier to generate at (0 = full).

WorldgenBatchGround

Properties

dx

dx: number;

Rise per meter along +x and +z (slope only).

dz

dz: number;

height

height: number;

Ground height at the origin, meters.

kind

kind: "flat" | "slope";

WorldgenBatchInput

Properties

budgets?

optional budgets?: Partial<WorldgenBudgets>;

buildings

buildings: BuildingRequest[];

fallbackStyle?

optional fallbackStyle?: string;

ground?

optional ground?: HeightSampler;

interiors?

optional interiors?: boolean;

Real ground-floor openings and lazy interior descriptors; needs the pack's interiors.

pack

pack: ResolvedStylePack;

props?

optional props?: ModelPlacementRequest[];

Authored point placements, admitted before procedural scatter.

rules?

optional rules?: StyleRule[];

Rules evaluated before the pack defaults (e.g. from a world binding).

scatter?

optional scatter?: ScatterRequest;

scatterId?

optional scatterId?: string;

tier?

optional tier?: number;

Detail tier for the batch (0 = full).

WorldgenBatchOutput

Properties

buildings?

optional buildings?: MeshBuffers;

hash

hash: string;

sha256 over every output array; equal hashes mean byte-identical output.

placements

placements: PlacementSet[];

records

records: BuildingRecord[];

stats

stats: WorldgenStats;

WorldgenBudgets

Properties

detailedCount

detailedCount: number;

Buildings eligible for extra detail after reserving simplified roofs and facades for the batch.

maxBuildings

maxBuildings: number;

maxBuildingVertices

maxBuildingVertices: number;

maxInstances

maxInstances: number;

Non-building instances per batch: signs, mapped props, roof props, then scatter; 0 disables them.

maxInstancesPerRule

maxInstancesPerRule: number;

Instances one scatter rule may emit per batch.

maxMaterialGroups

maxMaterialGroups: number;

maxPropModels

maxPropModels: number;

Model varieties admitted by procedural scatter (authored identity models are separate).

WorldgenBuildingData

Properties

appearance?

optional appearance?: BuildingAppearance;

height?

optional height?: number;

holes?

optional holes?: Vec2[][];

labels?

optional labels?: string[];

Labels the style's rules and props may look at (default: ['building']).

levels?

optional levels?: number;

outline

outline: Vec2[];

Outline in entity-local meters (+x right, +z toward the viewer), no closing point.

seed?

optional seed?: string;

Stable identity for the seed (default: the entity id).

storefronts?

optional storefronts?: StorefrontRequest[];

style

style: string;

Style id in the loaded pack, e.g. 'molen.worldgen.fantasy.hall'.

tier?

optional tier?: number;

Detail tier (default 0).

WorldgenHandle

Properties

index

readonly index: WorldgenIndex;

Methods

buildingAt()

buildingAt(x, z): BuildingRecord | undefined;

Parameters

x

number

z

number

Returns

BuildingRecord | undefined

buildingsNear()

buildingsNear(
   x, 
   z, 
   radius
): BuildingHit[];

Parameters

x

number

z

number

radius

number

Returns

BuildingHit[]

propsNear()

propsNear(
   x, 
   z, 
   radius
): PropHit[];

Parameters

x

number

z

number

radius

number

Returns

PropHit[]

WorldgenIndex

Properties

buildingCount

readonly buildingCount: number;

cellSize

readonly cellSize: number;

propCount

readonly propCount: number;

Methods

add()

add(records, placements): void;

Merge another batch into this index (e.g. a neighbouring batch).

Parameters

records

readonly BuildingRecord[]

placements

readonly PlacementSet[]

Returns

void

buildingAt()

buildingAt(x, z): BuildingRecord | undefined;

The building whose bounds contain the point and whose outline (when known) contains it.

Parameters

x

number

z

number

Returns

BuildingRecord | undefined

buildingsNear()

buildingsNear(
   x, 
   z, 
   radius
): BuildingHit[];

Buildings whose centroid lies within radius, nearest first.

Parameters

x

number

z

number

radius

number

Returns

BuildingHit[]

propsNear()

propsNear(
   x, 
   z, 
   radius
): PropHit[];

Prop and scatter instances within radius, nearest first.

Parameters

x

number

z

number

radius

number

Returns

PropHit[]

WorldgenIndexOptions

Properties

cellSize?

optional cellSize?: number;

Bucket size in meters (default 64).

outlines?

optional outlines?: ReadonlyMap<string, readonly Vec2[]>;

Outlines by identity so buildingAt can test the footprint, not only the bounds.

WorldgenProgress

Properties

done

done: number;

total

total: number;

WorldgenStats

Properties

buildingsBoxed

buildingsBoxed: number;

buildingsDropped

buildingsDropped: number;

buildingsIn

buildingsIn: number;

buildingsRendered

buildingsRendered: number;

buildingsSkipped

buildingsSkipped: number;

capFailures

capFailures: number;

footprintKinds

footprintKinds: Record<string, number>;

instanceBytes

instanceBytes: number;

materialsCollapsed

materialsCollapsed: number;

Buildings using vertex colors to satisfy geometry or material budgets.

meshBytes

meshBytes: number;

placementsByModel

placementsByModel: Record<string, number>;

roofs

roofs: Record<string, number>;

styles

styles: Record<string, number>;

triangles

triangles: number;

vertices

vertices: number;

Type Aliases

ArchLodFeature

type ArchLodFeature = 
  | "roof-shape"
  | "roof-features"
  | "facade-texture"
  | "facade-bands"
  | "props";

ArchPropAnchor

type ArchPropAnchor = "roof-ridge" | "roof-flat" | "roof-edge" | "wall-any" | "ground-any";

ArchRoofType

type ArchRoofType = "flat" | "gable" | "hip" | "pyramid" | "shed" | "mansard" | "gambrel";

Bounds2

type Bounds2 = [number, number, number, number];

FootprintKind

type FootprintKind = 
  | "box"
  | "L"
  | "T"
  | "U"
  | "Z"
  | "stair"
  | "H"
  | "plus"
  | "courtyard"
  | "complex"
  | "irregular"
  | "degenerate";

InteriorAlgorithm

type InteriorAlgorithm = 
  | "aisles"
  | "dining"
  | "rooms"
  | "workplace"
  | "storage"
  | "hall"
  | "residential";

InteriorFurniture

type InteriorFurniture = 
  | "shelf"
  | "checkout"
  | "table"
  | "counter"
  | "bed"
  | "sofa"
  | "desk"
  | "rack"
  | "bench"
  | "wardrobe"
  | "kitchen"
  | "vanity"
  | "toilet"
  | "shower"
  | "rug"
  | "coffee-table"
  | "bookcase"
  | "plant"
  | "dresser";

InteriorRoomUse

type InteriorRoomUse = "living" | "kitchen" | "bedroom" | "bathroom" | "stairwell";

LandmarkDefinitions

type LandmarkDefinitions = Readonly<Record<string, LandmarkDoc>>;

LandmarkDoc

type LandmarkDoc = 
  | SignLandmarkDoc
  | BoxLandmarkDoc;

MaterialSlot

type MaterialSlot = "wall" | "roof" | "trim" | "foundation" | "window" | "door";

RGB

type RGB = [number, number, number];

Linear RGB, each channel 0..1.

StylePackDocumentReader

type StylePackDocumentReader = (relativePath) => Promise<unknown>;

Parameters

relativePath

string

Returns

Promise<unknown>

Vec2

type Vec2 = [number, number];

Vec3

type Vec3 = [number, number, number];

Variables

DEFAULT_FOOTPRINT_OPTIONS

const DEFAULT_FOOTPRINT_OPTIONS: FootprintOptions;

DEFAULT_WORLDGEN_BUDGETS

const DEFAULT_WORLDGEN_BUDGETS: WorldgenBudgets;

Generic per-batch caps; world bindings scale these by quality and detail level.

DOTTED_ID_RE

const DOTTED_ID_RE: RegExp;

Namespaced dotted id, e.g. molen.worldgen.pnw.house.

FLAT_GROUND

const FLAT_GROUND: HeightSampler;

A perfectly flat ground plane at y = 0.

GABLE_BOX_EAVE

const GABLE_BOX_EAVE: 0.62 = .62;

Eave of the unit builtin:box.gable model, as a fraction of its height.

PLACEMENT_STRIDE

const PLACEMENT_STRIDE: number;

Floats per instance in PlacementSet.data: x, y, z, yaw, sx, sy, sz, r, g, b.

styleRuleSchema

const styleRuleSchema: z.ZodType<StyleRule>;

whenSchema

const whenSchema: z.ZodType<SelectionWhen>;

WORLDGEN_BUILDING_COMPONENT

const WORLDGEN_BUILDING_COMPONENT: string;

WORLDGEN_SEED_SCHEME

const WORLDGEN_SEED_SCHEME: "wg1";

WorldgenBuilding

const WorldgenBuilding: object;

Bare component handle (structurally a kernel ComponentType) without pulling the kernel.

Type Declaration

__type?

readonly optional __type?: WorldgenBuildingData;

name

readonly name: string;

Functions

analyzeFootprint()

function analyzeFootprint(
   outline, 
   holes?, 
   options?
): FootprintAnalysis;

Parameters

outline

readonly Vec2[]

holes?

readonly readonly Vec2[][]

options?

FootprintOptions

Returns

FootprintAnalysis

aspectSeed()

function aspectSeed(buildingSeed, aspect): number;

Seed of one named aspect (massing, roof, palette:<name>, ...) of a building.

Parameters

buildingSeed

string

aspect

string

Returns

number

buildingCellTransferables()

function buildingCellTransferables(cells): ArrayBuffer[];

Parameters

cells

readonly PreparedBuildingCell[]

Returns

ArrayBuffer[]

buildingMetrics()

function buildingMetrics(request, analysis): BuildingMetrics;

Metrics a rule engine evaluates for one request + analysis.

Parameters

request

BuildingRequest

analysis

FootprintAnalysis

Returns

BuildingMetrics

buildingSeedString()

function buildingSeedString(
   pack, 
   style, 
   identity
): string;

Parameters

pack

PackIdentity

style

VersionedId

identity

string

Returns

string

clipRingToRect()

function clipRingToRect(ring, rect): Vec2[];

Sutherland-Hodgman clip of a ring against an axis-aligned rectangle.

Parameters

ring

readonly Vec2[]

rect

Bounds2

Returns

Vec2[]

createHeightSampler()

function createHeightSampler(grid): HeightSampler;

Parameters

grid

HeightGrid

Returns

HeightSampler

createLandmarkLibrary()

function createLandmarkLibrary(docs): LandmarkLibrary;

Validate landmark documents and derive what the generators read from them.

Parameters

docs

LandmarkDocs

Returns

LandmarkLibrary

createWorldgenIndex()

function createWorldgenIndex(
   records?, 
   placements?, 
   options?
): WorldgenIndex;

Parameters

records?

readonly BuildingRecord[]

placements?

readonly PlacementSet[]

options?

WorldgenIndexOptions

Returns

WorldgenIndex

directionToWorld()

function directionToWorld(frame, local): Vec2;

Rotate a local direction into world space (no translation).

Parameters

frame

Frame

local

Returns

emptyWorldgenStats()

function emptyWorldgenStats(): WorldgenStats;

Returns

WorldgenStats

encodeGlb()

function encodeGlb(
   buffers, 
   materials?, 
   generator?
): Uint8Array;

Parameters

buffers

materials?

readonly GlbMaterialMeta[]

generator?

string

Returns

Uint8Array

generateBuilding()

function generateBuilding(input, out): BuildingResult;

Parameters

input

BuildingGenerateInput

out

MeshBufferBuilder

Returns

BuildingResult

generateInteriorGeometry()

function generateInteriorGeometry(plan, catalog): InteriorGeometry;

Parameters

plan

InteriorPlan

catalog

Returns

InteriorGeometry

generateInteriorGeometrySteps()

function generateInteriorGeometrySteps(plan, catalog): Generator<void, InteriorGeometry, void>;

Structured low-poly furniture, baked into one shared vertex-color batch per interior.

Parameters

plan

InteriorPlan

catalog

Returns

Generator<void, InteriorGeometry, void>

generateInteriorPlan()

function generateInteriorPlan(site, options): InteriorPlan;

Parameters

site

InteriorGenerateOptions

options

Returns

InteriorPlan

generateInteriorPlanSteps()

function generateInteriorPlanSteps(site, options): Generator<void, InteriorPlan, void>;

Cooperative pure layout pass. Named coordinate draws keep retained modules stable under caps.

Parameters

site

InteriorGenerateOptions

options

Returns

Generator<void, InteriorPlan, void>

generateLandmarkModel()

function generateLandmarkModel(
   name, 
   definitions, 
   detail?
): MeshBuffers | undefined;

Generate a landmark's sign or metric box recipe from the loaded definitions (a landmark library's definitions); undefined when name is not among them. Detail 2 retains the main silhouette.

Parameters

name

string

definitions

LandmarkDefinitions

detail?

0 | 2 | 1

Returns

MeshBuffers | undefined

generateSignModel()

function generateSignModel(design, detail?): MeshBuffers;

Parameters

design

SignDesign

detail?

0 | 2 | 1

Returns

generateWorldgenBatch()

function generateWorldgenBatch(input): WorldgenBatchOutput;

Run the stepwise generator to completion.

Parameters

input

WorldgenBatchInput

Returns

WorldgenBatchOutput

generateWorldgenBatchSteps()

function generateWorldgenBatchSteps(input, step?): Generator<WorldgenProgress, WorldgenBatchOutput, void>;

Parameters

input

WorldgenBatchInput

step?

number

Returns

Generator<WorldgenProgress, WorldgenBatchOutput, void>

groundSamplerForBatch()

function groundSamplerForBatch(ground): HeightSampler;

Ground sampler for a batch document.

Parameters

ground

WorldgenBatchGround

Returns

HeightSampler

hashCoord()

function hashCoord(
   a, 
   b, 
   salt
): number;

Hash two integer coordinates and a salt into a uint32 using integer multiplies only.

Parameters

a

number

b

number

salt

number

Returns

number

hashString()

function hashString(value): number;

FNV-1a of a string (bit-compatible with the kernel seedToInt).

Parameters

value

string

Returns

number

heightGridFromSampler()

function heightGridFromSampler(
   sampler, 
   originX, 
   originZ, 
   sizeX, 
   sizeZ, 
   cols, 
   rows
): HeightGrid;

Sample any ground into a grid (fixtures, worker payloads, tests).

Parameters

sampler

HeightSampler

originX

number

originZ

number

sizeX

number

sizeZ

number

cols

number

rows

number

Returns

HeightGrid

installWorldgen()

function installWorldgen(world, index): WorldgenHandle;

Register a worldgen index on a world and get the query handle. Generated geometry never enters world state; scripts and systems query the index through the handle.

Parameters

world

World

index

WorldgenIndex

Returns

WorldgenHandle

interiorToLocal()

function interiorToLocal(site, p): Vec2;

Parameters

site

p

Returns

interiorToWorld()

function interiorToWorld(site, p): Vec2;

Parameters

site

p

Returns

matchesWhen()

function matchesWhen(when, m): boolean;

Parameters

when

SelectionWhen | undefined

m

BuildingMetrics

Returns

boolean

normalizeBudgets()

function normalizeBudgets(partial): WorldgenBudgets;

Parameters

partial

Partial<WorldgenBudgets> | undefined

Returns

WorldgenBudgets

packIdentity()

function packIdentity(pack): PackIdentity;

Parameters

pack

Returns

PackIdentity

pointInRing()

function pointInRing(point, ring): boolean;

Even-odd containment test.

Parameters

point

ring

readonly Vec2[]

Returns

boolean

prepareBuildingCells()

function prepareBuildingCells(buffers, cellSize?): PreparedBuildingCell[];

Parameters

buffers

cellSize?

number

Returns

PreparedBuildingCell[]

propSalt()

function propSalt(
   pack, 
   scatter, 
   ruleId
): number;

Salt shared by every placement cell of one scatter rule.

Parameters

pack

PackIdentity

scatter

VersionedId

ruleId

string

Returns

number

quantizedIdentity()

function quantizedIdentity(
   x, 
   z, 
   quantum?
): string;

Fallback identity from a quantized centroid (c:<qx>,<qz>); prefer a real id when one exists.

Parameters

x

number

z

number

quantum?

number

Returns

string

queueBuildings()

function queueBuildings(input, stats): QueuedBuilding[];

The buildings, sorted by priority (area descending, then identity hash), with styles chosen.

Parameters

input

WorldgenBatchInput

stats

WorldgenStats

Returns

QueuedBuilding[]

registerWorldgenComponents()

function registerWorldgenComponents(): void;

Returns

void

registerWorldgenSchemas()

function registerWorldgenSchemas(): void;

Returns

void

resolveInteriorProfile()

function resolveInteriorProfile(labels, catalog): InteriorProfile;

The first profile whose labels match, in catalog order; the fallback profile otherwise.

Parameters

labels

readonly string[]

catalog

StylePackDocumentReader

Returns

InteriorProfile

resolveLandmarkCatalogDocuments()

function resolveLandmarkCatalogDocuments(data, readDocument): Promise<Readonly<Record<string, LandmarkDoc>>>;

Parameters

data

unknown

readDocument

(path) => Promise<unknown>

Returns

Promise<Readonly<Record<string, LandmarkDoc>>>

resolveStylePackDocuments()

function resolveStylePackDocuments(rootDoc, readDoc): Promise<ResolvedStylePack>;

Load and validate every document a manifest references; throws on any blocking issue.

Parameters

rootDoc

unknown

readDoc

Returns

Promise<ResolvedStylePack>

ringArea()

function ringArea(ring): number;

Parameters

ring

readonly Vec2[]

Returns

number

ringCentroid()

function ringCentroid(ring): Vec2;

Parameters

ring

readonly Vec2[]

Returns

selectStyle()

function selectStyle(
   rules, 
   metrics, 
   fallback, 
   identity?
): StyleSelection;

First matching rule wins; fallback closes the chain.

Parameters

rules

readonly StyleRule[]

metrics

BuildingMetrics

fallback

string

identity?

string

Returns

StyleSelection

stylePackAssetIndex()

function stylePackAssetIndex(pack, baseUrl): Record<string, string>;

Asset index for a pack served from baseUrl: material ids map to their document URLs (so a matgraph:<id> reference loads through the client asset provider) and asset ids map to their GLB URLs (sidecar directory + model.glb).

Parameters

pack

baseUrl

string

Returns

Record<string, string>

stylePackMaterialRefs()

function stylePackMaterialRefs(pack): string[];

Distinct doc-backed material references (matgraph, pixelgrid) any style part may use.

Parameters

pack

Returns

string[]

toLocal()

function toLocal(frame, point): Vec2;

Parameters

frame

Frame

point

Returns

toWorld()

function toWorld(frame, local): Vec2;

Parameters

frame

Frame

local

Returns

unit01()

function unit01(seed, stream): number;

Independent stateless draw in [0, 1) for a (seed, stream) pair.

Parameters

seed

number

stream

number

Returns

number

unreachableRuleIssues()

function unreachableRuleIssues(rules, path): ValidationIssue[];

Rules after a catch-all can never run.

Parameters

rules

readonly object[]

path

string

Returns

ValidationIssue[]

validateArchStyle()

function validateArchStyle(data): ValidationIssue[];

Cross-field checks: ranges, pitches, weights, catch-alls, palette refs, UV scales, tiers.

Parameters

data

unknown

Returns

ValidationIssue[]

validateInteriorCatalog()

function validateInteriorCatalog(data): InteriorCatalogDoc;

Parameters

data

unknown

Returns

validateScatter()

function validateScatter(data): ValidationIssue[];

Parameters

data

unknown

Returns

ValidationIssue[]

validateStylePack()

function validateStylePack(data): ValidationIssue[];

Parameters

data

unknown

Returns

ValidationIssue[]

validateStylePackBundle()

function validateStylePackBundle(pack): ValidationIssue[];

Cross-document checks over a resolved pack.

Parameters

pack