Skip to content

A fast 2D and 3D game engine — TypeScript SDK, C++/WebAssembly core, visual editor. Ship one project to web, desktop, WeChat MiniGames, playable ads, and native Android / iOS.

23.8 KB
Raw Blame

API surface — esengine/terrain

Symbols: 0 public · 0 beta · 115 experimental · 0 deprecated

Brush — interface @experimental

falloff: number
radius: number
x: number
z: number

Dirty — interface @experimental

i0: number
i1: number
j0: number
j1: number

Eroded — interface @experimental

field: Heightfield
flow: Float32Array<ArrayBufferLike>

ErosionParams — interface @experimental

amount: number
height: number
seed: number
sizeX: number
sizeZ: number

FACES — const @experimental

readonly { normal: readonly [number, number, number]; a: readonly [number, number, number]; b: readonly [number, number, number]; }[]

FieldSource — class @experimental

bounds: readonly [number, number, number, number]
ensureSplats: (second: boolean) => { a: Splat; b: Splat | null; }
field: Heightfield
height: (x: number, z: number) => number | null
infinite: false
maxHeight: number
minHeight: number
normal: (x: number, z: number) => [number, number, number] | null
paint: (x: number, z: number, h: number, ny: number) => LayerWeights
splats: () => { a: Splat | null; b: Splat | null; }
toData: () => FieldSourceData
static fromData: (d: FieldSourceData) => FieldSource
static new (field: Heightfield, data: Pick<TerrainData, "dirtHeight" | "height" | "rockSlope" | "sizeX" | "sizeZ" | "snowHeight">, splat: Splat | null, flow: Float32Array | null, range?: readonly [number, number], splat2?: Splat | null): FieldSource
static prototype: FieldSource

GroundEdit — class @experimental

apply: (patch: GroundPatch, side: "after" | "before") => void
area: { sizeX: number; sizeZ: number; }
begin: () => void
end: () => GroundPatch | null
field: Heightfield
heightAt: (x: number, z: number) => number | null
heightmapPixels: () => { width: number; height: number; pixels: Uint8Array; }
maxHeight: number
minHeight: number
origin: { x: number; z: number; }
paint: (layer: number, x: number, z: number, radius: number, falloff: number, strength: number, erase?: boolean) => void
samplesX: number
samplesZ: number
sculpt: (mode: number, x: number, z: number, radius: number, falloff: number, amount: number, target?: number) => void
splatmapPixels: () => { a: Splat | null; b: Splat | null; }
static new (host: GroundHost, source: FieldSource, modified: ModifiedSource, sizeX: number, sizeZ: number): GroundEdit
static prototype: GroundEdit

GroundPatch — interface @experimental

heights: Piece<Float32Array<ArrayBufferLike>> | null
splat2: Piece<Uint8Array<ArrayBufferLike>> | null
splat: Piece<Uint8Array<ArrayBufferLike>> | null

Heightfield — interface @experimental

data: Float32Array<ArrayBufferLike>
height: number
width: number

HeightmapFormat — const @experimental

{ readonly Grey: 0; readonly RedGreen16: 1; }

LayerImage — interface @experimental

height: number
pixels: Uint8Array<ArrayBufferLike>
width: number

LayerSource — interface @experimental

albedo: LayerImage | null
def: TerrainLayerDef
mask: LayerImage | null
normal: LayerImage | null

LayerWeights — type @experimental

readonly number[]

ModifiedSource — class @experimental

base: TerrainSource
bounds: readonly [number, number, number, number] | null
height: (x: number, z: number) => number | null
infinite: boolean
maxHeight: number
minHeight: number
normal: (x: number, z: number) => [number, number, number] | null
origin: { x: number; y: number; z: number; }
paint: (x: number, z: number, h: number, ny: number) => LayerWeights
region: ((x0: number, z0: number, spacing: number, count: number) => TerrainRegionSamples | Promise<TerrainRegionSamples>) | undefined
touched: (x0: number, z0: number, x1: number, z1: number) => boolean
static new (base: TerrainSource, modifiers: () => Iterable<TerrainModifier>, origin: { x: number; y: number; z: number; }, step: number): ModifiedSource
static prototype: ModifiedSource

