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.

9.1 KB
Raw Blame

API surface — esengine/water

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

Basin — interface @experimental

cells: number
deepest: { x: number; z: number; y: number; }
id: number
level: number
outlet: { x: number; z: number; y: number; index: number; }

BasinMap — interface @experimental

accumulation: Float32Array<ArrayBufferLike>
basin: Int32Array<ArrayBufferLike>
basins: Basin[]
downstream: Int32Array<ArrayBufferLike>
filled: Float32Array<ArrayBufferLike>
grid: ZoneGrid
ground: Float32Array<ArrayBufferLike>
sea: Uint8Array<ArrayBufferLike>

BasinOptions — interface @experimental

minCells: number | undefined
minDepth: number | undefined
seaLevel: number | undefined

FieldSample — interface @experimental

amp: number
calm: number
depth: number
exposure: number
flowX: number
flowZ: number
height: number
key: number
shore: number
still: number
surf: number
swell: number

Floating — const @experimental

ComponentDef<FloatingData>

FloatingBody — interface @experimental

angularVelocity: [number, number, number]
mass: number
position: [number, number, number]
velocity: [number, number, number]

FloatingData — interface @experimental

buoyancy: number
drag: number
points: Vec3Like[]
radius: number
wake: number

FloatingForce — interface @experimental

force: [number, number, number]
point: [number, number, number]

FloatingPlugin — class @experimental

build: (app: App) => void
name: string
static new (): FloatingPlugin
static prototype: FloatingPlugin

Point2 — interface @experimental

x: number
y: number

RippleField — class @experimental

cell: number
disturb: (x: number, z: number, radius: number, strength: number) => void
encode: (range: number, into?: Uint8Array) => Uint8Array
foamAt: (x: number, z: number) => number
heightAt: (x: number, z: number) => number
limit: number
n: number
originX: number
originZ: number
peak: () => number
recenter: (x: number, z: number) => boolean
size: number
step: (dt: number, speed: number, damping: number, foamFade: number) => void
static new (n: number, size: number): RippleField
static prototype: RippleField

UnderwaterPlugin — class @experimental

build: (app: App) => void
cleanup: () => void
name: string
static new (): UnderwaterPlugin
static prototype: UnderwaterPlugin

WATERFALL_SHADER_TEMPLATE — const @experimental

BuiltinShaderTemplate

WAVE_SET — const @experimental

readonly (readonly [number, number, number, number])[]

WaterBody — const @experimental

ComponentDef<WaterBodyData>

WaterBodyData — interface @experimental

bedDepth: number
bodyId: string
boundary: Point2[]
flowSpeed: number
form: number
shoreWidth: number
sizeX: number
sizeZ: number
waveHeight: number

WaterField — class @experimental

amp: Float32Array<ArrayBufferLike>
at: (x: number, z: number) => FieldSample | null
calm: Float32Array<ArrayBufferLike>
depth: Float32Array<ArrayBufferLike>
encode: (r: ZoneRanges) => { heights: Uint8Array; field: Uint8Array; exposure: Uint8Array; }
exposure: Float32Array<ArrayBufferLike>
flowX: Float32Array<ArrayBufferLike>
flowZ: Float32Array<ArrayBufferLike>
grid: ZoneGrid
height: Float32Array<ArrayBufferLike>
ocean: ZoneOcean | null
owner: Int32Array<ArrayBufferLike>
query: () => WaterQuery
ranges: (shoreReach?: number) => ZoneRanges
sample: (x: number, z: number) => FieldSample | null
shore: Float32Array<ArrayBufferLike>
steep: Float32Array<ArrayBufferLike>
still: Float32Array<ArrayBufferLike>
surf: Float32Array<ArrayBufferLike>
swell: Float32Array<ArrayBufferLike>
static bake: (grid: ZoneGrid, bodies: readonly ZoneBody[], ground?: ZoneGround, surfLength?: number) => WaterField
static baking: (grid: ZoneGrid, bodies: readonly ZoneBody[], ground?: ZoneGround, surfLength?: number) => Generator<number, WaterField, void>
static new (grid: ZoneGrid, ocean: ZoneOcean | null): WaterField
static prototype: WaterField

WaterForm — const @experimental

{ readonly Ocean: 0; readonly Lake: 1; readonly River: 2; }

WaterPlugin — class @experimental

