@bendyline/molen-worldgen-earth/client

Earth binding for Molen worldgen: terrain-semantics adapter, OSM label mapping, and lon/lat region atlas (kernel) with terrain tile renderers (client).

import { /* … */ } from '@bendyline/molen-worldgen-earth/client';

Interfaces

InThreadGeneratorOptions

Properties

atlas?

optional atlas?: RegionAtlasDoc;

places?

optional places?: PlacesContent;

Landmarks and business identities for mapped places (none when omitted).

regions?

optional regions?: RegionResolver;

yieldEveryBuildings?

optional yieldEveryBuildings?: number;

Buildings generated between cooperative yields (default 48).

---

LoadRegionAtlasOptions

Properties

fetch?

optional fetch?: (input, init?) => Promise<Response>;

MDN Reference

Parameters

input

RequestInfo | URL

init?

RequestInit

Returns

Promise<Response>

signal?

optional signal?: AbortSignal;

---

WorkerLike

Methods

addEventListener()

addEventListener(type, listener): void;

Parameters

type

"message"

listener

(event) => void

Returns

void

postMessage()

postMessage(message, transfer?): void;

Parameters

message

unknown

transfer?

Transferable[]

Returns

void

removeEventListener()?

optional removeEventListener(type, listener): void;

Parameters

type

"message"

listener

(event) => void

Returns

void

terminate()?

optional terminate(): void;

Returns

void

---

WorldgenGenerateRequest

Properties

budgets?

optional budgets?: Partial<WorldgenBudgets>;

features?

optional features?: object;

buildings?

optional buildings?: boolean;

interiors?

optional interiors?: boolean;

scatter?

optional scatter?: boolean;

geom

geom: TileGeometry;

ground

ground: HeightSampler;

World-space ground of the tile (a terrain heightfield).

renderCellsOnly?

optional renderCellsOnly?: boolean;

Renderer requests compact cells instead of retaining a second canonical vertex copy.

resolution

resolution: number;

Samples per tile edge for the transferable height grid (the terrain tile resolution).

tierOffset?

optional tierOffset?: number;

tile

tile: TerrainSemanticTile;

---

WorldgenGenerator

Produces tile output somewhere: in a worker, in-thread, or from a cache in front of either.

Methods

dispose()

dispose(): void;

Returns

void

generate()

generate(request, signal): Promise<WorldgenTileOutput | undefined>;

Parameters

request

WorldgenGenerateRequest

signal

AbortSignal

Returns

Promise<WorldgenTileOutput | undefined>

---

WorldgenRendererOptions

Properties

atlas?

optional atlas?: RegionAtlasDoc;

budgets?

optional budgets?: Partial<WorldgenBudgets>;

cache?

optional cache?: WorldgenTileCache;

CPU-side cache of generated tiles keyed by pack, atlas, quality, and address.

generator?

optional generator?: WorldgenGenerator;

Where tiles are generated (default: on this thread); e.g. createWorldgenWorkerBridge.

interiors?

optional interiors?: boolean | Omit<InteriorStreamingOptions, "catalog">;

Real openings and bounded lazy interiors, including residential upstairs (opt in). They are laid out by the style pack's interior catalog; a pack without one generates no interiors.

landcover?

optional landcover?: TerrainSemanticMeshOptions;

Options forwarded to the default land surface (colors default to the scatter surface colors).

landcoverGenerator?

optional landcoverGenerator?: TerrainLandcoverGenerator;

Optional worker-backed land-cover surface draping. Caller owns its lifetime.

lodPolicy?

optional lodPolicy?: ScreenSpaceLodPolicy;

Shared screen-space policy for resident building and vegetation LODs.

materials?

optional materials?: WorldgenMaterialSet;

metersPerUnit?

optional metersPerUnit?: number;

cos(center latitude) factor of the terrain package (1 for local packages).

models?

optional models?: ModelLibrary;