NOISE_PROVIDER — const @experimental

"estella:noise"

NoiseParams — type @experimental

Pick<TerrainData, 'seed' | 'frequency' | 'octaves' | 'persistence' | 'ridged' | 'warp' | 'erosion' | 'sizeX' | 'height'
    | 'rockSlope' | 'dirtHeight' | 'snowHeight'>

NoiseSource — class @experimental

bounds: null
height: (x: number, z: number) => number
infinite: true
maxHeight: number
minHeight: 0
normal: (x: number, z: number) => [number, number, number]
paint: (_x: number, _z: number, h: number, ny: number) => [number, number, number, number]
sample: (x: number, z: number) => [number, number, number]
toData: () => NoiseParams
static fromData: (p: NoiseParams) => NoiseSource
static new (p: NoiseParams): NoiseSource
static prototype: NoiseSource

PAGE_SIDE — const @experimental

number

PAGE_TEXELS — const @experimental

number

PATCH_CELLS — const @experimental

32

PackedLayers — interface @experimental

albedo: Uint8Array<ArrayBufferLike>[]
heightBlends: number[]
mask: Uint8Array<ArrayBufferLike>[]
normal: Uint8Array<ArrayBufferLike>[]
size: number
tiles: number[]

Page — interface @experimental

max: number
min: number
slot: number
stale: boolean | undefined
used: number

PageImage — interface @experimental

heights: Uint8Array<ArrayBufferLike>
max: number
min: number
paint2: Uint8Array<ArrayBufferLike>
paint: Uint8Array<ArrayBufferLike>

PageTable — class @experimental

atlasSize: number
capacity: number
claim: (key: string, min: number, max: number) => Page | null
clear: () => void
forget: (test: (key: string) => boolean) => void
get: (key: string) => Page | undefined
isStale: (key: string) => boolean
markStale: (test: (key: string) => boolean) => void
origin: (slot: number) => [number, number]
perRow: number
size: number
tick: () => void
touch: (key: string) => void
static new (atlasSize: number): PageTable
static prototype: PageTable

PaintDab — interface @experimental

brush: Brush
erase: boolean | undefined
layer: number
strength: number

Planet — const @experimental

ComponentDef<PlanetData>

PlanetData — interface @experimental

cellSize: number
collision: boolean
collisionDistance: number
collisionLayer: number
detail: number
friction: number
generatorVersion: number
gravity: number
layerColor0: Color
layerColor1: Color
layerColor2: Color
layerColor3: Color
layers: string[]
macroScale: number
macroVariation: number
provider: string
radius: number
sea: boolean
seaColor: Color
seaLevel: number
seaOpacity: number
seed: number
world: string

PlanetFacts — interface @experimental

centre: [number, number, number]
fieldNames: readonly string[]
fieldsAt: ((dx: number, dy: number, dz: number) => readonly number[] | null) | null
gravity: number
height: ((dx: number, dy: number, dz: number) => number | null) | null
layers: readonly string[]
paint: ((dx: number, dy: number, dz: number) => readonly number[] | null) | null
radius: number
sampleMany: ((directions: Float32Array, count: number) => PlanetSamples | null) | null
worker: { source: string; seed: number; version: number; world: string; } | null | undefined

PlanetPageSource — interface @experimental

levels: number
maxHeight: number
minHeight: number
paint: (() => PlanetPainter | null) | undefined
provider: PlanetProvider
radius: number
seed: number
version: number
world: string

PlanetPlugin — class @experimental

activeWhen: ComponentDef<PlanetData>[]
build: (app: App) => void
cleanup: (app?: App) => void
name: string
static new (): PlanetPlugin
static prototype: PlanetPlugin