activeWhen: (ComponentDef<WaterBodyData> | ComponentDef<WaterZoneData>)[]
build: (app: App) => void
cleanup: (app?: App) => void
name: string
static new (): WaterPlugin
static prototype: WaterPlugin

WaterSample — interface @experimental

bodyId: string
depth: number
entity: number
flow: [number, number, number]
inside: boolean
normal: [number, number, number]
surface: [number, number, number]

WaterZone — const @experimental

ComponentDef<WaterZoneData>

WaterZoneData — interface @experimental

cellSize: number
cells: number
foamFade: number
material: number
resolution: number
rings: number
rippleDamping: number
rippleSize: number
rippleSpeed: number
ripples: number
sizeX: number
sizeZ: number
surf: number
surfLength: number
waveDirection: number
waveLength: number
waveSpeed: number

Waterfall — const @experimental

ComponentDef<WaterfallData>

WaterfallAnchor — const @experimental

ComponentDef<WaterfallAnchorData>

WaterfallAnchorData — interface @experimental

at: number
lift: number

WaterfallData — interface @experimental

across: number
flare: number
maxDrop: number
rows: number
sheetGap: number
sheets: number
speed: number
width: number

WaterfallLanding — interface @experimental

heightAt: ((x: number, z: number) => number | null) | undefined
waterAt: ((x: number, z: number, y: number) => { body: number; above: number; } | null) | undefined

WaterfallLip — interface @experimental

dirX: number
dirZ: number
x: number
y: number
z: number

Waters — class @experimental

@internal app_: App | null
@internal field_: WaterField | null
@internal instance_: number
@internal revision_: number
@internal ripples_: RippleField | null
@internal zone_: WaterZoneData
baking: boolean
bodyAt: (x: number, z: number) => { entity: Entity; bodyId: string; form: number; level: number; } | null
depthAt: (x: number, z: number, y: number) => number | null
disturb: (x: number, y: number, z: number, radius: number, strength: number) => boolean
empty: boolean
heightAt: (x: number, z: number) => number | null
quality: WaterQuality
queryData: () => WaterQueryData | null
rippleAt: (x: number, _y: number, z: number) => number
sample: (x: number, y: number, z: number) => WaterSample | null
shoreAt: (x: number, z: number) => number | null
static new (): Waters
static prototype: Waters

WatersRes — const @experimental

ResourceDef<Waters>

WaveParams — interface @experimental

count: number | undefined
direction: number
height: number
length: number
speed: number

buildOceanMesh — function @experimental

(cells: number, rings: number, cellSize: number, skirt?: number): MeshData

buildWaterfall — function @experimental

(fall: WaterfallData, lip: WaterfallLip, landing: WaterfallLanding | null): MeshData | null

currentShare — function @experimental

(width: number, widest: number): number

drainPath — function @experimental

(map: BasinMap, x: number, z: number): { x: number; z: number; y: number; }[]

findBasins — function @experimental

(grid: ZoneGrid, ground: (x: number, z: number) => number | null, options?: BasinOptions): BasinMap

floatingForce — function @experimental

(body: FloatingBody, point: [number, number, number], sample: WaterSample | null, floating: FloatingData, gravity: [number, number, number], ppu: number, dt: number, points: number): FloatingForce | null

oceanReach — function @experimental

(cells: number, rings: number, cellSize: number): number

oceanSnap — function @experimental

(rings: number, cellSize: number): number

polygonSdf — function @experimental

(poly: readonly Point2[], x: number, z: number): number

registerUnderwaterEffect — function @experimental

(): void

shoreDamp — function @experimental

(reach: number, width: number): number

wakeStrength — function @experimental

(sample: WaterSample | null, velocity: [number, number, number], floating: FloatingData, dt: number): number

waterPlugin — const @experimental

Plugin

waterfallAnchorPoint — function @experimental

(fall: WaterfallData, seconds: number, anchor: WaterfallAnchorData): [number, number, number]

waterfallFlight — function @experimental

(fall: WaterfallData, lip: WaterfallLip, landing: WaterfallLanding | null, ahead?: number): { seconds: number; drop: number; }

waterfallHeading — function @experimental

(q: { x: number; y: number; z: number; w: number; }): [number, number]

waveFade — function @experimental

(length: number, cell: number): number

waveHeight — function @experimental

(p: WaveParams, x: number, z: number, time: number, cell?: number): number

waveSlope — function @experimental

(p: WaveParams, x: number, z: number, time: number): [number, number]