Prepared prop models; without it the classification layer keeps the default tree cones.

onTileStats?

optional onTileStats?: (output, generateMs) => void;

Parameters

output

WorldgenTileOutput

generateMs

number

Returns

void

places?

optional places?: PlacesContent;

Landmarks and business identities for mapped places; without them businesses are not recognized and street furniture is not placed. With a worker generator, pass the worker the same content; tile cache keys include its hashes.

prepareObject?

optional prepareObject?: (object, signal, parent?) => Promise<void>;

Prepare replacement architecture before a resident quality change becomes visible. parent is the layer object the replacement will join.

Parameters

object

Object3D

signal

AbortSignal

parent?

Object3D<Object3DEventMap>

Returns

Promise<void>

propLod?

optional propLod?: boolean;

Camera-distance vegetation LOD and spatial culling (default true).

quality?

optional quality?: WorldgenQualityPreset;

regions?

optional regions?: RegionResolver;

roads?

optional roads?: TerrainSemanticMeshOptions;

Shared surface styles/controller for roads, parking areas, markings and fixtures.

sampleStructureTerrain?

optional sampleStructureTerrain?: StructureTerrainSampler;

Fine or cross-tile ground samples; undefined coverage leaves the procedural fallback.

structureModels?

optional structureModels?: ModelLibrary;

Streamed geographic models; defaults to models when no separate library is supplied.

structureObjects?

optional structureObjects?: StructureModelLibrary;

Full glTF hierarchy and PBR materials for authored structures; preferred over flattened props.

structures?

optional structures?: StructureIndex;

Authored geographic structures, indexed by geohash for tile lookup.

viewingDate?

optional viewingDate?: string;

Explicit YYYY-MM-DD date for archival landmarks; omitted keeps them unloaded.

yieldEveryBuildings?

optional yieldEveryBuildings?: number;

Buildings generated between cooperative yields (default 48, in-thread only).

---

WorldgenRenderStats

Properties

boxes

boxes: number;

buildings

buildings: number;

cache?

optional cache?: object;

bytes

bytes: number;

hits

hits: number;

misses

misses: number;

size

size: number;

generateMs

generateMs: object;

last

last: number;

max

max: number;

mean

mean: number;

geometryBytes

geometryBytes: number;

interiors?

optional interiors?: InteriorStreamingStats;

props

props: number;

skippedByOwnership

skippedByOwnership: number;

tiles

tiles: number;

---

WorldgenSemanticRenderers

Properties

classification

classification: TerrainSemanticTileRenderer;

humanFeatures

humanFeatures: TerrainSemanticTileRenderer;

Methods

dispose()

dispose(): void;

Returns

void

setCacheBudget()

setCacheBudget(maxBytes): void;

Parameters

maxBytes

number

Returns

void

setQuality()

setQuality(quality): void;

Rebuild resident architecture cooperatively, keeping the previous geometry until ready.

Parameters

quality

WorldgenQualityPreset

Returns

void

stats()

stats(): WorldgenRenderStats;

Returns

WorldgenRenderStats

updateInteriors()

updateInteriors(position): void;

Call before walking collision with the camera in metric world coordinates.

Parameters

position

readonly [number, number, number]

Returns

void

---

WorldgenTileCache

Properties

bytes

readonly bytes: number;

evictions

readonly evictions: number;

hits

readonly hits: number;

misses

readonly misses: number;

size

readonly size: number;

Methods

clear()

clear(): void;

Returns

void

delete()

delete(key): boolean;

Parameters

key

string

Returns

boolean

get()

get(key): WorldgenTileOutput | undefined;

Parameters

key

string

Returns

WorldgenTileOutput | undefined

set()

set(key, output): void;

Parameters

key

string

output

WorldgenTileOutput

Returns

void

setLimits()

setLimits(options): void;

Trim immediately when the device working-set budget changes.

Parameters

options

WorldgenTileCacheOptions