PlanetProvider — interface @experimental

fields: readonly string[] | undefined
id: string
range: (seed: number, version: number, radius: number) => [number, number]
sample: (region: PlanetRegion) => PlanetSamples | Promise<PlanetSamples>
versions: readonly number[]
workerSource: string | undefined

PlanetRegion — interface @experimental

count: number
directions: Float32Array<ArrayBufferLike>
radius: number
seed: number
version: number
world: string

PlanetRegistry — class @experimental

altitude: (entity: Entity, x: number, y: number, z: number) => number | null
groundHeight: (entity: Entity, x: number, y: number, z: number) => number | null
groundPoint: (entity: Entity, x: number, y: number, z: number) => [number, number, number] | null
nearest: (x: number, y: number, z: number) => Entity | null
paintOf: (entity: Entity) => PlanetPainter | null
paintRevision: number
planets: Map<number, PlanetFacts>
remotePaintOf: (entity: Entity) => RemotePaint | null
setPaint: (entity: Entity, painter: PlanetPainter | null, remote?: RemotePaint | null) => void
up: (entity: Entity, x: number, y: number, z: number) => [number, number, number] | null
static new (): PlanetRegistry
static prototype: PlanetRegistry

PlanetRegistryRes — const @experimental

ResourceDef<PlanetRegistry>

PlanetSamples — interface @experimental

fields: Float32Array<ArrayBufferLike> | undefined
heights: Float32Array<ArrayBufferLike>
paint: Float32Array<ArrayBufferLike> | undefined

PlanetStatus — interface @experimental

reason: string | undefined
state: "failed" | "loading" | "ready"

Planets — class @experimental

built_: Map<number, Built>
status: (entity: Entity) => PlanetStatus | null
static new (): Planets
static prototype: Planets

ProceduralParams — interface @experimental

frequency: number
octaves: number
persistence: number
resolution: number
ridged: number
seed: number
warp: number | undefined

ProviderSource — class @experimental

bounds: null
height: (x: number, z: number) => number | null
infinite: true
maxHeight: number
minHeight: number
normal: (x: number, z: number) => [number, number, number] | null
paint: (_x: number, _z: number, h: number, ny: number) => [number, number, number, number]
provider: TerrainProvider
region: (x0: number, z0: number, spacing: number, count: number) => TerrainSamples | Promise<TerrainSamples>
seed: number
version: number
world: string
static new (provider: TerrainProvider, world: string, seed: number, version: number, originX: number, originZ: number, pointSpacing: number, paintRules: (h: number, ny: number) => [number, number, number, number]): ProviderSource
static prototype: ProviderSource

QuadtreeParams — interface @experimental

bounds: readonly [number, number, number, number] | null
leafSize: number
levels: number
maxHeight: number
minHeight: number
range0: number

ReachGround — interface @experimental

heightAt: (x: number, z: number) => number | null

ReachOptions — interface @experimental

blocked: ((x: number, z: number) => boolean) | undefined
detour: number | undefined
maxCells: number | undefined
maxSlope: number | undefined
step: number | undefined

ReachResult — interface @experimental

cells: number
length: number
path: { x: number; y: number; z: number; }[]
state: "exhausted" | "noGround" | "reached" | "unreachable"

SculptDab — interface @experimental

amount: number
brush: Brush
mode: number
target: number | undefined

SculptMode — const @experimental

{ readonly Raise: 0; readonly Lower: 1; readonly Smooth: 2; readonly Flatten: 3; }

SphereNode — interface @experimental

face: number
ix: number
iz: number
level: number

SphereTreeParams — interface @experimental

leafSize: number
maxHeight: number
minHeight: number
radius: number
range0: number

Splat — interface @experimental

height: number
pixels: Uint8Array<ArrayBufferLike>
width: number

Terrain — const @experimental

ComponentDef<TerrainData>

TerrainData — interface @experimental

cellSize: number
collision: boolean
collisionDistance: number
collisionLayer: number
colorMap: number
colorMapStrength: number
detail: number
dirtHeight: number
drawDistance: number
erosion: number
extent: number
frequency: number
friction: number
generatorVersion: number
height: number
heightmap: number
heightmapFormat: number
layerColor0: Color
layerColor1: Color
layerColor2: Color
layerColor3: Color
layers: string[]
material: number
occlusionMap: number
occlusionStrength: number
octaves: number
persistence: number
provider: string
resolution: number
ridged: number
rockSlope: number
seed: number
sizeX: number
sizeZ: number
snowHeight: number
splatmap2: number
splatmap: number
tiles: string
virtualTexture: boolean
virtualTextureFrom: number
warp: number
world: string

TerrainExtent — const @experimental

{ readonly Area: 0; readonly Infinite: 1; }

TerrainLayerAssetLoader — class @experimental

extensions: string[]
load: (path: string, ctx: LoadContext) => Promise<TerrainLayerDef>
type: "terrain-layer"
unload: () => void
static new (): TerrainLayerAssetLoader
static prototype: TerrainLayerAssetLoader

TerrainLayerDef — interface @experimental

albedo: string | undefined
heightBlend: number | undefined
mask: string | undefined
normal: string | undefined
normalStrength: number
occlusion: number | undefined
roughness: number
tile: number
tint: [number, number, number]

TerrainLoad — interface @experimental

cpuBytes: number
loading: number
tiles: number
unsaved: number

TerrainModifier — interface @experimental

apply: (x: number, z: number, h: number) => number
bounds: readonly [number, number, number, number]
id: string

TerrainNode — interface @experimental

ix: number
iz: number
level: number
size: number
x0: number
z0: number

TerrainPlugin — class @experimental

activeWhen: ComponentDef<TerrainData>[]
build: (app: App) => void
cleanup: (app?: App) => void
name: string
static new (): TerrainPlugin
static prototype: TerrainPlugin

TerrainProvider — interface @experimental

heightAt: ((world: string, seed: number, version: number, x: number, z: number) => number) | undefined
id: string
range: (seed: number, version: number) => [number, number]
sample: (region: TerrainRegion) => TerrainSamples | Promise<TerrainSamples>
versions: readonly number[]

TerrainRegion — interface @experimental

count: number
seed: number
spacing: number
version: number
world: string
x0: number
z0: number

TerrainRegionSamples — interface @experimental

heights: Float32Array<ArrayBufferLike>
paint2: Float32Array<ArrayBufferLike> | undefined
paint: Float32Array<ArrayBufferLike> | undefined

TerrainSamples — interface @experimental

heights: Float32Array<ArrayBufferLike>
paint: Float32Array<ArrayBufferLike> | undefined

TerrainSource — interface @experimental

bounds: readonly [number, number, number, number] | null
height: (x: number, z: number) => number | null
infinite: boolean
maxHeight: number
minHeight: number
normal: (x: number, z: number) => [number, number, number] | null
paint: (x: number, z: number, h: number, ny: number) => LayerWeights
region: ((x0: number, z0: number, spacing: number, count: number) => TerrainRegionSamples | Promise<TerrainRegionSamples>) | undefined

TerrainStatus — interface @experimental

reason: string | undefined
state: "failed" | "loading" | "ready"

TerrainUnavailable — class @experimental

static new (message?: string): TerrainUnavailable
static prototype: TerrainUnavailable

Terrains — class @experimental