Returns

void

---

WorldgenTileCacheKeyParts

Properties

atlasHash?

optional atlasHash?: string;

features

features: object;

buildings

buildings: boolean;

scatter

scatter: boolean;

level

level: number;

packHash

packHash: string;

quality

quality: string;

variant?

optional variant?: string;

Effective generation settings, when they differ within one named quality preset.

x

x: number;

z

z: number;

---

WorldgenTileCacheOptions

Properties

maxBytes?

optional maxBytes?: number;

Bytes of mesh and instance data kept (default 256 MiB).

maxEntries?

optional maxEntries?: number;

Entries kept (default 256).

---

WorldgenWorkerBridgeOptions

Properties

atlas?

optional atlas?: RegionAtlasDoc;

metersPerUnit

metersPerUnit: number;

ownsWorker?

optional ownsWorker?: boolean;

Terminate the worker on dispose (default true).

pack

pack: ResolvedStylePack;

places?

optional places?: PlacesContentDocs;

Places content documents to generate with (none when omitted). Give the renderer the same content as places so its tile cache keys match what the worker generates.

Type Aliases

StructureTerrainSampler

type StructureTerrainSampler = (coordinate, request) => number | undefined | Promise<number | undefined>;

Heights use the same metres and vertical reference as the host's terrain geometry.

Parameters

coordinate

readonly [number, number]

request

Readonly<{ entry: StructurePlacement; signal: AbortSignal; }>

Returns

number | undefined | Promise<number | undefined>

Functions

createInThreadWorldgenGenerator()

function createInThreadWorldgenGenerator(pack, options?): WorldgenGenerator;

Generate on the calling thread, yielding to the host between chunks and honouring aborts.

Parameters

pack

ResolvedStylePack

options?

InThreadGeneratorOptions

Returns

WorldgenGenerator

---

createWorldgenSemanticRenderers()

function createWorldgenSemanticRenderers(pack, options?): WorldgenSemanticRenderers;

Renderers for the classification and human-feature layers of a terrain package.

Parameters

pack

ResolvedStylePack

options?

WorldgenRendererOptions

Returns

WorldgenSemanticRenderers

---

createWorldgenTileCache()

function createWorldgenTileCache(options?): WorldgenTileCache;

Parameters

options?

WorldgenTileCacheOptions

Returns

WorldgenTileCache

---

createWorldgenWorkerBridge()

function createWorldgenWorkerBridge(worker, options): WorldgenGenerator;

Parameters

worker

WorkerLike

options

WorldgenWorkerBridgeOptions

Returns

WorldgenGenerator

---

loadRegionAtlas()

function loadRegionAtlas(url, options?): Promise<RegionAtlasDoc>;

Parameters

url

string | URL

options?

LoadRegionAtlasOptions

Returns

Promise<RegionAtlasDoc>

---

outputBytes()

function outputBytes(output): number;

Parameters

output

WorldgenTileOutput

Returns

number

---

tileHeightGrid()

function tileHeightGrid(
   ground, 
   geom, 
   resolution
): HeightGrid;

Sample a tile's ground into the grid both generation paths use.

Parameters

ground

HeightSampler

geom

TileGeometry

resolution

number

Returns

HeightGrid

---

withWorldgenTileCache()

function withWorldgenTileCache(
   generator, 
   cache, 
   keyOf
): WorldgenGenerator;

Serve repeat tiles from the cache; generate (and remember) the rest.

Parameters

generator

WorldgenGenerator

cache

WorldgenTileCache

keyOf

(request) => string

Returns

WorldgenGenerator

---

worldgenTileCacheKey()

function worldgenTileCacheKey(parts): string;

Parameters

parts

WorldgenTileCacheKeyParts

Returns

string

References

createRegionResolver

Re-exports createRegionResolver

---

RegionResolver

Re-exports RegionResolver

---

RegionResolverOptions

Re-exports RegionResolverOptions