@internal app_: App | null
@internal built_: Map<number, Built>
@internal modifiers_: Map<string, TerrainModifier>
@internal pager_: TerrainPager | null
@internal paint_: Repaint | null
@internal remake_: (b: readonly [number, number, number, number]) => void
@internal revision_: number
areaBounds: () => [number, number, number, number] | null
collisionReadyAt: (x: number, z: number) => boolean
deleteModifier: (id: string) => void
findPath: (from: { x: number; z: number; }, to: { x: number; z: number; }, options?: ReachOptions) => ReachResult
groundData: () => GroundData | null
groundEdit: (entity: Entity) => GroundEdit | TiledGroundEdit | null
groundKnownAt: (x: number, z: number) => boolean
heightAt: (x: number, z: number) => number | null
heightBeneathAt: (x: number, z: number) => number | null
layerNames: () => string[]
load: () => TerrainLoad
loading: boolean
normalAt: (x: number, z: number) => [number, number, number] | null
paintAt: (x: number, z: number) => readonly number[] | null
pending: number
preparing: boolean
raycast: (origin: { x: number; y: number; z: number; }, direction: { x: number; y: number; z: number; }, maxDistance: number) => { distance: number; point: { x: number; y: number; z: number; }; normal: { x: number; y: number; z: number; }; entity: Entity; } | null
repaint: () => void
setModifier: (modifier: TerrainModifier) => void
setPager: (pager: TerrainPager | null) => void
setPaint: (paint: Repaint | null) => void
status: (entity: Entity) => TerrainStatus | null
toPrepare: number
static new (): Terrains
static prototype: Terrains

TerrainsRes — const @experimental

ResourceDef<Terrains>

TiledGroundEdit — class @experimental

apply: (patch: TiledGroundPatch, side: "after" | "before") => void
area: { sizeX: number; sizeZ: number; }
begin: () => void
end: () => TiledGroundPatch | null
exportImage: (mode: "all" | "loaded") => Promise<{ width: number; height: number; pixels: Uint8Array; } | null>
heightAt: (x: number, z: number) => number | null
importImage: (field: Heightfield, mode: "all" | "loaded") => TiledGroundImage[]
maxHeight: number
minHeight: number
origin: { x: number; z: number; }
paint: (layer: number, x: number, z: number, radius: number, falloff: number, strength: number, erase?: boolean) => void
samplesX: number
samplesZ: number
saveImages: () => { images: TiledGroundImage[]; document: TerrainTilesDocument | null; }
saved: () => void
sculpt: (mode: number, x: number, z: number, radius: number, falloff: number, amount: number, target?: number) => void
tiled: true
unsaved: string[]
static new (host: GroundHost, source: TiledSource, modified: ModifiedSource, sizeX: number, sizeZ: number): TiledGroundEdit
static prototype: TiledGroundEdit

TiledGroundImage — interface @experimental

height: number
path: string
pixels: Uint8Array<ArrayBufferLike>
width: number

TiledGroundPatch — interface @experimental

bounds: [number, number, number, number]
overview: Arrays
tiles: Map<string, Arrays>

boxDistance — function @experimental

(x0: number, z0: number, size: number, y0: number, y1: number, ex: number, ey: number, ez: number): number

brushWeight — function @experimental

(d: number, radius: number, falloff: number): number

buildPatchMesh — function @experimental

(cells: number, flipped?: boolean): MeshData

direction — function @experimental

(face: number, u: number, v: number, out?: [number, number, number]): [number, number, number]

encodeHeightmap — function @experimental

(field: Heightfield): Uint8Array

erodeHeightfield — function @experimental

(field: Heightfield, p: ErosionParams): Eroded

erosionJob — function @experimental

(field: Heightfield, p: ErosionParams): Generator<number, Eroded, void>

faceOf — function @experimental

(dx: number, dy: number, dz: number): { face: number; u: number; v: number; }

findGroundPath — function @experimental

(ground: ReachGround, fromX: number, fromZ: number, toX: number, toZ: number, options?: ReachOptions): ReachResult

flattenModifier — function @experimental

(id: string, shape: { type: "circle"; x: number; z: number; radius: number; } | { type: "rect"; x: number; z: number; halfX: number; halfZ: number; yaw?: number; }, height: number, falloff: number): TerrainModifier

heightfieldFromPixels — function @experimental

(width: number, height: number, pixels: ArrayLike<number>, format?: number, wide?: ArrayLike<number>): Heightfield

levelRange — function @experimental

(p: Pick<QuadtreeParams, "range0">, level: number): number

levelsFor — function @experimental

(radius: number, leafSize: number): number

makePage — function @experimental

(source: TerrainSource, x0: number, z0: number, size: number, repaint?: Repaint): PageImage | Promise<PageImage>

makePlanetPage — function @experimental

(src: PlanetPageSource, node: SphereNode): PageImage | Promise<PageImage>

nodeAt — function @experimental

(levels: number, face: number, level: number, u: number, v: number): SphereNode

nodeBound — function @experimental

(p: SphereTreeParams, levels: number, node: SphereNode): { x: number; y: number; z: number; r: number; }

nodeDistance — function @experimental

(p: SphereTreeParams, levels: number, node: SphereNode, ex: number, ey: number, ez: number): number

nodeKey — function @experimental

(level: number, ix: number, iz: number): string

nodePoint — function @experimental

(p: SphereTreeParams, levels: number, node: SphereNode, s: number, t: number, height: number, out?: [number, number, number]): [number, number, number]

nodeRect — function @experimental

(levels: number, node: SphereNode): { u0: number; v0: number; span: number; }

nodeSpan — const @experimental

(levels: number, level: number) => number

noiseProvider — function @experimental

(params: (seed: number) => NoiseParams): TerrainProvider

noised — function @experimental

(x: number, y: number, seed: number): [number, number, number]

packLayers — function @experimental

(layers: readonly LayerSource[], maxSize?: number): PackedLayers

paintSplat — function @experimental

(a: Splat, b: Splat | null, sizeX: number, sizeZ: number, dab: PaintDab): Dirty | null

paintWeights — function @experimental

(h: number, ny: number, t: Pick<TerrainData, "dirtHeight" | "rockSlope" | "snowHeight">): [number, number, number, number]

parentOf — function @experimental

(n: TerrainNode, leafSize: number): TerrainNode

parseTerrainLayer — function @experimental

(json: unknown, file?: string): TerrainLayerDef

planetPlugin — const @experimental

PlanetPlugin

planetProvider — function @experimental

(id: string): PlanetProvider | undefined

proceduralHeightfield — function @experimental

(p: ProceduralParams): Heightfield

readTerrainImage — function @experimental

(app: App, path: string): Promise<{ width: number; height: number; pixels: Uint8Array; wide?: Uint16Array; } | null>

registerPlanetProvider — function @experimental

(provider: PlanetProvider): void

registerTerrainProvider — function @experimental

(provider: TerrainProvider): void

sampleHeight — function @experimental

(field: Heightfield, u: number, v: number): number

sculptField — function @experimental

(field: Heightfield, sizeX: number, sizeZ: number, dab: SculptDab): Dirty | null

selectNodes — function @experimental

(p: QuadtreeParams, ex: number, ey: number, ez: number): TerrainNode[]

selectSphereNodes — function @experimental

(p: SphereTreeParams, ex: number, ey: number, ez: number, levels?: number): SphereNode[]

sphereNodeKey — const @experimental

(n: SphereNode) => string

sphereRange — const @experimental

(p: Pick<SphereTreeParams, "range0">, level: number) => number

tangentFrame — function @experimental

(face: number, d: readonly [number, number, number], eu: [number, number, number], ev: [number, number, number]): void

terrainNormal — function @experimental

(field: Heightfield, u: number, v: number, sizeX: number, sizeZ: number, heightScale: number): [number, number, number]

terrainPlugin — const @experimental

Plugin

terrainProvider — function @experimental

(id: string): TerrainProvider | undefined

unionDirty — function @experimental

(a: Dirty | null, b: Dirty | null): Dirty | null