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.

453 KB
Raw Blame

API surface — esengine/wechat

Symbols: 115 public · 166 beta · 2203 experimental · 3 deprecated

ANCHOR_AXES — const @experimental

readonly AnchorAxis[]

ANIMATOR_FORMAT_VERSION — const @experimental

2

ANIM_CLIP_FORMAT_VERSION — const @experimental

"1.5"

ASSET_GROUP_MODES — const @experimental

readonly ["local", "subpackage", "remote"]

ATTACK_KEY — const @experimental

"KeyJ"

AVATAR_FORMAT_VERSION — const @experimental

1

AchievementProvider — interface @experimental

getStat: (name: string) => number
platformBacked: boolean
reset: () => Promise<void>
setStat: (name: string, value: number) => void
store: () => Promise<void>
unlock: (id: string) => Promise<void>
unlocked: (id: string) => boolean

Achievements — const @experimental

ResourceDef<AchievementsAPI>

AchievementsAPI — class @experimental

available: boolean
getStat: (name: string) => number
reset: () => Promise<void>
setKnown: (ids: readonly string[] | null) => void
setProvider: (provider: AchievementProvider | null) => void
setStat: (name: string, value: number) => void
store: () => Promise<void>
unlock: (id: string) => Promise<void>
unlocked: (id: string) => boolean
static new (): AchievementsAPI
static prototype: AchievementsAPI

ActionDef — interface @public

bindings: Binding[]
type: ActionType

ActionType — type @public

'button' | 'axis' | 'axis2d'

ActivationTrack — interface @experimental

childPath: string
name: string
ranges: ActivationRange[]
type: "activation"

ActiveShot — interface @experimental

curve: number
from: number | null
to: number
weight: number

AdProvider — interface @experimental

createInterstitialAd: (adUnitId: string) => PlatformInterstitialAd
createRewardedAd: (adUnitId: string) => PlatformRewardedAd

Added — function @experimental

<T extends AnyComponentDef>(component: T): AddedWrapper<T>

AddedEntity — interface @experimental

components: ComponentData[]
name: string
parentId: string | null
prefabEntityId: string
visible: boolean

AddedWrapper — interface @public

@internal _component: T
@internal _filterType: "added"

AddressableAssetType — type @experimental

| 'texture' | 'material' | 'spine' | 'bitmap-font' | 'font'
    | 'prefab' | 'json' | 'text' | 'binary' | 'audio'

AddressableManifest — interface @experimental

groups: Record<string, AddressableManifestGroup>
revision: string | undefined
version: "2.0"

AddressableManifestAsset — interface @experimental

address: string | undefined
compressedFormats: string[] | undefined
contentHash: string | undefined
labels: string[]
metadata: { atlas?: string; atlasPage?: number; atlasFrame?: { x: number; y: number; width: number; height: number; }; atlasPageWidth?: number; atlasPageHeight?: number; } | undefined
pack: AssetPackRef | undefined
path: string
size: number
spineImport: SpineManifestContract | undefined
streamTail: StreamTailInfo | undefined
textureImport: ParsedTextureImportSettings | undefined
type: AddressableAssetType

AddressableManifestGroup — interface @experimental

assets: Record<string, AddressableManifestAsset>
bundleMode: string
labels: string[]

Ads — const @experimental

ResourceDef<AdsAPI>

AdsAPI — class @experimental

available: boolean
preloadRewarded: (adUnitId: string) => Promise<void>
setProvider: (provider: AdProvider | null) => void
showInterstitial: (adUnitId: string) => Promise<void>
showRewarded: (adUnitId: string) => Promise<PlatformRewardedAdResult>
showing: boolean
static new (takeover: Takeover): AdsAPI
static prototype: AdsAPI

AiAction — type @experimental

(
    ctx: Ctx,
    bb: Blackboard,
    arg?: string,
    params?: AiParams,
    out?: AiOutputs,
) => void | Status

AiActionInput — interface @experimental

arg: string | undefined
params: Readonly<Record<string, AiParamValue>> | undefined

AiActionSpec — interface @experimental

outputs: readonly AiOutputDef[] | undefined
params: readonly AiParamDef[] | undefined
pure: boolean | undefined
run: AiAction<Ctx>
separator: string | undefined
touches: AiTouchesSource | undefined

AiCondition — type @experimental

(ctx: Ctx, bb: Blackboard) => boolean

AiContext — interface @experimental

blackboard: Blackboard
commands: CommandsInstance
dt: number
entity: number
get: <C extends AnyComponentDef>(component: C) => ComponentData<C>
has: (component: AnyComponentDef) => boolean
input: InputState
set: <C extends AnyComponentDef>(component: C, data: ComponentData<C>) => void
world: World

AiOutputDef — interface @experimental

label: string | undefined
name: string
tooltip: string | undefined
type: "bool" | "entity" | "number" | "string"

AiOutputs — type @experimental

Record<string, AiParamValue>

AiParamDef — interface @experimental

label: string | undefined
max: number | undefined
min: number | undefined
name: string
options: readonly { label: string; value: string; }[] | undefined
optionsSource: string | undefined
step: number | undefined
tooltip: string | undefined
type: "bool" | "enum" | "number" | "string"

AiParamValue — type @experimental

string | number | boolean

AiParams — type @experimental

Readonly<Record<string, AiParamValue>>

AiRegistry — class @experimental

actionNames: () => string[]
actionTouches: (name: string, input?: AiActionInput) => AiTouches | undefined
clear: () => void
conditionNames: () => string[]
conditionTouches: (name: string) => AiTouches | undefined
getAction: (name: string) => AiAction<Ctx> | undefined
getActionOutputs: (name: string) => readonly AiOutputDef[]
getActionParams: (name: string) => readonly AiParamDef[]
getActionSeparator: (name: string) => string
getCondition: (name: string) => AiCondition<Ctx> | undefined
hasAction: (name: string) => boolean
hasCondition: (name: string) => boolean
isActionPure: (name: string) => boolean
registerAction: (name: string, fn: AiAction<Ctx> | AiActionSpec<Ctx>) => void
registerCondition: (name: string, fn: AiCondition<Ctx> | AiConditionSpec<Ctx>) => void
registerValue: (name: string, spec: AiValueSpec<Ctx>) => void
static new <Ctx = unknown>(): AiRegistry<Ctx>
static prototype: AiRegistry<any>

AiValueSpec — interface @experimental

evaluate: (ctx: Ctx, bb: Blackboard, params: AiParams, out: AiOutputs) => void
outputs: readonly AiOutputDef[]
params: readonly AiParamDef[] | undefined
touches: AiTouches | undefined

AlignContent — enum @experimental

Center = 1
End = 2
SpaceAround = 5
SpaceBetween = 4
Start = 0
Stretch = 3

AlignItems — enum @experimental

Center = 1
End = 2
Start = 0
Stretch = 3

AlignSelf — enum @experimental

Auto = 0
Center = 2
End = 3
Start = 1
Stretch = 4

AmbientSkip — type @experimental

'hidden' | 'disabled' | 'no-intensity'

Ambiguity — interface @experimental

a: string
b: string
over: string[]

AnchorAxis — enum @experimental

Center = 1
End = 2
Start = 0
Stretch = 3

AnchorFields — interface @experimental

height: Dimension | undefined
insetBottom: Dimension
insetLeft: Dimension
insetRight: Dimension
insetTop: Dimension
marginBottom: Dimension
marginLeft: Dimension
marginRight: Dimension
marginTop: Dimension
position: number
width: Dimension | undefined

AnchorFlag — const @experimental

Readonly<{ TOP: 1; MID: 2; BOTTOM: 4; LEFT: 8; CENTER: 16; RIGHT: 32; HORIZONTAL: number; VERTICAL: number; }>

AnchorMode — const @experimental

Readonly<{ ONCE: 0; ON_RESIZE: 1; ALWAYS: 2; }>

AnchorPreset — interface @experimental

h: AnchorAxis
v: AnchorAxis

And — function @experimental

(...filters: FilterExpr[]): FilterExpr

AnimClipAssetData — interface @experimental

events: AnimClipEventData[] | undefined
fps: number | undefined
frameSizing: AnimClipSizing | undefined
frames: AnimClipFrameData[]
loop: boolean | undefined
pivot: AnimClipPivotData | undefined
sheet: AnimClipSheetData | undefined
type: "animation-clip"
version: string

AnimClipEventData — interface @experimental

data: unknown
frame: number
name: string

AnimClipFrameData — interface @experimental

atlasFrame: { x: number; y: number; width: number; height: number; pageWidth: number; pageHeight: number; } | undefined
cell: number | undefined
duration: number | undefined
offset: AnimClipVec2 | undefined
pivot: AnimClipPivotData | undefined
size: AnimClipVec2 | undefined
texture: string | undefined

AnimClipPivotData — interface @experimental

x: number
y: number

AnimClipSheetData — interface @experimental

cellHeight: number
cellWidth: number
margin: number
pageHeight: number
pageWidth: number
spacing: number
texture: string

AnimClipSizing — type @experimental

'entity' | 'frame'

AnimClipVec2 — interface @experimental

x: number
y: number

AnimFramesTrack — interface @experimental

childPath: string
frames: AnimFrame[]
name: string
type: "animFrames"

AnimationPlugin — class @experimental

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

Animator — const @beta

ComponentDef<AnimatorData>

AnimatorAvatar — interface @experimental

joints: Record<string, string>
rest: Record<string, Quat> | undefined
restPosition: Record<string, Vec3> | undefined
scale: number | undefined
space: Record<string, Quat> | undefined

AnimatorBlend1D — interface @experimental

parameter: string
thresholds: AnimatorBlendThreshold[]

AnimatorBlend1DMotion — interface @experimental

kind: "blend1d"
parameter: string
thresholds: AnimatorBlendStop[]

AnimatorBlend2DMotion — interface @experimental

kind: "blend2d"
parameterX: string
parameterY: string
points: AnimatorBlendPoint[]

AnimatorBlendPoint — interface @experimental

motion: AnimatorMotion
position: { x: number; y: number; }

AnimatorBlendStop — interface @experimental

motion: AnimatorMotion
value: number

AnimatorBlendThreshold — interface @experimental

clip: string
loop: boolean | undefined
speed: number | undefined
value: number

AnimatorClipMotion — interface @experimental

clip: string
kind: string
loop: boolean | undefined
speed: number | undefined

AnimatorCondition — type @experimental

| { param: string; op: 'gt' | 'lt' | 'eq' | 'neq'; value: number }
    | { param: string; op: 'true' | 'false' | 'trigger' }

AnimatorController — const @experimental

ResourceDef<AnimatorControllerAPI>

AnimatorControllerAPI — class @experimental

@internal useAssetControllers: (source: (ref: string) => AnimatorControllerDef | undefined) => void
clearControllers: () => void
getBool: (entity: Entity, name: string) => boolean
getController: (name: string) => AnimatorControllerDef | undefined
getFloat: (entity: Entity, name: string) => number
hasMotionDriver: (kind: string) => boolean
registerController: (name: string, def: AnimatorControllerDef) => void
registerMotionDriver: <M extends AnimatorMotion>(kind: M["kind"], driver: MotionDriver<M>) => void
removeEntity: (entity: Entity) => void
resetTrigger: (entity: Entity, name: string) => void
setBool: (entity: Entity, name: string, value: boolean) => void
setFloat: (entity: Entity, name: string, value: number) => void
setGroundProbe: (probe: GroundProbe | null) => void
setSpineDriver: (driver: SpineAnimationDriver | null) => void
setTrigger: (entity: Entity, name: string) => void
unregisterController: (name: string) => void
update: (world: World, dt?: number, events?: AnimatorEventSink) => void
useAssetAvatars: (source: (ref: string) => AnimatorAvatar | undefined) => void
static new (): AnimatorControllerAPI
static prototype: AnimatorControllerAPI

AnimatorControllerDef — interface @experimental

anyStateTransitions: AnimatorTransition[] | undefined
avatar: string | undefined
ik: AnimatorIK[] | undefined
initialState: string
layers: AnimatorLayer[] | undefined
parameters: AnimatorParam[]
states: AnimatorState[]
version: number | undefined

AnimatorData — interface @beta

avatar: string
controller: string
currentState: string
enabled: boolean
layerStates: string[]

AnimatorEdge — type @experimental

from: string
id: string
index: number
to: string
transition: AnimatorTransition

AnimatorEvalResult — interface @experimental

consumedTriggers: string[]
next: string | null

AnimatorEvent — const @experimental

EventDef<AnimatorEventPayload>

AnimatorEventPayload — interface @experimental

entity: number
name: string
text: string
value: number

AnimatorEventSink — interface @experimental

send: (event: AnimatorEventPayload) => void

AnimatorIK — interface @experimental

align: boolean | undefined
axis: "x" | "y" | "z" | undefined
kind: AnimatorIKKind
layers: number | undefined
parameter: string | undefined
pelvis: string | undefined
pole: string | undefined
reach: number | undefined
smooth: number | undefined
target: string
tip: string
weight: number | undefined

AnimatorIKKind — type @experimental

'two-bone' | 'look-at' | 'foot-plant'

AnimatorLayer — interface @experimental

anyStateTransitions: AnimatorTransition[] | undefined
blend: AnimatorLayerBlend | undefined
initialState: string
mask: AnimatorMask | undefined
name: string
states: AnimatorState[]
weight: number | undefined

AnimatorLayerBlend — type @experimental

'override' | 'additive'

AnimatorMask — interface @experimental

paths: string[]

AnimatorMigration — interface @experimental

def: AnimatorControllerDef
fromVersion: number
migrated: boolean

AnimatorMotion — type @experimental

| AnimatorClipMotion | AnimatorBlend1DMotion | AnimatorBlend2DMotion

AnimatorParam — interface @experimental

default: number | boolean | undefined
name: string
type: AnimatorParamType

AnimatorParamType — type @experimental

'float' | 'bool' | 'trigger'

AnimatorParamValues — type @experimental

Readonly<Record<string, number | boolean>>

AnimatorPathEvalResult — interface @experimental

consumedTriggers: string[]
fadeDuration: number
nextPath: string | null

AnimatorRootMotion — const @experimental

ComponentDef<AnimatorRootMotionData>

AnimatorRootMotionData — interface @experimental

active: boolean
deltaPosition: Vec3
deltaRotation: Quat
deltaTime: number
enabled: boolean

AnimatorScope — type @experimental

Pick<AnimatorControllerDef, 'states' | 'initialState' | 'anyStateTransitions'>

AnimatorSpineMotion — interface @experimental

animation: string
loop: boolean | undefined

AnimatorState — interface @experimental

blend: AnimatorBlend1D | undefined
clip: string | undefined
loop: boolean | undefined
motion: AnimatorMotion | undefined
name: string
rootMotion: boolean | undefined
speed: number | undefined
speedParameter: string | undefined
spine: AnimatorSpineMotion | undefined
stateMachine: AnimatorSubMachine | undefined
transitions: AnimatorTransition[]
x: number | undefined
y: number | undefined

AnimatorSubMachine — interface @experimental

anyStateTransitions: AnimatorTransition[] | undefined
initialState: string
states: AnimatorState[]

AnimatorTransition — interface @experimental

conditions: AnimatorCondition[]
duration: number | undefined
hasExitTime: boolean | undefined
to: string

AnyComponentDef — type @public

ComponentDef<any> | BuiltinComponentDef<any>

AotHost — type @experimental

WasmHeap & { readonly memory: WebAssembly.Memory }

AotManifest — interface @experimental

engineAbi: string
moduleContract: string | undefined
projectShapes: string
systems: readonly AotSystemDecl[]

AotSystemDecl — interface @experimental

commands: boolean | undefined
name: string
queries: readonly (readonly { comp: string; mut: boolean; }[])[]
readers: readonly { slot: number; event: string; fields: readonly string[]; }[] | undefined
resources: readonly { name: string; mut: boolean; fields?: readonly string[]; }[]
symbol: string
writers: readonly { slot: number; event: string; fields: readonly string[]; }[] | undefined

App — class @experimental

@internal addBundleSystems: (entries: ReadonlyArray<{ schedule: number; system: SystemDef | SystemSet; }>) => App
@internal connectCpp: (cppRegistry: CppRegistry, module?: ESEngineModule, options?: BridgeConnectOptions & { ownedRegistry?: boolean; }) => App
@internal wasmModule: ESEngineModule | null
addEvent: <T>(event: EventDef<T>) => App
addPlugin: (plugin: Plugin) => App
addPlugins: (plugins: Plugin[]) => App
addStartupSystem: (system: SystemDef) => App
addSystem: (system: SystemDef) => App
addSystemSet: (set: SystemSet) => App
addSystemSetToSchedule: (schedule: Schedule, set: SystemSet) => App
addSystemToSchedule: (schedule: Schedule, system: SystemDef, options?: { runBefore?: string[]; runAfter?: string[]; runIf?: RunCondition; profileDomain?: string; activeWhen?: readonly AnyComponentDef[]; }) => App
compiledSystemCount: number
compiledSystems: { readonly installed: readonly string[]; readonly calls: number; }
enableStats: () => App
getEntityCount: () => number
getFixedTimestep: () => number
getFrameCosts: () => FrameCosts | null
getFrameScopes: () => ReadonlyMap<string, number> | null
getFrameTiming: () => Readonly<FrameTiming> | null
getPhaseTimings: () => ReadonlyMap<string, number> | null
getPlaySpeed: () => number
getPlugin: <T extends Plugin>(ctor: new (...args: any[]) => T) => T | undefined
getRegisteredResourceNames: () => string[]
getResource: <T>(resource: ResourceDef<T>) => T
getResourceByName: (name: string) => unknown | undefined
getResourceChangeTick: (name: string) => number
getResourceEntries: () => Array<[string, unknown]>
getRunInBackground: () => boolean
getSteppedFrameCount: () => number
getSystemTimings: () => ReadonlyMap<string, number> | null
getTargetFrameRate: () => number
hasResource: <T>(resource: ResourceDef<T>) => boolean
holdExecution: () => () => void
hotSwapSystems: (incoming: ReadonlyArray<{ schedule: number; system: SystemDef; }>) => boolean
insertResource: <T>(resource: ResourceDef<T>, value: T) => App
installCompiledSystems: (source: string | BufferSource, manifest: AotManifest) => Promise<number>
isExecutionHeld: () => boolean
isPaused: () => boolean
isPhysicsReady: boolean
measureFrameScope: <T>(name: string, fn: () => T, options?: { remainder?: ScopeRemainder; }) => T
onError: (handler: (error: unknown, systemName: string) => void) => App
onExecutionChange: (callback: (held: boolean) => void) => () => void
onFrameEnd: (fn: (dtMs: number) => void) => () => void
onSystemError: (handler: (error: Error, systemName?: string) => "continue" | "pause") => App
onWasmError: (handler: (error: unknown, context: string) => void) => App
pipeline: RenderPipeline | null
quit: (options?: { keepRenderer?: boolean; }) => void
registerScene: (config: SceneConfig) => App
removeSystem: (systemId: symbol) => boolean
run: () => Promise<void>
scheduleAmbiguities: (schedule: Schedule) => Ambiguity[]
scheduleBatches: (schedule: Schedule) => string[][]
setFixedTimestep: (timestep: number) => App
setInitialScene: (name: string) => App
setMaxDeltaTime: (v: number) => App
setMaxFixedSteps: (v: number) => App
setPaused: (paused: boolean) => void
setPipeline: (pipeline: RenderPipeline) => void
setPlaySpeed: (speed: number) => void
setRunInBackground: (on: boolean) => void
setSideModules: (host: SideModuleHost, options?: { owned?: boolean; }) => void
setTargetFrameRate: (fps: number) => void
sideModules: SideModuleHost | null
spineInitPromise: Promise<unknown> | undefined
stepFrame: () => void
stepFrames: (frames?: number, dt?: number) => Promise<void>
subsystems: SubsystemRegistry
tick: (delta: number) => Promise<void>
useCompiledSystems: (opts: { readonly host: AotHost; readonly manifest: AotManifest; readonly wasm: BufferSource; }) => Promise<void>
waitForPhysics: () => Promise<void>
world: World
static new (): App
static new: () => App
static prototype: App

AppContext — class @experimental

componentRegistry: Map<string, any>
drainPendingPlugins: () => unknown[]
drainPendingSystems: () => PendingSystemEntry[]
editorBridge: EditorBridge | null
editorMode: boolean
pendingPlugins: unknown[]
pendingSystems: PendingSystemEntry[]
playMode: boolean
queueEpoch: number
reset: () => void
wasmError: WasmErrorState
static new (): AppContext
static prototype: AppContext

ApplyUpdateResult — interface @experimental

failed: AssetDownloadFailure[]
ok: boolean
reason: "nothing-staged" | undefined
revision: string | null
stages: UpdateStages
uncached: string[]
updated: number

ArrayDataSource — class @experimental

append: (items: readonly T[]) => void
getCount: () => number
getItem: (index: number) => T
insert: (index: number, items: readonly T[]) => void
remove: (index: number, count?: number) => void
setItems: (items: readonly T[]) => void
subscribe: (listener: (c: DataSourceChange) => void) => Unsubscribe
update: (index: number, item: T) => void
static new <T>(items?: readonly T[]): ArrayDataSource<T>
static prototype: ArrayDataSource<any>

AssetContentType — type @experimental

'json' | 'text' | 'binary' | 'image' | 'audio'

AssetFieldMeta — interface @public

field: string
type: AssetFieldType

AssetFieldType — type @public

'texture' | 'material' | 'font' | 'anim-clip' | 'audio' | 'sound-event' | 'video' | 'tilemap' | 'tileset' | 'timeline' | 'statemachine' | 'behaviortree' | 'scriptgraph' | 'animatorcontroller' | 'avatar' | 'mesh' | 'environment' | 'probeVolume' | 'prefab'

AssetGroupDef — interface @experimental

alwaysInclude: boolean | undefined
folder: string
mode: "local" | "remote" | "subpackage"

AssetGroupMode — type @experimental

typeof ASSET_GROUP_MODES[number]

AssetGroupsConfig — interface @experimental

activeProfile: string | undefined
atlases: Record<string, AtlasDef> | undefined
groups: Record<string, AssetGroupDef> | undefined
profiles: Record<string, BuildProfile> | undefined
version: string

AssetLease — interface @experimental

@internal failedDependencies: readonly string[] | undefined
generation: number
key: string
release: () => void
retain: () => AssetLease<T> | null
value: T

AssetPlugin — class @experimental

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

AssetRef — interface @public

path: string
type: string

AssetRefCounter — class @experimental

addFontRef: (path: string, entity: number) => void
addMaterialRef: (path: string, entity: number) => void
addTextureRef: (path: string, entity: number) => void
clear: () => void
getAllFontRefs: () => AssetRefInfo[]
getAllMaterialRefs: () => AssetRefInfo[]
getAllTextureRefs: () => AssetRefInfo[]
getFontRefCount: (path: string) => number
getFontRefs: (path: string) => number[]
getMaterialRefCount: (path: string) => number
getMaterialRefs: (path: string) => number[]
getTextureRefCount: (path: string) => number
getTextureRefs: (path: string) => number[]
getTotalRefCount: () => { textures: number; fonts: number; materials: number; }
getTotalRefRows: () => number
removeAllRefsForEntity: (entity: number) => void
removeFontRef: (path: string, entity: number) => void
removeMaterialRef: (path: string, entity: number) => void
removeTextureRef: (path: string, entity: number) => void
static new (): AssetRefCounter
static prototype: AssetRefCounter

AssetRefInfo — interface @experimental

assetPath: string
entities: number[]
refCount: number

AssetScope — class @experimental

@internal leases: () => readonly AssetLease[]
absorb: (other: AssetScope) => void
add: <T>(lease: AssetLease<T>) => AssetLease<T>
forget: (lease: AssetLease) => boolean
releaseAll: () => void
size: number
static new (): AssetScope
static prototype: AssetScope

AssetTypeEntry — interface @experimental

addressableType: AddressableAssetType | null
contentType: AssetContentType
editorType: EditorAssetType
extensions: string[]
hasTransitiveDeps: boolean
suffixes: string[] | undefined
wechatPackInclude: boolean

Assets — const @beta

ResourceDef<AssetsClass>

AssetsData — type @beta

@internal appScope: AssetScope
@internal assetGraphSettled: () => Promise<void>
@internal dependenciesOf: (type: string, ref: string) => readonly DependencyReceipt[]
@internal dependentsOfAsset: (asset: AssetIdentity) => AssetIdentity[]
@internal dependentsOfSource: (ref: string) => AssetIdentity[]
@internal entityScopes: EntityAssetScopes
@internal epoch: number
@internal handleBoundTypes: () => string[]
@internal preparePrefab: (ref: string, overrides?: readonly PrefabOverride[]) => Promise<PreparedPrefab>
@internal publishedRegistryAssets: <T>(type: string) => T[]
@internal registryAssetVersion: (type: string) => number
@internal releaseTextureLease: (lease: AssetRefLease<number>) => void
@internal releaseTyped: (type: string, ref: string) => void
@internal releaseTypedLease: (type: string, lease: AssetRefLease<PreparedLoad<unknown>>) => void
@internal resolveRegistryAsset: <T>(type: string, ref: string) => T | undefined
@internal sizes: () => { textureCached: number; pendingLoads: number; propagations: number; refCounts: number; refRows: number; genericCaches: number; genericCached: number; handlePaths: number; invalidateListeners: number; registrySlots: number; trackedRefRows: number; }
acquireSpine: (skeletonRef: string, atlasRef?: string) => Promise<AssetLease<SpineResult>>
acquireTexture: (ref: string) => Promise<AssetLease<TextureResult>>
acquireTyped: <T>(type: string, ref: string) => Promise<AssetLease<T>>
applyUpdate: (onProgress?: (loaded: number, total: number) => void) => Promise<ApplyUpdateResult>
backend: Backend
baseUrl: string | undefined
catalog: Catalog
checkForUpdate: (options: CheckForUpdateOptions) => Promise<UpdatePlan>
cleanDiskCache: (budgetBytes: number, execute?: boolean) => Promise<CacheCleanupResult>
createMesh: (data: MeshData) => number
diskCacheReport: (rescan?: boolean) => Promise<ContentCacheReport>
fetchBinary: (ref: string) => Promise<ArrayBuffer>
fetchJson: <T = unknown>(ref: string) => Promise<T>
fetchText: (ref: string) => Promise<string>
getAssetProblems: (asset: string) => readonly string[]
getAssetRefResolver: () => AssetRefResolver | null
getAtlasFrame: (ref: string) => AtlasFrameInfo | null
getLoader: <T>(type: string) => AssetLoader<T> | undefined
getManifest: () => ManifestModel | null
getRefCounter: () => AssetRefCounter | null
getTexture: (ref: string) => TextureResult | undefined
getTextureLoader: () => TextureLoader
invalidate: (ref: string) => boolean
load: <T>(type: string, ref: string) => Promise<T>
loadAnimClip: (ref: string) => Promise<AnimClipResult>
loadAnimatorController: (ref: string) => Promise<AnimatorControllerResult>
loadAudio: (ref: string) => Promise<AudioResult>
loadBehaviorTree: (ref: string) => Promise<BtResult>
loadByLabel: (label: string, onProgress?: (loaded: number, total: number) => void) => Promise<AssetBundle>
loadFont: (ref: string) => Promise<FontResult>
loadGroup: (groupName: string, onProgress?: (loaded: number, total: number) => void) => Promise<AssetBundle>
loadJson: <T = unknown>(ref: string) => Promise<JsonResult<T>>
loadLocaleTable: (ref: string) => Promise<LocaleResult>
loadMaterial: (ref: string) => Promise<MaterialResult>
loadPrefab: (ref: string) => Promise<PrefabResult>
loadSpine: (skeletonRef: string, atlasRef?: string) => Promise<SpineResult>
loadStateMachine: (ref: string) => Promise<FsmResult>
loadTexture: (ref: string) => Promise<TextureResult>
loadTextureRaw: (ref: string) => Promise<TextureResult>
loadTilemap: (ref: string) => Promise<TilemapResult>
loadTileset: (ref: string) => Promise<TilesetResult>
loadTimeline: (ref: string) => Promise<TimelineResult>
meshRealizations: () => { handle: number; realized: boolean; }[]
meshesAwaitingRematerialization: () => number[]
onInvalidate: (listener: InvalidateListener) => () => void
pathForHandle: (kind: string, handle: number) => string | null
pathForRenderedTexture: (renderId: number) => string | null
preload: (refs: ReadonlyArray<string>, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; }) => Promise<{ failed: MissingAsset[]; }>
preloadSceneAssets: (sceneData: SceneData, onProgress?: (loaded: number, total: number) => void, options?: { readonly maxConcurrent?: number; readonly skipSpine?: boolean; }) => Promise<SceneAssetResult>
readMeshData: (handle: number) => Promise<MeshData | null>
recoverFromDeviceLoss: () => Promise<boolean>
register: <T>(loader: AssetLoader<T>) => void
releaseAll: () => void
releaseAnimClip: (ref: string) => void
releaseAssets: (byType: ReadonlyMap<string, ReadonlySet<string>>) => void
releaseAudio: (ref: string) => void
releaseBuiltMesh: (handle: number) => void
releaseFont: (ref: string) => void
releaseGroup: (groupName: string) => void
releaseMaterial: (handle: number) => void
releasePrefab: (ref: string) => void
releaseTexture: (ref: string) => void
releaseTilemap: (ref: string) => void
releaseTimeline: (ref: string) => void
rematerializeMeshesAfterDeviceLoss: () => Promise<number>
remoteRoot: string | undefined
resizeTexture: (handle: number, maxEdge: number) => Promise<{ width: number; height: number; } | null>
resolveLoadPath: (ref: string) => string
resolveRef: (ref: string) => string | null
resolveSceneAssetPaths: (sceneData: SceneData, result: SceneAssetResult) => void
restorePersistedUpdate: (key: string) => boolean
retainDiskCacheVersion: (revision: string, retain?: boolean) => Promise<ContentCacheReport>
reuploadTexturesAfterDeviceLoss: () => Promise<number>
setAssetProblemListener: (listener: ((asset: string, problems: readonly string[]) => void) | null) => void
setAssetRefResolver: (resolver: AssetRefResolver) => void
setManifest: (manifest: AddressableManifest | ManifestModel | null) => void
setRefCounter: (counter: AssetRefCounter) => void
setRemoteRoot: (url: string | undefined) => void
setTextureImportSettingsResolver: (resolver: TextureImportSettingsResolver | null) => void
setTextureStreamingStart: (edge: number | (() => number)) => void
textureFormatReport: () => TextureFormatReport
textureFullSize: (handle: number) => { width: number; height: number; } | null
textureResizable: (handle: number) => boolean
texturesAwaitingReupload: () => { handle: number; content: TextureContent; path: string; }[]
trackSceneAssetReferences: (scene: SceneData, entities: ReadonlyMap<number, number>) => void
updateStatus: () => UpdateStatus
static create: (options: AssetsOptions) => AssetsClass
static new (options: AssetsOptions): AssetsClass
static prototype: AssetsClass

AsyncCache — class @experimental

@internal failures: () => Generator<[string, Error]>
@internal sizes: () => { cached: number; pending: number; failed: number; }
clear: () => void
clearAll: () => void
delete: (key: string) => boolean
entries: () => IterableIterator<[string, T]>
get: (key: string) => T | undefined
getOrLoad: (key: string, loader: () => Promise<T>, timeout?: number) => Promise<T>
has: (key: string) => boolean
invalidate: (key: string) => boolean
set: (key: string, value: T) => void
values: () => IterableIterator<T>
static new <T>(dispose_?: ((value: T) => void) | undefined): AsyncCache<T>
static prototype: AsyncCache<any>

AtlasDef — interface @experimental

folder: string

AtlasEntry — interface @experimental

height: number
uvOffset: { x: number; y: number; }
uvScale: { x: number; y: number; }
width: number
x: number
y: number

AttenuationModel — enum @experimental

Exponential = 2
Inverse = 1
Linear = 0

Audio — const @beta

ResourceDef<AudioAPI>

AudioAPI — class @experimental

@internal getVoiceState: (handle: AudioHandle) => "ended" | "paused" | "playing" | "stopped" | "untracked"
@internal onPlaybackStop: (callback: (generation: number) => void) => () => void
@internal playbackGeneration: number
baseUrl: string
bufferBudget: number
delivery: AudioDelivery
dispose: () => void
ensureBus: (name: string, parent?: string) => boolean
getBufferHandle: (url: string) => AudioBufferHandle | undefined
getBufferStats: () => AudioBufferStats
getBusDucking: (target: string) => BusDuckRule | null
getBusEffects: (busName: string) => BusEffectDef[]
getBusVolume: (busName: string) => number
getMasterVolume: () => number
getMusicVolume: () => number
getSFXVolume: () => number
getSpectrum: (out: Uint8Array) => boolean
getUIVolume: () => number
hasMixerGraph: () => boolean
invalidateBuffer: (url: string) => boolean
isBusMuted: (busName: string) => boolean
maxVoices: number
muteBus: (busName: string, muted: boolean) => void
playBGM: (url: string, config?: { volume?: number; fadeIn?: number; crossFade?: number; loopStart?: number; }) => void
playBuffer: (buffer: AudioBufferHandle, config?: PlayConfig) => AudioHandle
playLayers: (layers: Readonly<Record<string, string>>, config?: MusicLayersConfig) => MusicLayers
playSFX: (url: string, config?: { volume?: number; pitch?: number; pan?: number; priority?: number; }) => AudioHandle
playTrack: (url: string, config?: PlayConfig) => Promise<AudioHandle | null>
preload: (url: string) => Promise<void>
preloadAll: (urls: string[]) => Promise<void>
preloadFromData: (url: string, data: ArrayBuffer) => Promise<void>
releaseBuffer: (url: string) => void
resume: () => void
retainBuffer: (url: string) => boolean
setAssetResolver: (resolver: (url: string) => ArrayBuffer | null) => void
setBufferBudget: (bytes: number | null) => void
setBusDucking: (target: string, rule: BusDuckRule | null) => boolean
setBusEffects: (busName: string, effects: BusEffectDef[]) => boolean
setBusVolume: (busName: string, volume: number) => void
setEncodedClips: (clips: Readonly<Record<string, AudioClipTrim>> | null) => void
setLoadTypes: (types: Readonly<Record<string, AudioLoadType>> | null) => void
setMasterVolume: (volume: number) => void
setMaxVoices: (max: number) => void
setMusicVolume: (volume: number) => void
setRefResolver: (resolver: ((ref: string) => string) | null) => void
setSFXVolume: (volume: number) => void
setUIVolume: (volume: number) => void
stopAll: () => void
stopBGM: (fadeOut?: number) => void
suspend: () => void
trimBufferCache: () => number
updateDucking: () => void
updateFades: (dt: number) => void
static new (backend: PlatformAudioBackend, mixer?: AudioMixer | null): AudioAPI
static prototype: AudioAPI

AudioBackendInitOptions — interface @experimental

initialPoolSize: number | undefined
mixerConfig: AudioMixerConfig | undefined

AudioBufferHandle — interface @experimental

bytes: number | undefined
duration: number
id: number
savedBytes: number | undefined
streamed: boolean | undefined

AudioBufferStats — interface @experimental

bufferBudget: number
bufferBytes: number
bufferCount: number
evictableCount: number
streamedCount: number
streamedSavedBytes: number

AudioBus — class @experimental

addChild: (child: AudioBus) => void
connect: (destination: AudioBus | AudioNode) => void
duckTo: (level: number, timeConstant: number) => void
effects: BusEffectDef[]
input: GainNode
muted: boolean
name: string
node: GainNode
setEffects: (defs: BusEffectDef[]) => void
volume: number
static new (context: AudioContext, config: AudioBusConfig): AudioBus
static prototype: AudioBus

AudioBusConfig — interface @experimental

muted: boolean | undefined
name: string
parent: string | undefined
volume: number | undefined

AudioBusDecl — interface @experimental

duck: BusDuckRule | undefined
effects: BusEffectDef[] | undefined
muted: boolean | undefined
name: string
parent: string | undefined
volume: number | undefined

AudioDelivery — type @experimental

'bytes' | 'url'

AudioHandle — interface @experimental

currentTime: number
duration: number
id: number
isPlaying: boolean
onEnd: (() => void) | undefined
pause: () => void
resume: () => void
setLoop: (loop: boolean) => void
setPan: (pan: number) => void
setPlaybackRate: (rate: number) => void
setVolume: (volume: number) => void
stop: () => void

AudioListener — const @experimental

ComponentDef<AudioListenerData>

AudioListenerData — interface @experimental

enabled: boolean

AudioLoadType — type @experimental

'auto' | 'decompress' | 'streaming'

AudioMixer — class @experimental

busNames: () => string[]
createBus: (config: AudioBusConfig) => AudioBus
getBus: (name: string) => AudioBus | undefined
getDucking: (target: string) => BusDuckRule | null
master: AudioBus
music: AudioBus
setDucking: (target: string, rule: BusDuckRule | null) => boolean
sfx: AudioBus
ui: AudioBus
updateDucking: () => void
voice: AudioBus
static new (context: AudioContext, config?: AudioMixerConfig): AudioMixer
static prototype: AudioMixer

AudioMixerConfig — interface @experimental

masterVolume: number | undefined
musicVolume: number | undefined
sfxVolume: number | undefined
uiVolume: number | undefined
voiceVolume: number | undefined

AudioPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
name: string
stopAllSources: () => void
static new (config?: AudioPluginConfig): AudioPlugin
static prototype: AudioPlugin

AudioPluginConfig — interface @experimental

initialPoolSize: number | undefined
masterVolume: number | undefined
musicVolume: number | undefined
sfxVolume: number | undefined

AudioPool — class @experimental

acquire: () => PooledAudioNode
activeCount: number
capacity: number
release: (node: PooledAudioNode) => void
static new (context: AudioContext, initialSize?: number): AudioPool
static prototype: AudioPool

AudioProjectConfig — interface @experimental

buses: AudioBusDecl[] | undefined
encoded: Record<string, { seconds: number; lead: number; }> | undefined
loadTypes: Record<string, "decompress" | "streaming"> | undefined
maxVoices: number | undefined

AudioSource — const @experimental

ComponentDef<AudioSourceData>

AudioSourceData — interface @experimental

attenuationModel: number
bus: string
clip: string
enabled: boolean
fadeIn: number
fadeOut: number
finished: boolean
loop: boolean
loopStart: number
maxDistance: number
minDistance: number
pitch: number
playOnAwake: boolean
playing: boolean
priority: number
rolloff: number
spatial: boolean
volume: number

AudioTrack — interface @experimental

childPath: string
events: AudioEvent[]
name: string
type: "audio"

AuthoredLight — interface @experimental

color: { r?: number; g?: number; b?: number; } | undefined
enabled: boolean | undefined
falloff: number | undefined
followEnvironmentSun: boolean | undefined
innerAngle: number | undefined
innerRadius: number | undefined
intensity: number | undefined
inverseSquare: boolean | undefined
outerAngle: number | undefined
radius: number | undefined
type: number | undefined

Axis1D — const @public

(...bindings: Binding[]) => ActionDef

Axis2D — const @public

(...bindings: Binding[]) => ActionDef

BAKE_DEFAULTS — const @experimental

{ atlasSize: number; texelsPerUnit: number; bounces: number; samples: number; ambient: readonly [number, number, number]; dilate: number; probeGrids: readonly ProbeGrid[]; probeSamples: number; skyOcclusion: boolean; reflectionProbes: readonly (readonly [number, number, number])[]; reflectionWidth: number; }

BONE_LIMITS — const @experimental

Readonly<Record<BoneClass, { swing: number; twist: number; }>>

BUILTIN_AUDIO_BUSES — const @experimental

readonly [{ readonly name: "master"; readonly parent: null; readonly volume: 1; }, { readonly name: "music"; readonly parent: "master"; readonly volume: 0.8; }, { readonly name: "sfx"; readonly parent: "master"; readonly volume: 1; }, { readonly name: "ui"; readonly parent: "master"; readonly volume: 1; }, { readonly name: "voice"; readonly parent: "master"; readonly volume: 1; }]

BUILTIN_MESH_TEMPLATES — const @experimental

readonly BuiltinMeshTemplate[]

BUILTIN_SHADER_TEMPLATES — const @experimental

readonly BuiltinShaderTemplate[]

BUILTIN_UI_PREFABS — const @experimental

Record<string, PrefabData>

BUILTIN_UI_WIDGET_NAMES — const @experimental

readonly ["TreeView", "ColorPicker", "TabView", "Tooltip", "VirtualJoystick", "VirtualButton", "Button", "Toggle", "Slider", "Dialog", "TextInput", "Progress", "Dropdown", "ListView", "ScrollView"]

BUNDLE_MODES — const @experimental

readonly BundleMode[]

Backend — interface @experimental

fetchBinary: (path: string) => Promise<ArrayBuffer>
fetchText: (path: string) => Promise<string>
resolveUrl: (path: string) => string
setBaseUrl: ((url: string) => void) | undefined

BakeInputs — interface @experimental

ambient: readonly [number, number, number] | undefined
lights: readonly BakeLight[]
options: BakeOptions | undefined
reflections: readonly (readonly [number, number, number])[] | undefined
surfaces: readonly { mesh: string; transform: ArrayLike<number>; albedo?: readonly [number, number, number]; texture?: string; holdsStill?: boolean; realtimeDirect?: boolean; twoSided?: boolean; material?: string; }[]
volumes: readonly { center: readonly [number, number, number]; halfExtents: readonly [number, number, number]; spacing: number; }[]

BakeJob — type @experimental

| { kind: 'direct'; out: Float32Array }
    | { kind: 'gather'; atlas: Float32Array; out: Float32Array }

BakeLight — interface @experimental

color: readonly [number, number, number]
direction: readonly [number, number, number] | undefined
falloff: number | undefined
followsEnvironmentSun: boolean | undefined
innerCos: number | undefined
innerRadius: number | undefined
intensity: number
kind: "directional" | "point" | "spot"
metre: number | undefined
outerCos: number | undefined
position: readonly [number, number, number] | undefined
radius: number | undefined

BakeLightContribution — type @experimental

| { lamp: BakeLight; ambient?: undefined }
    | { ambient: [number, number, number]; lamp?: undefined }

BakeMobility — interface @experimental

bodyType: BodyType | undefined
characterController: boolean | undefined

BakeOptions — interface @experimental

ambient: readonly [number, number, number] | undefined
atlasSize: number | undefined
bounces: number | undefined
dilate: number | undefined
occluders: readonly BakeSurface[] | undefined
probeGrids: readonly ProbeGrid[] | undefined
probeSamples: number | undefined
reflectionProbes: readonly (readonly [number, number, number])[] | undefined
reflectionSky: SkyRadiance | undefined
reflectionWidth: number | undefined
samples: number | undefined
sky: SkySpec | SkyRadiance | undefined
skyOcclusion: boolean | undefined
texelsPerUnit: number | undefined

BakeProgress — interface @experimental

label: string
progress: number

BakeResult — interface @experimental

lumels: number
pixels: Uint8Array<ArrayBufferLike>
probeSkyVisibility: Float32Array<ArrayBufferLike>[]
probes: Float32Array<ArrayBufferLike>[]
reflections: CapturedPanorama[]
scaleOffset: [number, number, number, number][]
shared: Float32Array<ArrayBufferLike>
size: number

BakeScene — interface @experimental

atlasSize: number
lights: readonly BakeLight[]
lookup: HitLookup
lumels: LumelField
samples: number
sky: SkySpec | SkyRadiance
tris: TriangleSoup

BakeStep — interface @experimental

job: BakeJob
scene: BakeScene

BakeSurface — interface @experimental

albedo: readonly [number, number, number] | undefined
coverage: number | undefined
label: string | undefined
mesh: MeshData
realtimeDirect: boolean | undefined
transform: ArrayLike<number>
twoSided: boolean | undefined

BakedLighting — const @experimental

ComponentDef<BakedLightingData>

BakedLightingData — interface @experimental

atlasSize: number
bakedFrom: string
bounces: number
probeSamples: number
samples: number
skyOcclusion: boolean
texelsPerUnit: number

Bakes — class @experimental

active: BakeProgress[]
budgetMs: number
clear: (owner: object) => void
frameBudgetMs: number
hasTime: (owner?: object) => boolean
mark: (owner: object, label: string, progress: number) => void
priorityExtraMs: number
run: <T>(label: string, job: WorkJob<T>) => { done: Promise<T>; cancel: () => void; }
step: (now?: () => number) => void
urge: (owner: object, urgent: boolean) => void
urgent: boolean
static new (): Bakes
static prototype: Bakes

BakesRes — const @experimental

ResourceDef<Bakes>

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

BatchBreak — enum @experimental

Blend = 4
Cull = 8
Depth = 7
IndexGap = 12
Instanced = 2
Layout = 5
Material = 6
None = 0
RunStart = 1
Scissor = 10
Shader = 3
State = 9
Stencil = 11
TextureSlots = 13

BehaviorContext — interface @experimental

commands: CommandsInstance
entity: number
get: <C extends AnyComponentDef>(component: C) => ComponentData<C>
has: (component: AnyComponentDef) => boolean
input: InputState
self: S
set: <C extends AnyComponentDef>(component: C, data: ComponentData<C>) => void
time: TimeData
world: World

BehaviorDef — interface @experimental

destroy: ((ctx: BehaviorContext<S>) => void) | undefined
metadata: ComponentMetadata | undefined
schedule: Schedule | undefined
start: ((ctx: BehaviorContext<S>) => void) | undefined
state: S | undefined
touches: SystemTouches | undefined
update: ((ctx: BehaviorContext<S>, dt: number) => void) | undefined

BezierPoints — interface @experimental

p1x: number
p1y: number
p2x: number
p2y: number

Billboard — const @experimental

BuiltinComponentDef<BillboardData>

BillboardData — interface @beta

enabled: boolean
mode: BillboardMode

BillboardMode — enum @beta

Upright = 1
ViewPlane = 0

Binding — type @public

| { kind: 'key'; code: string }
    | { kind: 'mouse'; button: number }
    | { kind: 'gpButton'; button: number; pad?: number }
    | { kind: 'gpAxis'; axis: number; pad?: number; scale?: number }
    | { kind: 'keys1d'; neg: string; pos: string }
    | { kind: 'keys2d'; up: string; down: string; left: string; right: string }
    | { kind: 'stick'; stick: 'left' | 'right'; pad?: number }
    | { kind: 'virtual'; id: string }

BiomeCondition — interface @experimental

blend: number | undefined
field: string
max: number | undefined
min: number | undefined

BiomeDef — interface @experimental

conditions: readonly BiomeCondition[]
id: string
paint: readonly number[] | undefined
paintStrength: number | undefined
recipes: readonly BiomeRecipe[]
transition: number | undefined
weight: number | undefined

BiomeRecipe — interface @experimental

density: number
layer: string
recipe: string

BitmapText — const @experimental

BuiltinComponentDef<BitmapTextData>

BitmapTextData — interface @experimental

align: TextAlign
color: Color
enabled: boolean
font: number
fontSize: number
layer: number
parallax: Vec2
spacing: number
text: string

Blackboard — class @experimental

clearTriggers: () => void
consume: (trigger: string) => void
delete: (key: string) => void
fire: (trigger: string) => void
get: <T = unknown>(key: string) => T | undefined
has: (key: string) => boolean
isFired: (trigger: string) => boolean
set: (key: string, value: unknown) => void
static new (): Blackboard
static prototype: Blackboard

BlackboardGuard — interface @experimental

key: string
op: CompareOp
value: string | number | boolean | undefined

BladeParams — interface @experimental

band: number | undefined
height: number
lean: number | undefined
paint: { base: [number, number, number]; tip: [number, number, number]; } | null | undefined
segments: number
thin: number
width: number

BlendCurve — type @experimental

(typeof BlendCurve)[keyof typeof BlendCurve]

BlendMode — enum @experimental

Additive = 1
Darken = 7
Lighten = 6
Multiply = 2
None = 9
Normal = 0
Overlay = 8
PmaAdditive = 5
PremultipliedAlpha = 4
Screen = 3

BlobShadow — const @experimental

ComponentDef<BlobShadowData>

BlobShadowData — interface @experimental

enabled: boolean
fadeHeight: number
groundY: number
lift: number
opacity: number
radius: number
shrink: number
softness: number

BlobShadowGround — type @experimental

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

BodyPusher — type @experimental

(entity: Entity, velocity: Vec3) => boolean

BodyType — enum @experimental

Dynamic = 2
Kinematic = 1
Static = 0

Bone2D — const @experimental

ComponentDef<Bone2DData>

Bone2DData — interface @experimental

length: number

BoneClass — type @experimental

'spine' | 'neck' | 'head' | 'shoulder' | 'upperArm' | 'forearm' | 'hand' | 'thigh' | 'shin' | 'foot' | 'toe' | 'other'

BoneConstraint2D — const @experimental

ComponentDef<BoneConstraint2DData>

BoneConstraint2DData — interface @experimental

enabled: boolean
kind: number
max: number
min: number
offset: number
source: number
weight: number

BoneConstraintKind — const @experimental

{ readonly LimitRotation: 0; readonly CopyRotation: 1; readonly CopyPosition: 2; readonly LookAt: 3; }

BoxCollider2D — const @experimental

BuiltinComponentDef<BoxCollider2DData>

BoxCollider2DData — interface @experimental

categoryBits: number
density: number
enabled: boolean
friction: number
halfExtents: Vec2
isSensor: boolean
maskBits: number
offset: Vec2
radius: number
restitution: number

BoxCollider3D — const @experimental

BuiltinComponentDef<BoxCollider3DData>

BoxCollider3DData — interface @experimental

center: Vec3 | undefined
enabled: boolean
friction: number
halfExtents: Vec3
isSensor: boolean
restitution: number

Breakable — const @experimental

ComponentDef<BreakableData>

BreakableData — interface @experimental

breakImpulse: number
broken: boolean
burst: number
enabled: boolean
lifetime: number
origin: Vec3
pieces: string

BreakablePlugin — class @experimental

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

Broke — const @experimental

EventDef<BrokePayload>

BrokePayload — interface @experimental

entity: number
impulse: number
x: number
y: number
z: number

BuildProfile — interface @experimental

remoteRoot: string | undefined

BuiltinComponentDef — interface @public

@internal _builtin: true
@internal _cppName: string
@internal _default: T
@internal _id: symbol
@internal _name: string
animatableFields: readonly string[]
assetFields: readonly AssetFieldMeta[]
colorKeys: readonly string[]
discoverAssets: ((data: Record<string, unknown>) => AssetRef[]) | undefined
entityFields: readonly string[]
fieldMeta: Readonly<Record<string, FieldMeta>>
readonlyFields: readonly string[]
renderableField: string | null
replicatedFields: readonly string[]
skeletalFields: SkeletalFieldMeta | undefined
transient: boolean

BuiltinMeshTemplate — interface @experimental

build: () => MeshData
closed: boolean
description: string
id: string
label: string
ref: string

BuiltinShaderTemplate — interface @experimental

defaults: Record<string, unknown>
description: string
id: string
label: string
source: string

BuiltinSideModuleId — type @experimental

'physics' | 'physics3d' | 'physics3d:physx' | 'basis' | 'videodec' | 'dragonbones' | `spine:${SpineVersion}`

BundleMode — type @experimental

'local' | 'lazy' | 'remote'

BusDuckRule — interface @experimental

amount: number
attack: number | undefined
release: number | undefined
threshold: number | undefined
trigger: string

BusEffectDef — type @experimental

FilterEffectDef | ReverbEffectDef | CompressorEffectDef

Button — const @public

(...bindings: Binding[]) => ActionDef

ButtonHandle — interface @experimental

dispose: () => void
entity: number
setDisabled: (disabled: boolean) => void

ButtonOptions — interface @experimental

background: UIVisualInit | undefined
disabled: boolean | undefined
events: UIEventQueue
fadeDuration: number | undefined
focusable: boolean | undefined
node: UINodeInit | undefined
onClick: ((entity: Entity) => void) | undefined
parent: number | undefined
states: Record<string, ButtonStateVisual> | undefined
tabIndex: number | undefined
text: string | TextInit | undefined
userGesture: boolean | undefined
world: World

ButtonStateVisual — interface @experimental

color: Color | undefined
scale: number | undefined
sprite: number | undefined

CAPSULE_ARC_SEGMENTS — const @experimental

16

CLIP_EPSILON — const @experimental

0.00001

COLLIDER3D_RING_SEGMENTS — const @experimental

24

COMBAT_ATTACK_END — const @experimental

"attack-end"

COMBAT_ATTACK_START — const @experimental

"attack-start"

COMBAT_HIT — const @experimental

"hit"

COMPOSITE_DEFAULTS — const @experimental

CompositeLimits

CacheCleanupPreview — interface @experimental

budgetBytes: number
budgetMet: boolean | null
candidates: string[]
releaseBytes: number
remainingBytes: number | null
report: ContentCacheReport

CacheCleanupResult — interface @experimental

budgetBytes: number
budgetMet: boolean | null
candidates: string[]
failed: string[]
indexPersisted: boolean | undefined
releaseBytes: number
remainingBytes: number | null
removed: string[]
report: ContentCacheReport

Camera — const @beta

BuiltinComponentDef<CameraData>

CameraBounds — const @experimental

ComponentDef<CameraBoundsData>

CameraBoundsData — interface @experimental

maxX: number
maxY: number
minX: number
minY: number

CameraClip — interface @experimental

camera: string
curve: number | undefined
duration: number
start: number

CameraCommit — const @beta

ResourceDef<CameraCommitData>

CameraCommitData — interface @beta

revision: number
valid: boolean
viewProjection: Float32Array<ArrayBufferLike>
vpH: number
vpW: number
vpX: number
vpY: number

CameraCommitListener — type @beta

() => void

CameraData — interface @beta

aspectRatio: number
clearFlags: ClearFlags
cullingMask: number
farPlane: number
fov: number
isActive: boolean
nearPlane: number
orthoSize: number
pixelPerfect: boolean
priority: number
projectionType: ProjectionType
renderTarget: number
showFrustum: boolean
viewport: Vec4

CameraDirector — const @experimental

ResourceDef<CameraDirectorState>

CameraDirectorState — interface @experimental

blending: boolean
currentMain: CameraPOV | null
curve: number
duration: number
from: CameraPOV | null
hasPending: boolean
pendingCurve: number
pendingTarget: number
pendingTime: number
shakeSeq: number
shakes: ActiveShake[]
startTime: number
target: number
timelineOwner: number
timelineShot: TimelineShot | null

CameraExtents — interface @experimental

cameraX: number
cameraY: number
entity: number
halfH: number
halfW: number

CameraFields — interface @beta

clearFlags: number
cullingMask: number | undefined
farPlane: number
fov: number
isActive: boolean
nearPlane: number
orthoSize: number
pixelPerfect: boolean
priority: number
projectionType: number
renderTarget: number | undefined
viewport: { x: number; y: number; z: number; w: number; }

CameraLens — interface @beta

viewProjection: Float32Array<ArrayBufferLike>
vpH: number
vpW: number
vpX: number
vpY: number

CameraPOV — interface @experimental

clearFlags: number
cullingMask: number
entity: number
far: number
fov: number
isActive: boolean
near: number
orbit: { yaw: number; pitch: number; focusZ: number; } | undefined
orthoSize: number
pixelPerfect: boolean
priority: number
projection: number
renderTarget: number
rotation: number
tilt: { x: number; y: number; z: number; w: number; } | undefined
viewport: { x: number; y: number; z: number; w: number; }
x: number
y: number
z: number

CameraRenderParams — interface @experimental

cameraEntity: number | undefined
clearColor: { x: number; y: number; z: number; w: number; } | undefined
clearFlags: number
cullingMask: number | undefined
elapsed: number
registry: { _cpp: CppRegistry; }
renderPolicy: RenderResolution | undefined
renderTarget: number | undefined
renderViewProjection: Float32Array<ArrayBufferLike> | undefined
viewProjection: Float32Array<ArrayBufferLike>
viewportPixels: Viewport
worldHeight: number | undefined

CameraTrack — interface @experimental

childPath: string
clips: CameraClip[]
name: string
type: "camera"

CameraTransformFields — interface @beta

worldPosition: { x: number; y: number; z: number; }
worldRotation: { x: number; y: number; z: number; w: number; }

CameraView — const @experimental

ResourceDef<CameraViewAPI>

CameraViewAPI — class @experimental

clipSegment: (a: Vec3, b: Vec3) => { a: Vec3; b: Vec3; } | null
getWorldBounds: () => { left: number; right: number; bottom: number; top: number; } | null
getWorldMousePosition: () => { x: number; y: number; } | null
pointerRay: (pointerX: number, pointerY: number) => WorldRay | null
pointerToWorld: (pointerX: number, pointerY: number, planeZ?: number) => { x: number; y: number; } | null
projectDirectionAt: (at: Vec3, dir: Vec3) => { x: number; y: number; } | null
screenRay: (screenX: number, screenY: number) => WorldRay | null
screenToWorld: (screenX: number, screenY: number, planeZ?: number) => { x: number; y: number; } | null
worldToScreen: (worldX: number, worldY: number, worldZ?: number) => { x: number; y: number; } | null
static new (app_: App, lens_?: (app: App) => CameraLens | null): CameraViewAPI
static prototype: CameraViewAPI

Canvas — const @experimental

BuiltinComponentDef<CanvasData>

CanvasData — interface @experimental

backgroundColor: Color
designResolution: Vec2
layer: number
matchWidthOrHeight: number
pixelsPerUnit: number
scaleMode: CanvasScaleMode

CanvasScale — interface @experimental

designResolution: { x: number; y: number; }
matchWidthOrHeight: number
scaleMode: number

CanvasTexture — interface @experimental

destroy: () => void
handle: number
height: number
update: () => void
width: number

CapsuleCollider2D — const @experimental

BuiltinComponentDef<CapsuleCollider2DData>

CapsuleCollider2DData — interface @experimental

categoryBits: number
density: number
enabled: boolean
friction: number
halfHeight: number
isSensor: boolean
maskBits: number
offset: Vec2
radius: number
restitution: number

CapsuleCollider3D — const @experimental

BuiltinComponentDef<CapsuleCollider3DData>

CapsuleCollider3DData — interface @experimental

center: Vec3 | undefined
enabled: boolean
friction: number
halfHeight: number
isSensor: boolean
radius: number
restitution: number

CapturePass — enum @experimental

Overlay = 1
Scene = 0

CaptureSource — interface @experimental

engineVersion: string | undefined
gpu: string | undefined
label: string | undefined
platform: string | undefined
realm: string | undefined

CaptureSummary — interface @experimental

budgetMs: number
counters: Record<string, number>
drawCalls: number
entities: number
fps: number
frames: number
longFrames: number
mean: FrameProfile
p50: number
p95: number
p99: number
triangles: number
worstFrameId: number | null
worstFrameMs: number

CapturedFrame — interface @experimental

counters: Record<string, number> | undefined
drawCalls: number | undefined
dtMs: number
editor: { ms: number; phases: Record<string, number>; parts?: Record<string, number>; } | undefined
entities: number | undefined
gpuMs: number | undefined
id: number
memory: { wasmBytes?: number; jsHeapBytes?: number; vramBytes?: number; audioBytes?: number; audioStreamedCount?: number; audioStreamedSavedBytes?: number; } | undefined
nativeScopes: ScopeCost[] | undefined
quality: QualityReport | undefined
scopes: ScopeCost[]
systems: SystemCost[]
triangles: number | undefined

CapturedPanorama — interface @experimental

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

CardRect — interface @experimental

u0: number
u1: number
v0: number
v1: number

Catalog — class @experimental

addressOf: (path: string) => string | null
getAllLabels: () => string[]
getAtlasFrame: (path: string) => AtlasFrameInfo | null
getBuildPath: (path: string) => string
getByLabel: (label: string) => string[]
getDeps: (path: string) => string[]
getEntry: (path: string) => CatalogEntry | null
getStreamTail: (path: string) => StreamTailInfo | null
hasAddress: (address: string) => boolean
hasEntry: (path: string) => boolean
isEmpty: boolean
resolve: (ref: string) => string
static empty: () => Catalog
static fromJson: (data: CatalogData) => Catalog
static new (entries: Map<string, CatalogEntry>, addresses: Map<string, string>, labels: Map<string, string[]>): Catalog
static prototype: Catalog

CatalogData — interface @experimental

addresses: Record<string, string> | undefined
entries: Record<string, CatalogEntry>
labels: Record<string, string[]> | undefined
version: number

CatalogEntry — interface @experimental

atlas: string | undefined
buildPath: string | undefined
deps: string[] | undefined
frame: { x: number; y: number; w: number; h: number; } | undefined
streamTail: StreamTailInfo | undefined
trim: { sourceW: number; sourceH: number; offsetX: number; offsetY: number; } | undefined
type: string
uv: { offset: [number, number]; scale: [number, number]; } | undefined

CellResidency — type @experimental

'unloaded' | 'preparing' | 'prepared' | 'publishing' | 'resident' | 'unloading'

Census — interface @experimental

atMs: number
entries: ReadonlyMap<string, CensusEntry>
failedProbes: readonly string[]

CensusContext — interface @experimental

app: App | undefined
module: ESEngineModule | null | undefined
world: World | undefined

CensusDelta — interface @experimental

after: number
before: number
delta: number
key: string
tier: CensusTier
unit: "bytes" | "count"

CensusEntry — interface @experimental

key: string
tier: CensusTier
unit: "bytes" | "count"
value: number

CensusProbe — interface @experimental

id: string
read: (ctx: CensusContext) => readonly CensusEntry[] | undefined

CensusReport — interface @experimental

cycles: number
failedProbes: readonly string[]
judgedFrom: number
leaks: readonly CensusVerdict[]
projectCycles: number
verdicts: readonly CensusVerdict[]

CensusSeriesOptions — interface @experimental

boundedSlopeTolerance: number | undefined
projectCycles: number | undefined
trendByteBudgetPerCycle: number | undefined
warmupCycles: number | undefined

CensusTier — type @experimental

'conserved' | 'bounded' | 'trend' | 'info'

CensusVerdict — interface @experimental

confidentSlopePerCycle: number
first: number
key: string
last: number
leaking: boolean
projected: number
reason: string | undefined
risingFraction: number
slopePerCycle: number
tier: CensusTier
unit: "bytes" | "count"

ChainCollider2D — const @experimental

ComponentDef<ChainCollider2DData>

Changed — function @experimental

<T extends AnyComponentDef>(component: T): ChangedWrapper<T>

ChangedWrapper — interface @public

@internal _component: T
@internal _filterType: "changed"

CharacterController2D — const @beta

ComponentDef<CharacterController2DData>

CharacterController2DData — interface @beta

blockSteepSlopes: boolean
constantSlopeSpeed: boolean
dropThrough: boolean
dynamicBodies: number
floorEntity: number
floorMaxAngle: number
floorNormal: Vec2
floorVelocity: Vec2
followPlatform: boolean
isOnCeiling: boolean
isOnFloor: boolean
isOnWall: boolean
maskBits: number
maxSlides: number
pushForce: number
realVelocity: Vec2
skinWidth: number
slideOnCeiling: boolean
snapLength: number
stepHeight: number
stopOnSlope: boolean
up: Vec2
velocity: Vec2

CharacterController3D — const @experimental

BuiltinComponentDef<CharacterController3DData>

CharacterController3DData — interface @experimental

enabled: boolean
floorNormal: Vec3
halfHeight: number
isOnFloor: boolean
layer: number
mass: number
maxSlope: number
pushForce: number
radius: number
realVelocity: Vec3
snapDown: number
stepHeight: number
velocity: Vec3

CharacterDynamicBodies — const @experimental

{ readonly Block: 0; readonly Push: 1; readonly Ignore: 2; }

Children — const @public

BuiltinComponentDef<ChildrenData>

ChildrenData — interface @public

entities: number[]

ChunkLayer — interface @experimental

async: boolean | undefined
extent: readonly [number, number, number, number] | null
generation: string | number
label: string
loadRadius: number
make: (cx: number, cz: number, signal: AbortSignal) => T | null | Promise<T | null>
originX: number
originZ: number
plane: "xy" | "xz" | undefined
publish: (cx: number, cz: number, value: T) => void
release: (cx: number, cz: number, value: T) => void
sizeX: number
sizeZ: number
sources: (() => Iterable<ChunkSource>) | undefined
unloadRadius: number

ChunkLayerStatus — interface @experimental

failed: number
making: number
pending: number
ready: number
reason: string | undefined
stale: number

ChunkSource — interface @experimental

x: number
y: number | undefined
z: number

ChunkState — type @experimental

'making' | 'ready' | 'stale' | 'failed'

CircleCollider2D — const @experimental

BuiltinComponentDef<CircleCollider2DData>

CircleCollider2DData — interface @experimental

categoryBits: number
density: number
enabled: boolean
friction: number
isSensor: boolean
maskBits: number
offset: Vec2
radius: number
restitution: number

ClearFlags — enum @beta

Color = 1
ColorAndDepth = 3
Depth = 2
Nothing = 0

ClipTriangle — type @experimental

[ClipVertex, ClipVertex, ClipVertex]

ClipVertex — interface @experimental

n: [number, number, number]
p: [number, number, number]

Collider2DInstance — interface @experimental

enabled: boolean
isSensor: boolean
shape: Collider2DShape

Collider2DOutline — interface @experimental

circles: { c: Vec2; r: number; }[]
declined: Vec2[][] | undefined
polylines: Vec2[][]

Collider2DShape — type @experimental

| { kind: 'box'; halfExtents: Vec2; offset: Vec2 }
    | { kind: 'circle'; radius: number; offset: Vec2 }
    | { kind: 'capsule'; radius: number; halfHeight: number; offset: Vec2 }
    | { kind: 'segment'; point1: Vec2; point2: Vec2 }
    | { kind: 'polygon'; vertices: Vec2[] }
    | { kind: 'chain'; points: Vec2[]; isLoop: boolean }

Collider3DComponent — type @experimental

| 'CompoundCollider3D' | 'BoxCollider3D' | 'SphereCollider3D' | 'CapsuleCollider3D'
    | 'MeshCollider3D' | 'ConvexCollider3D' | 'CharacterController3D'

Collider3DInstance — interface @experimental

active: boolean
component: Collider3DComponent
isSensor: boolean
shape: Collider3DShape

Collider3DShape — type @experimental

{ rotation?: Quat } & (
    | { kind: 'box'; halfExtents: Vec3; center: Vec3 }
    | { kind: 'sphere'; radius: number; center?: Vec3 }
    | { kind: 'capsule'; radius: number; halfHeight: number; center?: Vec3 })

CollisionEnterEvent — interface @experimental

contactX: number
contactY: number
entityA: number
entityB: number
normalX: number
normalY: number

CollisionGeometry — class @experimental

delete: (key: string) => void
deleteAll: (prefix: string) => void
entries: () => IterableIterator<[string, CollisionPiece]>
get: (key: string) => CollisionPiece | undefined
revision: number
set: (key: string, piece: CollisionPiece) => void
size: number
static new (): CollisionGeometry
static prototype: CollisionGeometry

CollisionGeometryRes — const @experimental

ResourceDef<CollisionGeometry>

CollisionHitEvent — interface @experimental

approachSpeed: number
entityA: number
entityB: number
normalX: number
normalY: number
pointX: number
pointY: number

CollisionPiece — interface @experimental

friction: number
indices: Uint32Array<ArrayBufferLike>
layer: number
origin: readonly [number, number, number]
owner: number
positions: Float32Array<ArrayBufferLike>
restitution: number

Color — interface @public

a: number
b: number
g: number
r: number

ColorPickerHandle — interface @beta

dispose: () => void
entity: number
getColor: () => Color
setColor: (color: Color) => void

ColorPickerOptions — interface @beta

alphaEnabled: boolean | undefined
color: Color | undefined
events: UIEventQueue
format: number | undefined
history: readonly Color[] | undefined
historyLimit: number | undefined
node: UINodeInit | undefined
onChange: ((color: Color) => void) | undefined
onHistoryChange: ((colors: readonly Color[]) => void) | undefined
parent: number | undefined
rememberColors: boolean | undefined
world: World

ColorRole — type @experimental

keyof ThemeColors

Commands — function @public

(): CommandsDescriptor

CommandsDescriptor — interface @public

@internal _type: "commands"

CommandsInstance — class @public

@internal describe: () => string
@internal isWorldIterating: () => boolean
@internal reserveEntity: () => Entity
@internal spawnImmediate: (components: SpawnComponentEntry[], entityRef: { entity: Entity; }, name?: string, parent?: Entity | null) => void
despawn: (entity: Entity) => CommandsInstance
entity: (entity: Entity) => EntityCommands
flush: () => void
insertResource: <T>(resource: ResourceDef<T>, value: T) => CommandsInstance
queueInsert: (entity: Entity, component: AnyComponentDef, data: unknown) => void
queueRemove: (entity: Entity, component: AnyComponentDef) => void
queueSetParent: (entity: Entity, parent: Entity) => void
resource: <T>(def: ResourceDef<T>) => T | null
spawn: (name?: string) => EntityCommands
static new (world: World, resources: ResourceStorage): CommandsInstance
static prototype: CommandsInstance

CompareOp — type @experimental

'==' | '!=' | '<' | '<=' | '>' | '>=' | 'truthy' | 'falsy'

Completable — interface @experimental

cancel: () => void
pause: () => void
resume: () => void
state: TweenState

ComponentData — type @public

C extends BuiltinComponentDef<infer T> ? T :
    C extends ComponentDef<infer T> ? T :
    never

ComponentDef — interface @public

@internal _builtin: false
@internal _default: T
@internal _id: symbol
@internal _name: string
animatableFields: readonly string[]
assetFields: readonly AssetFieldMeta[]
colorKeys: readonly string[]
create: (data?: Partial<T>) => T
discoverAssets: ((data: Record<string, unknown>) => AssetRef[]) | undefined
entityFields: readonly string[]
fieldMeta: Readonly<Record<string, FieldMeta>>
readonlyFields: readonly string[]
renderableField: string | null
replicatedFields: readonly string[]
skeletalFields: SkeletalFieldMeta | undefined
transient: boolean

ComponentMetadata — interface @public

animatableFields: string[] | undefined
assetFields: AssetFieldMeta[] | undefined
discoverAssets: ((data: Record<string, unknown>) => AssetRef[]) | undefined
entityFields: string[] | undefined
fields: Record<string, FieldMeta> | undefined
readonlyFields: string[] | undefined
renderableField: string | undefined
replicatedFields: string[] | undefined
skeletalFields: SkeletalFieldMeta | undefined
transient: boolean | undefined
worldUnitFields: string[] | undefined

ComponentsData — type @public

{
    [K in keyof C]: ComponentData<UnwrapQueryArg<C[K]>>;
}

CompositeBatch — const @experimental

ComponentDef<CompositeBatchData>

CompositeBatchData — interface @experimental

cellSize: number
draws: number
drawsBefore: number
instanceMin: number
instanced: number
moving: number
parts: number

CompositeBatchPlugin — class @experimental

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

CompositeBatching — class @experimental

@internal busy_: boolean
@internal composites_: Map<number, CompositeState>
@internal forced_: Set<number>
counts: { scans: number; applies: number; merges: number; placementWrites: number; }
refresh: (root?: Entity) => void
report: (root: Entity) => { sets: number; chunks: number; alone: number; moving: number; refused: number; parts: number; } | null
static new (): CompositeBatching
static prototype: CompositeBatching

CompositeBatchingRes — const @experimental

ResourceDef<CompositeBatching>

CompositeChunk — interface @experimental

entities: number[]
id: string
key: string

CompositeInstanceSet — interface @experimental

entities: number[]
key: string
mesh: number

CompositeLimits — interface @experimental

cellSize: number
instanceMin: number
maxVertices: number

CompositePart — interface @experimental

center: readonly [number, number, number]
entity: number
key: string
local: Mat4
mesh: number
vertices: number

CompositePlan — interface @experimental

alone: number[]
cellSize: number
chunks: CompositeChunk[]
sets: CompositeInstanceSet[]

CompressedTextureFormat — enum @experimental

ASTC_4x4 = "astc-4x4"
ETC2_RGBA8 = "etc2-rgba8"
S3TC_DXT5 = "s3tc-dxt5"

CompressorEffectDef — interface @experimental

attack: number | undefined
kneeDb: number | undefined
ratio: number | undefined
release: number | undefined
thresholdDb: number | undefined
type: "compressor"

ComputeEffectSource — interface @experimental

source: string
workgroupSize: [number, number] | undefined

ConsoleLevel — type @experimental

'info' | 'warn' | 'error'

ContentCacheEntry — interface @experimental

hash: string | undefined
key: string | undefined
lastAccess: number
name: string
protection: string[]
size: number
versions: string[]

ContentCacheReport — interface @experimental

capability: "managed" | "storage-only" | "unavailable"
entries: ContentCacheEntry[]
indexBytes: number | null
owner: string | undefined
protectedBytes: number | null
reclaimableBytes: number | null
usedBytes: number | null
versions: { owner: string; revision: string; reason: CacheProtection | null; missing: number; retained: boolean; }[]

ContentRectPlugin — class @experimental

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

ControllerState — interface @experimental

current: string
name: string
pages: string[]

ConvexCollider3D — const @experimental

BuiltinComponentDef<ConvexCollider3DData>

ConvexCollider3DData — interface @experimental

enabled: boolean
friction: number
isSensor: boolean
mesh: number
restitution: number

CookedAtlasInfo — interface @experimental

frame: { x: number; y: number; width: number; height: number; }
page: number | undefined
pageHeight: number
pageWidth: number

CoverFade — const @experimental

ComponentDef<CoverFadeData>

CoverFadeData — interface @experimental

enabled: boolean
fadeTime: number
margin: number
opacity: number
round: boolean

CoverFadeTarget — const @experimental

ComponentDef<{}>

CreateListViewOptions — interface @experimental

background: UIVisualInit | undefined
data: DataSource<T> | readonly T[]
decelerationRate: number | undefined
direction: "both" | "horizontal" | "vertical" | undefined
dragScroll: boolean | undefined
host: ListViewHost
item: ListItemTemplate<T> | Record<string, ListItemTemplate<T>>
layout: ListLayoutSpec | LayoutProvider
node: UINodeInit | undefined
onItemBound: ((entity: Entity, data: T, index: number) => void) | undefined
parent: number | undefined
recycleBuffer: number | undefined
viewportSize: Vec2
wheelSpeed: number | undefined
world: World

CreateWebAppOptions — interface @experimental

colorSpace: "gamma" | "linear" | undefined
depthLayers: number | undefined
getViewportSize: (() => { width: number; height: number; }) | undefined
msaaSamples: number | undefined
outputTransform: OutputTransform | undefined
ownsSideModules: boolean | undefined
plugins: Plugin[] | undefined
quality: QualityConfig | undefined
randomSeed: number | undefined
renderSurface: RenderSurfaceSource | undefined
screenFit: ScreenScalingData | undefined
sideModules: SideModuleHost | undefined
wasmBaseUrl: string | undefined
ySortLayers: number | undefined

CullMode — enum @experimental

Back = 1
Front = 2
None = 0

Curve — interface @experimental

keys: Keyframe[]

CustomEvent — interface @experimental

name: string
payload: Record<string, unknown>
time: number

CustomEventTrack — interface @experimental

childPath: string
events: CustomEvent[]
name: string
type: "customEvent"

CutWorld — interface @experimental

documents: Map<string, SceneData>
errors: readonly string[]
manifest: WorldManifest
persistent: SceneData
warnings: readonly string[]

DARK_TOKENS — const @experimental

ThemeTokens

DEBUG_CHANNEL_PROTOCOL — const @experimental

1

DEFAULT_ANIM_CLIP_PIVOT — const @experimental

AnimClipPivotData

DEFAULT_DESIGN_HEIGHT — const @experimental

number

DEFAULT_DESIGN_WIDTH — const @experimental

number

DEFAULT_EDITOR_GRID — const @experimental

EditorGridData

DEFAULT_EDITOR_VIEW — const @experimental

EditorViewData

DEFAULT_EDITOR_VIEW_LIGHTING — const @experimental

EditorViewLightingData

DEFAULT_EDITOR_VIEW_SHADING — const @experimental

EditorViewShadingData

DEFAULT_FACING_COSINE — const @experimental

0.2

DEFAULT_FALLBACK_DT — const @experimental

number

DEFAULT_FIXED_TIMESTEP — const @experimental

number

DEFAULT_FONT_FAMILY — const @experimental

"Arial"

DEFAULT_FONT_SIZE — const @experimental

24

DEFAULT_GRAVITY — const @experimental

{ x: number; y: number; }

DEFAULT_LINE_HEIGHT — const @experimental

1.2

DEFAULT_MAX_DELTA_TIME — const @experimental

0.5

DEFAULT_PHYSICS3D_WORLD — const @experimental

Physics3DWorldConfig

DEFAULT_PIXELS_PER_UNIT — const @experimental

number

DEFAULT_SCREEN_SCALING — const @experimental

ScreenScalingData

DEFAULT_SPINE_SKIN — const @experimental

"default"

DEFAULT_SPRITE_SIZE — const @experimental

{ x: number; y: number; }

DEFAULT_TEXT_CANVAS_SIZE — const @experimental

512

DEFAULT_UI_CAMERA_INFO — const @experimental

{ readonly viewProjection: Float32Array<ArrayBuffer>; readonly vpX: 0; readonly vpY: 0; readonly vpW: 0; readonly vpH: 0; readonly screenW: 0; readonly screenH: 0; readonly worldLeft: 0; readonly worldBottom: 0; readonly worldRight: 0; readonly worldTop: 0; readonly worldMouseX: 0; readonly worldMouseY: 0; readonly valid: false; readonly revision: 0; }

DODGE_KEY — const @experimental

"ShiftLeft"

DOMAIN_SCRIPTS — const @experimental

"scripts"

DOMAIN_UNATTRIBUTED — const @experimental

"unattributed"

DataSource — interface @experimental

getCount: () => number
getItem: (index: number) => T
getItemId: ((index: number, item: T) => string | number) | undefined
getItemType: ((index: number) => string) | undefined
subscribe: ((listener: (change: DataSourceChange) => void) => Unsubscribe) | undefined

DataSourceChange — type @experimental

| { type: 'insert'; index: number; count: number }
    | { type: 'remove'; index: number; count: number }
    | { type: 'update'; index: number; count: number }
    | { type: 'reset' }

DataType — enum @experimental

Float = 1
Float2 = 2
Float3 = 3
Float4 = 4
Int = 5
Int2 = 6
Int3 = 7
Int4 = 8

DebugChannelConfig — interface @experimental

project: string | undefined
url: string

DebugChannelMessage — type @experimental

| {
        t: 'hello'; v: number; platform: string; title: string; project: string | null; revision: string | null;
        /** The graphics API the game draws through; null until the game has started. */
        graphics: string | null;
    }
    | { t: 'reply'; reqId: number; data: unknown; pixels?: number }
    | { t: 'reply'; reqId: number; error: string }
    | { t: 'logs'; entries: Array<{ level: ConsoleLevel; line: string }> }

DebugChannelQuery — type @experimental

| { t: 'query'; reqId: number; kind: 'frameCapture' }
    | { t: 'query'; reqId: number; kind: 'frameReplay'; drawIndex: number; maxSide?: number }
    /** The whole composited frame, as the engine drew it. */
    | { t: 'query'; reqId: number; kind: 'screen'; maxSide?: number }
    | { t: 'query'; reqId: number; kind: 'stats' }
    | { t: 'query'; reqId: number; kind: 'updateStatus' }
    | { t: 'query'; reqId: number; kind: 'diskCache'; rescan?: boolean }
    | { t: 'query'; reqId: number; kind: 'cleanDiskCache'; budgetBytes: number; execute?: boolean }
    | { t: 'query'; reqId: number; kind: 'retainDiskCacheVersion'; revision: string; retain?: boolean }
    | { t: 'query'; reqId: number; kind: 'snapshot'; selectedId: number | null; withTree: boolean }
    | ({ t: 'query'; reqId: number; kind: 'control' } & DebugControl)

DebugControl — interface @experimental

fps: number | undefined
paused: boolean | undefined
step: number | undefined

DecalBakeOptions — interface @experimental

facing: number | undefined

DecalProjector — const @experimental

ComponentDef<DecalProjectorData>

DecalProjectorData — interface @experimental

bakedFrom: string
facing: number

DecalReceiver — interface @experimental

indices: Uint32Array<ArrayBufferLike>
normals: Float32Array<ArrayBufferLike>
positions: Float32Array<ArrayBufferLike>

DecodedPixels — interface @experimental

height: number
pixels: Uint8Array<ArrayBufferLike>
sourceHeight: number | undefined
sourceWidth: number | undefined
width: number

DeferredRecord — interface @experimental

id: number
overrides: PrefabOverride[]
prefab: string

Device — const @experimental

{ capabilities: () => DeviceCapabilities; state: () => DeviceState; power: () => PowerState; motion: { start: (options?: MotionOptions) => Promise<DeviceResult>; stop: () => Promise<DeviceResult>; onChange: (handler: (sample: MotionSample) => void) => () => void; }; vibrate: (options?: VibrationOptions) => Promise<DeviceResult>; keepScreenOn: (enabled: boolean) => Promise<DeviceResult>; fullscreen: (enabled: boolean, target?: unknown) => Promise<DeviceResult>; pointerLock: (enabled: boolean, target?: unknown) => Promise<DeviceResult>; onChange: (handler: (state: DeviceState) => void) => () => void; dispose: () => void; }

DeviceCapabilities — interface @experimental

accelerometer: boolean
fullscreen: boolean
gyroscope: boolean
keepScreenOn: boolean
orientation: boolean
pointerLock: boolean
vibration: boolean
vibrationIntensity: boolean

DeviceIdentity — interface @experimental

backend: string
renderer: string
vendor: string
version: string

DeviceLostReason — const @experimental

{ readonly Unknown: 0; readonly ContextLost: 1; readonly OutOfMemory: 2; readonly Reset: 3; readonly Removed: 4; readonly Destroyed: 5; readonly Validation: 6; readonly Internal: 7; }

DeviceQualityInfo — interface @experimental

cores: number | undefined
gpu: string | undefined
memoryGB: number | undefined
model: string | undefined

DeviceQualityRule — interface @experimental

gpuIncludes: string | undefined
level: QualityLevel
maxCores: number | undefined
maxMemoryGB: number | undefined
modelIncludes: string | undefined

DeviceRequestStatus — type @experimental

'ok' | 'unavailable' | 'denied' | 'failed'

DeviceRestoredListener — type @experimental

(generation: number) => void

DeviceResult — interface @experimental

reason: string | undefined
status: DeviceRequestStatus

DeviceState — interface @experimental

fullscreen: boolean
motionActive: boolean
pointerLocked: boolean
screenOn: boolean

DeviceStatus — const @experimental

{ readonly Live: 0; readonly Lost: 1; readonly Recovering: 2; readonly Dead: 3; }

DiagnosticEvent — interface @experimental

context: Record<string, unknown> | undefined
count: number
firstAt: number
id: string
kind: DiagnosticKind
lastAt: number
message: string
source: string | undefined
stack: string | undefined

DiagnosticKind — type @experimental

| 'engine'
    /** Reached the host with nobody catching it: `window.onerror`,
     *  `unhandledrejection`, `wx.onError`. Usually game code outside a system —
     *  a callback, a promise, a timer. */
    | 'unhandled'
    /** The GPU took the context away (backgrounded, driver reset, too many
     *  contexts). The frame after this one draws nothing. */
    | 'context-lost'
    /** The OS says memory is running out. Not yet a failure — it is the warning
     *  that arrives before the process is killed, which is the crash no report
     *  ever gets sent for. */
    | 'memory'
    /** The game itself called `Diagnostics.report` — a failed purchase, a save
     *  that would not write, whatever it considers worth knowing. */
    | 'game'

DiagnosticReport — interface @experimental

context: Record<string, unknown> | undefined
error: unknown
kind: DiagnosticKind
message: string
source: string | undefined

Diagnostics — const @experimental

ResourceDef<DiagnosticsAPI>

DiagnosticsAPI — class @experimental

clear: () => void
dropped: number
events: readonly DiagnosticEvent[]
flush: () => void
report: (report: DiagnosticReport) => void
reportError: (kind: DiagnosticReport["kind"], error: unknown, source?: string) => void
setSink: (sink: DiagnosticsSink | null) => void
tick: (deltaSeconds: number) => void
static new (options?: DiagnosticsOptions): DiagnosticsAPI
static prototype: DiagnosticsAPI

DiagnosticsOptions — interface @experimental

flushIntervalSec: number | undefined
maxDistinct: number | undefined

DiagnosticsPlugin — class @experimental

build: (app: App) => void
cleanup: (app: App) => void
name: string
profileDomain: "diagnostics"
static new (options_?: DiagnosticsPluginOptions): DiagnosticsPlugin
static prototype: DiagnosticsPlugin

DiagnosticsPluginOptions — interface @experimental

captureLevel: LogLevel | undefined
flushIntervalSec: number | undefined
maxDistinct: number | undefined

DiagnosticsSink — type @experimental

(events: readonly DiagnosticEvent[]) => void

DialogHandle — interface @experimental

close: () => void
dispose: () => void
entity: number
isOpen: () => boolean
open: () => void
panelEntity: number

DialogOptions — interface @experimental

backdropNode: UINodeInit | undefined
backdropVisual: UIVisualInit | undefined
closeOnBackdrop: boolean | undefined
closeOnEscape: boolean | undefined
events: UIEventQueue
onOpenChange: ((open: boolean) => void) | undefined
panelNode: UINodeInit | undefined
panelVisual: UIVisualInit | undefined
parent: number | undefined
startHidden: boolean | undefined
world: World

DiffOptions — interface @experimental

floatEpsilon: number | undefined
ignoreEntityNames: readonly string[] | undefined
ignoreMetadataKeys: readonly string[] | undefined

Dimension — interface @public

unit: number
value: number

DimensionUnit — type @public

(typeof DimensionUnit)[keyof typeof DimensionUnit]

Disabled — const @experimental

ComponentDef<{}>

DistanceJoint2D — const @experimental

ComponentDef<DistanceJoint2DData>

DistanceJoint3D — const @experimental

ComponentDef<DistanceJoint3DData>

DistanceJoint3DData — interface @experimental

anchor: Vec3
breakForce: number
breakTorque: number
collideConnected: boolean
connectedAnchor: Vec3
connectedEntity: number
damping: number
enabled: boolean
frequency: number
maxLength: number
minLength: number

DocumentDiagnostic — interface @experimental

code: string
entityId: DocumentEntityId | undefined
field: string | undefined
message: string
severity: DocumentDiagnosticSeverity

DocumentDiagnosticSeverity — type @experimental

'error' | 'warning'

DocumentEntityId — type @experimental

string | number

DocumentNode — interface @experimental

children: readonly DocumentEntityId[]
components: readonly { type: string; data: Record<string, unknown>; }[]
id: DocumentEntityId
parent: DocumentEntityId | null

DragPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
dependencies: "uiInteraction"[]
name: "drag"
static new (): DragPlugin
static prototype: DragPlugin

DragState — const @experimental

ComponentDef<DragStateData>

DragStateData — interface @experimental

currentWorldPos: { x: number; y: number; }
deltaWorld: { x: number; y: number; }
isDragging: boolean
pointerStartWorld: { x: number; y: number; }
startWorldPos: { x: number; y: number; }
totalDeltaWorld: { x: number; y: number; }

Draggable — const @experimental

BuiltinComponentDef<DraggableData>

DraggableData — interface @experimental

constrainMax: boolean
constrainMin: boolean
constraintMax: Vec2
constraintMin: Vec2
dragThreshold: number
enabled: boolean
lockX: boolean
lockY: boolean

DragonBones — const @experimental

ResourceDef<DragonBonesManager | null>

DragonBonesAnimation — const @experimental

BuiltinComponentDef<DragonBonesAnimationData>

DragonBonesAnimationData — interface @experimental

animation: string
armature: string
atlasPath: string
color: Color
enabled: boolean
fadeInTime: number
flipX: boolean
flipY: boolean
layer: number
loop: boolean
material: number
playing: boolean
skeletonPath: string
skeletonScale: number
timeScale: number

DragonBonesPlugin — class @experimental

acquire: () => Promise<DragonBonesManager | null>
build: (app: App) => void
cleanup: () => void
manager: DragonBonesManager | null
name: string
static new (manager?: DragonBonesManager): DragonBonesPlugin
static prototype: DragonBonesPlugin

Draw — const @experimental

DrawAPI

DrawAPI — interface @experimental

begin: (viewProjection: Float32Array, viewportWidth?: number, viewportHeight?: number) => void
circle: (center: Vec2, radius: number, color: Color, filled?: boolean, segments?: number) => void
circleOutline: (center: Vec2, radius: number, color: Color, thickness?: number, segments?: number) => void
drawMesh: (geometry: GeometryHandle, shader: ShaderHandle, transform: Float32Array) => void
drawMeshWithMaterial: (geometry: GeometryHandle, material: MaterialHandle, transform?: Float32Array) => void
end: () => void
getDrawCallCount: () => number
getPrimitiveCount: () => number
line3D: (from: Vec3, to: Vec3, color: Color, thickness?: number) => void
line3DScreen: (from: Vec3, to: Vec3, color: Color, thickness?: number) => void
line3DScreenOffset: (anchor: Vec3, fromOffset: Vec2, toOffset: Vec2, color: Color, thickness?: number) => void
line: (from: Vec2, to: Vec2, color: Color, thickness?: number) => void
rect: (position: Vec2, size: Vec2, color: Color, filled?: boolean) => void
rectOutline: (position: Vec2, size: Vec2, color: Color, thickness?: number) => void
setBlendMode: (mode: BlendMode) => void
setDepth: (depth: number) => void
setDepthTest: (enabled: boolean) => void
setLayer: (layer: number) => void
texture: (position: Vec2, size: Vec2, textureHandle: number, tint?: Color) => void
textureRotated: (position: Vec2, size: Vec2, rotation: number, textureHandle: number, tint?: Color) => void
withDepthState: (state: { test: boolean; write: boolean; }, draw: () => void) => boolean

DrawBudgetReport — interface @experimental

budget: number
draws: number
over: number
passes: DrawPassShare[]

DrawCallInfo — interface @experimental

blendMode: number
breakReason: BatchBreak
entities: number[]
index: number
indexCount: number
instanceCount: number
layer: number
materialId: number
pass: number
passKind: CapturePass
scissorEnabled: boolean
scissorH: number
scissorW: number
scissorX: number
scissorY: number
shaderId: number
stage: number
stencilRef: number
stencilTest: boolean
stencilWrite: boolean
textureId: number
textureSlotUsage: number
textures: number[]
triangleCount: number
type: RenderType

DrawCallback — type @experimental

(elapsed: number, frame: DrawFrameInfo) => void

DrawFrameInfo — interface @experimental

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

DrawPass — type @experimental

'lists' | 'shadow' | 'prepass' | 'reflection' | 'motion' | 'cover' | 'other'

DrawPassShare — interface @experimental

draws: number
pass: DrawPass

DrawRank — interface @experimental

groupInner: number | null | undefined
layer: number
order: LayerOrder
orderInLayer: number
worldY: number
worldZ: number

DropShadowFilterOptions — interface @experimental

blur: number | undefined
color: { r: number; g: number; b: number; a: number; } | undefined
offsetX: number | undefined
offsetY: number | undefined
texelSize: { x: number; y: number; } | undefined

DropdownHandle — interface @experimental

close: () => void
dispose: () => void
entity: number
getSelected: () => T
getSelectedIndex: () => number
isOpen: () => boolean
labelEntity: number
open: () => void
setSelectedIndex: (index: number) => void

DropdownOptions — interface @experimental

buttonStates: { normal?: Color; hover?: Color; pressed?: Color; } | undefined
disabled: boolean | undefined
events: UIEventQueue
focusable: boolean | undefined
node: UINodeInit | undefined
onSelect: ((index: number, option: T, entity: Entity) => void) | undefined
optionHeight: number | undefined
optionToLabel: ((option: T, index: number) => string) | undefined
options: readonly T[]
parent: number | undefined
selectedIndex: number | undefined
tabIndex: number | undefined
world: World

EDITOR_EXPOSURE_RANGE — const @experimental

{ readonly min: -6; readonly max: 6; }

EDITOR_UI_ANCHOR — const @experimental

{ readonly x: 0; readonly y: 0; }

EDITOR_VIEW_ENTITY — const @experimental

-1

ENGINE_WEBGPU_FEATURES — const @experimental

readonly ["texture-compression-astc", "texture-compression-bc", "texture-compression-etc2", "timestamp-query"]

EasingType — enum @experimental

CubicBezier = 14
EaseInBack = 7
EaseInBounce = 31
EaseInCirc = 28
EaseInCubic = 4
EaseInElastic = 10
EaseInExpo = 25
EaseInOutBack = 9
EaseInOutBounce = 32
EaseInOutCirc = 30
EaseInOutCubic = 6
EaseInOutElastic = 12
EaseInOutExpo = 27
EaseInOutQuad = 3
EaseInOutQuart = 21
EaseInOutQuint = 24
EaseInOutSine = 18
EaseInQuad = 1
EaseInQuart = 19
EaseInQuint = 22
EaseInSine = 16
EaseOutBack = 8
EaseOutBounce = 13
EaseOutCirc = 29
EaseOutCubic = 5
EaseOutElastic = 11
EaseOutExpo = 26
EaseOutQuad = 2
EaseOutQuart = 20
EaseOutQuint = 23
EaseOutSine = 17
Linear = 0
Smootherstep = 34
Smoothstep = 33
Step = 15

EditorAssetType — type @experimental

| 'texture' | 'material' | 'shader' | 'spine-atlas' | 'spine-skeleton'
    | 'dragonbones-atlas' | 'dragonbones-skeleton'
    | 'bitmap-font' | 'font' | 'prefab' | 'json' | 'audio' | 'sound-event' | 'world-rules' | 'terrain-layer' | 'terrain-tiles' | 'video' | 'scene' | 'anim-clip'
    | 'tilemap' | 'tileset' | 'timeline' | 'mesh'
    | 'unknown'

EditorBridge — interface @experimental

onComponentAdded: ((entity: number, component: string) => void) | undefined
onComponentChanged: ((entity: number, component: string) => void) | undefined
onComponentRemoved: ((entity: number, component: string) => void) | undefined
onEntityDespawned: ((entity: number) => void) | undefined
onEntitySpawned: ((entity: number, name?: string) => void) | undefined
onParentChanged: ((child: number, parent: number | null) => void) | undefined
registerComponent: (name: string, defaults: Record<string, unknown>, isTag: boolean) => void

EditorGrid — const @experimental

ResourceDef<EditorGridData>

EditorGridData — interface @experimental

axisColors: [GridColor, GridColor, GridColor]
color: GridColor
enabled: boolean
majorColor: GridColor
majorEvery: number
spacing: number

EditorLightingMode — type @experimental

'scene' | 'studio'

EditorView — const @experimental

ResourceDef<EditorViewData>

EditorViewBasis — interface @experimental

forward: Vec3
right: Vec3
up: Vec3

EditorViewData — interface @experimental

active: boolean
distance: number
fov: number
orthoSize: number
perspective: boolean
pitch: number
uiPreviewAspect: number
x: number
y: number
yaw: number
z: number

EditorViewLighting — const @experimental

ResourceDef<EditorViewLightingData>

EditorViewLightingData — interface @experimental

exposure: number
fillIntensity: number
keyIntensity: number
mode: EditorLightingMode
rotation: number
showSky: boolean
skyIntensity: number

EditorViewShading — const @experimental

ResourceDef<EditorViewShadingData>

EditorViewShadingData — interface @experimental

mode: ViewShading
weights: { entity: number; joint: number; } | null

EditorWorkPlane — interface @experimental

normal: WorldAxis
u: WorldAxis
v: WorldAxis

EffectDef — interface @experimental

builtinTextures: Record<string, () => BuiltinTexture> | undefined
category: EffectCategory | undefined
colors: EffectColorDef[] | undefined
compute: ComputeEffectSource | undefined
factory: (() => ShaderHandle) | undefined
fallback: EffectSubPass[] | undefined
label: string
multiPass: EffectSubPass[] | undefined
native: string | undefined
stage: "output" | undefined
textures: EffectTextureDef[] | undefined
type: string
uniforms: EffectUniformDef[]

EffectUniformDef — interface @experimental

defaultValue: number
internal: boolean | undefined
label: string
max: number
min: number
name: string
neutralValue: number | undefined
step: number
worldUnits: 1 | -1 | undefined

EmbeddedSideModuleEntry — interface @experimental

glue: string
wasm: Uint8Array<ArrayBufferLike>

EmbeddedSideModuleRegistry — type @experimental

Partial<Record<SideModuleId, EmbeddedSideModuleEntry>>

EmitterShape — enum @beta

Box = 2
Circle = 1
Cone = 3
Hemisphere = 5
Point = 0
Sphere = 4

EngineApi — type @experimental

NativeEngineApi & Partial<NativeHeap>

Entity — type @public

number

EntityBox — interface @experimental

cx: number
cy: number
cz: number
hd: number
hh: number
hw: number
rot: Quat

EntityBoxOptions — interface @experimental

extentOf: ((entity: Entity) => { x: number; y: number; width: number; height: number; } | null) | undefined
iconHalf: number | ((at: Vec3) => number) | undefined

EntityCommands — class @public

@internal describe: () => string
childOf: (parent: Entity) => EntityCommands
finalize: () => void
id: () => Entity
insert: <T extends object>(component: AnyComponentDef, data?: Partial<T> | undefined) => EntityCommands
remove: (component: AnyComponentDef) => EntityCommands
static new (commands: CommandsInstance, entity: Entity | null, name?: string): EntityCommands
static prototype: EntityCommands

EntityEvent — interface @experimental

currentTarget: number
data: TData
defaultPrevented: boolean
preventDefault: () => void
propagationStopped: boolean
stopPropagation: () => void
target: number
type: string

EntityEventHandler — type @experimental

(event: EntityEvent<TData>) => void

EntityEventObservation — interface @experimental

currentTarget: number
defaultPrevented: boolean
eventId: number
propagationStopped: boolean
target: number
type: string

EntityEventQueue — class @experimental

@internal requeue: (event: EntityEvent) => void
clear: () => void
drain: () => readonly EntityEvent[]
emit: <TData = unknown>(entity: Entity, type: string, data?: TData) => EntityEvent<TData>
emitBubbled: (ancestor: Entity, rootEvent: EntityEvent) => EntityEvent
hasListenersFor: (type: string) => boolean
observe: (handler: (event: EntityEventObservation) => void) => Unsubscribe
on: { (entity: Entity, type: string, handler: EntityEventHandler): Unsubscribe; (type: string, handler: EntityEventHandler): Unsubscribe; }
query: (type: string) => readonly EntityEvent[]
removeAll: (entity: Entity) => void
static new (): EntityEventQueue
static prototype: EntityEventQueue

EntityEvents — const @experimental

ResourceDef<EntityEventQueue>

EntityPickOptions — interface @experimental

depthLayers: number | undefined
extentOf: ((entity: Entity) => { x: number; y: number; width: number; height: number; } | null) | undefined
iconHalf: number | ((at: Vec3) => number) | undefined
pickable: ((entity: Entity) => boolean) | undefined
ySortLayers: number | undefined

EnvironmentLightEntity — interface @experimental

components: readonly { type: string; data: Record<string, unknown>; }[]
id: number
name: string
visible: boolean | undefined

Eroded — interface @experimental

field: Heightfield
flow: Float32Array<ArrayBufferLike>

ErosionParams — interface @experimental

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

EventBinding — const @experimental

ComponentDef<EventBindingData>

EventBindingData — interface @experimental

rows: EventBindingRow[]

EventBindingPlugin — class @experimental

build: (app: App) => void
cleanup: () => void
name: string
profileDomain: "events"
static new (): EventBindingPlugin
static prototype: EventBindingPlugin

EventBindingRow — interface @experimental

action: string
arg: string | undefined
enabled: boolean | undefined
event: string
guard: string | undefined
once: boolean | undefined
params: Record<string, AiParamValue> | undefined
target: string | undefined

EventDef — interface @public

@internal _default: object | undefined
@internal _id: symbol
@internal _name: string
@internal _phantom: T | undefined

EventReader — function @public

<T>(event: EventDef<T>): EventReaderDescriptor<T>

EventReaderDescriptor — interface @public

@internal _event: EventDef<T>
@internal _type: "event_reader"

EventReaderInstance — class @public

[Symbol.iterator]: () => Iterator<T>
isEmpty: () => boolean
toArray: () => T[]
static new <T>(bus: EventBus<T>): EventReaderInstance<T>
static prototype: EventReaderInstance<any>

EventRegistry — class @experimental

@internal rewindWrites: (marks: Map<symbol, number>) => void
@internal writeMarks: () => Map<symbol, number>
@internal writtenSince: (marks: Map<symbol, number>) => string
busNamed: (name: string) => EventBus<unknown> | undefined
getBus: <T>(event: EventDef<T>) => EventBus<T>
register: <T>(event: EventDef<T>) => void
swapAll: () => void
static new (): EventRegistry
static prototype: EventRegistry

EventWriter — function @public

<T>(event: EventDef<T>): EventWriterDescriptor<T>

EventWriterDescriptor — interface @public

@internal _event: EventDef<T>
@internal _type: "event_writer"

EventWriterInstance — class @public

send: (event: T) => void
static new <T>(bus: EventBus<T>): EventWriterInstance<T>
static prototype: EventWriterInstance<any>

ExploredGrid — class @experimental

cells: Uint8Array<ArrayBufferLike>
fromString: (text: string) => boolean
mark: (x: number, y: number, left: number, bottom: number, width: number, height: number) => boolean
markFan: (origin: SightPoint, distances: Float32Array, left: number, bottom: number, width: number, height: number) => boolean
size: number
toString: () => string
static new (size: number): ExploredGrid
static prototype: ExploredGrid

ExternalEntityRef — interface @experimental

componentType: string
entityId: number
field: string
target: number

ExtractEntity — interface @experimental

children: number[]
components: ComponentData[]
id: number
name: string
parent: number | null
visible: boolean | undefined

FACES — const @experimental

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

FILL_AXIS — const @experimental

Record<LinearFillDirection, readonly [FillMethod, FillOrigin]>

FieldMeta — interface @public

advanced: boolean | undefined
bitmask: { bits?: number; source?: string; } | undefined
category: string | undefined
curve: boolean | undefined
effectStack: boolean | undefined
enum: readonly { label: string; value: number; }[] | undefined
enumSource: string | undefined
flags: readonly { label: string; value: number; }[] | undefined
gradient: boolean | undefined
label: string | undefined
labelSource: string | undefined
map: boolean | undefined
max: number | undefined
min: number | undefined
normalizedOf: string | undefined
shownWhen: { field: string; values: ReadonlyArray<number>; } | undefined
slider: boolean | undefined
step: number | undefined
tooltip: string | undefined
unit: string | 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

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

FillMethod — enum @beta

Horizontal = 0
Radial180 = 4
Radial360 = 2
Radial90 = 3
Vertical = 1

FillOrigin — enum @beta

Bottom = 2
Left = 0
Right = 1
Top = 3

FilterEffectDef — interface @experimental

filter: "bandpass" | "highpass" | "highshelf" | "lowpass" | "lowshelf" | "notch" | "peaking"
frequency: number
gainDb: number | undefined
q: number | undefined
type: "filter"

FilterExpr — type @public

| { readonly kind: 'with'; readonly component: AnyComponentDef }
    | { readonly kind: 'without'; readonly component: AnyComponentDef }
    | { readonly kind: 'and'; readonly filters: readonly FilterExpr[] }
    | { readonly kind: 'or'; readonly filters: readonly FilterExpr[] }
    | { readonly kind: 'not'; readonly filter: FilterExpr }

Filters — const @experimental

{ identityMatrix(): number[]; grayscaleMatrix(): number[]; sepiaMatrix(): number[]; brightnessMatrix(value: number): number[]; contrastMatrix(value: number): number[]; saturationMatrix(value: number): number[]; invertMatrix(): number[]; getColorMatrixShader: () => ShaderHandle; colorMatrixUniforms(matrix: number[]): Record<string, number[]>; }

FingerPoseDef — interface @experimental

joints: Record<string, Quat>

FixedJoint2D — const @experimental

ComponentDef<FixedJoint2DData>

FixedJoint3D — const @experimental

ComponentDef<FixedJoint3DData>

FixedJoint3DData — interface @experimental

breakForce: number
breakTorque: number
collideConnected: boolean
connectedEntity: number
enabled: boolean

FlattenContext — interface @experimental

allocateId: () => number
deferred: DeferredRecord[] | undefined
depth: number | undefined
loadPrefab: (path: string) => PrefabData | null
visited: Set<string> | undefined

FlattenResult — interface @experimental

entities: ProcessedEntity[]
rootId: number
unresolved: PrefabOverride[]

FlexContainer — const @experimental

BuiltinComponentDef<FlexContainerData>

FlexContainerData — interface @experimental

alignContent: AlignContent
alignItems: AlignItems
direction: FlexDirection
gap: Vec2
justifyContent: JustifyContent
padding: Padding
wrap: FlexWrap

FlexDirection — enum @experimental

Column = 1
ColumnReverse = 3
Row = 0
RowReverse = 2

FlexWrap — enum @experimental

NoWrap = 0
Wrap = 1

FocusInspectionWorld — type @experimental

Pick<World, 'getWasmModule' | 'getCppRegistry' | 'getEntitiesWithComponents' | 'valid' | 'has' | 'get'>

FocusManager — const @experimental

ResourceDef<FocusManagerState>

FocusManagerState — class @experimental

blur: () => Entity | null
focus: (entity: Entity, visible?: boolean) => Entity | null
focusVisible: boolean
focusedEntity: number | null
isVisiblyFocused: (entity: Entity) => boolean
static new (): FocusManagerState
static prototype: FocusManagerState

FocusPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
dependencies: "uiInteraction"[]
name: "focus"
static new (): FocusPlugin
static prototype: FocusPlugin

FocusSkipReason — type @experimental

'disabled' | 'hidden' | 'outside-dialog'

FocusTraversalEntry — interface @experimental

entity: number
skipped: FocusSkipReason | null
tabIndex: number

FocusTraversalInspection — interface @experimental

entries: FocusTraversalEntry[]
visibilityResolved: boolean

Focusable — const @experimental

ComponentDef<FocusableData>

FocusableData — interface @experimental

isFocused: boolean
tabIndex: number

FogOfWar — const @experimental

ComponentDef<FogOfWarData>

FogOfWarData — interface @experimental

enabled: boolean
height: number
rays: number
texels: number
viewRadius: number
width: number

Foliage — const @experimental

ComponentDef<FoliageData>

FoliageData — interface @experimental

bladeHeight: number
bladeLean: number
bladeWidth: number
cardTent: number
cardU0: number
cardU1: number
cardV0: number
cardV1: number
castShadows: boolean
cellSize: number
colorMap: number
colorMapFrom: number
colorMapStrength: number
count: number
densityMap: number
drawDistance: number
faceEye: number
faceEyeNear: number
farCards: boolean
farGrow: number
farGrowUp: number
farKeep: number
farLevels: number
farStep: number
farTilt: number
heightMax: number
heightMin: number
lodDistance: number
material: number
maxScale: number
mesh: number
minScale: number
minUp: number
palette: number
scaleMap: number
seed: number
sizeX: number
sizeZ: number
waterDepth: number
zonePadding: number
zoneTags: string
zoneWorld: string

FoliageField — class @experimental

@internal app_: App | null
@internal authoredWind_: Map<number, number>
@internal built_: Map<number, BuiltFoliage>
@internal landed_: (() => void)[]
cellCount: number
pending: number
retired_: { instance: number; frames: number; }[]
static new (): FoliageField
static prototype: FoliageField

FoliagePlugin — class @experimental

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

FoliageRes — const @experimental

ResourceDef<FoliageField>

FollowTarget — const @experimental

ComponentDef<FollowTargetData>

FollowTargetData — interface @experimental

damping: number
deadzone: number
followZ: boolean
offsetX: number
offsetY: number
offsetZ: number
target: number

FontHandle — type @experimental

number

Footsteps — const @experimental

ComponentDef<FootstepsData>

FootstepsData — interface @experimental

enabled: boolean
layer: number
onBareGround: boolean
printColor: { r: number; g: number; b: number; a: number; }
printLife: number
printSize: number
printTexture: number
rippleColor: { r: number; g: number; b: number; a: number; }
rippleLife: number
rippleSize: number
rippleTexture: number
stride: number
width: number

ForceFieldType — enum @experimental

Directional = 0
Drag = 3
Point = 1
Vortex = 2

FrameAssetNames — interface @experimental

material: (id: number) => string | null
texture: (renderId: number) => string | null

FrameCaptureData — interface @experimental

drawCalls: DrawCallInfo[]
passCount: number

FrameCosts — interface @experimental

scopes: ScopeCost[]
systems: SystemCost[]

FrameDebugReport — interface @experimental

draws: DrawCallInfo[]
materials: Record<number, string>
names: Record<number, string>
passCount: number
textures: Record<number, string>

FrameHistory — class @experimental

count: number
getAll: () => FrameSnapshot[]
getLatest: () => FrameSnapshot | null
push: (frameTimeMs: number, phaseTimings: Map<string, number>, systemTimings?: Map<string, number>) => void
reset: () => void
static new (capacity?: number): FrameHistory
static prototype: FrameHistory

FramePixels — interface @experimental

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

FrameProfile — interface @experimental

cpuMs: number
domains: readonly ProfileNode[]
frameMs: number
gpuMs: number
idleMs: number
waitMs: number

FrameProfileInput — interface @experimental

frameMs: number
gpuMs: number | undefined
nativeScopes: readonly ScopeCost[] | undefined
scopes: readonly ScopeCost[]
systems: readonly SystemCost[]

FrameReplayImage — interface @experimental

height: number
matchesCapture: boolean
pixels: Uint8ClampedArray<ArrayBufferLike>
width: number

FrameSnapshot — interface @experimental

frameTimeMs: number
phaseTimings: Map<string, number>
systemTimings: Map<string, number>

FrameStats — interface @experimental

culled: number
drawCallBudget: number
drawCalls: number
entityCount: number
fps: number
frameTimeMs: number
gpuDraws: number
meshes: number
phaseTimings: Map<string, number>
skeletal: number
sprites: number
systemTimings: Map<string, number>
text: number
triangles: number

FrameStatsReport — interface @experimental

audioBytes: number | undefined
audioStreamedCount: number | undefined
audioStreamedSavedBytes: number | undefined
compositeBatch: { entity: number; parts: number; instanced: number; draws: number; drawsBefore: number; moving: number; }[] | undefined
costs: FrameCosts | null
cppCounters: Record<string, number>
cppScopes: Record<string, number>
drawCalls: number
entities: number
frameMs: number | undefined
gpuDraws: number | undefined
gpuMs: number
gpuScopes: Record<string, number>
phases: Record<string, number>
quality: QualityReport | undefined
seq: number | undefined
sprites: number
staticBatch: StaticBatchSummary | undefined
textureStreaming: { enabled: boolean; textures: number; streamedMB: number; fullMB: number; moves: number; failures: number; startedSmall: number; } | undefined
triangles: number
vramBytes: number
wasmBytes: number

FrameTiming — interface @experimental

busyMs: number
frameMs: number
seq: number

FrameVerdict — type @experimental

'gpu-pressure' | 'frame-pressure' | 'headroom' | 'steady'

GLDebug — const @experimental

{ enable(): void; disable(): void; check(context: string): number; diagnose(): void; }

GameSocket — class @experimental

close: (code?: number, reason?: string) => void
connect: () => void
delivery: "reliable-ordered"
on: <K extends keyof PlatformSocketEvents>(event: K, handler: (...args: PlatformSocketEvents[K]) => void) => () => void
readyState: PlatformSocketReadyState
send: (data: string | ArrayBuffer) => void
static new (options: GameSocketOptions): GameSocket
static prototype: GameSocket

GameSocketOptions — type @experimental

PlatformSocketOptions

GamepadAxis — enum @public

LeftX = 0
LeftY = 1
RightX = 2
RightY = 3

GamepadButton — enum @public

Back = 8
DpadDown = 13
DpadLeft = 14
DpadRight = 15
DpadUp = 12
East = 1
Guide = 16
LeftBumper = 4
LeftStick = 10
LeftTrigger = 6
North = 3
RightBumper = 5
RightStick = 11
RightTrigger = 7
South = 0
Start = 9
West = 2

GamepadSnapshot — interface @experimental

axes: number[]
buttons: number[]
connected: boolean
index: number
mapping: string

GearBinding — interface @experimental

component: string
controller: string
pages: Record<string, GearValue>
property: string
tween: GearTween | undefined

GearTween — interface @experimental

duration: number
easing: EasingType

GearValue — type @experimental

number | boolean | string | Color | Vec2 | Vec3

Geometry — const @experimental

{ create(options: GeometryOptions): GeometryHandle; updateVertices(handle: GeometryHandle, vertices: Float32Array, offset?: number): void; release(handle: GeometryHandle): void; isValid(handle: GeometryHandle): boolean; createQuad(width?: number, height?: number): GeometryHandle; createCircle(radius?: number, segments?: number): GeometryHandle; createPolygon(points: Array<{ x: number; y: number; }>): GeometryHandle; }

GeometryHandle — type @experimental

number

GeometryOptions — interface @experimental

dynamic: boolean | undefined
indices: Uint32Array<ArrayBufferLike> | Uint16Array<ArrayBufferLike> | undefined
layout: VertexAttributeDescriptor[]
vertices: Float32Array<ArrayBufferLike>

GestureDetector — class @experimental

onLongPress: ((x: number, y: number) => void) | null
onPinch: ((scale: number, centerX: number, centerY: number) => void) | null
onSwipe: ((direction: SwipeDirection, speed: number) => void) | null
onTap: ((x: number, y: number) => void) | null
reset: () => void
update: (dt: number) => void
static new (input: InputState): GestureDetector
static prototype: GestureDetector

GetWorld — function @public

(): GetWorldDescriptor

GetWorldDescriptor — interface @public

@internal _type: "get_world"

GlImageSource — type @experimental

PlatformImage | PlatformCanvas | ImageBitmap

GlyphPreload — interface @experimental

done: Promise<void>
progress: number
release: () => void

GlyphPreloadOptions — interface @experimental

budgetMs: number | undefined

GpAxis — const @public

(axis: number, pad?: number, scale?: number) => Binding

GpButton — const @public

(button: number, pad?: number) => Binding

GraphNodeType — type @beta

| 'output' // the root: its `color` input becomes fragColor
  | 'subgraph' // another graph used as one node (inlined before compile)
  | 'subInput' // inside a subgraph: one of its inputs, read by the nodes that use it
  | 'subOutput' // inside a subgraph: its result
  | 'normalMap' // sample a tangent-space normal map (read as data, unpacked like the standard material)
  | 'channel' // one component (r/g/b/a) of a value, as a scalar
  | 'literal' // a constant the compiler makes when a subgraph input is left unconnected
  | 'uvTransform' // uv × tiling + offset
  | 'switch' // a compile-time variant: one of two values, chosen by a #pragma switch the material turns on or off
  | 'uv' // v_texCoord
  | 'vertexColor' // v_color (the sprite's per-instance tint)
  | 'time' // u_time.x — the injected engine frame clock (seconds)
  | 'screenUV' // gl_FragCoord over the canvas size (0..1, y-up)
  | 'constFloat' // a scalar material param (#pragma param ... float)
  | 'constColor' // an RGBA material param (#pragma param ... color)
  | 'textureSample' // sample a texture material param at a UV (#pragma param ... texture)
  | 'multiply'
  | 'add'
  | 'lerp'
  | 'oneMinus' // 1 - x (invert a mask)
  | 'saturate' // clamp(x, 0, 1)
  | 'sin'
  | 'smoothstep' // smoothstep(edge0, edge1, x) — edges are node literals
  | 'noise' // procedural value noise over a UV (scale is a node literal)
  | 'panner'

GraphType — type @beta

'float' | 'vec2' | 'vec3' | 'vec4'

Graphics — class @experimental

arc: (cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean, segments?: number) => void
beginFill: (color: Color) => void
clear: () => void
cubicCurveTo: (cp1x: number, cp1y: number, cp2x: number, cp2y: number, x: number, y: number, segments?: number) => void
curveTo: (cpx: number, cpy: number, x: number, y: number, segments?: number) => void
drawArc: (cx: number, cy: number, radius: number, startAngle: number, endAngle: number, anticlockwise?: boolean, segments?: number) => void
drawCircle: (cx: number, cy: number, radius: number, segments?: number) => void
drawEllipse: (cx: number, cy: number, rw: number, rh: number, segments?: number) => void
drawRect: (x: number, y: number, width: number, height: number) => void
drawRoundRect: (x: number, y: number, width: number, height: number, radius: number) => void
endFill: () => void
fillCommands: FillCmd[]
flush: () => void
lineCommands: LineCmd[]
lineStyle: (thickness: number, color: Color) => void
lineTo: (x: number, y: number) => void
moveTo: (x: number, y: number) => void
pathLength: number
static new (): Graphics
static prototype: Graphics

GridColor — type @experimental

[number, number, number, number]

GridLayoutProvider — class @experimental

getContentSize: (count: number) => Vec2
getItemRect: (index: number) => Rect
getVisibleRange: (viewport: Rect, count: number) => [number, number]
static new (opts: GridLayoutOptions): GridLayoutProvider
static prototype: GridLayoutProvider

GripFinger — interface @experimental

base: number | undefined
bend: [number, number, number] | undefined
curl: number
fan: number | undefined
spread: number | undefined

GripHand — const @experimental

{ readonly Right: 0; readonly Left: 1; }

GripHandStatus — interface @experimental

hand: number | null
joints: number
missing: string[]
pose: string
touching: string[]
weight: number

GripHolder — const @experimental

ComponentDef<GripHolderData>

GripHolderData — interface @experimental

blendSeconds: number
held: number
leftHand: string
mainHand: number
placement: number
rightHand: string
supportWeight: number
weight: number

GripJoint — interface @experimental

axis: { x: number; y: number; z: number; }
bone: { x: number; y: number; z: number; }
entity: number
finger: string
joint: number

GripMirror — const @experimental

{ readonly X: 0; readonly Y: 1; readonly Z: 2; }

GripPlacement — const @experimental

{ readonly Hand: 0; readonly Object: 1; }

GripPose — const @experimental

ComponentDef<GripPoseData>

GripPoseData — interface @experimental

blendSeconds: number
leftHand: string
leftPose: string
leftTrigger: number
leftWeight: number
rightHand: string
rightPose: string
rightTrigger: number
rightWeight: number

GripPoseDef — interface @experimental

index: GripFinger
middle: GripFinger
pinky: GripFinger
ring: GripFinger
thumb: GripThumb
trigger: GripFinger | undefined

GripProfile — const @experimental

ComponentDef<GripProfileData>

GripProfileData — interface @experimental

hand: number
mainAnchor: number
mainFingers: string
mainPose: string
mirror: number
supportAnchor: number
supportFingers: string
supportPose: string
wrap: boolean

GripSurface — const @experimental

ComponentDef<GripSurfaceData>

GripSurfaceData — interface @experimental

center: Vec3
direction: number
height: number
radius: number
shape: number
size: Vec3

GripSurfaceShape — const @experimental

{ readonly Cylinder: 0; readonly Capsule: 1; readonly Sphere: 2; readonly Box: 3; }

GripThumb — interface @experimental

gap: number | undefined
opposition: number
to: "fingers" | "index" | undefined

Ground — type @experimental

(x: number, z: number) => { y: number; up: number } | null

GroundContext — interface @experimental

dt: number
memory: Map<string, { lift: number; normal: Vec3; }>
probe: GroundProbe | null
rest: Map<number, { position: Vec3; rotation: Quat; }> | undefined

GroundHit — interface @experimental

normal: Vec3
y: number

GroundProbe — type @experimental

(origin: Vec3, drop: number, layers: number) => GroundHit | null

Group — interface @experimental

anchor: Placement
id: string
layer: string
members: Placement[]
priority: number
radius: number
x: number
z: number

GroupOpacity — const @experimental

BuiltinComponentDef<GroupOpacityData>

GroupOpacityData — interface @beta

enabled: boolean
opacity: number

HdrFormat — interface @experimental

effective: string
fellBack: boolean
linear: boolean
reason: string
requested: string

HeadlessAppOptions — interface @experimental

plugins: Plugin[] | undefined
sideModules: SideModuleHost | undefined

Heightfield — interface @experimental

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

HeightmapFormat — const @experimental

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

HingeJoint2D — const @experimental

ComponentDef<HingeJoint2DData>

HingeJoint3D — const @experimental

ComponentDef<HingeJoint3DData>

HingeJoint3DData — interface @experimental

anchor: Vec3
angle: number
axis: Vec3
breakForce: number
breakTorque: number
collideConnected: boolean
connectedEntity: number
enableLimit: boolean
enableMotor: boolean
enabled: boolean
lowerAngle: number
maxMotorTorque: number
motorSpeed: number
upperAngle: number

HitAreaShape — type @experimental

| { type: 'rect'; x: number; y: number; width: number; height: number }
    | { type: 'circle'; cx: number; cy: number; radius: number }
    | { type: 'polygon'; points: number[] }

HttpBackend — class @experimental

fetchBinary: (path: string) => Promise<ArrayBuffer>
fetchText: (path: string) => Promise<string>
resolveUrl: (path: string) => string
setBaseUrl: (url: string) => void
static new (options: HttpBackendOptions): HttpBackend
static prototype: HttpBackend

IK2D — const @experimental

ComponentDef<IK2DData>

IK2DData — interface @experimental

bend: number
chainLength: number
enabled: boolean
matchTargetRotation: boolean
target: number
weight: number

IMPOSTOR_BAKE_LAYER — const @experimental

31

INTERACTION_CONTROLLER — const @experimental

"$interaction"

INTERACTION_PAGES — const @experimental

readonly ["normal", "hover", "pressed", "disabled", "focused"]

INVALID_ENTITY — const @experimental

number

INVALID_FONT — const @experimental

number

INVALID_MATERIAL — const @experimental

0

INVALID_TEXTURE — const @experimental

number

Identity — const @experimental

ResourceDef<IdentityAPI>

IdentityAPI — class @experimental

available: boolean
login: () => Promise<LoginResult>
sessionValid: () => Promise<boolean>
static new (): IdentityAPI
static prototype: IdentityAPI

ImageLoadResult — interface @experimental

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

ImageSegment — interface @experimental

height: number
offsetX: number
offsetY: number
scale: number
src: string
tint: Color | null
type: "image"
valign: ImageValign
width: number

ImportedScenePlugin — class @experimental

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

Impostor — const @experimental

BuiltinComponentDef<ImpostorData>

ImpostorAtlases — class @experimental

given: Map<number, string>
kinds: Map<string, ImpostorKind>
ready: number
static new (): ImpostorAtlases
static prototype: ImpostorAtlases

ImpostorAtlasesRes — const @experimental

ResourceDef<ImpostorAtlases>

ImpostorData — interface @beta

enabled: boolean
frames: number
resolution: number
screenSize: number

ImpostorPlugin — class @experimental

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

InferParam — type @public

P extends QueryDescriptor<infer C> ? QueryInstance<C> :
    P extends ResDescriptor<infer T> ? T :
    P extends ResMutDescriptor<infer T> ? ResMutInstance<T> :
    P extends CommandsDescriptor ? CommandsInstance :
    P extends EventWriterDescriptor<infer T> ? EventWriterInstance<T> :
    P extends EventReaderDescriptor<infer T> ? EventReaderInstance<T> :
    P extends RemovedQueryDescriptor<infer _T> ? RemovedQueryInstance<_T> :
    P extends GetWorldDescriptor ? World :
    never

InferParams — type @public

{
    [K in keyof P]: InferParam<P[K]>;
}

Input — const @beta

ResourceDef<InputState>

InputHandler — interface @experimental

onKeyDown: ((code: string, mods: Modifiers) => boolean | void) | undefined
onKeyUp: ((code: string, mods: Modifiers) => boolean | void) | undefined
onPointerDown: ((button: number, x: number, y: number, mods: Modifiers) => boolean | void) | undefined
onPointerMove: ((x: number, y: number, mods: Modifiers) => boolean | void) | undefined
onPointerUp: ((button: number, mods: Modifiers) => boolean | void) | undefined
onTouchCancel: ((id: number) => boolean | void) | undefined
onTouchEnd: ((id: number) => boolean | void) | undefined
onTouchMove: ((id: number, x: number, y: number) => boolean | void) | undefined
onTouchStart: ((id: number, x: number, y: number) => boolean | void) | undefined
onWheel: ((deltaX: number, deltaY: number, mods: Modifiers) => boolean | void) | undefined

InputMap — class @public

@internal evaluate: (input: InputState) => void
actions: () => string[]
axis2d: (name: string) => Vec2
cancelListen: () => void
down: (name: string) => boolean
getBindings: (name: string) => Binding[]
isListening: () => boolean
listenForBinding: (opts?: ListenOptions) => Promise<Binding | null>
load: (key: string) => boolean
loadJSON: (data: Record<string, Binding[]>) => void
pressed: (name: string) => boolean
rebind: (name: string, opts?: ListenOptions & { append?: boolean; }) => Promise<Binding | null>
released: (name: string) => boolean
save: (key: string) => void
setBindings: (name: string, bindings: Binding[]) => void
toAsset: () => InputMapAsset
toJSON: () => Record<string, Binding[]>
value: (name: string) => number
static new (actions: Record<string, ActionDef>): InputMap
static prototype: InputMap

InputMapAsset — interface @public

actions: Record<string, ActionDef>
version: number

InputPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
name: string
static new (target?: unknown): InputPlugin
static prototype: InputPlugin

InputRouter — class @experimental

currentMods: Modifiers
dispatchKeyDown: (code: string) => boolean
dispatchKeyUp: (code: string) => boolean
dispatchPointerDown: (button: number, x: number, y: number) => boolean
dispatchPointerMove: (x: number, y: number) => boolean
dispatchPointerUp: (button: number) => boolean
dispatchTouchCancel: (id: number) => boolean
dispatchTouchEnd: (id: number) => boolean
dispatchTouchMove: (id: number, x: number, y: number) => boolean
dispatchTouchStart: (id: number, x: number, y: number) => boolean
dispatchWheel: (deltaX: number, deltaY: number) => boolean
resetModifiers: () => void
setEditorHandler: (handler: InputHandler | null) => () => void
setUIHandler: (handler: InputHandler | null) => () => void
static new (): InputRouter
static prototype: InputRouter

InputState — class @beta

@internal admitTouch: (id: number) => boolean
@internal cancelVirtualSources: () => void
@internal forgetTouches: () => void
@internal touchIgnored: (id: number, retiring?: boolean) => boolean
beginFixedStep: () => void
clearFrameState: () => void
clearVirtual: () => void
endFixedStep: () => void
endTouch: (id: number) => void
gamepadButtonThreshold: number
gamepadDeadzone: number
gamepads: Map<number, PadState>
getGamepadAxis: (axis: number, pad?: number) => number
getGamepadButtonValue: (button: number, pad?: number) => number
getGamepads: () => number[]
getMouseDelta: () => { x: number; y: number; }
getMousePosition: () => { x: number; y: number; }
getScrollDelta: () => { x: number; y: number; }
getTouch: (id: number) => TouchPoint | null
getTouchCount: () => number
getTouches: () => TouchPoint[]
getTouchesEnded: () => TouchPoint[]
getTouchesStarted: () => TouchPoint[]
getVirtual: (id: string) => Vec2
injectGamepad: (snapshot: GamepadSnapshot) => void
isGamepadButtonDown: (button: number, pad?: number) => boolean
isGamepadButtonPressed: (button: number, pad?: number) => boolean
isGamepadButtonReleased: (button: number, pad?: number) => boolean
isGamepadConnected: (pad?: number) => boolean
isKeyDown: (key: string) => boolean
isKeyPressed: (key: string) => boolean
isKeyReleased: (key: string) => boolean
isMouseButtonDown: (button: number) => boolean
isMouseButtonPressed: (button: number) => boolean
isMouseButtonReleased: (button: number) => boolean
isMultiTouchEnabled: () => boolean
isPointerOverUI: () => boolean
isTouchActive: (id: number) => boolean
keysDown: Set<string>
keysPressed: Set<string>
keysPressedFixed: Set<string>
keysReleased: Set<string>
keysReleasedFixed: Set<string>
mouseButtons: Set<number>
mouseButtonsPressed: Set<number>
mouseButtonsPressedFixed: Set<number>
mouseButtonsReleased: Set<number>
mouseButtonsReleasedFixed: Set<number>
mouseDeltaX: number
mouseDeltaY: number
mouseX: number
mouseY: number
noteKeyDown: (code: string) => void
noteKeyUp: (code: string) => void
noteMouseDown: (button: number) => void
noteMouseUp: (button: number) => void
pointerOverUI: boolean
releaseGamepad: (index?: number) => void
removeVirtualSource: (owner: object) => void
scrollDeltaX: number
scrollDeltaY: number
setMultiTouch: (enabled: boolean) => void
setVirtual: (id: string, x: number, y?: number) => void
setVirtualSource: (owner: object, id: string, x: number, y?: number) => void
touchAvailable: boolean
touches: Map<number, TouchPoint>
touchesEnded: Map<number, TouchPoint>
touchesStarted: Map<number, TouchPoint>
updateGamepads: (snapshots: GamepadSnapshot[]) => void
static new (): InputState
static prototype: InputState

InstantiatePrefabOptions — interface @experimental

assetBaseUrl: string | undefined
assets: Assets | undefined
expandDeferred: boolean | undefined
overrides: PrefabOverride[] | undefined
parent: number | undefined

InstantiatePrefabResult — interface @beta

entities: Map<number, number>
root: number

Interactable — const @experimental

BuiltinComponentDef<InteractableData>

InteractableData — interface @experimental

blockRaycast: boolean
enabled: boolean
raycastTarget: boolean

InterpType — type @experimental

(typeof InterpType)[keyof typeof InterpType]

Joint3DShape — interface @experimental

anchor: Vec3 | null
axis: Vec3 | null
connectedAnchor: Vec3 | null
connectedEntity: number
enabled: boolean
limits: SwingTwistJoint3DData | SixDOFJoint3DData | undefined
type: string

JointMotion3D — const @experimental

{ readonly Locked: 0; readonly Limited: 1; readonly Free: 2; }

JointResolver — type @experimental

(root: Entity, path: string) => Entity | null

JsonResult — interface @experimental

data: T

JustifyContent — enum @experimental

Center = 1
End = 2
SpaceAround = 4
SpaceBetween = 3
SpaceEvenly = 5
Start = 0

Key — const @public

(code: string) => Binding

Keyframe — interface @experimental

inTangent: number
interpolation: InterpType | undefined
outTangent: number
time: number
value: number

Keys1D — const @public

(neg: string, pos: string) => Binding

Keys2D — const @public

(up: string, down: string, left: string, right: string) => Binding

KineticScroll — class @experimental

beginDrag: () => void
endDrag: () => void
getVelocity: () => Vec2
isCoasting: () => boolean
isDragging: () => boolean
killAxis: (axis: "x" | "y") => void
sample: (delta: Vec2, dt: number) => void
stop: () => void
tick: (dt: number) => Vec2
static new (opts?: KineticScrollOptions): KineticScroll
static prototype: KineticScroll

LIGHTMAP_RANGE — const @experimental

8

LIGHT_FORWARD — const @experimental

Readonly<Vec3>

LIGHT_TOKENS — const @experimental

ThemeTokens

LayerImage — interface @experimental

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

LayerOrder — enum @experimental

Depth = 2
Painter = 0
YSort = 1

LayerReach — interface @experimental

admits: (track: PoseTrack) => boolean

LayerSource — interface @experimental

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

LayerWeights — type @experimental

readonly number[]

LayoutProvider — interface @experimental

getContentSize: (count: number) => Vec2
getItemRect: (index: number) => Rect
getVisibleRange: (viewport: Rect, count: number) => [start: number, end: number]

LayoutWorld — type @experimental

ReadableWorld & Pick<World, 'getCppRegistry' | 'getWasmModule'>

Lifecycle — const @experimental

ResourceDef<LifecycleManager>

LifecycleEvent — type @experimental

'show' | 'hide' | 'pause' | 'resume'

LifecycleListener — type @experimental

(event: LifecycleEvent) => void

LifecycleManager — class @experimental

@internal emit_: (event: LifecycleEvent) => void
@internal setFocused_: (v: boolean) => void
@internal setVisible_: (v: boolean) => void
autoPause: boolean
focused: boolean
off: (listener: LifecycleListener) => void
on: (listener: LifecycleListener) => () => void
removeAllListeners: () => void
visible: boolean
static new (autoPause?: boolean): LifecycleManager
static prototype: LifecycleManager

LifecyclePlugin — class @experimental

build: (app: App) => void
cleanup: () => void
name: string
static new (options_?: LifecyclePluginOptions | undefined): LifecyclePlugin
static prototype: LifecyclePlugin

LifecyclePluginOptions — interface @experimental

autoPause: boolean | undefined

Light — const @experimental

BuiltinComponentDef<LightData>

LightData — interface @experimental

aimFollowedSun: boolean
bakedTint: Color
color: Color
cookie: number
cookieSize: Vec2
diffuseScale: number
diffuseTint: Color
drawEnvironment: boolean
enabled: boolean
environment: number
environmentRotation: number
falloff: number
followEnvironmentSun: boolean
groundColor: Color
hemisphere: boolean
innerAngle: number
innerRadius: number
intensity: number
inverseSquare: boolean
layerMax: number | undefined
layerMin: number | undefined
meshShadows: boolean
outerAngle: number
radius: number
reflectionSaturation: number
reflectionScale: number
shadowDistance: number
shadowExtent: number
shadowSoftness: number
shadowStrength: number
sourceAngle: number
type: LightType

LightProbeVolume — const @experimental

BuiltinComponentDef<LightProbeVolumeData>

LightProbeVolumeData — interface @experimental

capture: boolean
captureInterval: number
enabled: boolean
halfExtents: Vec3
probes: number
spacing: number

LightStatus — interface @experimental

accepted: boolean
environmentSunAim: [number, number, number] | null
limit: number
refusal: "capacity" | "no-environment-sun" | "none"
refusedCount: number
requested: number

LightType — enum @experimental

Ambient = 2
Directional = 1
Point = 0
Spot = 3

LineCap — type @experimental

'butt' | 'round' | 'square'

LineJoin — type @experimental

'miter' | 'round' | 'bevel'

LinearFillDirection — type @experimental

'right' | 'left' | 'up' | 'down'

LinearLayoutProvider — class @experimental

getContentSize: (count: number) => Vec2
getItemRect: (index: number) => Rect
getVisibleRange: (viewport: Rect, count: number) => [number, number]
static new (opts: LinearLayoutOptions): LinearLayoutProvider
static prototype: LinearLayoutProvider

ListItemTemplate — interface @experimental

bind: (entity: Entity, data: T, index: number) => void
create: (world: World, parent: Entity) => Entity

ListLayoutSpec — type @experimental

| { itemHeight: number | ((index: number) => number); spacing?: number; direction?: 'column' }
    | { itemWidth: number; spacing?: number; direction: 'row' }
    | { columns: number; itemSize: Vec2; spacing?: Vec2 }

ListView — class @experimental

dispose: () => void
getContentSize: () => Vec2
getMountedCount: () => number
getViewport: () => Rect
getVisibleRange: () => [number, number]
refresh: () => void
setScrollOffset: (offset: Vec2) => void
setViewportSize: (size: Vec2) => void
update: () => void
static new <T = unknown>(opts: ListViewOptions<T>): ListView<T>
static prototype: ListView<any>

ListViewHandle — interface @experimental

content: number
data: DataSource<T>
dispose: () => void
entity: number
mountedCount: () => number
refresh: () => void
scroll: ScrollContainer
scrollToIndex: (index: number) => void
view: ListView<T>

ListViewHost — interface @experimental

attachScrollContainer: (entity: Entity, container: ScrollContainer) => void
detachScrollContainer: (entity: Entity) => void
registerListView: (list: ListView<unknown>) => void
unregisterListView: (list: ListView<unknown>) => void

ListViewOptions — interface @experimental

dataSource: DataSource<T>
layout: LayoutProvider
onItemBound: ((entity: Entity, data: T, index: number) => void) | undefined
parent: number
placeItem: ((world: World, entity: Entity, rect: Rect, index: number) => void) | undefined
recycleBuffer: number | undefined
setVisible: ((world: World, entity: Entity, visible: boolean) => void) | undefined
templates: Record<string, ListViewItemTemplate<T>>
viewportSize: Vec2
world: World

ListenOptions — interface @public

gamepad: boolean | undefined
keyboard: boolean | undefined
mouse: boolean | undefined

LiveBindings — const @beta

ResourceDef<LiveBindingsData>

LiveBindingsData — interface @beta

settled: () => Promise<void>

LoadRuntimeSceneOptions — interface @experimental

app: App
externalEntities: ReadonlyMap<number, number> | undefined
module: ESEngineModule | null
onPhase: ((phase: string, ms: number) => void) | undefined
physics3dBackend: Physics3DBackend | undefined
physics3dModule: Physics3DWasmModule | undefined
physics3dWorld: Partial<Physics3DWorldConfig> | undefined
physicsConfig: Physics2DPluginConfig | undefined
physicsEnabled: boolean | undefined
physicsModule: PhysicsWasmModule | null | undefined
sceneData: SceneData
sceneName: string | undefined
source: RuntimeAssetSource
spineManager: SpineManager | null | undefined
spineModule: SpineWasmModule | null | undefined
uiTheme: "dark" | "light" | undefined
uiThemeOverrides: ThemeOverrides | undefined

LocalTransform — const @experimental @deprecated

BuiltinComponentDef<TransformData>

LocalTransformData — type @experimental

TransformData

LocaleCatalog — type @experimental

Record<string, LocaleEntry>

LocaleEntry — type @experimental

string | PluralForms

LocaleResult — interface @experimental

keyCount: number
locale: string

LocaleTableAsset — interface @experimental

entries: LocaleCatalog
locale: string
version: number

Localization — const @experimental

ResourceDef<LocalizationAPI>

LocalizationAPI — class @experimental

addCatalog: (locale: string, entries: LocaleCatalog) => void
availableLocales: () => string[]
fallbackLocale: string
has: (key: string) => boolean
locale: string
setFallbackLocale: (locale: string) => void
setLocale: (locale: string) => void
setPluralSelector: (locale: string, selector: PluralSelector) => void
setPseudoLocalization: (options: PseudoLocalizationOptions | null) => void
t: (key: string, params?: TParams) => string
static new (locale?: string, fallback?: string): LocalizationAPI
static prototype: LocalizationAPI

LocalizationOptions — interface @experimental

catalogs: Record<string, LocaleCatalog> | undefined
fallback: string | undefined
locale: string | undefined
tables: string[] | undefined

LocalizationPlugin — class @experimental

build: (app: App) => void
name: string
static new (opts?: LocalizationOptions): LocalizationPlugin
static prototype: LocalizationPlugin

LodDecision — interface @experimental

level: number | null
levels: number
screenSize: number
unbiased: number | null

LogEntry — interface @experimental

category: string
data: unknown
level: LogLevel
message: string
timestamp: number

LogHandler — interface @experimental

handle: (entry: LogEntry) => void

LogLevel — enum @experimental

Debug = 0
Error = 3
Info = 1
Warn = 2

Logger — class @experimental

addHandler: (handler: LogHandler) => void
clearHandlers: () => void
debug: (category: string, message: string, data?: unknown) => void
error: (category: string, message: string, data?: unknown) => void
info: (category: string, message: string, data?: unknown) => void
removeHandler: (handler: LogHandler) => void
setMinLevel: (level: LogLevel) => void
warn: (category: string, message: string, data?: unknown) => void
static new (): Logger
static prototype: Logger

LoginResult — interface @experimental

code: string

LoopMode — enum @experimental

None = 0
PingPong = 2
Restart = 1

MATERIAL_FORMAT_VERSION — const @experimental

"1.0"

MAX_POLYGON_VERTICES — const @experimental

8

MAX_PRESENT_WAIT_MS — const @experimental

50

MAX_SEQUENCE_DEPTH — const @experimental

4

MESH_MAX_BONES — const @experimental

256

MIN_CHAIN_POINTS — const @experimental

4

MIN_POLYGON_VERTICES — const @experimental

3

MOST_WATER_WAVES — const @experimental

8

ManifestModel — class @experimental

allAssets: () => AddressableManifestAsset[]
assetByKey: (key: string) => AddressableManifestAsset | null
assetByPath: (path: string) => AddressableManifestAsset | null
assetPathsInGroup: (name: string) => string[]
assetsByLabel: (label: string) => AddressableManifestAsset[]
assetsInGroup: (name: string) => AddressableManifestAsset[]
bundleMode: (name: string) => BundleMode
entries: () => Array<{ group: string; key: string; asset: AddressableManifestAsset; }>
findAsset: (pathOrAddress: string) => AddressableManifestAsset | null
group: (name: string) => AddressableManifestGroup | null
groupNames: () => string[]
groupsByMode: (mode: BundleMode) => string[]
packMembers: () => Map<string, Set<string>>
packOf: (path: string) => AssetPackRef | null
remoteAssetIdentity: (ref: string) => string | null
remoteAssetPath: (ref: string) => string | null
resolvePath: (ref: string) => string
revision: () => string | null
spineCullingLookup: () => (skeleton: string, atlas: string) => SpineCullingRect | undefined
textureImportLookup: () => (ref: string) => ParsedTextureImportSettings | undefined
static empty: () => ManifestModel
static fromJson: (manifest: AddressableManifest) => ManifestModel
static new (manifest: AddressableManifest): ManifestModel
static prototype: ManifestModel

Marker — const @experimental

ComponentDef<MarkerData>

MarkerData — interface @experimental

properties: Record<string, string>
type: string

MaskMode — enum @experimental

Scissor = 0
Stencil = 1

MaskReach — class @experimental

admits: (track: PoseTrack) => boolean
resolve: (world: Pick<World, "tryGet">, root: Entity, mask: AnimatorMask, resolveJoint: JointResolver) => void
static new (): MaskReach
static prototype: MaskReach

MaskRect — interface @experimental

dry: number
h: number
w: number
x: number
y: number

Material — const @experimental

{ createShader(vertexSrc: string, fragmentSrc: string): ShaderHandle; releaseShader(shader: ShaderHandle): void; create(options: MaterialOptions): MaterialHandle; compileShader(esshaderSource: string, features?: string[]): ShaderHandle; materialsDeclaring(param: string): MaterialHandle[]; noteProgram(shader: ShaderHandle, features: readonly string[], esshaderSource: string, compile: (features: string[]) => ShaderHandle): void; recompile(material: MaterialHandle, changes: Record<string, boolean>): boolean; getSwitch(material: MaterialHandle, name: string): boolean; setSwitch(material: MaterialHandle, name: string, on: boolean): void; get(material: MaterialHandle): MaterialData | undefined; getRenderState(material: MaterialHandle): Omit<ResolvedMaterial, "uniforms"> | null; applyState(material: MaterialHandle, state: Omit<MaterialOptions, "shader">, textureLeases?: ReadonlyMap<string, TextureLease>): void; setUniform(material: MaterialHandle, name: string, value: UniformValue): void; getUniform(material: MaterialHandle, name: string): UniformValue | undefined; setBlendMode(material: MaterialHandle, mode: BlendMode): void; getBlendMode(material: MaterialHandle): BlendMode; setDepthTest(material: MaterialHandle, enabled: boolean): void; setDepthWrite(material: MaterialHandle, enabled: boolean): void; setDepthBias(material: MaterialHandle, units: number): void; setCull(material: MaterialHandle, cull: CullMode): void; getShader(material: MaterialHandle): ShaderHandle; release(material: MaterialHandle): void; isValid(material: MaterialHandle): boolean; renderPreview(material: MaterialHandle, w: number, h: number, shape?: { mesh?: number; texture?: number; }): Promise<ImageData | null>; releaseAll(): void; createFromAsset(data: MaterialAssetData, shaderHandle: ShaderHandle, parentHandle?: MaterialHandle): MaterialHandle; createInstance(source: MaterialHandle): MaterialHandle; toAssetData(material: MaterialHandle, shaderPath: string, parentPath?: string): MaterialAssetData | null; getUniforms(material: MaterialHandle): Map<string, UniformValue>; tex(textureId: number, slot?: number): TextureRef; }

MaterialAssetData — interface @experimental

blendMode: number | undefined
cull: number | undefined
depthBias: number | undefined
depthTest: boolean | undefined
depthWrite: boolean | undefined
instanceOf: string | undefined
properties: Record<string, unknown>
shader: string
switches: Record<string, boolean> | undefined
type: "material"
version: string

MaterialData — interface @experimental

blendMode: BlendMode
cachedBuffer_: Float32Array<ArrayBufferLike> | null
cachedIdx_: number
cull: CullMode
depthBias: number
depthTest: boolean
depthWrite: boolean
dirty_: boolean
overrides: Set<string>
ownShader: number | undefined
parent: number | undefined
pushed_: boolean | undefined
sent_: Map<string, number[]> | undefined
shader: number
switches: Record<string, boolean>
uniforms: Map<string, UniformValue>

MaterialGraph — interface @beta

domain: string | undefined
kind: "subgraph" | undefined
name: string | undefined
nodes: MaterialGraphNode[]
output: string

MaterialGraphNode — interface @beta

id: string
inputs: Record<string, string> | undefined
params: Record<string, unknown> | undefined
type: GraphNodeType
x: number | undefined
y: number | undefined

MaterialHandle — type @experimental

number

MaterialOptions — interface @experimental

blendMode: BlendMode | undefined
cull: CullMode | undefined
depthBias: number | undefined
depthTest: boolean | undefined
depthWrite: boolean | undefined
shader: number
switches: Record<string, boolean> | undefined
uniforms: Record<string, UniformValue> | undefined

MeasureTextOptions — interface @experimental

bold: boolean | undefined
fontFamily: string | undefined
fontSize: number
italic: boolean | undefined
letterSpacing: number | undefined
lineHeight: number | undefined
maxWidth: number | undefined

MeasuredLinearLayoutProvider — class @experimental

getContentSize: (count: number) => Vec2
getItemRect: (index: number) => Rect
getVisibleRange: (viewport: Rect, count: number) => [number, number]
invalidate: () => void
static new (opts: MeasuredLinearLayoutOptions): MeasuredLinearLayoutProvider
static prototype: MeasuredLinearLayoutProvider

MeshChannel — const @experimental

{ readonly Position: 0; readonly Color: 1; readonly TexCoord0: 2; readonly Normal: 3; readonly Tangent: 4; readonly Joints: 5; readonly Weights: 6; readonly TexCoord1: 7; }

MeshChannelDesc — interface @experimental

components: number
offset: number
semantic: number
type: number

MeshChannelType — const @experimental

{ readonly Float32: 0; readonly UNorm8: 1; readonly UInt16: 2; }

MeshCollider3D — const @experimental

BuiltinComponentDef<MeshCollider3DData>

MeshCollider3DData — interface @experimental

enabled: boolean
friction: number
layer: number
mesh: number
restitution: number

MeshData — interface @experimental

aabbMax: [number, number, number]
aabbMin: [number, number, number]
channels: MeshChannelDesc[]
indices: Uint32Array<ArrayBufferLike>
inverseBindMatrices: Float32Array<ArrayBufferLike> | undefined
morph: MeshMorphTargets | undefined
vertexCount: number
vertexStride: number
vertices: Uint8Array<ArrayBufferLike>

MeshMorphTargets — interface @experimental

deltas: Float32Array<ArrayBufferLike>
hasNormals: boolean
names: string[]

MeshRenderer — const @experimental

BuiltinComponentDef<MeshRendererData>

MeshRendererAPI — class @experimental

clearGeometry: (entity: Entity) => void
getGeometry: (entity: Entity) => MeshRendererGeometry | undefined
setGeometry: (entity: Entity, geometry: MeshRendererGeometry) => void
static new (module_: NonNullable<EngineApi>, registry_: CppRegistry): MeshRendererAPI
static prototype: MeshRendererAPI

MeshRendererData — interface @experimental

castShadows: boolean
color: Color
cullBackfaces: boolean
enabled: boolean
geometry: MeshRendererGeometry
layer: number
lit: boolean
material: number
mesh: number
normalMap: number
opaque: boolean
parallax: Vec2
texture: number

MeshRendererGeometry — interface @experimental

colors: number[] | undefined
indices: number[]
positions: number[]
uvs: number[] | undefined

MeshRendererPlugin — class @experimental

build: (app: App) => void
cleanup: () => void
name: string
profileDomain: "render"
static new (): MeshRendererPlugin
static prototype: MeshRendererPlugin

MeshRenderers — const @experimental

ResourceDef<MeshRendererAPI>

MeshResult — interface @experimental

handle: number

MigrationResult — interface @experimental

data: PrefabData
fromVersion: string
migrated: boolean
toVersion: string

MiniGameSocket — class @experimental

close: (code?: number, reason?: string) => void
connect: () => void
delivery: "reliable-ordered"
on: <K extends keyof PlatformSocketEvents>(event: K, handler: (...args: PlatformSocketEvents[K]) => void) => () => void
readyState: PlatformSocketReadyState
send: (data: string | ArrayBuffer) => void
static new (options: GameSocketOptions, global: MiniGameGlobal): MiniGameSocket
static prototype: MiniGameSocket

MissingAssetCallback — type @experimental

(missing: MissingAsset[]) => void

MissingAssetsError — class @experimental

missing: MissingAsset[]
static new (missing: MissingAsset[]): MissingAssetsError
static prototype: MissingAssetsError

MockAdProviderOptions — interface @experimental

completed: boolean | undefined
durationMs: number | undefined

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

Modifiers — interface @experimental

alt: boolean
ctrl: boolean
meta: boolean
shift: boolean

MotionContext — interface @experimental

borrowDelta: () => RootMotionDelta
borrowMix: () => WeightedPose[]
borrowPose: () => Pose
drive: (motion: AnimatorMotion, enter: boolean) => void
duration: (motion: AnimatorMotion) => number
entity: number
events: (motion: AnimatorMotion, span: MotionSpan, out: MotionEvent[]) => void
extractRootMotion: boolean
finished: (motion: AnimatorMotion) => boolean
loops: (motion: AnimatorMotion) => boolean
params: Readonly<Record<string, number | boolean>>
releaseDelta: (delta: RootMotionDelta) => void
releaseMix: (mix: WeightedPose[]) => void
releasePose: (pose: Pose) => void
resolveJoint: JointResolver
rootDelta: (motion: AnimatorMotion, span: MotionSpan, out: RootMotionDelta) => boolean
sample: (motion: AnimatorMotion, time: number, pose: Pose) => boolean
world: World

MotionDriver — interface @experimental

apply: ((ctx: MotionContext, motion: M, enter: boolean) => void) | undefined
duration: ((ctx: MotionContext, motion: M) => number) | undefined
events: ((ctx: MotionContext, motion: M, span: MotionSpan, out: MotionEvent[]) => void) | undefined
isFinished: ((ctx: MotionContext, motion: M) => boolean) | undefined
loops: ((ctx: MotionContext, motion: M) => boolean) | undefined
rootMotion: ((ctx: MotionContext, motion: M, span: MotionSpan, out: RootMotionDelta) => boolean) | undefined
sample: ((ctx: MotionContext, motion: M, time: number, pose: Pose) => boolean) | undefined

MotionEvent — interface @experimental

name: string
text: string
value: number

MotionOptions — interface @experimental

accelerometer: boolean | undefined
gyroscope: boolean | undefined
orientation: boolean | undefined
rate: MotionRate | undefined

MotionRate — type @experimental

'normal' | 'ui' | 'game'

MotionRegistry — class @experimental

context: (world: World, entity: Entity, params: MotionParams, resolveJoint?: JointResolver) => MotionContext
driverFor: (motion: AnimatorMotion) => MotionDriver | undefined
has: (kind: string) => boolean
register: <M extends AnimatorMotion>(kind: M["kind"], driver: MotionDriver<M>) => void
unregister: (kind: string) => void
static new (): MotionRegistry
static prototype: MotionRegistry

MotionSample — interface @experimental

acceleration: Vec3 | null
accelerationIncludingGravity: Vec3 | null
gravity: Vec3 | null
gyroscope: Vec3 | null
orientation: Vec3 | null
timestamp: number

MotionSpan — interface @experimental

from: number
inclusiveStart: boolean
to: number

MotorJoint2D — const @experimental

ComponentDef<MotorJoint2DData>

MouseButton — const @public

((button: number) => Binding) & { readonly Left: 0; readonly Middle: 1; readonly Right: 2; }

Mut — function @public

<T extends AnyComponentDef>(component: T): MutWrapper<T>

MutWrapper — interface @public

@internal _component: T
@internal _type: "mut"

NODE_SPECS — const @beta

Record<GraphNodeType, NodeSpec>

NOISE_PROVIDER — const @experimental

"estella:noise"

Name — const @public

ComponentDef<NameData>

NameData — interface @public

value: string

NativeChannel — const @experimental

NativeChannelApi

NativeChannelApi — interface @experimental

available: boolean
call: <T = unknown>(method: string, args?: unknown) => Promise<T>
has: (method: string) => boolean
on: <T = unknown>(event: string, handler: (data: T) => void) => () => void

NestedPrefabRef — interface @experimental

overrides: PrefabOverride[]
prefabPath: string

NetTransport — interface @experimental

on: (event: "message", handler: (data: string | ArrayBuffer) => void) => () => void
send: (data: string | ArrayBuffer) => void

NextFrame — type @experimental

() => Promise<void>

NodeParamSpec — interface @beta

key: string
kind: "bool" | "channel" | "color" | "float" | "text" | "texture"
label: string

NodePort — interface @beta

name: string
type: GraphType

NodeSpec — interface @beta

addable: boolean
inputs: NodePort[]
label: string
output: GraphType | null
params: NodeParamSpec[]

NodeVisibility — const @experimental

ComponentDef<{ visible: boolean; }>

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

Not — function @experimental

(filter: FilterExpr): FilterExpr

Occluder — const @experimental

BuiltinComponentDef<OccluderData>

OccluderData — interface @beta

enabled: boolean
halfExtents: Vec3

OneWayPlatform2D — const @experimental

ComponentDef<OneWayPlatform2DData>

Or — function @experimental

(...filters: FilterExpr[]): FilterExpr

OutlineFilterOptions — interface @experimental

color: { r: number; g: number; b: number; a: number; } | undefined
texelSize: { x: number; y: number; } | undefined
width: number | undefined

OutputTransform — type @experimental

'none' | 'aces' | 'neutral'

PAGE_SIDE — const @experimental

number

PAGE_TEXELS — const @experimental

number

PATCH_CELLS — const @experimental

32

PREFAB_FORMAT_VERSION — const @experimental

"2"

PROFILE_CAPTURE_VERSION — const @experimental

1

PTR_LAYOUTS — const @experimental

Record<string, PtrLayout>

PackagedAssetIndex — interface @experimental

addressOf: (ref: string) => string | null
assetPaths: () => string[]
catalog: Catalog | undefined
manifest: AddressableManifest
model: ManifestModel
resolvePath: (ref: string) => string
spineCulling: (skeleton: string, atlas: string) => SpineCullingRect | undefined
textureImport: (ref: string) => ParsedTextureImportSettings | undefined

PackagedAssetSourceOptions — interface @experimental

backend: Backend | undefined
decodePixels: ((path: string, flip: boolean, maxEdge?: number) => Promise<{ width: number; height: number; pixels: Uint8Array; }>) | undefined

PackagedGameConfig — interface @experimental

achievements: string[] | undefined
aot: { module: string; manifest: AotManifest; } | undefined
audioConfig: AudioProjectConfig | undefined
colorSpace: "gamma" | "linear" | undefined
debugChannel: DebugChannelConfig | undefined
depthLayers: number | undefined
engineBytes: number | undefined
engineJs: boolean | undefined
entryScene: string
hotUpdate: { remoteRoot?: string; persistUpdateKey?: string; } | undefined
leaderboardEncryptionKey: string | undefined
msaaSamples: number | undefined
outputTransform: "aces" | "neutral" | "none" | undefined
physics3dBackend: Physics3DBackend | undefined
physics3dWorld: Partial<Physics3DWorldConfig> | undefined
physicsConfig: Physics2DPluginConfig | undefined
physicsEnabled: boolean | undefined
quality: QualityConfig | undefined
renderBackend: "webgl2" | "webgpu" | undefined
runtime: RuntimeBuildConfig | undefined
scenes: { name: string; path: string; }[] | undefined
screenFit: { designWidth: number; designHeight: number; scaleMode: number; matchWidthOrHeight: number; } | undefined
scripts: string | undefined
sideModules: { id: string; file: string; globalName?: string; }[] | undefined
steamAppId: number | undefined
uiTheme: "light" | undefined
uiThemeColors: Record<string, string> | undefined
webChannel: "crazygames" | "poki" | "youtube" | undefined
worlds: { scene: string; manifest: string; }[] | undefined
ySortLayers: number | undefined

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

PageDef — interface @experimental

mount: number | (() => Entity) | undefined
onClose: "destroy" | "keep" | undefined
overrides: PrefabOverride[] | undefined
parent: number | (() => Entity) | undefined
prefab: string

PageHandle — interface @experimental

find: (name: string) => Entity | undefined
has: (name: string) => boolean
id: string
names: () => IterableIterator<string>
root: 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

Panorama — interface @experimental

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

Parent — const @public

BuiltinComponentDef<ParentData>

ParentData — interface @public

entity: number

ParsedTextureImportSettings — interface @experimental

filter: "linear" | "nearest" | undefined
mipmaps: boolean | undefined
sliceBorder: { left: number; right: number; top: number; bottom: number; } | undefined
srgb: boolean | undefined
wrap: "clamp" | "mirror" | "repeat" | undefined

Particle — const @experimental

ResourceDef<ParticleAPI>

ParticleAPI — class @experimental

@internal collisionContacts: readonly ParticleCollisionEventPayload[]
collisionError: string | null
collisionEvents: readonly ParticleCollisionEventPayload[]
collisionStats: readonly ParticleCollisionStats[]
debugNormals: boolean
emitAt: (entity: Entity, count: number, position: { x: number; y: number; z: number; }, options?: { normal?: { x: number; y: number; z: number; }; velocity?: { x: number; y: number; z: number; }; }) => number
getAliveCount: (entity: Entity) => number
play: (entity: Entity) => void
reset: (entity: Entity) => void
setBursts: (entity: Entity, bursts: readonly { time: number; count: number; }[] | null) => void
setCollisionBudget: (budget: Partial<ParticleCollisionBudget>) => void
setColorLut: (entity: Entity, lut: Float32Array | null) => void
setSizeLut: (entity: Entity, lut: Float32Array | null) => void
setSpeedLut: (entity: Entity, lut: Float32Array | null) => void
stop: (entity: Entity) => void
update: (dt: number) => void
static new (module: NonNullable<EngineApi>, registry: CppRegistry, resolve?: ParticleQueryResolver): ParticleAPI
static prototype: ParticleAPI

ParticleCollider — const @experimental

BuiltinComponentDef<ParticleColliderData>

ParticleColliderData — interface @beta

enabled: boolean
halfExtents: Vec3
halfHeight: number
inverted: boolean
mask: number
radius: number
shape: ParticleColliderShape

ParticleColliderShape — enum @beta

Box = 1
Capsule = 2
Sphere = 0

ParticleCollisionBudget — interface @beta

events: number
queries: number

ParticleCollisionEvent — const @beta

EventDef<ParticleCollisionEventPayload>

ParticleCollisionEventPayload — interface @beta

body: number
emitter: number
mode: number
normalX: number
normalY: number
normalZ: number
particle: number
velocityX: number
velocityY: number
velocityZ: number
x: number
y: number
z: number

ParticleCollisionFallback — enum @beta

Floor = 0
Skip = 1

ParticleCollisionMode — enum @beta

Depth = 3
Floor = 0
Physics2D = 1
Physics3D = 2
Sdf = 4

ParticleCollisionStats — interface @beta

budgetSkipped: number
distanceSkipped: number
emitter: number
eventDropped: number
events: number
fallbacks: number
hits: number
mode: number
queries: number
unavailable: number

ParticleEasing — enum @beta

EaseIn = 1
EaseInOut = 3
EaseOut = 2
Linear = 0

ParticleEmitter — const @beta

BuiltinComponentDef<ParticleEmitterData>

ParticleEmitterData — interface @beta

addedVelocityMax: Vec3
addedVelocityMin: Vec3
angleSpreadMax: number
angleSpreadMin: number
angularVelocityMax: number
angularVelocityMin: number
blendMode: number
burstCount: number
burstInterval: number
bursts: { time: number; count: number; }[]
collisionBounce: number
collisionEnabled: boolean
collisionEventBudget: number
collisionEvents: boolean
collisionFallback: ParticleCollisionFallback
collisionFloor: number
collisionFriction: number
collisionLifetimeLoss: number
collisionMask: number
collisionMaxDistance: number
collisionMode: ParticleCollisionMode
collisionQueryBudget: number
collisionThickness: number
colorEasing: ParticleEasing
colorGradient: { stops: { t: number; color: Color; }[]; }
damping: number
duration: number
enabled: boolean
endColor: Color
endSizeMax: number
endSizeMin: number
gpuSimulation: boolean
gravity: Vec3
layer: number
lengthScale: number
lifetimeMax: number
lifetimeMin: number
limitDampen: number
looping: boolean
material: number
maxParticles: number
noiseFrequency: number
noiseOctaves: number
noiseScrollSpeed: number
noiseStrength: number
playOnStart: boolean
rate: number
renderMode: ParticleRenderMode
rotationMax: number
rotationMin: number
shape: EmitterShape
shapeAngle: number
shapeRadius: number
shapeSize: Vec3
simulationSpace: SimulationSpace
simulationSpeed: number
sizeCurve: { keys: { t: number; v: number; }[]; }
sizeEasing: ParticleEasing
speedLimit: number
speedMax: number
speedMin: number
spriteColumns: number
spriteFPS: number
spriteLoop: boolean
spriteRows: number
startColor: Color
startDelay: number
startSizeMax: number
startSizeMin: number
subEmitter: number
subEmitterChance: number
subEmitterInheritVelocity: number
subEmitterTrigger: SubEmitterTrigger
texture: number
trailEnabled: boolean
trailMinDistance: number
trailPoints: number
trailWidth: number
velocityScale: number

ParticleForceField — const @experimental

BuiltinComponentDef<ParticleForceFieldData>

ParticleForceFieldData — interface @experimental

direction: Vec3
enabled: boolean
falloff: boolean
radius: number
strength: number
type: ForceFieldType

ParticleModelUnits — const @experimental

ComponentDef<{ startSizeMin: number; startSizeMax: number; endSizeMin: number; endSizeMax: number; speedMin: number; speedMax: number; gravity: Vec3; }>

ParticlePlugin — class @experimental

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

ParticleRenderMode — enum @beta

Billboard = 0
Stretched = 1

PartitionOptions — interface @experimental

entityFieldsOf: (componentType: string) => readonly string[]
resolvePrefab: ((ref: string) => PrefabRoot | null) | undefined

PartitionedCell — interface @experimental

data: SceneData
entityCount: number
maxX: number
maxZ: number
minX: number
minZ: number
name: string
rootCount: number
x: number
z: number

PathColor — type @experimental

readonly [number, number, number, number]

PathFill — interface @experimental

color: PathColor
holes: readonly (readonly Vec2[])[] | undefined

PathFollower — const @experimental

ComponentDef<PathFollowerData>

PathFollowerData — interface @experimental

distance: number
mode: number
orient: number
playing: boolean
speed: number
spline: number

PathMode — const @experimental

{ readonly Once: 0; readonly Loop: 1; readonly PingPong: 2; }

PathOrient — const @experimental

{ readonly None: 0; readonly FaceXZ: 1; readonly FaceXY: 2; }

PathStroke — interface @experimental

cap: LineCap | undefined
color: PathColor
join: LineJoin | undefined
miterLimit: number | undefined
width: number

PathStyle — interface @experimental

arcStep: number | undefined
closed: boolean | undefined
feather: number | undefined
fill: PathFill | undefined
stroke: PathStroke | undefined

Physics2D — const @beta

ResourceDef<Physics2DAPI>

Physics2DContactEventData — interface @experimental

approachSpeed: number | undefined
isSensor: boolean | undefined
other: number

Physics2DEventType — type @experimental

typeof Physics2DEventType[keyof typeof Physics2DEventType]

Physics2DEvents — const @beta

ResourceDef<Physics2DEventsData>

Physics2DEventsData — interface @beta

collisionEnters: CollisionEnterEvent[]
collisionExits: { entityA: Entity; entityB: Entity; }[]
collisionHits: CollisionHitEvent[]
sensorEnters: SensorEvent[]
sensorExits: SensorEvent[]

Physics2DPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
name: string
static new (wasmUrl: string, config?: Physics2DPluginConfig, factory?: PhysicsModuleFactory): Physics2DPlugin
static prototype: Physics2DPlugin

Physics2DPluginConfig — interface @experimental

collisionLayerMasks: number[] | undefined
contactDampingRatio: number | undefined
contactHertz: number | undefined
contactSpeed: number | undefined
enableContinuous: boolean | undefined
enableSleep: boolean | undefined
fixedTimestep: number | undefined
gravity: Vec2 | undefined
maxLinearSpeed: number | undefined
restitutionThreshold: number | undefined
subStepCount: number | undefined

Physics3D — const @experimental

ResourceDef<Physics3DQueries | null>

Physics3DBackend — type @experimental

'jolt' | 'physx'

Physics3DDebugDraw — const @experimental

ResourceDef<Physics3DDebugDrawConfig>

Physics3DDebugDrawConfig — interface @experimental

enabled: boolean
showColliders: boolean
showContacts: boolean

Physics3DEvents — const @experimental

ResourceDef<Physics3DEventsData>

Physics3DPlugin — class @experimental

build: (app: App) => void
cleanup: () => void
name: string
static new (wasmUrl: string, config?: Partial<Physics3DConfig>, factory?: Physics3DModuleFactory): Physics3DPlugin
static prototype: Physics3DPlugin

Physics3DWorldConfig — interface @experimental

bounceThreshold: number
collisionSteps: number
enableSleep: boolean
gravity: Vec3
maxBodies: number
positionIterations: number
unitsPerMeter: number
velocityIterations: number

PhysicsModuleFactory — type @experimental

(config?: Record<string, unknown>) => Promise<PhysicsWasmModule>

PhysicsWasmModule — interface @experimental

HEAPF32: Float32Array<ArrayBufferLike>
HEAPU32: Uint32Array<ArrayBufferLike>
HEAPU8: Uint8Array<ArrayBufferLike>
_free: (ptr: number) => void
_malloc: (size: number) => number
_physics_addBoxShape: (entityId: number, halfW: number, halfH: number, offX: number, offY: number, radius: number, density: number, friction: number, restitution: number, isSensor: number, categoryBits: number, maskBits: number) => void
_physics_addCapsuleShape: (entityId: number, radius: number, halfHeight: number, offX: number, offY: number, density: number, friction: number, restitution: number, isSensor: number, categoryBits: number, maskBits: number) => void
_physics_addChainShape: (entityId: number, pointsPtr: number, pointCount: number, isLoop: number, friction: number, restitution: number, categoryBits: number, maskBits: number) => void
_physics_addCircleShape: (entityId: number, radius: number, offX: number, offY: number, density: number, friction: number, restitution: number, isSensor: number, categoryBits: number, maskBits: number) => void
_physics_addPolygonShape: (entityId: number, verticesPtr: number, vertexCount: number, radius: number, density: number, friction: number, restitution: number, isSensor: number, categoryBits: number, maskBits: number) => void
_physics_addSegmentShape: (entityId: number, x1: number, y1: number, x2: number, y2: number, density: number, friction: number, restitution: number, isSensor: number, categoryBits: number, maskBits: number) => void
_physics_applyAngularImpulse: (entityId: number, impulse: number) => void
_physics_applyForce: (entityId: number, forceX: number, forceY: number) => void
_physics_applyImpulse: (entityId: number, impulseX: number, impulseY: number) => void
_physics_applyTorque: (entityId: number, torque: number) => void
_physics_capturePoses: () => void
_physics_clearShapes: (entityId: number) => void
_physics_collectEvents: () => void
_physics_createBody: (entityId: number, bodyType: number, x: number, y: number, angle: number, gravityScale: number, linearDamping: number, angularDamping: number, fixedRotation: number, bullet: number) => void
_physics_createDistanceJoint: (entityIdA: number, entityIdB: number, anchorAx: number, anchorAy: number, anchorBx: number, anchorBy: number, length: number, enableSpring: number, hertz: number, dampingRatio: number, enableLimit: number, minLength: number, maxLength: number, enableMotor: number, maxMotorForce: number, motorSpeed: number, collideConnected: number) => number
_physics_createMotorJoint: (entityIdA: number, entityIdB: number, linearVelX: number, linearVelY: number, maxVelocityForce: number, angularVelocity: number, maxVelocityTorque: number, linearHertz: number, linearDampingRatio: number, maxSpringForce: number, angularHertz: number, angularDampingRatio: number, maxSpringTorque: number, collideConnected: number) => number
_physics_createMouseJoint: (entityId: number, targetX: number, targetY: number, hertz: number, dampingRatio: number, maxForce: number) => number
_physics_createPrismaticJoint: (entityIdA: number, entityIdB: number, anchorAx: number, anchorAy: number, anchorBx: number, anchorBy: number, axisX: number, axisY: number, enableSpring: number, hertz: number, dampingRatio: number, enableLimit: number, lowerTranslation: number, upperTranslation: number, enableMotor: number, maxMotorForce: number, motorSpeed: number, collideConnected: number) => number
_physics_createRevoluteJoint: (entityIdA: number, entityIdB: number, anchorAx: number, anchorAy: number, anchorBx: number, anchorBy: number, enableMotor: number, motorSpeed: number, maxMotorTorque: number, enableLimit: number, lowerAngle: number, upperAngle: number, collideConnected: number) => number
_physics_createWeldJoint: (entityIdA: number, entityIdB: number, anchorAx: number, anchorAy: number, anchorBx: number, anchorBy: number, linearHertz: number, angularHertz: number, linearDampingRatio: number, angularDampingRatio: number, collideConnected: number) => number
_physics_createWheelJoint: (entityIdA: number, entityIdB: number, anchorAx: number, anchorAy: number, anchorBx: number, anchorBy: number, axisX: number, axisY: number, enableSpring: number, hertz: number, dampingRatio: number, enableLimit: number, lowerTranslation: number, upperTranslation: number, enableMotor: number, maxMotorTorque: number, motorSpeed: number, collideConnected: number) => number
_physics_destroyBody: (entityId: number) => void
_physics_destroyJoint: (entityId: number) => void
_physics_destroyMouseJoint: () => void
_physics_enableDistanceJointLimit: (entityId: number, enable: number) => void
_physics_enableDistanceJointMotor: (entityId: number, enable: number) => void
_physics_enableDistanceJointSpring: (entityId: number, enable: number) => void
_physics_enablePrismaticJointLimit: (entityId: number, enable: number) => void
_physics_enablePrismaticJointMotor: (entityId: number, enable: number) => void
_physics_enablePrismaticJointSpring: (entityId: number, enable: number) => void
_physics_enableRevoluteLimit: (entityId: number, enable: number) => void
_physics_enableRevoluteMotor: (entityId: number, enable: number) => void
_physics_enableWheelJointLimit: (entityId: number, enable: number) => void
_physics_enableWheelJointMotor: (entityId: number, enable: number) => void
_physics_enableWheelJointSpring: (entityId: number, enable: number) => void
_physics_getAngularVelocity: (entityId: number) => number
_physics_getBodyCenterOfMass: (entityId: number) => number
_physics_getBodyCount: () => number
_physics_getBodyInertia: (entityId: number) => number
_physics_getBodyMass: (entityId: number) => number
_physics_getCollisionEnterBuffer: () => number
_physics_getCollisionEnterCount: () => number
_physics_getCollisionExitBuffer: () => number
_physics_getCollisionExitCount: () => number
_physics_getDistanceJointCurrentLength: (entityId: number) => number
_physics_getDistanceJointLength: (entityId: number) => number
_physics_getDistanceJointMotorForce: (entityId: number) => number
_physics_getDynamicBodyCount: () => number
_physics_getDynamicBodyTransforms: () => number
_physics_getGravity: () => number
_physics_getHitEventBuffer: () => number
_physics_getHitEventCount: () => number
_physics_getInterpolatedCount: () => number
_physics_getInterpolatedTransforms: (alpha: number) => number
_physics_getJointCount: () => number
_physics_getLinearVelocity: (entityId: number) => number
_physics_getMoveCharacterBuffer: () => number
_physics_getOverlapBuffer: () => number
_physics_getPrismaticJointMotorForce: (entityId: number) => number
_physics_getPrismaticJointSpeed: (entityId: number) => number
_physics_getPrismaticJointTranslation: (entityId: number) => number
_physics_getRaycastBuffer: () => number
_physics_getRevoluteAngle: (entityId: number) => number
_physics_getRevoluteMotorTorque: (entityId: number) => number
_physics_getSensorEnterBuffer: () => number
_physics_getSensorEnterCount: () => number
_physics_getSensorExitBuffer: () => number
_physics_getSensorExitCount: () => number
_physics_getShapeCastBuffer: () => number
_physics_getShapeCount: () => number
_physics_getTrackingRows: () => number
_physics_getWheelJointMotorTorque: (entityId: number) => number
_physics_hasBody: (entityId: number) => number
_physics_hasJoint: (entityId: number) => number
_physics_hasMouseJoint: () => number
_physics_init: (gx: number, gy: number, timestep: number, substeps: number, contactHertz: number, contactDampingRatio: number, contactSpeed: number) => void
_physics_isAwake: (entityId: number) => number
_physics_moveCharacter: (px: number, py: number, c1x: number, c1y: number, c2x: number, c2y: number, radius: number, velX: number, velY: number, dt: number, upX: number, upY: number, floorCos: number, maskBits: number, selfEntity: number, skinWidth: number, maxSlides: number, snapLength: number, slideOnCeiling: number, carryX: number, carryY: number, flags: number, stepHeight: number) => number
_physics_overlapAABB: (minX: number, minY: number, maxX: number, maxY: number, maskBits: number) => number
_physics_overlapCircle: (centerX: number, centerY: number, radius: number, maskBits: number) => number
_physics_raycast: (originX: number, originY: number, dirX: number, dirY: number, maxDistance: number, maskBits: number) => number
_physics_setAngularVelocity: (entityId: number, omega: number) => void
_physics_setAwake: (entityId: number, awake: number) => void
_physics_setBodyEnabled: (entityId: number, enabled: number) => void
_physics_setBodyTargetTransform: (entityId: number, x: number, y: number, angle: number, dt: number) => void
_physics_setBodyTransform: (entityId: number, x: number, y: number, angle: number) => void
_physics_setBodyTransforms: ((bufferPtr: number, count: number, ppu: number) => number) | undefined
_physics_setDistanceJointLength: (entityId: number, length: number) => void
_physics_setDistanceJointLimits: (entityId: number, minLength: number, maxLength: number) => void
_physics_setDistanceJointMaxMotorForce: (entityId: number, force: number) => void
_physics_setDistanceJointMotorSpeed: (entityId: number, speed: number) => void
_physics_setGravity: (gx: number, gy: number) => void
_physics_setLinearVelocity: (entityId: number, vx: number, vy: number) => void
_physics_setMotorJointAngularVelocity: (entityId: number, omega: number) => void
_physics_setMotorJointLinearVelocity: (entityId: number, vx: number, vy: number) => void
_physics_setMotorJointMaxVelocityForce: (entityId: number, force: number) => void
_physics_setMotorJointMaxVelocityTorque: (entityId: number, torque: number) => void
_physics_setMouseTarget: (targetX: number, targetY: number) => void
_physics_setOneWayPlatform: (entityId: number, nx: number, ny: number, enable: number) => void
_physics_setOneWayPlatformLocal: (entityId: number, nx: number, ny: number, enable: number) => void
_physics_setPrismaticJointLimits: (entityId: number, lower: number, upper: number) => void
_physics_setPrismaticJointMaxMotorForce: (entityId: number, force: number) => void
_physics_setPrismaticJointMotorSpeed: (entityId: number, speed: number) => void
_physics_setRevoluteLimits: (entityId: number, lower: number, upper: number) => void
_physics_setRevoluteMaxMotorTorque: (entityId: number, torque: number) => void
_physics_setRevoluteMotorSpeed: (entityId: number, speed: number) => void
_physics_setWheelJointLimits: (entityId: number, lower: number, upper: number) => void
_physics_setWheelJointMaxMotorTorque: (entityId: number, torque: number) => void
_physics_setWheelJointMotorSpeed: (entityId: number, speed: number) => void
_physics_setWorldConfig: (enableSleep: number, enableContinuous: number, restitutionThreshold: number, maxLinearSpeed: number) => void
_physics_shapeCastBox: (centerX: number, centerY: number, halfW: number, halfH: number, angle: number, translationX: number, translationY: number, maskBits: number) => number
_physics_shapeCastCapsule: (center1X: number, center1Y: number, center2X: number, center2Y: number, radius: number, translationX: number, translationY: number, maskBits: number) => number
_physics_shapeCastCircle: (centerX: number, centerY: number, radius: number, translationX: number, translationY: number, maskBits: number) => number
_physics_shutdown: () => void
_physics_step: (dt: number) => void
_physics_updateBodyProperties: (entityId: number, bodyType: number, gravityScale: number, linearDamping: number, angularDamping: number, fixedRotation: number, bullet: number) => void

PickCandidate — interface @experimental

entity: T
index: number
rank: DrawRank

PickWorld — type @experimental

LayoutWorld & Pick<World, 'getAllEntities'>

PickableWorld — type @experimental

Pick<World, 'getCppRegistry' | 'getWasmModule'>

PlacedObject — const @experimental

ComponentDef<PlacedObjectData>

PlacedObjectData — interface @experimental

id: string
kind: string

Placement — interface @experimental

attach: "align" | "upright"
biome: string
canopy: number
far: { u0: number; v0: number; u1: number; v1: number; tent?: boolean; } | null | undefined
footprint: number
grounding: GroundFit | undefined
group: string
id: string
interactive: string | null
layer: string
material: number
member: string
mesh: number
normal: [number, number, number]
plant: string | null
recipe: string
recipeVersion: number
scale: number
up: [number, number, number] | undefined
x: number
y: number
yaw: number
z: number
zone: string | null

PlacementChange — interface @experimental

scale: number | undefined
x: number | undefined
y: number | undefined
yaw: number | undefined
z: number | undefined

PlacementDiffs — class @experimental

change: (id: string, change: PlacementChange) => void
changeOf: (id: string) => PlacementChange | undefined
isRemoved: (id: string) => boolean
load: (data: PlacementDiffsData) => void
onChange: ((id: string) => void) | null
remove: (id: string) => void
restore: (id: string) => void
revision: number
subscribe: (listener: NonNullable<PlacementDiffs["onChange"]>) => () => void
toJSON: () => PlacementDiffsData
static new (): PlacementDiffs
static prototype: PlacementDiffs

PlacementDiffsData — interface @experimental

changed: Record<string, PlacementChange>
removed: string[]
version: 1

PlacementLayer — interface @experimental

chunkSize: number | undefined
drawDistance: number
farSpacing: number | undefined
id: string
lodDistance: number | undefined
occupies: boolean | undefined
spacing: number
version: number | undefined

PlanarReflection — const @experimental

BuiltinComponentDef<PlanarReflectionData>

PlanarReflectionData — interface @experimental

axis: ReflectionAxis
clipOffset: number
cullingMask: number
enabled: boolean
maxSize: number
quality: ReflectionQuality
resolutionScale: number
revision: number
update: ReflectionUpdate
updatesPerSecond: number

PlanarReflectionStatus — interface @experimental

bytes: number | undefined
draws: number | undefined
height: number | undefined
rejected: number | undefined
state: "budget-excluded" | "inactive" | "ready" | "unavailable"
updated: boolean | undefined
width: number | undefined

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

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

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

Plant — interface @experimental

key: string | undefined
phase: number
scale: number
shade: number
shear: readonly [number, number] | undefined
spread: number | undefined
tilt: number | undefined
up: readonly [number, number, number] | undefined
x: number
y: number
yaw: number
z: number

PlatformAdapter — interface @experimental

bindInputEvents: (callbacks: InputEventCallbacks, target?: unknown) => void
canManageCache: (() => boolean) | undefined
canPay: (() => boolean) | undefined
canSignIn: (() => boolean) | undefined
checkSession: (() => Promise<boolean>) | undefined
clearStorage: (prefix: string) => void
createAudioBackend: (() => PlatformAudioBackend) | undefined
createCanvas: (width: number, height: number) => PlatformCanvas
createImage: () => PlatformImage
createInterstitialAd: ((adUnitId: string) => PlatformInterstitialAd | null) | undefined
createRewardedAd: ((adUnitId: string) => PlatformRewardedAd | null) | undefined
createSocket: ((options: PlatformSocketOptions) => PlatformSocket) | undefined
createTextEditor: (() => PlatformTextEditor | null) | undefined
createVideoBackend: ((ctx: VideoBackendContext) => PlatformVideoBackend) | undefined
device: (() => DeviceBackend) | undefined
deviceName: (() => string) | undefined
devicePixelRatio: () => number
deviceQualityInfo: (() => DeviceQualityInfo) | undefined
family: "minigame" | undefined
fetch: (url: string, options?: PlatformRequestOptions) => Promise<PlatformResponse>
fileExists: (path: string) => Promise<boolean>
flushStorage: (() => Promise<void>) | undefined
getStorageItem: (key: string) => string | null
hasCacheStorage: (() => boolean) | undefined
hasTouch: (() => boolean) | undefined
instantiateWasm: (pathOrBuffer: string | ArrayBuffer, imports: WebAssembly.Imports) => Promise<WasmInstantiateResult>
isHandheld: (() => boolean) | undefined
language: (() => string) | undefined
listCacheFiles: (() => Promise<{ name: string; size: number; lastAccess: number; }[]>) | undefined
loadImagePixels: (path: string) => Promise<ImageLoadResult>
loadSubpackage: ((name: string) => Promise<void>) | undefined
login: (() => Promise<string>) | undefined
name: PlatformName
nativeChannel: (() => PlatformNativeChannel | null) | undefined
now: () => number
onAppHide: ((callback: () => void) => () => void) | undefined
onAppShow: ((callback: () => void) => () => void) | undefined
onAudioMute: ((handler: (muted: boolean) => void) => () => void) | undefined
onContextLost: ((callback: () => void) => () => void) | undefined
onMemoryWarning: ((callback: () => void) => () => void) | undefined
onShareRequest: ((provide: () => PlatformShareOptions) => void) | undefined
onStoreOverlay: ((listener: (covered: boolean) => void) => () => void) | undefined
onUnhandledError: ((callback: (error: unknown) => void) => () => void) | undefined
openDataCanvas: (() => PlatformCanvas | null) | undefined
openDataPostMessage: ((message: Record<string, unknown>) => void) | undefined
pollGamepads: (() => GamepadSnapshot[]) | undefined
rasterizeGlyph: ((request: PlatformGlyphRequest) => PlatformGlyph | null) | undefined
readCacheFile: ((key: string) => Promise<ArrayBuffer | null>) | undefined
readFile: (path: string) => Promise<ArrayBuffer>
readTextFile: (path: string) => Promise<string>
registerFont: ((family: string, bytes: ArrayBuffer) => Promise<void>) | undefined
removeCacheFile: ((name: string) => Promise<void>) | undefined
removeStorageItem: (key: string) => void
requestPayment: ((request: PlatformPaymentRequest) => Promise<void>) | undefined
safeAreaInsets: (() => { top: number; bottom: number; left: number; right: number; }) | undefined
screenRecorder: (() => PlatformScreenRecorder | null) | undefined
setCloudKeyValues: ((entries: Readonly<Record<string, string>>) => boolean) | undefined
setStorageItem: (key: string, value: string) => void
setWindowSize: ((width: number, height: number) => void) | undefined
share: ((options: PlatformShareOptions) => void) | undefined
steamAchievements: ((appId: number) => AchievementProvider | null) | undefined
steamIdentity: (() => { id: string; name: string; } | null) | undefined
submitScore: ((score: number) => Promise<void>) | undefined
unbindInputEvents: (() => void) | undefined
writeCacheFile: ((key: string, bytes: ArrayBuffer) => Promise<void>) | undefined

PlatformAudioBackend — interface @experimental

delivery: AudioDelivery
dispose: () => void
ensureResumed: () => Promise<void>
getFrequencyData: ((out: Uint8Array) => boolean) | undefined
initialize: (options?: AudioBackendInitOptions) => Promise<void>
invalidateSource: ((src: string) => void) | undefined
isReady: boolean
loadBuffer: (src: string, options?: AudioLoadOptions) => Promise<AudioBufferHandle>
loadBufferFromData: (src: string, data: ArrayBuffer, options?: AudioLoadOptions) => Promise<AudioBufferHandle>
mixer: AudioMixer | null
name: string
play: (buffer: AudioBufferHandle, config: PlayConfig) => AudioHandle
resume: () => void
suspend: () => void
unloadBuffer: (handle: AudioBufferHandle) => void

PlatformCanvas — interface @experimental

getContext: (contextId: "2d", options?: PlatformCanvasContextAttributes) => PlatformCanvas2DContext | null
height: number
width: number

PlatformCanvas2DContext — interface @experimental

clearRect: (x: number, y: number, w: number, h: number) => void
drawImage: { (image: PlatformImageSource, dx: number, dy: number): void; (image: PlatformImageSource, dx: number, dy: number, dw: number, dh: number): void; }
fillStyle: PlatformCanvasPaint
fillText: (text: string, x: number, y: number) => void
font: string
getImageData: (sx: number, sy: number, sw: number, sh: number) => PlatformImageData
measureText: (text: string) => PlatformTextMetrics
textAlign: string
textBaseline: string

PlatformImage — interface @experimental

crossOrigin: string | null | undefined
height: number
onerror: PlatformImageEventHandler
onload: PlatformImageEventHandler
src: string
width: number

PlatformPaymentRequest — interface @experimental

offerId: string
quantity: number
sandbox: boolean | undefined
zoneId: string | undefined

PlatformRecording — interface @experimental

blob: Blob | undefined
durationMs: number
highlights: readonly (readonly [number, number])[]
path: string | undefined

PlatformRecordingShareOptions — interface @experimental

desc: string | undefined
query: string | undefined
title: string | undefined

PlatformRequestOptions — interface @experimental

body: string | ArrayBuffer | undefined
headers: Record<string, string> | undefined
method: "DELETE" | "GET" | "HEAD" | "OPTIONS" | "POST" | "PUT" | undefined
responseType: "arraybuffer" | "json" | "text" | undefined
timeout: number | undefined

PlatformResponse — interface @experimental

arrayBuffer: () => Promise<ArrayBuffer>
headers: Record<string, string>
json: <T = unknown>() => Promise<T>
ok: boolean
status: number
statusText: string
text: () => Promise<string>

PlatformScreenRecorder — interface @experimental

abort: () => Promise<void>
canShare: boolean
highlight: (beforeSeconds: number, afterSeconds: number) => void
limits: { readonly minSeconds: number; readonly maxSeconds: number; }
pause: () => Promise<void>
resume: () => Promise<void>
share: (recording: PlatformRecording, options: PlatformRecordingShareOptions) => Promise<void>
start: (maxSeconds: number, onFailure: (error: Error) => void) => Promise<void>
stop: () => Promise<PlatformRecording>

PlatformShareOptions — interface @experimental

imageUrl: string | undefined
query: string | undefined
title: string | undefined

PlatformSocket — interface @experimental

close: (code?: number, reason?: string) => void
connect: () => void
delivery: "reliable-ordered"
on: <K extends keyof PlatformSocketEvents>(event: K, handler: (...args: PlatformSocketEvents[K]) => void) => () => void
readyState: PlatformSocketReadyState
send: (data: string | ArrayBuffer) => void

PlatformSocketEvents — interface @experimental

close: [code: number, reason: string]
error: [error: unknown]
message: [data: string | ArrayBuffer]
open: []

PlatformSocketOptions — interface @experimental

protocols: string | string[] | undefined
url: string

PlatformSocketReadyState — type @experimental

'connecting' | 'open' | 'closing' | 'closed'

PlatformType — type @experimental @deprecated

PlatformName

PlatformVideoBackend — interface @experimental

createStream: (url: string, options: VideoStreamOptions) => VideoStreamHandle
dispose: () => void
name: string

PlatformerController2D — const @experimental

ComponentDef<PlatformerController2DData>

PlatformerController2DData — interface @experimental

airAcceleration: number
airDeceleration: number
airJumps: number
coyoteTime: number
dropPressed: boolean
dropTime: number
enabled: boolean
fallGravityScale: number
gravity: number
groundAcceleration: number
groundDeceleration: number
jumpBuffer: number
jumpCut: number
jumpHeld: boolean
jumpPressed: boolean
jumpSpeed: number
keepPlatformVelocity: boolean
maxFallSpeed: number
moveInput: number
moveSpeed: number
readKeyboard: boolean

PlayConfig — interface @experimental

bus: string | undefined
loop: boolean | undefined
loopStart: number | undefined
pan: number | undefined
playbackRate: number | undefined
priority: number | undefined
startOffset: number | undefined
together: object | undefined
volume: number | undefined

PlayRealmRuntimeConfig — interface @experimental

achievements: string[] | undefined
app: App
assetBaseUrl: string | undefined
assetManifest: Record<string, string>
assetPathMap: Record<string, string> | undefined
audioConfig: AudioProjectConfig | undefined
canvas: HTMLCanvasElement
catalogData: CatalogData | null | undefined
compressedTexture: ((path: string) => Promise<Uint8Array | "pending" | null>) | undefined
enableStats: boolean | undefined
entrySceneName: string | undefined
extraScenes: { name: string; data?: SceneData; path?: string; }[] | undefined
manifest: AddressableManifest | null | undefined
module: ESEngineModule
persistUpdateKey: string | undefined
physics3dBackend: Physics3DBackend | undefined
physics3dWorld: Partial<Physics3DWorldConfig> | undefined
physicsConfig: Physics2DPluginConfig | undefined
physicsEnabled: boolean | undefined
remoteRoot: string | undefined
runtime: RuntimeBuildConfig | undefined
sceneData: SceneData
uiTheme: "dark" | "light" | undefined
uiThemeOverrides: ThemeOverrides | undefined
wasmBaseUrl: string | undefined

PlayableAdBridge — interface @experimental

cta: ((url?: string) => void) | undefined
gameEnd: (() => void) | undefined
onActive: ((listener: (active: boolean) => void) => () => void) | undefined
ready: (() => void) | undefined
retry: (() => void) | undefined

PlayableRuntimeConfig — interface @experimental

app: App
assetPathMap: Record<string, string> | undefined
assets: Record<string, string>
audioConfig: AudioProjectConfig | undefined
canvas: HTMLCanvasElement
depthLayers: number | undefined
firstScene: string
manifest: AddressableManifest | null | undefined
module: ESEngineModule
onBeforeRun: (() => void) | undefined
physics3dBackend: Physics3DBackend | undefined
physics3dWorld: Partial<Physics3DWorldConfig> | undefined
physicsConfig: Physics2DPluginConfig | undefined
physicsEnabled: boolean | undefined
prewarmShaders: { timeoutMs?: number; onProgress?: (pending: number, making: number) => void; } | undefined
runtime: RuntimeBuildConfig | undefined
scenes: { name: string; data: SceneData; }[]
uiTheme: "dark" | "light" | undefined
uiThemeOverrides: ThemeOverrides | undefined
ySortLayers: number | undefined

PlayheadRun — interface @experimental

from: number
inclusiveStart: boolean
to: number

Playthrough — const @experimental

ResourceDef<PlaythroughData>

PlaythroughData — interface @experimental

facts: Record<string, PlaythroughValue>

PlaythroughValue — type @experimental

string | number | boolean

Plugin — interface @experimental

activeWhen: readonly AnyComponentDef[] | undefined
after: string[] | undefined
before: string[] | undefined
build: (app: App) => void
cleanup: ((app?: App) => void) | undefined
dependencies: PluginDependency[] | undefined
finish: ((app: App) => void) | undefined
name: string | undefined
profileDomain: string | undefined

PluginDependency — type @experimental

string | ResourceDef<any>

PluralCategory — type @experimental

'zero' | 'one' | 'two' | 'few' | 'many' | 'other'

PluralForms — interface @experimental

few: string | undefined
many: string | undefined
one: string | undefined
other: string
two: string | undefined
zero: string | undefined

PluralSelector — type @experimental

(count: number) => PluralCategory

Point2 — interface @experimental

x: number
y: number

PointJoint3D — const @experimental

ComponentDef<PointJoint3DData>

PointJoint3DData — interface @experimental

anchor: Vec3
breakForce: number
breakTorque: number
collideConnected: boolean
connectedEntity: number
enabled: boolean

PolygonCollider2D — const @experimental

ComponentDef<PolygonCollider2DData>

PolygonDecomposition — interface @experimental

degenerate: boolean
pieces: readonly Vec2[][]

PooledAudioNode — interface @experimental

gain: GainNode
inUse: boolean
panner: StereoPannerNode
source: AudioBufferSourceNode | MediaElementAudioSourceNode | null
startTime: number

PostProcess — const @experimental

ResourceDef<PostProcessAPI>

PostProcessAPI — class @experimental

_applyForCamera: (camera: Entity) => void
_applyScreenStack: () => void
_beginScreenCapture: () => void
_endScreenCapture: () => void
_executeScreenPasses: () => void
_resetAfterCamera: () => void
antialiasing: "msaa" | "temporal"
begin: () => void
bind: (camera: Entity, stack: PostProcessStack) => void
createStack: () => PostProcessStack
dynamicGIReduced: boolean
effectAllowed: (type: string) => boolean
end: () => void
getStack: (camera: Entity) => PostProcessStack | null
hdrFormat: () => HdrFormat | null
init: (width: number, height: number) => boolean
isInitialized: () => boolean
msaaCapability: () => { effective: number; max: number; }
resize: (width: number, height: number) => void
screenStack: PostProcessStack | null
setBypass: (bypass: boolean) => void
setMsaaSamples: (samples: number) => void
setOutputTransform: (transform: OutputTransform) => void
setOutputViewport: (x: number, y: number, w: number, h: number) => void
setPresentRequired: (required: boolean) => void
setQualityFilter: (profile: Readonly<QualityProfile> | null) => void
setScreenStack: (stack: PostProcessStack | null) => void
shutdown: () => void
state: PostProcessState
unbind: (camera: Entity) => void
volumeShaders: Map<string, number>
volumeStacks: Map<number, PostProcessStack>
static new (): PostProcessAPI
static prototype: PostProcessAPI

PostProcessPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
name: string
profileDomain: "render"
static new (): PostProcessPlugin
static prototype: PostProcessPlugin

PostProcessStack — class @experimental

addComputePass: (name: string, compute: ComputePassSource) => PostProcessStack
addNativePass: (name: string, kind: string) => PostProcessStack
addPass: (name: string, shader: ShaderHandle, scale?: number, continuesEffect?: boolean) => PostProcessStack
clearDirty: () => void
clearPasses: () => PostProcessStack
destroy: () => void
displayLut: { readonly texture: number; readonly amount: number; }
enabledPassCount: number
id: number
isDestroyed: boolean
isDirty: boolean
passCount: number
passes: readonly PassConfig[]
removePass: (name: string) => PostProcessStack
setAllPassesEnabled: (enabled: boolean) => void
setDisplayLut: (texture: number, amount: number) => PostProcessStack
setEnabled: (name: string, enabled: boolean) => PostProcessStack
setTexture: (passName: string, uniform: string, textureHandle: number) => PostProcessStack
setUniform: (passName: string, uniform: string, value: number) => PostProcessStack
setUniformVec4: (passName: string, uniform: string, value: Vec4) => PostProcessStack
static new (state: PostProcessState): PostProcessStack
static prototype: PostProcessStack

PostProcessVolume — const @experimental

ComponentDef<PostProcessVolumeData>

PostProcessVolumeData — interface @experimental

blendDistance: number
effects: { type: string; enabled: boolean; uniforms: Record<string, number>; textures?: Record<string, string>; colors?: Record<string, { r: number; g: number; b: number; a: number; }>; }[]
isGlobal: boolean
priority: number
shape: "box" | "sphere"
size: { x: number; y: number; z?: number; }
weight: number

PowerDecision — interface @experimental

ceiling: PowerLevel | null
fps: number
reason: "battery" | "critical" | "none" | "thermal"
saving: boolean

PowerLevel — type @experimental

'low' | 'medium' | 'high'

PowerPolicy — interface @experimental

ceiling: PowerLevel | undefined
fps: number | undefined
lowBattery: number | undefined
severe: "critical" | "never" | undefined
thermal: "critical" | "never" | "serious" | undefined

PowerState — interface @experimental

charging: boolean | null
level: number | null
thermal: "critical" | "fair" | "nominal" | "serious" | null

PreSceneDrawCallback — type @experimental

(info: PreSceneDrawInfo) => void

PreSceneDrawInfo — interface @experimental

elapsed: number
height: number
width: number

PrefabComponentData — interface @experimental

data: Record<string, unknown>
type: string

PrefabData — interface @experimental

basePrefab: string | undefined
entities: PrefabEntityData[]
name: string
overrides: PrefabOverride[] | undefined
rootEntityId: string
version: string

PrefabDiagnostic — type @experimental

DocumentDiagnostic

PrefabDiagnosticSeverity — type @experimental

DocumentDiagnosticSeverity

PrefabEntityData — interface @experimental

children: string[]
components: ComponentData[]
metadata: Record<string, unknown> | undefined
name: string
nestedPrefab: NestedPrefabRef | undefined
parent: string | null
prefabEntityId: string
visible: boolean

PrefabEntityId — type @experimental

string

PrefabInstanceDelta — interface @experimental

added: AddedEntity[]
overrides: PrefabOverride[]
prefab: string
removed: string[]

PrefabInstanceEntry — interface @experimental

added: AddedEntity[]
id: number
overrides: PrefabOverride[]
parent: number | null
prefab: string
removed: string[]

PrefabOverride — interface @beta

componentData: ComponentData | undefined
componentType: string | undefined
metadataKey: string | undefined
prefabEntityId: string
propertyName: string | undefined
type: "component_added" | "component_removed" | "component_replaced" | "metadata_removed" | "metadata_set" | "name" | "parent" | "property" | "visibility"
value: unknown

PrefabRoot — interface @experimental

position: Vec3
rootId: string

PrefabServer — class @beta

instantiate: (pathOrAddress: string, options?: { baseUrl?: string; parent?: Entity; overrides?: SpawnOverride[]; scene?: boolean; }) => Promise<InstantiatePrefabResult>
prepare: (pathOrAddress: string) => Promise<{ release(): void; }>
static new (world: World, getAssets: () => AssetsClass, getScenes?: () => SceneManagerState | null): PrefabServer
static prototype: PrefabServer

Prefabs — const @beta

ResourceDef<PrefabServer>

PrefabsPlugin — class @experimental

build: (app: App) => void
dependencies: ResourceDef<AssetsClass>[]
name: string
static new (): PrefabsPlugin
static prototype: PrefabsPlugin

PresentedCameraView — const @beta

ResourceDef<CameraViewAPI>

ProbeGrid — interface @experimental

max: readonly [number, number, number]
min: readonly [number, number, number]
resolution: readonly [number, number, number]

ProbedRegistrations — interface @experimental

fingerprint: string
pending: PendingSystemEntry[]

ProceduralChunks — class @experimental

@internal progress_: () => { label: string; progress: number; owner: object; }[]
@internal sources_: () => ChunkSource[]
clear: () => void
has: (id: string) => boolean
invalidate: (id: string, x0: number, z0: number, x1: number, z1: number) => void
pending: number
remove: (id: string) => void
set: <T>(id: string, def: ChunkLayer<T>) => void
stateAt: (id: string, x: number, z: number) => ChunkState | null
status: (id: string) => ChunkLayerStatus | null
step: (hasTime: () => boolean) => boolean
suspended: boolean
static new (): ProceduralChunks
static prototype: ProceduralChunks

ProceduralChunksRes — const @experimental

ResourceDef<ProceduralChunks>

ProceduralParams — interface @experimental

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

ProcessedEntity — interface @experimental

children: number[]
components: ComponentData[]
id: number
metadata: Record<string, unknown> | undefined
name: string
parent: number | null
prefabEntityId: string
visible: boolean

ProfileCapture — interface @experimental

budgetMs: number
frames: CapturedFrame[]
generatedAt: string
longTasks: { startMs: number; ms: number; name: string; }[] | undefined
source: CaptureSource
version: number

ProfileNode — interface @experimental

children: readonly ProfileNode[]
id: string
kind: ProfileNodeKind
label: string
ms: number
query: QueryCost | undefined

ProfileNodeKind — type @experimental

'domain' | 'system' | 'scope' | 'rest'

ProfileRecorder — class @experimental

clear: () => void
frameCount: number
recording: boolean
start: () => void
stop: () => void
take: () => ProfileCapture
static new (app: App, options?: ProfileRecorderOptions): ProfileRecorder
static prototype: ProfileRecorder

ProfileRecorderOptions — interface @experimental

budgetMs: number | undefined
instrumentation: "enable" | "existing" | undefined
maxFrames: number | undefined
source: CaptureSource | undefined

ProfileRecorderPlugin — class @experimental

build: (app: App) => void
cleanup: () => void
name: "profileRecorder"
profileDomain: "diagnostics"
recorder: ProfileRecorder | null
static new (options_?: ProfileRecorderOptions, onReady_?: ((recorder: ProfileRecorder) => void) | undefined): ProfileRecorderPlugin
static prototype: ProfileRecorderPlugin

ProgressHandle — interface @experimental

dispose: () => void
entity: number
fillEntity: number
getValue: () => number
setValue: (v: number) => void

ProgressOptions — interface @experimental

background: UIVisualInit | undefined
direction: LinearFillDirection | undefined
fill: { color?: Color; sprite?: number; } | undefined
node: UINodeInit | undefined
parent: number | undefined
radial: boolean | undefined
value: number | undefined
world: World

ProjectionType — enum @beta

Orthographic = 1
Perspective = 0

PropertyChannel — interface @experimental

keyframes: Keyframe[]
property: string

PropertyTrack — interface @experimental

channels: PropertyChannel[]
childPath: string
component: string
name: string
type: "property"

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

PseudoLocalizationOptions — interface @experimental

accents: boolean | undefined
expansion: number | undefined

PtrLayout — interface @experimental

fields: readonly PtrFieldDesc[]
ptrFn: string

PushValue — interface @experimental

w: number
x: number
y: number
z: number

QuadtreeParams — interface @experimental

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

Quality — const @experimental

ResourceDef<QualityController | null>

QualityConfig — interface @experimental

asyncShaderCompile: boolean | undefined
deviceRules: DeviceQualityRule[] | undefined
dynamicResolution: boolean | undefined
mode: QualityMode | undefined
power: PowerPolicy | undefined
prewarmShaders: boolean | undefined
prewarmTimeoutMs: number | undefined
profiles: Partial<Record<QualityLevel, Partial<QualityProfile>>> | undefined
renderOnDemand: boolean | undefined
renderOnDemandTail: number | undefined
targetFps: number | undefined

QualityController — class @experimental

enabled: boolean
profile: Readonly<QualityProfile>
renderScale: number
report: () => QualityReport
sample: (sample: Readonly<QualitySample>) => void
setCeiling: (level: QualityLevel | null) => void
setLimitation: (reason: string, active: boolean) => void
setMode: (mode: QualityMode) => void
static new (config: QualityConfig, device_?: DeviceQualityInfo): QualityController
static prototype: QualityController

QualityLevel — type @experimental

'low' | 'medium' | 'high'

QualityMode — type @experimental

'off' | 'auto' | QualityLevel

QualityProfile — interface @experimental

antialiasing: "msaa" | "temporal"
depthPrepass: boolean
detailScale: number
drawCallBudget: number
dynamicGIReduced: boolean
lighting: "direct" | "full"
minRenderScale: number
msaaSamples: 2 | 1 | 4 | 8
particleLimit: number
planarReflectionMaxSize: number
planarReflectionScale: number
planarReflectionUpdatesPerSecond: number
postProcess: boolean
renderScale: number
shadowAtlasSize: number
shadowCascades: number
shadowCellSize: number
shadowDistance: number
shadowSoftSamples: number
shelterMaskSize: number
skipEffects: readonly string[]
ssao: boolean
textureStreaming: boolean
textureStreamingBudget: number
waterCaustics: boolean
waterDisplacement: boolean
waterMirror: boolean
waterRippleCells: number
waterWaves: number

QualityReport — interface @experimental

busyMs: number
drawCallBudget: number
frameMs: number
gpuMs: number
level: QualityLevel
limitations: string[]
mode: QualityMode
reason: string
renderScale: number
targetFps: number

QualitySample — interface @experimental

busyMs: number | undefined
frameMs: number
gpuMs: number | undefined

Quat — interface @public

w: number
x: number
y: number
z: number

Query — function @public

<C extends QueryArg[]>(...components: C): QueryBuilder<C>

QueryArg — type @public

AnyComponentDef | MutWrapper<AnyComponentDef> | AddedWrapper<AnyComponentDef> | ChangedWrapper<AnyComponentDef>

QueryBuilder — interface @public

@internal _addedFilters: { index: number; component: AnyComponentDef; }[]
@internal _changedFilters: { index: number; component: AnyComponentDef; }[]
@internal _components: C
@internal _filter: FilterExpr | null
@internal _mutIndices: number[]
@internal _type: "query"
@internal _with: AnyComponentDef[]
@internal _without: AnyComponentDef[]
filter: (expr: FilterExpr) => QueryBuilder<C>
with: (...components: AnyComponentDef[]) => QueryBuilder<C>
without: (...components: AnyComponentDef[]) => QueryBuilder<C>

QueryCost — interface @experimental

calls: number
filtered: number
scanned: number

QueryDescriptor — interface @public

@internal _addedFilters: { index: number; component: AnyComponentDef; }[]
@internal _changedFilters: { index: number; component: AnyComponentDef; }[]
@internal _components: C
@internal _filter: FilterExpr | null
@internal _mutIndices: number[]
@internal _type: "query"
@internal _with: AnyComponentDef[]
@internal _without: AnyComponentDef[]

QueryInstance — class @public

@internal resetChangeSequence: (sequence: number) => void
@internal resetTick: (tick: number) => void
@internal settleKeptRows: () => void
@internal takeCost: () => QueryCost
[Symbol.iterator]: () => Iterator<QueryResult<C>>
count: () => number
forEach: (callback: (entity: Entity, ...components: ComponentsData<C>) => void) => void
isEmpty: () => boolean
single: () => QueryResult<C> | null
toArray: () => QueryResult<C>[]
static new <C extends readonly QueryArg[]>(world: World, descriptor: QueryDescriptor<C>, lastRunTick?: number): QueryInstance<C>
static prototype: QueryInstance<any>

QueryResult — type @public

[
    Entity,
    ...ComponentsData<C>
]

RAW_PAYLOAD_UPLOAD — const @experimental

TextureUploadDecision

REFERENCE_UNITS_PER_METER — const @experimental

100

RENAMED_COMPONENT_TYPES — const @experimental

ReadonlyMap<string, string>

RETIRED_COMPONENT_TYPES — const @experimental

ReadonlySet<string>

RUNTIME_BUILD_DEFAULTS — const @experimental

Readonly<Required<RuntimeBuildConfig>>

Ragdoll — const @experimental

ComponentDef<RagdollData>

RagdollData — interface @experimental

active: boolean
bend: number
facing: number
friction: number
minBoneLength: number
profile: number
recoverTime: number
skin: number
swing: number
thickness: number
twist: number

RagdollFacing — const @experimental

{ readonly PlusZ: 0; readonly MinusZ: 1; readonly PlusX: 2; readonly MinusX: 3; }

RagdollJoint — const @experimental

ComponentDef<RagdollJointData>

RagdollJointData — interface @experimental

bend: number
body: boolean
custom: boolean
fold: number
swing: number
twist: number

RagdollPlan — interface @experimental

bones: number[]
limbs: { limb: RagdollLimb; joint: { kind: "swingTwist"; data: SwingTwistJoint3DData; } | { kind: "sixDOF"; data: SixDOFJoint3DData; } | null; }[]
skin: number

RagdollProfile — const @experimental

{ readonly Uniform: 0; readonly Humanoid: 1; }

RainShelter — const @experimental

ComponentDef<RainShelterData>

RainShelterData — interface @experimental

enabled: boolean
margin: number
round: boolean

RainUpright — const @experimental

ComponentDef<RainUprightData>

RainUprightData — interface @experimental

enabled: boolean
inset: number

ReadableWorld — type @experimental

Pick<World, 'valid' | 'has' | 'get'>

ReadonlySignal — interface @experimental

get: () => T
subscribe: (fn: (value: T) => void) => () => void

Recipe — interface @experimental

anchor: RecipeMember
id: string
members: readonly RecipeMember[] | undefined
tags: readonly string[] | undefined
version: number

RecipeMember — interface @experimental

arc: readonly [number, number] | undefined
attach: "align" | "upright" | undefined
canopy: number | undefined
chance: number | undefined
count: readonly [number, number] | undefined
far: { u0: number; v0: number; u1: number; v1: number; tent?: boolean; } | undefined
footprint: number
grounding: GroundingOptions | undefined
id: string
interactive: string | undefined
material: string | number | undefined
mesh: string | number | undefined
minUp: number | undefined
plant: string | undefined
ring: readonly [number, number] | undefined
scale: readonly [number, number] | undefined
scaleFootprint: boolean | undefined
tags: readonly string[] | undefined
waterDepth: number | undefined

RectAnchors — const @experimental

ComponentDef<RectAnchorsData>

RectAnchorsData — interface @experimental

alignFlags: number
alignMode: number
bottom: number
enabled: boolean
horizontalCenter: number
isAbsBottom: boolean
isAbsHorizontalCenter: boolean
isAbsLeft: boolean
isAbsRight: boolean
isAbsTop: boolean
isAbsVerticalCenter: boolean
left: number
right: number
top: number
verticalCenter: number

ReflectionAxis — enum @experimental

X = 0
Y = 1
Z = 2

ReflectionProbe — const @experimental

BuiltinComponentDef<ReflectionProbeData>

ReflectionProbeData — interface @beta

enabled: boolean
halfExtents: Vec3
reflection: number
slot: number

ReflectionQuality — enum @experimental

Custom = 1
Project = 0

ReflectionUpdate — enum @experimental

EveryFrame = 0
FixedRate = 1
OnDemand = 2

Rejection — type @experimental

'noBiome' | 'density' | 'noGround' | 'slope' | 'water' | 'relief' | 'zone' | 'occupied' | 'conflict'

ReliableOrderedTransport — interface @experimental

delivery: "reliable-ordered"
on: (event: "message", handler: (data: string | ArrayBuffer) => void) => () => void
send: (data: string | ArrayBuffer) => void

Removed — function @experimental

<T extends AnyComponentDef>(component: T): RemovedQueryDescriptor<T>

RemovedQueryDescriptor — interface @public

@internal _component: T
@internal _type: "removed"

RemovedQueryInstance — class @public

@internal activateRetention: () => void
@internal dispose: () => void
@internal releaseThrough: (_lastRunTick: number) => void
@internal resetTick: (tick: number) => void
[Symbol.iterator]: () => Iterator<Entity>
isEmpty: () => boolean
toArray: () => Entity[]
static new <T extends AnyComponentDef>(world: World, component: T, lastRunTick: number): RemovedQueryInstance<T>
static prototype: RemovedQueryInstance<any>

RenderBackendRequest — type @experimental

'webgl2' | 'webgpu' | 'auto'

RenderDemand — class @experimental

disable: () => void
enable: (options?: RenderOnDemandOptions) => void
enabled: boolean
hold: () => () => void
request: () => void
shouldRender: (probe: RenderDemandProbe) => boolean
stats: { drawn: number; skipped: number; }
static new (): RenderDemand
static prototype: RenderDemand

RenderOnDemandOptions — interface @experimental

tailFrames: number | undefined

RenderOriginState — interface @experimental

step: number
x: number
y: number
z: number

RenderParams — interface @experimental

clearColor: { x: number; y: number; z: number; w: number; } | undefined
elapsed: number
frameAlreadyBegun: boolean | undefined
height: number
registry: { _cpp: CppRegistry; }
viewProjection: Float32Array<ArrayBufferLike>
width: number

RenderPipeline — class @experimental

addPreFlushCallback: (cb: (registry: { _cpp: CppRegistry; }, viewProjection?: Float32Array) => void) => void
addScreenOverlayCallback: (cb: (registry: { _cpp: CppRegistry; }, viewProjection?: Float32Array) => void) => void
beginFrame: (elapsedSec?: number) => void
beginScreenCapture: () => void
demand: RenderDemand
endFrame: () => void
endScreenCapture: () => void
frameElapsed: number
render: (params: RenderParams) => void
renderCamera: (params: CameraRenderParams) => void
renderScreenOverlay: (registry: { _cpp: CppRegistry; }, overlay: ScreenOverlayData, target?: number) => void
renderingEnabled: boolean
runPreFlushCallbacks: (registry: { _cpp: CppRegistry; }, viewProjection?: Float32Array) => void
setActiveScenes: (scenes: Set<string> | null) => void
setPostProcess: (pp: PostProcessAPI | null) => void
setQuality: (quality: QualityController, apply?: () => void) => void
setRenderingEnabled: (enabled: boolean) => void
submitScene: (registry: { _cpp: CppRegistry; }, viewProjection: Float32Array, viewport: Viewport, _elapsed: number) => void
static new (): RenderPipeline
static prototype: RenderPipeline

RenderStage — enum @experimental

Background = 0
Opaque = 1
Overlay = 3
Transparent = 2

RenderStats — interface @experimental

culled: number
drawCalls: number
gpuDraws: number
meshes: number
skeletal: number
sprites: number
text: number
triangles: number

RenderSurfaceSource — type @experimental

| {
        readonly kind: 'gl-context';
        readonly handle: number;
        /** The context is WeChat's EmscriptenGLX one, whose GL calls the linked
         *  library issues natively rather than through the JS glue. */
        readonly glx?: boolean;
    }
    | {
        readonly kind: 'webgpu';
        readonly canvasSelector?: string;
        /** Configure the swapchain so the engine can read its own frames back
         *  (`captureFrame`). Fixed at surface configuration, hence here. */
        readonly readback?: boolean;
    }
    | { readonly kind: 'default' }

RenderTargetHandle — type @experimental

number

RenderTexture — const @experimental

{ create(options: RenderTextureOptions): RenderTextureHandle; release(rt: RenderTextureHandle): void; resize(rt: RenderTextureHandle, width: number, height: number): RenderTextureHandle; begin(rt: RenderTextureHandle, viewProjection: Float32Array): void; end(): void; getDepthTexture(rt: RenderTextureHandle): number; contentLost(rt: RenderTextureHandle): boolean; contentDrawn(rt: RenderTextureHandle): void; }

RenderTextureHandle — interface @experimental

_depth: boolean
_filter: "linear" | "nearest"
_generation: number
_handle: number
height: number
texture: number
textureId: number
width: number

RenderTextureOptions — interface @experimental

depth: boolean | undefined
filter: "linear" | "nearest" | undefined
height: number
width: number

RenderType — enum @experimental

ExternalMesh = 3
Mesh = 2
Particle = 5
Shape = 6
Spine = 1
Sprite = 0
Text = 4
UIElement = 7

Renderer — const @experimental

{ init(width: number, height: number): void; resize(width: number, height: number): void; beginFrame(elapsedSec?: number): void; setOrigin(x: number, y: number, z: number): void; updateTransforms(registry: { _cpp: CppRegistry; }): void; begin(viewProjection: Float32Array, target?: RenderTargetHandle, clearFlags?: number, clearColor?: { x: number; y: number; z: number; w: number; }, clearRect?: { x: number; y: number; w: number; h: number; }): void; flush(): void; end(): void; endFrame(): void; hasScreenOverlay(): boolean; beginScreenOverlay(projection: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): void; submitScreenOverlay(registry: { _cpp: CppRegistry; }): void; endScreenOverlay(target?: RenderTargetHandle): void; submitAll(registry: { _cpp: CppRegistry; }, vpX: number, vpY: number, vpW: number, vpH: number): void; setStage(stage: RenderStage): void; createRenderTarget(width: number, height: number, flags?: number): RenderTargetHandle; releaseRenderTarget(handle: RenderTargetHandle): void; getTargetTexture(handle: RenderTargetHandle): number; getTargetDepthTexture(handle: RenderTargetHandle): number; bakeMaterial(material: number, shader: number, target: RenderTargetHandle, x: number, y: number, w: number, h: number, a: readonly [number, number, number, number], b: readonly [number, number, number, number]): number; bakeState(ticket: number): number; setClearColor(r: number, g: number, b: number, a: number): void; setViewport(x: number, y: number, w: number, h: number): void; setYSortLayers(mask: number): void; setDepthLayers(mask: number): void; setTreeSortLayers(mask: number): void; setCullingMask(mask: number): void; setViewId(view: number): void; lodInspect(view: number, entity: number): LodDecision | null; setLodPreview(view: number, entity: number, level: number | null): void; setViewShading(view: number, mode: ViewShading): void; setMeshEdgeBuffers(enabled: boolean): void; setViewSkinWeights(view: number, entity: number | null, joint?: number): void; lightStatus(entity: number): LightStatus | null; shadowStatus(entity: number): ShadowStatus | null; setTextureParams(textureId: number, minFilter: number, magFilter: number, wrapS: number, wrapT: number): void; measureBitmapText(fontHandle: number, text: string, fontSize: number, spacing: number): { width: number; height: number; }; getStats(): RenderStats; captureNextFrame(): void; getCapturedData(): FrameCaptureData | null; hasCapturedData(): boolean; replayToDrawCall(drawCallIndex: number): void; getSnapshotImageData(): Promise<ImageData | null>; snapshotMatchesCapture(): boolean; }

ReplayReport — interface @experimental

stable: boolean
why: string

ReplaySnapshot — interface @experimental

image: ImageData
matchesCapture: boolean

Res — function @public

<T>(resource: ResourceDef<T>): ResDescriptor<T>

ResDescriptor — interface @public

@internal _resource: ResourceDef<T>
@internal _type: "res"

ResMut — function @public

<T>(resource: ResourceDef<T>): ResMutDescriptor<T>

ResMutDescriptor — interface @public

@internal _resource: ResourceDef<T>
@internal _type: "res_mut"

ResMutInstance — class @public

@internal updateValue: (value: T) => void
get: () => T
modify: (fn: (value: T) => void) => void
set: (value: T) => void
static new <T>(value: T, setter: (v: T) => void): ResMutInstance<T>
static prototype: ResMutInstance<any>

ResidencyDecision — interface @experimental

prefetch: string[]
target: string[]
toLoad: string[]
toUnload: string[]

ResidencySource — interface @experimental

loadRadius: number
prefetchRadius: number
unloadRadius: number
x: number
z: number

ResolvedAssetGroup — interface @experimental

alwaysInclude: boolean
delivery: BundleMode
name: string

ResolvedAtlas — interface @experimental

folder: string
name: string

ResourceDef — interface @public

@internal _default: T
@internal _id: symbol
@internal _name: string

ResourceStats — interface @experimental

cacheHits: number
cacheMisses: number
indexBufferCount: number
retainedBytes: number
shaderCount: number
textureBudget: number
textureBytes: number
textureCount: number
textureEvictableCount: number
vertexBufferCount: number

ReverbEffectDef — interface @experimental

decay: number | undefined
seconds: number | undefined
type: "reverb"
wet: number | undefined

RichTextRun — type @experimental

TextSegment | ImageSegment

RigidBody2D — const @experimental

BuiltinComponentDef<RigidBody2DData>

RigidBody2DData — interface @experimental

angularDamping: number
bodyType: number
bullet: boolean
enabled: boolean
fixedRotation: boolean
gravityScale: number
linearDamping: number

RigidBody3D — const @experimental

BuiltinComponentDef<RigidBody3DData>

RigidBody3DData — interface @experimental

angularDamping: number
bodyType: BodyType
continuousCollision: boolean
enabled: boolean
fixedRotation: boolean
gravityScale: number
layer: number
linearDamping: number
mass: number

Rng — interface @experimental

chance: (p: number) => boolean
float: () => number
fork: (label: string | number) => Rng
int: (min: number, max: number) => number
nextU32: () => number
pick: <T>(items: readonly T[]) => T
shuffle: <T>(items: readonly T[]) => T[]
weighted: <T>(items: readonly T[], weight: (item: T) => number) => T

RngSeed — type @experimental

number | string | readonly (number | string)[]

RootMotionDelta — interface @experimental

position: Vec3
rotation: Quat

RootPlacement — interface @experimental

position: Vec3
rotation: Quat

RunCondition — type @public

() => boolean

RuntimeAssetSource — interface @experimental

backend: Backend
compressedTexture: ((path: string) => Promise<Uint8Array | "pending" | null>) | undefined
decodePixels: (path: string, flip: boolean, maxEdge?: number) => Promise<{ width: number; height: number; pixels: Uint8Array; }>
listAssetPaths: (() => string[]) | undefined
resolveAddress: ((ref: string) => string | null) | undefined
resolveRef: ((ref: string) => string) | undefined
spineCulling: ((skeleton: string, atlas: string) => { x: number; y: number; width: number; height: number; } | undefined) | undefined
textureImportSettings: ((ref: string) => ParsedTextureImportSettings | undefined) | undefined

RuntimeBuildConfig — interface @experimental

assetFailureCooldown: number | undefined
assetLoadTimeout: number | undefined
audioCacheBudget: number | undefined
defaultFontFamily: string | undefined
maxDeltaTime: number | undefined
maxFixedSteps: number | undefined
multiTouch: boolean | undefined
retainedBudget: number | undefined
sceneTransitionColor: string | undefined
sceneTransitionDuration: number | undefined
textCanvasSize: number | undefined
textureCacheBudget: number | undefined

RuntimeConfig — const @experimental

{ sceneTransitionDuration: number; sceneTransitionColor: { r: number; g: number; b: number; a: number; }; defaultFontFamily: string; maxDeltaTime: number; maxFixedSteps: number; textCanvasSize: number; assetLoadTimeout: number; assetFailureCooldown: number; multiTouch: boolean; textureCacheBudget: number; audioCacheBudget: number; retainedBudget: number; }

RuntimeInitConfig — interface @experimental

achievements: string[] | undefined
aot: { module: string | BufferSource; manifest: AotManifest; } | undefined
app: App
aspectRatio: number | undefined
audioConfig: AudioProjectConfig | undefined
catalog: Catalog | undefined
cellDocuments: ReadonlyMap<string, SceneData> | undefined
debugChannel: DebugChannelConfig | undefined
firstScene: string
manifest: AddressableManifest | ManifestModel | null | undefined
module: ESEngineModule | null
persistUpdateKey: string | undefined
physics3dBackend: Physics3DBackend | undefined
physics3dWorld: Partial<Physics3DWorldConfig> | undefined
physicsConfig: Physics2DPluginConfig | undefined
physicsEnabled: boolean | undefined
physicsModule: PhysicsWasmModule | null | undefined
remoteRoot: string | undefined
runtime: RuntimeBuildConfig | undefined
scenes: { name: string; data?: SceneData; path?: string; }[]
screenFit: { designWidth: number; designHeight: number; scaleMode: number; matchWidthOrHeight: number; } | undefined
source: RuntimeAssetSource
spineManager: SpineManager | null | undefined
spineModule: SpineWasmModule | null | undefined
steamAppId: number | undefined
uiTheme: "dark" | "light" | undefined
uiThemeOverrides: ThemeOverrides | undefined
worlds: WorldManifest[] | undefined

RuntimeOnly — const @public

ComponentDef<{}>

SCENE_FORMAT_VERSION — const @experimental

4

SCREEN_FIT_OFF — const @experimental

-1

SH_BASIS_SCALE — const @experimental

readonly [0.282095, 0.488603, 0.488603, 0.488603, 1.092548, 1.092548, 0.315392, 1.092548, 0.546274]

SH_COSINE_BAND — const @experimental

readonly [1, number, number, number, 0.25, 0.25, 0.25, 0.25, 0.25]

SIDE_MODULES — const @experimental

Record<BuiltinSideModuleId, SideModuleDescriptor>

SPINE_MOTION — const @experimental

"spine"

SPINE_VERSIONS — const @experimental

readonly SpineVersion[]

SPRITE_MOTION — const @experimental

"sprite"

STATE_PATH_SEP — const @experimental

"/"

STATIC_BATCH_DEFAULTS — const @experimental

StaticBatchLimits

SWAY_PUSHERS — const @experimental

8

SafeArea — const @experimental

ComponentDef<SafeAreaData>

SafeAreaData — interface @experimental

applyBottom: boolean
applyLeft: boolean
applyRight: boolean
applyTop: boolean
avoidHostMenu: boolean

SafeAreaPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
dependencies: "uiLayout"[]
name: "safeArea"
static new (): SafeAreaPlugin
static prototype: SafeAreaPlugin

SampleDeps — interface @experimental

getComponent: (name: string) => AnyComponentDef | undefined
resolveChild: (root: Entity, childPath: string) => Entity | null
world: SampleWorld

SampleOptions — interface @experimental

skipChannel: ((childPath: string, component: string, property: string) => boolean) | undefined

SampleWorld — interface @experimental

get: (entity: Entity, def: AnyComponentDef) => Record<string, unknown>
has: (entity: Entity, def: AnyComponentDef) => boolean
set: (entity: Entity, def: AnyComponentDef, data: Record<string, unknown>) => void

SaveEnvelope — interface @experimental

data: T
savedAt: number
version: number

SaveManager — class @experimental

has: (slot: string) => boolean
load: <T>(slot: string) => T | null
remove: (slot: string) => void
save: <T>(slot: string, data: T) => void
saveAsync: <T>(slot: string, data: T) => Promise<void>
savedAt: (slot: string) => number | null
static new (opts: SaveManagerOptions): SaveManager
static prototype: SaveManager

SaveManagerOptions — interface @experimental

keyPrefix: string | undefined
migrations: Record<number, SaveMigration> | undefined
now: (() => number) | undefined
storage: SaveStorage | undefined
version: number

SaveMigration — type @experimental

(data: unknown) => unknown

SaveStorage — interface @experimental

flush: (() => Promise<void>) | undefined
getJSON: <T>(key: string, defaultValue?: T) => T | undefined
has: (key: string) => boolean
remove: (key: string) => void
setJSON: <T>(key: string, value: T) => void

ScaleMode — type @experimental

(typeof ScaleMode)[keyof typeof ScaleMode]

ScatterParams — interface @experimental

cellKey: number
centerX: number
centerZ: number
count: number
heightMax: number
heightMin: number
maxScale: number
minScale: number
minUp: number
seed: number
size: number

SceneAmbientLight — interface @experimental

drawEnvironment: boolean
entityId: number
environment: string | null
environmentMissing: boolean
intensity: number
name: string
rotation: number
skipped: AmbientSkip | null

SceneAssetRefs — interface @experimental

byType: Map<string, Set<string>>
dragonBones: SpineAssetRef[]
meshMaterials: Set<string>
meshTextures: Set<string>
rawByType: Map<string, Set<string>>
rawFor: Map<string, string>
spines: SpineAssetRef[]
unresolved: string[]

SceneComponentCodec — interface @experimental

exportData: ((entity: number, data: Record<string, unknown>) => void) | undefined
importData: ((entity: number, outOfBand: Record<string, unknown>) => void) | undefined
outOfBandFields: readonly string[] | undefined

SceneComponentData — interface @experimental

data: Record<string, unknown>
type: string

SceneConfig — interface @beta

cleanup: ((ctx: SceneContext) => void) | undefined
data: SceneData | undefined
discardPrepared: (() => number) | undefined
externalEntities: (() => ReadonlyMap<number, Entity>) | undefined
name: string
onPhase: ((phase: string, ms: number) => void) | undefined
path: string | undefined
prepare: (() => Promise<void>) | undefined
readyRenderPrograms: (() => Promise<RenderReadiness>) | undefined
setup: ((ctx: SceneContext) => void | Promise<void>) | undefined
systems: { schedule: Schedule; system: SystemDef; }[] | undefined

SceneContext — interface @beta

adopt: (entity: Entity) => void
bindPostProcess: (camera: Entity, stack: PostProcessStack) => void
despawn: (entity: Entity) => void
entities: ReadonlySet<number>
name: string
registerDrawCallback: (id: string, fn: DrawCallback) => void
setPersistent: (entity: Entity, persistent: boolean) => void
spawn: () => Entity
trackAssetScope: (scope: AssetScope) => void
trackAssets: (byType: ReadonlyMap<string, ReadonlySet<string>>) => void
unbindPostProcess: (camera: Entity) => void

SceneDark — type @experimental

'no-lights' | 'no-enabled-light'

SceneData — interface @experimental

deferredInstances: DeferredRecord[] | undefined
entities: SceneEntityData[]
generator: string | undefined
name: string
textureMetadata: Record<string, TextureMetadata> | undefined
version: string | number

SceneEntityData — interface @experimental

children: number[]
components: SceneComponentData[]
id: number
name: string
parent: number | null
visible: boolean | undefined

SceneEntry — type @experimental

SceneEntityData | PrefabInstanceEntry

SceneLoadCancelled — class @experimental

static new (name: string): SceneLoadCancelled
static prototype: SceneLoadCancelled

SceneLoadOptions — interface @experimental

abortOnMissingAssets: boolean | undefined
assetBaseUrl: string | undefined
assets: Assets | undefined
collectAssets: LoadedSceneAssets | undefined
externalEntities: ReadonlyMap<number, number> | undefined
onMissingAssets: MissingAssetCallback | undefined
onPhase: ScenePhaseSink | undefined
onProgress: SceneLoadProgressCallback | undefined

SceneLoadProgressCallback — type @beta

(loaded: number, total: number) => void

SceneManager — const @beta

ResourceDef<SceneManagerState>

SceneManagerState — class @beta

@internal assetScopeFor: (name: string) => AssetScope | null
bringToTop: (name: string) => void
discardPrepared: (name: string) => number
getActive: () => string | null
getActiveScenes: () => string[]
getInitial: () => string | null
getLoadOrder: () => string[]
getLoaded: () => string[]
getLoading: () => string[]
getScene: (name: string) => SceneContext | null
getSceneStatus: (name: string) => SceneStatus | null
isActive: (name: string) => boolean
isLoaded: (name: string) => boolean
isPaused: (name: string) => boolean
isSleeping: (name: string) => boolean
isTransitioning: () => boolean
load: (name: string, onProgress?: SceneLoadProgressCallback) => Promise<SceneContext>
loadAdditive: (name: string, onProgress?: SceneLoadProgressCallback) => Promise<SceneContext>
pause: (name: string) => void
prepare: (name: string) => Promise<void>
readyRenderPrograms: (name: string) => Promise<RenderReadiness>
register: (config: SceneConfig) => void
reload: (options?: TransitionOptions) => Promise<void>
reset: () => void
resume: (name: string) => void
setInitial: (name: string) => void
sleep: (name: string) => void
switchTo: (name: string, options?: TransitionOptions) => Promise<void>
unload: (name: string, options?: TransitionOptions) => Promise<void>
updateTransition: (dt: number) => void
wake: (name: string) => void
whenLoadsSettle: () => Promise<void>
static new (app: App): SceneManagerState
static prototype: SceneManagerState

SceneMigrationResult — interface @experimental

data: SceneData
fromVersion: number
migrated: boolean
retired: string[]
toVersion: number

SceneOrigins — const @experimental

ResourceDef<Map<number, number>>

SceneOwner — const @experimental

ComponentDef<SceneOwnerData>

SceneOwnerData — interface @experimental

persistent: boolean
scene: string

SceneStatus — type @beta

'loading' | 'running' | 'paused' | 'sleeping' | 'unloading'

SceneStreamHost — interface @experimental

isLoaded: (name: string) => boolean
isSleeping: (name: string) => boolean
loadAdditive: (name: string) => Promise<unknown>
sleep: (name: string) => void
unload: (name: string) => Promise<void>
wake: (name: string) => void

SceneStreaming — const @experimental

ResourceDef<SceneStreamingController>

SceneStreamingConfig — interface @experimental

loadRadius: number
policy: StreamPolicy | undefined
unloadRadius: number

SceneStreamingController — class @experimental

clear: () => void
configure: (config: SceneStreamingConfig) => void
getActive: () => string[]
getFocusEntity: () => Entity | null
register: (cell: StreamCell) => void
setFocus: (x: number, y: number, z?: number) => void
setFocusEntity: (entity: Entity | null) => void
unregister: (scene: string) => void
update: () => void
static new (host: SceneStreamHost, config?: SceneStreamingConfig): SceneStreamingController
static prototype: SceneStreamingController

Schedule — enum @public

First = 1
FixedPostUpdate = 12
FixedPreUpdate = 10
FixedUpdate = 11
Last = 5
PostUpdate = 4
PreUpdate = 2
Startup = 0
Update = 3

ScopeCost — interface @experimental

ms: number
name: string
parent: string | undefined
remainder: ScopeRemainder
system: string

ScopeRemainder — type @experimental

'work' | 'wait'

Scores — const @experimental

{ readonly available: boolean; submit(score: number): Promise<void>; }

ScreenAxis — interface @experimental

depth: number
dx: number
dy: number

ScreenInfo — class @experimental

dpr: number
height: number
on: <K extends keyof ScreenInfoEvents>(event: K, handler: (...args: ScreenInfoEvents[K]) => void) => () => void
orientation: ScreenOrientation
update: (width: number, height: number, dpr?: number) => void
width: number
static new (): ScreenInfo
static prototype: ScreenInfo

ScreenInfoEvents — interface @experimental

orientationchange: [orientation: ScreenOrientation]
resize: [width: number, height: number]

ScreenOrientation — enum @experimental

Landscape = "landscape"
Portrait = "portrait"

ScreenOverlay — const @experimental

ResourceDef<ScreenOverlayData>

ScreenOverlayData — interface @experimental

active: boolean
layerMask: number
pointerX: number
pointerY: number
projection: Float32Array<ArrayBufferLike>
surfaceH: number
surfaceW: number
vpH: number
vpW: number
vpX: number
vpY: number

ScreenRect — interface @experimental

h: number
w: number
x: number
y: number

ScreenScaling — const @experimental

ResourceDef<ScreenScalingData>

ScreenScalingData — interface @experimental

designHeight: number
designWidth: number
matchWidthOrHeight: number
renderPolicy: RenderResolution | undefined
scaleMode: number

ScrollContainer — class @experimental

absorb: (axis: "x" | "y", velocity: number) => void
dispose: () => void
dragTo: (raw: Vec2) => void
getContentSize: () => Vec2
getDecelerationRate: () => number
getDragScroll: () => boolean
getMaxOffset: () => Vec2
getOffset: () => Vec2
getOverscroll: () => Vec2
getShowScrollbar: () => boolean
getViewportSize: () => Vec2
getWheelSpeed: () => number
isElastic: () => boolean
isSpringing: () => boolean
onOverscroll: (listener: OverscrollListener) => () => void
onScroll: (listener: ScrollListener) => () => void
releaseSpring: () => void
scrollBy: (delta: Vec2) => void
setContentSize: (size: Vec2) => void
setOffset: (offset: Vec2) => void
setSizes: (viewport: Vec2, content: Vec2) => void
setViewportSize: (size: Vec2) => void
tickSpring: (dt: number) => boolean
static new (opts: ScrollContainerOptions): ScrollContainer
static prototype: ScrollContainer

ScrollViewHandle — interface @experimental

content: number
dispose: () => void
entity: number
scroll: ScrollContainer
scrollTo: (offset: Vec2) => void
setContentSize: (size: Vec2) => void

ScrollViewOptions — interface @experimental

background: UIVisualInit | undefined
contentSize: Vec2
decelerationRate: number | undefined
direction: "both" | "horizontal" | "vertical" | undefined
dragScroll: boolean | undefined
host: ListViewHost
node: UINodeInit | undefined
onScroll: ((offset: Vec2) => void) | undefined
parent: number | undefined
viewportSize: Vec2
wheelSpeed: number | undefined
world: World

SegmentCollider2D — const @experimental

BuiltinComponentDef<SegmentCollider2DData>

SensorEvent — interface @experimental

sensorEntity: number
visitorEntity: number

SequenceClip — interface @experimental

duration: number
loop: boolean
root: string
speed: number
start: number
timeline: string

SequenceLayer — interface @experimental

asset: TimelineAsset
clip: SequenceClip
key: string
ref: string
root: number
time: number

SequenceLookup — type @experimental

(ref: string) => TimelineAsset | undefined

SequenceTrack — interface @experimental

childPath: string
clips: SequenceClip[]
name: string
type: "sequence"

ServicesPlugin — class @experimental

build: (app: App) => void
name: string
profileDomain: "services"
static new (): ServicesPlugin
static prototype: ServicesPlugin

ShaderHandle — type @experimental

number

ShaderParam — interface @experimental

default: number[]
defaultTexture: string | undefined
displayName: string
layered: true | undefined
name: string
range: { min: number; max: number; } | undefined
texel: "data" | undefined
type: ShaderParamType
ui: string | undefined
worldUnits: 1 | -1 | undefined

ShaderParamType — type @experimental

'float' | 'vec2' | 'vec3' | 'vec4' | 'color' | 'int' | 'texture'

ShaderReflection — interface @experimental

domain: string
params: ShaderParam[]

ShaderSources — const @experimental

{ SPRITE_VERTEX: string; SPRITE_FRAGMENT: string; COLOR_VERTEX: string; COLOR_FRAGMENT: string; }

ShaderWarmup — interface @experimental

frames: number
ms: number
pending: number
timedOut: boolean

ShaderWarmupOptions — interface @experimental

onProgress: ((pending: number, making: number) => void) | undefined
settleFrames: number | undefined
timeoutMs: number | undefined

ShadowCaster2D — const @experimental

BuiltinComponentDef<ShadowCaster2DData>

ShadowCaster2DData — interface @experimental

enabled: boolean
path: Vec2[]
size: Vec2

ShadowStatus — interface @experimental

deniedCasters: number
granted: number
reducedCasters: number
refusal: "atlas-full" | "none" | "tile-budget" | "tile-too-large"
requested: number

ShapeRenderer — const @experimental

BuiltinComponentDef<ShapeRendererData>

ShapeRendererData — interface @experimental

color: Color
cornerRadius: number
enabled: boolean
layer: number
parallax: Vec2
shapeType: ShapeType
size: Vec2

ShapeType — enum @experimental

Capsule = 1
Circle = 0
RoundedRect = 2

SheetGrid — interface @experimental

cellHeight: number
cellWidth: number
margin: number
pageHeight: number
pageWidth: number
spacing: number

Shelter — interface @experimental

dry: number
hx: number
hy: number
x: number
y: number

ShotState — interface @experimental

curve: number
from: string | null
to: string
weight: number

SideModuleDescriptor — interface @experimental

file: string
globalName: string | undefined

SideModuleHost — interface @experimental

acquire: (id: SideModuleId) => Promise<SideModule | null>
dispose: (() => void) | undefined
onDispose: ((release: () => void) => void) | undefined
source: ((id: SideModuleId) => Promise<SideModuleSource | null>) | undefined

SideModuleId — type @experimental

BuiltinSideModuleId | (string & {})

SightPoint — interface @experimental

x: number
y: number

SightRing — type @experimental

readonly SightPoint[]

SightTarget — const @experimental

ComponentDef<SightTargetData>

SightTargetData — interface @experimental

enabled: boolean
fadeTime: number
hiddenOpacity: number

SightViewer — const @experimental

ComponentDef<SightViewerData>

SightViewerData — interface @experimental

enabled: boolean
radius: number

Signal — interface @experimental

get: () => T
set: (value: T) => void
subscribe: (fn: (value: T) => void) => () => void
update: (fn: (prev: T) => T) => void

SimulationSpace — enum @beta

Local = 1
World = 0

SixDOFJoint3D — const @experimental

ComponentDef<SixDOFJoint3DData>

SixDOFJoint3DData — interface @experimental

anchor: Vec3
angularVelocity: Vec3
axis: Vec3
breakForce: number
breakTorque: number
collideConnected: boolean
connectedEntity: number
enableMotor: boolean
enabled: boolean
linearVelocity: Vec3
maxMotorForce: number
maxMotorTorque: number
normalAxis: Vec3
rotationLower: Vec3
rotationMotion: Vec3
rotationUpper: Vec3
translationLower: Vec3
translationMotion: Vec3
translationUpper: Vec3

SkeletalFieldMeta — interface @public

atlasField: string
runtime: string
skeletonField: string

SkeletalPreview — class @experimental

dispose: () => void
height: number
live: boolean
render: (viewProjection: Float32Array) => Promise<ImageData | null>
submit: (batch: SkeletalPreviewBatch) => boolean
width: number
static create: (module: unknown, w: number, h: number) => SkeletalPreview | null
static new (core: SkeletalPreviewCore, id: number, width: number, height: number): SkeletalPreview
static prototype: SkeletalPreview

SkeletalPreviewBatch — interface @experimental

blendMode: number
depth: number | undefined
indexCount: number
indices: Uint8Array<ArrayBufferLike>
layer: number | undefined
materialId: number | undefined
premultipliedColor: boolean | undefined
textureId: number
transform: Float32Array<ArrayBufferLike>
vertexCount: number
vertices: Uint8Array<ArrayBufferLike>

SkyClockState — interface @experimental

driftX: number
driftZ: number
evolve: number
upperDriftX: number
upperDriftZ: number

SkyEffectSource — interface @experimental

colors: EffectColorDef[] | undefined
glsl: string
groundShadow: boolean | undefined
label: string
textures: Record<string, () => BuiltinTexture> | undefined
type: string
uniforms: EffectUniformDef[] | undefined
wgsl: string

SkyRadiance — type @experimental

(dx: number, dy: number, dz: number,
                           out: Float32Array, at: number) => void

SkySpec — type @experimental

| { kind: 'flat'; rgb: readonly [number, number, number] }
    /** An environment's nine irradiance coefficients as the frame reads them:
     *  turned `yaw` radians about +Y and scaled by `tint`. */
    | { kind: 'sh'; irradiance: readonly number[]; yaw: number; tint: readonly [number, number, number] }

SkyUnavailable — type @experimental

'no-ambient' | 'no-environment' | 'missing' | 'off' | 'unusable'

SliceBorder — interface @experimental

bottom: number
left: number
right: number
top: number

SliderHandle — interface @experimental

dispose: () => void
entity: number
fillEntity: number
getValue: () => number
handleEntity: number
setValue: (value: number) => void
trackEntity: number

SliderJoint2D — const @experimental

ComponentDef<SliderJoint2DData>

SliderJoint3D — const @experimental

ComponentDef<SliderJoint3DData>

SliderJoint3DData — interface @experimental

anchor: Vec3
axis: Vec3
breakForce: number
breakTorque: number
collideConnected: boolean
connectedEntity: number
enableLimit: boolean
enableMotor: boolean
enabled: boolean
lowerTranslation: number
maxMotorForce: number
motorSpeed: number
translation: number
upperTranslation: number

SliderOptions — interface @experimental

disabled: boolean | undefined
events: UIEventQueue
fillVisual: UIVisualInit | undefined
focusable: boolean | undefined
handleVisual: UIVisualInit | undefined
handleWidth: number | undefined
max: number | undefined
min: number | undefined
node: UINodeInit | undefined
onChange: ((value: number, entity: Entity) => void) | undefined
parent: number | undefined
step: number | undefined
tabIndex: number | undefined
trackVisual: UIVisualInit | undefined
value: number | undefined
world: World

SnapshotComponent — interface @experimental

data: Record<string, unknown>
type: string

SnapshotEntity — interface @experimental

children: number[]
components: SnapshotComponent[]
hidden: boolean | undefined
hideable: boolean | undefined
id: number
name: string
parent: number | null
src: number | undefined

SocketReadyState — type @experimental

PlatformSocketReadyState

SortingGroup — const @experimental

BuiltinComponentDef<SortingGroupData>

SortingGroupData — interface @beta

enabled: boolean
layer: number
order: number

SoundEventAsset — interface @beta

bus: string
clips: SoundEventClip[]
cooldown: number
maxInstances: number
mode: SoundEventMode
playbackRate: [number, number]
priority: number
spatial: SpatialAudioConfig | undefined
version: 1
volume: [number, number]

SoundEventClip — interface @beta

clip: string
weight: number

SoundEventEmitter — interface @beta

dispose: () => void
disposed: boolean
ref: string
trigger: (position?: Vec3) => SoundEventHandle

SoundEventHandle — interface @beta

currentTime: number
duration: number
error: string | null
id: number
isPlaying: boolean
onEnd: (() => void) | undefined
pause: () => void
ready: Promise<SoundEventStatus>
reason: SoundEventRejection | null
resume: () => void
selection: Readonly<SoundEventSelection> | null
setLoop: (loop: boolean) => void
setPan: (pan: number) => void
setPlaybackRate: (rate: number) => void
setVolume: (volume: number) => void
status: SoundEventStatus
stop: () => void

SoundEventMode — type @beta

'random' | 'no-repeat' | 'sequence'

SoundEventPlayback — class @beta

@internal resetOwners: () => void
dispose: () => void
getStats: () => SoundEventStats
load: (ref: string, options?: { owner?: Entity; seed?: number; alive?: () => boolean; }) => Promise<SoundEventEmitter | null>
stopAll: () => void
stopOwner: (owner: Entity) => void
update: (delta: number, listener?: Vec3, right?: Vec3) => void
static new (audio: AudioAPI, resources: () => Resources | null, ownerAlive?: (owner: Entity) => boolean, ownerPosition?: (owner: Entity) => Vec3 | null): SoundEventPlayback
static prototype: SoundEventPlayback

SoundEventRejection — type @beta

'disposed' | 'owner-gone' | 'cooldown' | 'event-limit'
    | 'empty' | 'zero-weight' | 'missing-position' | 'load-failed' | 'global-limit' | 'backend-refused'

SoundEventSelection — interface @beta

clip: string
playbackRate: number
slot: number
volume: number

SoundEventSelectionResult — type @beta

{ selection: SoundEventSelection; reason?: never }
    | { selection: null; reason: 'empty' | 'zero-weight' }

SoundEventSelector — class @beta

next: () => SoundEventSelectionResult
static new (asset: SoundEventAsset, seed?: number): SoundEventSelector
static prototype: SoundEventSelector

SoundEventSource — const @beta

ComponentDef<SoundEventSourceData>

SoundEventSourceData — interface @beta

enabled: boolean
event: string
playOnAwake: boolean
seed: number

SoundEventStats — interface @beta

active: number
admitted: number
definitions: number
emitters: number
ended: number
pendingClips: number
pendingDefinitions: number
played: number
reasons: Partial<Record<SoundEventRejection, number>>
rejected: number
stopped: number

SoundEventStatus — type @beta

'loading' | 'playing' | 'paused' | 'ended' | 'stopped' | 'rejected'

SoundEvents — const @beta

ResourceDef<SoundEventPlayback>

SourceDelta — interface @experimental

added: readonly AddedEntity[]
overrides: readonly PrefabOverride[]
removed: readonly string[]

SpatialAudioConfig — interface @experimental

maxDistance: number
model: AttenuationModel
refDistance: number
rolloff: number

SpawnOverride — type @beta

Omit<PrefabOverride, 'prefabEntityId'> & { prefabEntityId?: string }

Speculation — const @experimental

ResourceDef<SpeculationInstance>

SpeculationInstance — class @experimental

replay: (body: (commands: CommandsInstance) => SpeculationOutcome) => ReplayReport
run: (body: (commands: CommandsInstance) => SpeculationOutcome) => SpeculationOutcome
static new (world: World, resources: ResourceStorage, events: EventRegistry | null): SpeculationInstance
static prototype: SpeculationInstance

SpeculationOutcome — type @experimental

'commit' | 'abandon'

SphereCollider3D — const @experimental

BuiltinComponentDef<SphereCollider3DData>

SphereCollider3DData — interface @experimental

center: Vec3 | undefined
enabled: boolean
friction: number
isSensor: boolean
radius: number
restitution: number

SphereNode — interface @experimental

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

SphereTreeParams — interface @experimental

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

Spine — const @beta

ResourceDef<SpineManager>

SpineAnimation — const @beta

BuiltinComponentDef<SpineAnimationData>

SpineAnimationData — interface @beta

animation: string
atlasPath: string
color: Color
enabled: boolean
flipX: boolean
flipY: boolean
layer: number
loop: boolean
material: number
playing: boolean
skeletonPath: string
skeletonScale: number
skin: string
timeScale: number

SpineAnimationDriver — interface @experimental

setAnimation: (entity: Entity, animation: string, loop: boolean) => void

SpineCullingContract — interface @experimental

atlas: string
bounds: SpineCullingRect

SpineCullingRect — interface @experimental

height: number
width: number
x: number
y: number

SpineEvents — const @experimental

ResourceDef<SpineEventsData>

SpineLoadResult — interface @experimental

error: string | undefined
success: boolean

SpineManifestContract — interface @experimental

atlas: string
cullingBounds: SpineCullingRect

SpinePlugin — class @experimental

build: (app: App) => void
cleanup: () => void
finish: (app: App) => void
name: string
setSpineManager: (manager: SpineManager) => void
spineManager: SpineManager | null
static new (manager?: SpineManager): SpinePlugin
static prototype: SpinePlugin

SpineTrack — interface @experimental

blendIn: number
childPath: string
clips: SpineClip[]
name: string
type: "spine"

SpineVersion — type @experimental

'2.1' | '3.8' | '4.1' | '4.2' | '4.3'

Splat — interface @experimental

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

Spline — const @experimental

ComponentDef<SplineData>

SplineCurve — class @experimental

closed: boolean
count: number
length: number
nearest: (x: number, z: number) => SplineNearest
position: (s: number) => [number, number, number]
tangent: (s: number) => [number, number, number]
width: (s: number) => number
static new (points: readonly SplinePoint[], closed?: boolean): SplineCurve
static prototype: SplineCurve

SplineData — interface @experimental

closed: boolean
points: SplinePoint[]

SplineNearest — interface @experimental

distance: number
s: number
side: number

SplinePlugin — class @experimental

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

SplinePoint — interface @experimental

width: number
x: number
y: number
z: number

SpringBone — const @experimental

BuiltinComponentDef<SpringBoneData>

SpringBoneAPI — class @experimental

release: (root: Entity) => void
reset: (root: Entity) => void
snapshot: (root: Entity) => SpringBoneParticle[]
update: (dt: number) => void
static new (module: NonNullable<EngineApi>, registry: CppRegistry): SpringBoneAPI
static prototype: SpringBoneAPI

SpringBoneCollider — const @experimental

BuiltinComponentDef<SpringBoneColliderData>

SpringBoneColliderData — interface @experimental

height: number
offset: Vec3
radius: number
shape: SpringBoneShape

SpringBoneData — interface @experimental

colliders: number[]
drag: number
enabled: boolean
endLength: number
gravity: Vec3
radius: number
stiffness: number
weight: number
wind: Vec3
windFrequency: number
windGust: number

SpringBoneParticle — interface @experimental

parent: number
pose: [number, number, number]
position: [number, number, number]

SpringBonePlugin — class @experimental

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

SpringBoneRes — const @experimental

ResourceDef<SpringBoneAPI>

Sprite — const @public

BuiltinComponentDef<SpriteData>

SpriteAnimClip — interface @experimental

events: SpriteAnimEvent[] | undefined
fps: number
frames: SpriteAnimFrame[]
labels: Record<string, number> | undefined
loop: boolean
name: string

SpriteAnimEvent — interface @experimental

data: unknown
frame: number
name: string

SpriteAnimEventHandler — type @experimental

(event: SpriteAnimEvent, entity: Entity) => void

SpriteAnimFrame — interface @experimental

duration: number | undefined
pivot: { x: number; y: number; } | undefined
size: { x: number; y: number; } | undefined
texture: number
uvOffset: { x: number; y: number; } | undefined
uvScale: { x: number; y: number; } | undefined

SpriteAnimTrack — interface @experimental

childPath: string
clip: string
name: string
startTime: number
type: "spriteAnim"

SpriteAnimation — const @experimental

ResourceDef<SpriteAnimationAPI>

SpriteAnimationAPI — class @experimental

@internal useAssetClips: (source: (ref: string) => SpriteAnimClip | undefined) => void
aliasClip: (name: string, clip: SpriteAnimClip) => void
clearClips: () => void
getClip: (name: string) => SpriteAnimClip | undefined
gotoFrame: (animator: SpriteAnimatorData, frameIndex: number, andPlay?: boolean) => void
gotoLabel: (animator: SpriteAnimatorData, label: string, andPlay?: boolean) => void
onEvent: (entity: Entity, handler: SpriteAnimEventHandler) => () => void
onEventGlobal: (handler: SpriteAnimEventHandler) => () => void
registerClip: (clip: SpriteAnimClip) => void
removeEntityListeners: (entity: Entity) => void
unregisterClip: (name: string) => void
update: (world: World, deltaTime: number) => void
static new (): SpriteAnimationAPI
static prototype: SpriteAnimationAPI

SpriteAnimator — const @beta

ComponentDef<SpriteAnimatorData>

SpriteAnimatorData — interface @beta

clip: string
currentFrame: number
enabled: boolean
finished: boolean
frameTimer: number
loop: boolean
playing: boolean
speed: number

SpriteData — interface @public

color: Color
drawMode: SpriteDrawMode | undefined
enabled: boolean
flipX: boolean
flipY: boolean
layer: number
lit: boolean
maskInteraction: SpriteMaskInteraction | undefined
material: number
order: number | undefined
parallax: Vec2
pivot: Vec2
size: Vec2
texture: number
tileSize: Vec2
tileSpacing: Vec2
uvOffset: Vec2
uvScale: Vec2

SpriteDrawMode — enum @public

Auto = 0
NineSlice = 3
Simple = 1
Tiled = 2

SpriteFilter — const @experimental

{ createOutline(options?: OutlineFilterOptions): MaterialHandle; createGlow(options?: OutlineFilterOptions): MaterialHandle; createDropShadow(options?: DropShadowFilterOptions): MaterialHandle; setOutlineColor(material: MaterialHandle, color: { r: number; g: number; b: number; a: number; }): void; setOutlineWidth(material: MaterialHandle, width: number): void; setShadowOffset(material: MaterialHandle, x: number, y: number): void; setShadowBlur(material: MaterialHandle, blur: number): void; }

SpriteMask — const @experimental

BuiltinComponentDef<SpriteMaskData>

SpriteMaskData — interface @beta

alphaCutoff: number
enabled: boolean
limitRange: boolean
rangeEndLayer: number
rangeEndOrder: number

SpriteMaskInteraction — enum @public

None = 0
VisibleInside = 1
VisibleOutside = 2

StaleOverride — interface @experimental

nestedAt: string | undefined
override: PrefabOverride
reason: string
site: "instance" | "nested" | "variant"

StaticBatch — const @experimental

ComponentDef<StaticBatchData>

StaticBatchData — interface @experimental

batched: number
group: string
state: number

StaticBatchDrawState — interface @experimental

castShadows: boolean | undefined
color: { r: number; g: number; b: number; a: number; }
cullBackfaces: boolean
group: string
layer: number
lit: boolean
material: number
normalMap: number
parallax: { x: number; y: number; }
texture: number

StaticBatchGroup — interface @experimental

bytes: number
drawsBefore: number
entity: number
parts: number[]
triangles: number
vertices: number

StaticBatchLimits — interface @experimental

cellSize: number
maxVertices: number

StaticBatchPlugin — class @experimental

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

StaticBatchRefusal — type @experimental

| 'no-mesh'
    /** Posed by a skeleton: one draw can only be in one pose. */
    | 'skinned'
    /** Carries blend shapes: one draw can only be in one shape. */
    | 'morph'
    /** Chooses among levels of detail at run time, which a merged mesh cannot. */
    | 'lod'
    /** A billboard: it turns to each view, and a merged mesh is fixed where it was baked. */
    | 'billboard'
    /** Lit by a bake: its atlas patch belongs to the object, not to the batch. */
    | 'baked'
    /** Blended: its result depends on order, and merging is the loss of order. */
    | 'blended'
    /** Moves (a dynamic body or a character): a static batch bakes where it stands. */
    | 'moves'
    /** Switched off, so there is nothing to draw. */
    | 'disabled'
    /** Vertex layout the merge cannot transform (positions or normals not float). */
    | 'layout'
    /** The only member of its group: merging it would cost memory and save nothing. */
    | 'alone'

StaticBatchReport — interface @experimental

groups: StaticBatchGroup[]
refused: Map<number, StaticBatchRefusal>

StaticBatchState — const @experimental

{ readonly Pending: 0; readonly Merged: 1; readonly Skinned: 2; readonly Morph: 3; readonly Lod: 4; readonly Blended: 5; readonly Moves: 6; readonly Baked: 7; readonly Alone: 8; readonly NoMesh: 9; readonly Layout: 10; readonly Disabled: 11; readonly Billboard: 12; }

StaticBatchSummary — interface @experimental

groups: { entity: number; parts: number[]; partCount: number; triangles: number; bytes: number; drawsBefore: number; }[]
refused: { reason: string; count: number; entities: number[]; }[]

StaticBatching — class @experimental

@internal busy_: boolean
@internal dirty_: boolean
@internal groups_: StaticBatchGroupState[]
@internal pending_: number
@internal refused_: Map<number, StaticBatchRefusal>
@internal seen_: Set<number>
@internal stable_: number
limits: StaticBatchLimits
pending: number
rebuild: () => void
report: () => StaticBatchReport
summary: () => StaticBatchSummary | null
static new (): StaticBatching
static prototype: StaticBatching

StaticBatchingRes — const @experimental

ResourceDef<StaticBatching>

Stats — const @experimental

ResourceDef<FrameStats>

StatsCollector — class @experimental

getFps: () => number
getFrameTimeMs: () => number
pushFrame: (deltaSeconds: number) => void
reset: () => void
static new (): StatsCollector
static prototype: StatsCollector

StatsOverlay — class @experimental

dispose: () => void
hide: () => void
show: () => void
update: (stats: FrameStats) => void
static new (container: HTMLElement, position?: StatsPosition): StatsOverlay
static prototype: StatsOverlay

StatsPlugin — class @experimental

build: (app: App) => void
cleanup: () => void
name: "stats"
static new (options?: StatsPluginOptions): StatsPlugin
static prototype: StatsPlugin

StatsPluginOptions — interface @experimental

container: HTMLElement | undefined
overlay: boolean | undefined
position: StatsPosition | undefined

StatsPosition — type @experimental

'top-left' | 'top-right' | 'bottom-left' | 'bottom-right'

StepKind — enum @experimental

Print = 1
Water = 0

StepSurface — const @experimental

ComponentDef<StepSurfaceData>

StepSurfaceData — interface @experimental

enabled: boolean
kind: StepKind
margin: number
round: boolean

Stick — const @public

(stick: "left" | "right", pad?: number) => Binding

Storage — const @experimental

{ flush(): Promise<void>; getString(key: string, defaultValue?: string): string | undefined; setString(key: string, value: string): void; getNumber(key: string, defaultValue?: number): number | undefined; setNumber(key: string, value: number): void; getBoolean(key: string, defaultValue?: boolean): boolean | undefined; setBoolean(key: string, value: boolean): void; getJSON<T>(key: string, defaultValue?: T): T | undefined; setJSON<T>(key: string, value: T): void; remove(key: string): void; has(key: string): boolean; clear(): void; }

StreamCell — interface @experimental

radius: number
scene: string
x: number
y: number
z: number | undefined

StreamDecision — interface @experimental

toActivate: string[]
toDeactivate: string[]

StreamMove — interface @experimental

edge: number
handle: number

StreamPlane — enum @experimental

Ground = 0
Screen = 1

StreamPolicy — type @experimental

'unload' | 'sleep'

StreamedTexture — interface @experimental

edge: number
fullHeight: number
fullWidth: number
handle: number
seenAt: number
smallerSince: number
wanted: number

StreamedWorld — const @experimental

ComponentDef<StreamedWorldData>

StreamedWorldData — interface @experimental

cellSize: number
plane: StreamPlane

StudioPreviewReport — interface @experimental

environment: SceneAmbientLight | null
sceneDark: SceneDark | null
sceneLights: number
skyUnavailable: SkyUnavailable | null

SubEmitterTrigger — enum @beta

Birth = 1
Collision = 2
Death = 0

SubgraphInput — interface @beta

default: number
name: string
type: GraphType

SubgraphResolver — type @beta

(ref: string) => MaterialGraph | null

SubsystemActivity — type @experimental

'stepping' | 'idle' | 'inactive'

SubsystemEvent — interface @experimental

atMs: number
detail: string | undefined
id: string
phase: SubsystemPhase
seq: number

SubsystemPhase — type @experimental

'registered' | 'initializing' | 'ready' | 'error'

SubsystemRegistry — class @experimental

getStatuses: () => SubsystemStatus[]
markError: (id: string, reason?: string) => void
markStepped: (id: string) => void
phaseOf: (id: string) => SubsystemPhase | undefined
recentEvents: (limit?: number) => SubsystemEvent[]
register: (id: string, opts?: { displayName?: string; dependsOn?: string[]; }) => void
subscribe: (fn: () => void) => () => void
transition: (id: string, phase: SubsystemPhase, detail?: string) => void
static new (): SubsystemRegistry
static prototype: SubsystemRegistry

SubsystemStatus — interface @experimental

activity: SubsystemActivity
dependsOn: readonly string[]
detail: string | undefined
displayName: string
id: string
lastError: string | undefined
phase: SubsystemPhase
phaseAgeMs: number

SwayPusher — const @experimental

ComponentDef<SwayPusherData>

SwayPusherData — interface @experimental

enabled: boolean
radius: number
strength: number

SwingTwistJoint3D — const @experimental

ComponentDef<SwingTwistJoint3DData>

SwingTwistJoint3DData — interface @experimental

anchor: Vec3
angularVelocity: Vec3
axis: Vec3
breakForce: number
breakTorque: number
collideConnected: boolean
connectedEntity: number
enableMotor: boolean
enabled: boolean
maxMotorTorque: number
normalAxis: Vec3
normalHalfConeAngle: number
planeHalfConeAngle: number
twistMaxAngle: number
twistMinAngle: number

SwipeDirection — type @experimental

'left' | 'right' | 'up' | 'down'

SyncPrefabResolver — type @experimental

(path: string) => PrefabData | null

SystemCost — interface @experimental

domain: string
ms: number
name: string
query: QueryCost | undefined

SystemDef — interface @public

@internal _fn: (...args: never[]) => void | Promise<void>
@internal _id: symbol
@internal _name: string
@internal _params: readonly SystemParam[]
@internal _runAfter: readonly string[] | undefined
@internal _runBefore: readonly string[] | undefined
@internal _runWhenPaused: boolean | undefined
@internal _touches: SystemTouches | (() => SystemTouches) | undefined

SystemOptions — interface @public

name: string | undefined
runAfter: string[] | undefined
runBefore: string[] | undefined
runWhenPaused: boolean | undefined
touches: SystemTouches | (() => SystemTouches) | undefined

SystemParam — type @public

| QueryDescriptor<readonly QueryArg[]>
    | ResDescriptor<unknown>
    | ResMutDescriptor<unknown>
    | CommandsDescriptor
    | EventWriterDescriptor<unknown>
    | EventReaderDescriptor<unknown>
    | RemovedQueryDescriptor<AnyComponentDef>
    | GetWorldDescriptor

SystemRunner — class @experimental

@internal useAot: (runtime: AotRuntime | null) => void
clearTimings: () => void
evict: (systemId: symbol) => void
getQueryCosts: () => ReadonlyMap<string, QueryCost> | null
getTimings: () => ReadonlyMap<string, number> | null
reset: () => void
run: (system: SystemDef) => void | Promise<void>
setTimingEnabled: (enabled: boolean) => void
static new (world: World, resources: ResourceStorage, eventRegistry?: EventRegistry): SystemRunner
static prototype: SystemRunner

SystemSet — interface @public

@internal _kind: "set"
@internal _name: string
@internal _runAfter: readonly string[] | undefined
@internal _runBefore: readonly string[] | undefined
@internal _runIf: RunCondition | undefined
@internal _systems: readonly SystemDef[]

SystemSetOptions — interface @public

runAfter: string[] | undefined
runBefore: string[] | undefined
runIf: RunCondition | undefined
systems: SystemDef[]

SystemTouches — interface @public

opaque: boolean | undefined
reads: readonly string[] | undefined
writes: readonly string[] | undefined

TERRAIN_TILE_BUDGET — const @experimental

number

TEXTURE_STREAMING_DEFAULTS — const @experimental

TextureStreamingOptions

THEME_COLOR_ROLES — const @experimental

readonly (keyof ThemeColors)[]

TIMELINE_FORMAT_VERSION — const @experimental

"1.3"

TIMELINE_MOTION — const @experimental

"timeline"

TPC_ATTACK — const @experimental

"attack"

TPC_DODGE — const @experimental

"dodge"

TPC_GROUNDED — const @experimental

"grounded"

TPC_JUMP — const @experimental

"jump"

TPC_SPEED — const @experimental

"speed"

TParams — type @experimental

Record<string, string | number>

TabViewHandle — interface @beta

dispose: () => void
entity: number
pages: readonly number[]
select: (index: number) => void
tabs: readonly number[]

TabViewOptions — interface @beta

events: UIEventQueue
labels: readonly string[]
node: UINodeInit | undefined
onChange: ((index: number, page: Entity) => void) | undefined
parent: number | undefined
selectedIndex: number | undefined
tabHeight: number | undefined
world: World

Takeover — interface @experimental

active: boolean
around: <T>(show: () => Promise<T>) => Promise<T>
begin: () => void
end: () => void

TakeoverHost — interface @experimental

isPaused: () => boolean
resumeAudio: () => void
setPaused: (paused: boolean) => void
suspendAudio: () => void

Terrain — const @experimental

ComponentDef<TerrainData>

TerrainBand2D — const @experimental

ComponentDef<TerrainBand2DData>

TerrainBand2DData — interface @experimental

collider: boolean
depth: number
edgeColor: { r: number; g: number; b: number; a: number; }
edgeTexture: number
edgeTile: number
edgeWidth: number
resolution: number
tile: number

TerrainBandBuild — interface @experimental

closed: boolean
edge: MeshRendererGeometry | null
geometry: MeshRendererGeometry
outline: Vec2[]

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; }

TerrainImage — interface @experimental

height: number
pixels: Uint8Array<ArrayBufferLike>
wide: Uint16Array<ArrayBufferLike> | undefined
width: number

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]

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"

TerrainTileEntry — interface @experimental

height: string
splat2: string | undefined
splat: string | undefined
x: number
z: number

TerrainTileStats — interface @experimental

bytes: number
evictions: number
reading: number
reads: number
resident: number

TerrainTilesDocument — interface @experimental

format: number
overview: string
overviewSplat2: string | undefined
overviewSplat: string | undefined
tileSamples: number
tiles: TerrainTileEntry[]
tilesX: number
tilesZ: number
version: 1

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>

Text — const @public

ComponentDef<TextData>

TextAlign — type @public

(typeof TextAlign)[keyof typeof TextAlign]

TextData — interface @public

align: TextAlign
bold: boolean
boxHeight: number | undefined
boxPivot: Vec2 | undefined
boxWidth: number | undefined
color: Color
content: string
enabled: boolean
font: number
fontFamily: string
fontSize: number
i18nKey: string
italic: boolean
layer: number
letterSpacing: number | undefined
lineHeight: number
overflow: TextOverflow
renderMode: TextRenderMode
richText: boolean
shadowBlur: number
shadowColor: Color
shadowOffsetX: number
shadowOffsetY: number
strokeColor: Color
strokeWidth: number
underline: boolean | undefined
verticalAlign: TextVerticalAlign
wordWrap: boolean

TextInit — interface @experimental

align: TextAlign | undefined
bold: boolean | undefined
boxHeight: number | undefined
boxPivot: Vec2 | undefined
boxWidth: number | undefined
color: Color | undefined
content: string | undefined
enabled: boolean | undefined
font: number | undefined
fontFamily: string | undefined
fontSize: number | undefined
i18nKey: string | undefined
italic: boolean | undefined
layer: number | undefined
letterSpacing: number | undefined
lineHeight: number | undefined
overflow: TextOverflow | undefined
renderMode: TextRenderMode | undefined
richText: boolean | undefined
shadowBlur: number | undefined
shadowColor: Color | undefined
shadowOffsetX: number | undefined
shadowOffsetY: number | undefined
strokeColor: Color | undefined
strokeWidth: number | undefined
underline: boolean | undefined
verticalAlign: TextVerticalAlign | undefined
wordWrap: boolean | undefined

TextInput — const @experimental

ComponentDef<TextInputData>

TextInputData — interface @experimental

backgroundColor: Color
color: Color
cursorPos: number
focused: boolean
font: number
fontFamily: string
fontSize: number
inputFilter: TextInputFilter
maxLength: number
multiline: boolean
padding: number
password: boolean
placeholder: string
placeholderColor: Color
placeholderI18nKey: string | undefined
readOnly: boolean
renderMode: TextRenderMode
textAlign: TextAlign
value: string

TextInputFilter — type @experimental

typeof TextInputFilter[keyof typeof TextInputFilter]

TextInputHandle — interface @experimental

dispose: () => void
entity: number
getValue: () => string
setValue: (value: string) => void

TextInputOptions — interface @experimental

backgroundColor: Color | undefined
color: Color | undefined
disabled: boolean | undefined
events: UIEventQueue
fontFamily: string | undefined
fontSize: number | undefined
maxLength: number | undefined
multiline: boolean | undefined
node: UINodeInit | undefined
onChange: ((value: string, entity: Entity) => void) | undefined
onSubmit: ((value: string, entity: Entity) => void) | undefined
padding: number | undefined
parent: number | undefined
password: boolean | undefined
placeholder: string | undefined
placeholderColor: Color | undefined
placeholderI18nKey: string | undefined
readOnly: boolean | undefined
renderMode: TextRenderMode | undefined
tabIndex: number | undefined
value: string | undefined
world: World

TextInputPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
dependencies: "focus"[]
name: "textInput"
static new (): TextInputPlugin
static prototype: TextInputPlugin

TextInspection — interface @experimental

horizontalOverflow: boolean
metrics: TextMetrics | null
unsupported: "complex-script" | "custom-font" | "invalid-box" | "rich-text" | null
verticalOverflow: boolean

TextInspectionOptions — interface @experimental

bold: boolean | undefined
customFont: boolean | undefined
fontFamily: string | undefined
fontSize: number
height: number
italic: boolean | undefined
letterSpacing: number | undefined
lineHeight: number | undefined
maxWidth: number | undefined
richText: boolean | undefined
width: number
wordWrap: boolean | undefined

TextMetrics — interface @experimental

height: number
lineCount: number
width: number

TextOverflow — type @public

(typeof TextOverflow)[keyof typeof TextOverflow]

TextPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
name: string
preload: (app: App, entity: Entity, text: string, options?: GlyphPreloadOptions) => GlyphPreload
static new (): TextPlugin
static prototype: TextPlugin

TextRenderMode — type @public

(typeof TextRenderMode)[keyof typeof TextRenderMode]

TextSegment — interface @experimental

bold: boolean
color: Color | null
fontSize: number | null
italic: boolean
text: string
type: "text"

TextVerticalAlign — type @public

(typeof TextVerticalAlign)[keyof typeof TextVerticalAlign]

TextureAtlas — const @experimental

{ pack(sources: readonly number[], options?: TextureAtlasOptions): TextureAtlasHandle | null; }

TextureAtlasHandle — interface @experimental

get: (source: number) => AtlasEntry | undefined
height: number
release: () => void
repaint: () => void
sprite: (source: number) => { texture: number; uvOffset: { x: number; y: number; }; uvScale: { x: number; y: number; }; }
texture: number
width: number

TextureAtlasOptions — interface @experimental

filter: "linear" | "nearest" | undefined
maxSize: number | undefined
padding: number | undefined

TextureCanvas — const @experimental

{ create(width: number, height: number, options?: TextureCanvasOptions): TextureCanvasHandle | null; }

TextureCanvasHandle — interface @experimental

clear: () => void
draw: (source: number, x: number, y: number, width?: number, height?: number) => void
height: number
release: () => void
texture: number
width: number

TextureCanvasOptions — interface @experimental

filter: "linear" | "nearest" | undefined

TextureFilter — type @experimental

(typeof TextureFilter)[keyof typeof TextureFilter]

TextureFormatRecord — interface @experimental

effective: UploadedGpuFormat
path: string
payload: "ktx2" | "raw"
reason: TextureUploadReason
target: CompressedTextureFormat | null

TextureFormatReport — interface @experimental

compressed: number
decoded: number
deviceFormats: readonly CompressedTextureFormat[]
deviceProbed: boolean
textures: readonly TextureFormatRecord[]

TextureHandle — type @experimental

number

TextureInfo — interface @experimental

fullHeight: number | undefined
fullWidth: number | undefined
handle: number
height: number
width: number

TextureRef — interface @experimental

slot: number | undefined
textureId: number

TextureStreaming — class @experimental

bytes: () => { now: number; full: number; }
enabled: boolean
failures: number
held: Set<number>
inFlight: number
moves: number
refused: Set<number>
restoring: Set<number>
textures: Map<number, StreamedTexture>
static new (): TextureStreaming
static prototype: TextureStreaming

TextureStreamingOptions — interface @experimental

budgetBytes: number
minEdge: number
shrinkAfter: number
unseenAfter: number

TextureStreamingPlugin — class @experimental

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

TextureStreamingRes — const @experimental

ResourceDef<TextureStreaming>

TextureUploadDecision — interface @experimental

effective: UploadedGpuFormat
payload: "ktx2" | "raw"
reason: TextureUploadReason
target: CompressedTextureFormat | null

TextureUploadReason — type @experimental

| 'compressed'
    | 'no-device-format'
    | 'transcode-failed'
    | 'not-block-aligned'
    | 'uncompressed-payload'

TextureWrap — type @experimental

(typeof TextureWrap)[keyof typeof TextureWrap]

ThemeColors — interface @beta

backdrop: Color
control: Color
controlActive: Color
controlFocus: Color
controlHover: Color
onPrimary: Color
primary: Color
primaryActive: Color
primaryHover: Color
surface: Color
surfaceElevated: Color
text: Color
track: Color

ThemeOverrides — interface @experimental

colors: Partial<ThemeColors> | undefined
type: Partial<ThemeType> | undefined

ThemeStyle — const @experimental

ComponentDef<ThemeStyleData>

ThemeStyleData — interface @experimental

input: { background?: ColorRole; text?: ColorRole; placeholder?: ColorRole; } | undefined
states: Record<string, keyof ThemeColors> | undefined
text: keyof ThemeColors | undefined
visual: keyof ThemeColors | undefined

ThemeTokens — interface @experimental

colors: ThemeColors
type: ThemeType

ThemeType — interface @experimental

body: number
label: number
title: number

TiledSource — class @experimental

@internal dirtyTiles: () => string[]
@internal ensureTileSplats: (tile: Tile, tx: number, tz: number, second: boolean) => void
@internal hasTile: (tx: number, tz: number) => boolean
@internal markDirty: (tx: number, tz: number) => void
@internal markOverviewDirty: () => void
@internal markSaved: () => void
@internal overviewDirty: boolean
@internal overviewSplats: (make: boolean, second: boolean) => { a: Splat | null; b: Splat | null; }
@internal readTile: (tx: number, tz: number) => Promise<Tile | null>
@internal tileAt: (tx: number, tz: number) => Tile | undefined
bounds: readonly [number, number, number, number]
budget: number
doc: TerrainTilesDocument
height: (x: number, z: number) => number | null
infinite: false
maxHeight: number
minHeight: 0
normal: (x: number, z: number) => [number, number, number] | null
overview: Heightfield
overviewBytes: number
overviewSpacing: number
paint: (x: number, z: number, h: number, ny: number) => LayerWeights
region: (x0: number, z0: number, spacing: number, count: number) => TerrainRegionSamples | Promise<TerrainRegionSamples>
samplesX: number
samplesZ: number
stats: () => TerrainTileStats
trim: (keep?: ReadonlySet<string>) => void
static new (doc: TerrainTilesDocument, params: Params, overview: Heightfield, overviewSplat: Splat | null, overviewSplat2: Splat | null, read: (path: string) => Promise<TerrainImage | null>, budget?: number): TiledSource
static prototype: TiledSource

Time — const @public

ResourceDef<TimeData>

TimeData — interface @public

delta: number
elapsed: number
fixedAlpha: number
fixedDelta: number
fixedTick: number
frameCount: number
scale: number
unscaledDelta: number

TimeDrive — const @experimental

{ readonly Lights: 1; readonly Sky: 2; readonly Fog: 4; readonly Exposure: 8; readonly Reflections: 16; readonly All: 31; }

TimeOfDay — const @experimental

ComponentDef<TimeOfDayData>

TimeOfDayData — interface @experimental

daySeconds: number
declination: number
drive: number
hour: number
latitude: number
north: number

TimeOfDayState — interface @experimental

daylight: number
exposure: number
fogBrightness: number
fogDusk: number
hour: number
light: number
lightDir: [number, number, number]
lightTint: [number, number, number]
moonDir: [number, number, number]
reflection: number
reflectionSaturation: number
sky: number
skyTint: [number, number, number]
sunAzimuth: number
sunDir: [number, number, number]
sunElevation: number

Timeline — const @experimental

ResourceDef<TimelineAPI>

TimelineAPI — class @experimental

@internal clearStates: () => void
@internal ensureState: (entity: Entity, wrapMode: WrapMode, speed: number) => TimelineState
@internal removeState: (entity: Entity) => void
@internal useAssetTimelines: (source: (ref: string) => TimelineAsset | undefined) => void
getAsset: (name: string) => TimelineAsset | undefined
getCurrentTime: (entity: Entity) => number
getState: (entity: Entity) => TimelineState | undefined
isPlaying: (entity: Entity) => boolean
pause: (entity: Entity) => void
play: (entity: Entity) => void
registerAsset: (name: string, asset: TimelineAsset) => void
setTime: (entity: Entity, time: number) => void
stop: (entity: Entity) => void
unregisterAsset: (name: string) => void
static new (flags_?: PlayerFlagChannel | null): TimelineAPI
static prototype: TimelineAPI

TimelineAsset — interface @experimental

duration: number
tracks: Track[]
type: "timeline"
version: string
wrapMode: WrapMode

TimelinePlayer — const @experimental

ComponentDef<TimelinePlayerData>

TimelinePlayerData — interface @experimental

finished: boolean
playing: boolean
speed: number
timeline: string
wrapMode: string

TimelinePlugin — class @experimental

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

TimelineShot — interface @experimental

curve: number
from: number | null
to: number
weight: number

TimerHandle — class @experimental

cancel: () => void
elapsed: number
id: number
isActive: boolean
pause: () => TimerHandle
repeatCount: number
reset: () => TimerHandle
resume: () => TimerHandle
static new (manager: TimerManager, id: number): TimerHandle
static prototype: TimerHandle

TimerManager — class @experimental

activeCount: number
cancel: (id: number) => void
cancelAll: () => void
delay: (seconds: number, callback: (timer: TimerHandle) => void) => TimerHandle
getElapsed: (id: number) => number
getRepeatCount: (id: number) => number
has: (id: number) => boolean
interval: (seconds: number, callback: (timer: TimerHandle) => void, maxRepeat?: number) => TimerHandle
pause: (id: number) => void
reset: (id: number) => void
resume: (id: number) => void
tick: (dt: number) => void
timeScale: number
static new (): TimerManager
static prototype: TimerManager

TimerRes — const @experimental

ResourceDef<TimerManager>

ToggleHandle — interface @experimental

dispose: () => void
entity: number
getValue: () => boolean
setDisabled: (disabled: boolean) => void
setValue: (value: boolean) => void

ToggleOptions — interface @experimental

background: UIVisualInit | undefined
check: { node?: UINodeInit; color?: Color; sprite?: number; } | undefined
disabled: boolean | undefined
events: UIEventQueue
focusable: boolean | undefined
interactionStates: Record<string, ButtonStateVisual> | undefined
isOn: boolean | undefined
node: UINodeInit | undefined
onChange: ((isOn: boolean, entity: Entity) => void) | undefined
parent: number | undefined
tabIndex: number | undefined
world: World

TooltipHandle — interface @beta

dispose: () => void
entity: number

TooltipOptions — interface @beta

content: string | undefined
node: UINodeInit | undefined
parent: number | undefined
settings: Partial<UITooltipData> | undefined
world: World

TouchPoint — interface @beta

id: number
x: number
y: number

Track — type @experimental

PropertyTrack | SpineTrack | SpriteAnimTrack | ParticleTrack | AudioTrack | ActivationTrack | MarkerTrack | CustomEventTrack | AnimFramesTrack | CameraTrack | SequenceTrack

TrackType — type @experimental

(typeof TrackType)[keyof typeof TrackType]

Trail — const @experimental

ResourceDef<TrailAPI>

TrailAPI — class @experimental

clear: (entity: Entity) => void
update: (dt: number) => void
static new (module: NonNullable<EngineApi>, registry: CppRegistry): TrailAPI
static prototype: TrailAPI

TrailPlugin — class @experimental

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

TrailRenderer — const @experimental

BuiltinComponentDef<TrailRendererData>

TrailRendererData — interface @experimental

blendMode: number
emitting: boolean
enabled: boolean
endColor: Color
endWidth: number
layer: number
material: number
minVertexDistance: number
startColor: Color
startWidth: number
texture: number
time: number

Transaction — class @experimental

add: (op: TransactionOp) => void
addDeferred: (op: TransactionOp) => void
id: string
label: string
opCount: number
redo: () => void
timestamp: number
undo: () => void
static new (label: string, id?: string): Transaction
static prototype: Transaction

TransactionManager — class @experimental

begin: (label: string) => Transaction
canRedo: () => boolean
canUndo: () => boolean
clear: () => void
commit: (tx: Transaction) => void
peekRedo: () => Transaction | null
peekUndo: () => Transaction | null
redo: () => Transaction | null
rollback: (tx: Transaction) => void
undo: () => Transaction | null
static new (options?: TransactionManagerOptions): TransactionManager
static prototype: TransactionManager

TransactionManagerOptions — interface @experimental

historyLimit: number | undefined

TransactionOp — interface @experimental

forward: () => void
reverse: () => void

Transform — const @public

BuiltinComponentDef<TransformData>

TransformData — interface @public

position: Vec3
rotation: Quat
scale: Vec3
worldPosition: Vec3
worldRotation: Quat
worldScale: Vec3

TransitionConfig — interface @beta

color: Color | undefined
duration: number
type: "fade"

TransitionOptions — interface @beta

color: Color | undefined
duration: number | undefined
keepPersistent: boolean | undefined
onComplete: (() => void) | undefined
onStart: (() => void) | undefined
transition: "fade" | "none" | undefined

TreeDataSource — interface @beta

getChildren: (item: T) => readonly T[]
getId: (item: T) => TreeItemId
getLabel: (item: T) => string
getRoots: () => readonly T[]
isSelectable: ((item: T) => boolean) | undefined
subscribe: ((listener: () => void) => Unsubscribe) | undefined

TreeDropRequest — interface @beta

position: "after" | "before" | "inside"
source: TreeRow<T>
target: TreeRow<T>

TreeItemId — type @beta

string | number

TreeRow — interface @beta

depth: number
expanded: boolean
hasChildren: boolean
id: TreeItemId
item: T
parentId: TreeItemId | null
selectable: boolean
selected: boolean

TreeViewHandle — interface @beta

dispose: () => void
entity: number
getModel: () => TreeViewModel<T> | undefined
refresh: () => void
reveal: (id: TreeItemId) => void

TreeViewModel — class @beta

canDrop: (request: TreeDropRequest<T>) => boolean
dispose: () => void
expandedIds: readonly TreeItemId[]
getCount: () => number
getItem: (index: number) => TreeRow<T>
getItemId: (_index: number, row: TreeRow<T>) => TreeItemId
getNode: (id: TreeItemId) => TreeRow<T> | undefined
indexOf: (id: TreeItemId) => number
isSelected: (id: TreeItemId) => boolean
refresh: () => void
reveal: (id: TreeItemId) => void
select: (ids: readonly TreeItemId[], mode?: number) => void
selectedIds: readonly TreeItemId[]
setExpanded: (ids: readonly TreeItemId[]) => void
source: TreeDataSource<T>
subscribe: (listener: (change: DataSourceChange) => void) => Unsubscribe
toggle: (id: TreeItemId) => void
static new <T>(source: TreeDataSource<T>, expanded?: readonly TreeItemId[]): TreeViewModel<T>
static prototype: TreeViewModel<any>

TreeViewNode — interface @beta

children: TreeViewNode[] | undefined
id: string
label: string
selectable: boolean | undefined

TreeViewOptions — interface @beta

canDrop: ((request: TreeDropRequest<T>) => boolean) | undefined
data: TreeDataSource<T> | undefined
dragHandle: ((rowEntity: Entity) => Entity) | undefined
events: UIEventQueue
item: ListItemTemplate<TreeRow<T>> | undefined
node: UINodeInit | undefined
nodes: TreeViewNode[] | undefined
onChange: ((ids: readonly TreeItemId[]) => void) | undefined
onDrop: ((request: TreeDropRequest<T>) => void) | undefined
parent: number | undefined
settings: Partial<Omit<UITreeViewData, "nodes">> | undefined
world: World

Tween — const @experimental

ResourceDef<TweenAPI>

TweenAPI — class @experimental

@internal activeCompositionCount: number
@internal clear: () => void
cancel: (tweenHandle: TweenHandle) => void
cancelAll: (entity: Entity) => void
delay: (seconds: number) => ValueTweenHandle
parallel: (tweens: Completable[]) => TweenGroup
sequence: (factories: TweenFactory[]) => TweenSequence
to: (entity: Entity, target: TweenTarget, from: number, to: number, duration: number, options?: TweenOptions) => TweenHandle
update: (deltaTime: number) => void
value: (from: number, to: number, duration: number, callback: (value: number) => void, options?: TweenOptions) => ValueTweenHandle
static new (module: AnimCore, registry: CppRegistry): TweenAPI
static prototype: TweenAPI

TweenFactory — type @experimental

() => Completable

TweenGroup — class @experimental

@internal checkComplete: () => boolean
cancel: () => void
onComplete: (callback: () => void) => TweenGroup
pause: () => void
resume: () => void
state: TweenState
static new (tweens: Completable[]): TweenGroup
static prototype: TweenGroup

TweenHandle — class @experimental

bezier: (p1x: number, p1y: number, p2x: number, p2y: number) => TweenHandle
cancel: () => void
entity: number
pause: () => void
resume: () => void
state: TweenState
then: (next: TweenHandle | ValueTweenHandle) => TweenHandle
static new (module: AnimCore, registry: CppRegistry, valueManager: ValueTweenManager, entity: Entity): TweenHandle
static prototype: TweenHandle

TweenOptions — interface @experimental

delay: number | undefined
easing: EasingType | undefined
loop: LoopMode | undefined
loopCount: number | undefined

TweenSequence — class @experimental

@internal checkComplete: () => boolean
cancel: () => void
onComplete: (callback: () => void) => TweenSequence
pause: () => void
resume: () => void
state: TweenState
static new (factories: TweenFactory[]): TweenSequence
static prototype: TweenSequence

TweenState — enum @experimental

Cancelled = 3
Completed = 2
Paused = 1
Running = 0

TweenTarget — enum @experimental

CameraOrthoSize = 12
ColorA = 9
ColorB = 8
ColorG = 7
ColorR = 6
PositionX = 0
PositionY = 1
PositionZ = 2
RotationZ = 5
ScaleX = 3
ScaleY = 4
SizeX = 10
SizeY = 11

UICameraData — interface @beta

revision: number
screenH: number
screenW: number
valid: boolean
viewProjection: Float32Array<ArrayBufferLike>
vpH: number
vpW: number
vpX: number
vpY: number
worldBottom: number
worldLeft: number
worldMouseX: number
worldMouseY: number
worldRight: number
worldTop: number

UICameraInfo — const @beta

ResourceDef<UICameraData>

UIColorPicker — const @beta

ComponentDef<UIColorPickerData>

UIColorPickerData — interface @beta

alpha: number
alphaEnabled: boolean
alphaRamp: number
color: Color
cursor: number
fields: number[]
format: number
hex: number
history: Color[]
historyLimit: number
historyRoot: number
hue: number
preview: number
rememberButton: number
rememberColors: boolean
sv: number

UIController — const @experimental

ComponentDef<UIControllerData>

UIControllerData — interface @experimental

controllers: ControllerState[]

UIDialog — const @experimental

ComponentDef<UIDialogData>

UIDialogData — interface @experimental

closeOnBackdrop: boolean
closeOnEscape: boolean

UIDisplay — enum @experimental

Flex = 0
None = 1

UIDropdown — const @experimental

ComponentDef<UIDropdownData>

UIDropdownData — interface @experimental

label: number
optionHeight: number
options: string[]
selectedIndex: number

UIEntityInit — interface @experimental

node: UINodeInit | undefined
parent: number | undefined
text: TextInit | undefined
visual: UIVisualInit | undefined
world: World

UIEvent — interface @experimental

currentTarget: number
data: TData
defaultPrevented: boolean
preventDefault: () => void
propagationStopped: boolean
stopPropagation: () => void
target: number
type: string

UIEventHandler — type @experimental

(event: EntityEvent<TData>) => void

UIEventQueue — class @experimental

@internal requeue: (event: EntityEvent) => void
clear: () => void
drain: () => readonly EntityEvent[]
emit: <TData = unknown>(entity: Entity, type: string, data?: TData) => EntityEvent<TData>
emitBubbled: (ancestor: Entity, rootEvent: EntityEvent) => EntityEvent
hasListenersFor: (type: string) => boolean
observe: (handler: (event: EntityEventObservation) => void) => Unsubscribe
on: { (entity: Entity, type: string, handler: EntityEventHandler): Unsubscribe; (type: string, handler: EntityEventHandler): Unsubscribe; }
query: (type: string) => readonly EntityEvent[]
removeAll: (entity: Entity) => void
static new (): EntityEventQueue
static prototype: EntityEventQueue

UIEventType — type @experimental

typeof UIEventType[keyof typeof UIEventType]

UIEvents — const @experimental

ResourceDef<EntityEventQueue>

UIGear — const @experimental

ComponentDef<UIGearData>

UIGearData — interface @experimental

bindings: GearBinding[]

UIInteraction — const @experimental

BuiltinComponentDef<UIInteractionData>

UIInteractionData — interface @experimental

hovered: boolean
justPressed: boolean
justReleased: boolean
pressed: boolean

UIInteractionPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
dependencies: "uiLayout"[]
name: "uiInteraction"
static new (): UIInteractionPlugin
static prototype: UIInteractionPlugin

UILayoutGeneration — const @experimental

ResourceDef<UILayoutGenerationData>

UILayoutGenerationData — interface @experimental

generation: number

UILayoutPlugin — class @experimental

build: (app: App) => void
name: string
profileDomain: "ui"
static new (): UILayoutPlugin
static prototype: UILayoutPlugin

UIMask — const @experimental

BuiltinComponentDef<UIMaskData>

UIMaskData — interface @experimental

alphaCutoff: number
enabled: boolean
mode: MaskMode

UIMaskPlugin — class @experimental

build: (app: App) => void
name: "uiMask"
static new (): UIMaskPlugin
static prototype: UIMaskPlugin

UINode — const @beta

BuiltinComponentDef<UINodeData>

UINodeInit — interface @experimental

fill: boolean | undefined
flexGrow: number | undefined
flexShrink: number | undefined
height: Dimension | undefined
insetBottom: Dimension | undefined
insetLeft: Dimension | undefined
insetRight: Dimension | undefined
insetTop: Dimension | undefined
marginBottom: Dimension | undefined
marginLeft: Dimension | undefined
marginRight: Dimension | undefined
marginTop: Dimension | undefined
opacity: number | undefined
pointerEvents: number | undefined
position: number | undefined
width: Dimension | undefined

UIPages — class @experimental

close: (id: string) => void
has: (id: string) => boolean
isBuilt: (id: string) => boolean
isOpen: (id: string) => boolean
onBuilt: (listener: (page: PageHandle) => void) => () => void
open: (id: string) => Promise<PageHandle>
page: (id: string) => PageHandle | null
preload: (id: string) => Promise<void>
register: (id: string, def: PageDef) => void
registerDeferred: (entity: Entity, onClose?: PageDef["onClose"]) => string | null
registerDeferredAll: (root?: Entity, onClose?: PageDef["onClose"]) => string[]
static new (world_: World, assets_: Assets): UIPages
static prototype: UIPages

UIPlugin — class @experimental

attachScrollContainer: (entity: Entity, container: ScrollContainer) => void
build: (app: App) => void
cleanup: (app?: App) => void
detachScrollContainer: (entity: Entity) => void
events: UIEventQueue
name: string
registerListView: (list: ListView<unknown>) => void
unregisterListView: (list: ListView<unknown>) => void
static new (): UIPlugin
static prototype: UIPlugin

UIPointerEvents — enum @experimental

Auto = 0
None = 1
Receive = 2

UIPositionType — enum @experimental

Absolute = 1
Relative = 0

UIRenderOrderPlugin — class @experimental

after: ("text" | "uiInteraction" | "uiMask")[]
build: (app: App) => void
dependencies: "uiLayout"[]
name: "uiRenderOrder"
static new (): UIRenderOrderPlugin
static prototype: UIRenderOrderPlugin

UISlider — const @experimental

ComponentDef<UISliderData>

UISliderData — interface @experimental

fill: number
handle: number
max: number
min: number
step: number
value: number

UITabView — const @beta

ComponentDef<UITabViewData>

UITabViewData — interface @beta

allowSwitchOff: boolean
labels: string[]
loopNavigation: boolean
pages: number[]
selectOnFocus: boolean
selectedIndex: number
tabs: number[]
vertical: boolean

UIToggle — const @experimental

ComponentDef<UIToggleData>

UIToggleData — interface @experimental

check: number
isOn: boolean

UIToggleGroup — const @experimental

ComponentDef<UIToggleGroupData>

UIToggleGroupData — interface @experimental

allowSwitchOff: boolean

UITooltip — const @beta

ComponentDef<UITooltipData>

UITooltipData — interface @beta

avoidEdges: boolean
content: string
focus: boolean
gap: number
hover: boolean
hoverDelay: number
longPress: boolean
longPressDelay: number
maxWidth: number
side: number
stylePrefab: string

UITreeView — const @beta

ComponentDef<UITreeViewData>

UITreeViewData — interface @beta

dragEnabled: boolean
emptyPrefab: string
expandedIds: (string | number)[]
indent: number
nodes: TreeViewNode[]
rowHeight: number
rowPrefab: string
selectedIds: (string | number)[]
selectionMode: number

UIVisibilityPlugin — class @experimental

build: (app: App) => void
dependencies: "uiInteraction"[]
name: "uiVisibility"
static new (): UIVisibilityPlugin
static prototype: UIVisibilityPlugin

UIVisual — const @beta

BuiltinComponentDef<UIVisualData>

UIVisualData — interface @beta

color: Color
enabled: boolean
fillAmount: number
fillMethod: FillMethod
fillOrigin: FillOrigin
fit: UIVisualFit
material: number
sliceBorder: Vec4
texture: number
tileSize: Vec2
uvOffset: Vec2
uvScale: Vec2
visualType: UIVisualType

UIVisualFit — enum @beta

Contain = 1
Cover = 2
Fill = 0

UIVisualInit — interface @experimental

color: { r: number; g: number; b: number; a: number; } | undefined
enabled: boolean | undefined
fillAmount: number | undefined
fillMethod: FillMethod | undefined
fillOrigin: FillOrigin | undefined
fit: UIVisualFit | undefined
material: number | undefined
sliceBorder: { x: number; y: number; z: number; w: number; } | undefined
texture: number | undefined
tileSize: Vec2 | undefined
uvOffset: Vec2 | undefined
uvScale: Vec2 | undefined
visualType: UIVisualType | undefined

UIVisualType — enum @beta

Filled = 5
Image = 2
NineSlice = 3
None = 0
SolidColor = 1
Tiled = 4

UIWorldAnchor — const @experimental

ComponentDef<UIWorldAnchorData>

UIWorldAnchorData — interface @experimental

behind: boolean
camera: number
clampToEdges: boolean
distance: number
edgeMargin: number
hideWhenBehind: boolean
offset: Vec3
onScreen: boolean
target: number

UNTIMED_SCOPE_LABEL — const @experimental

"untimed"

UniformValue — type @experimental

number | Vec2 | Vec3 | Vec4 | number[] | TextureRef

Unsubscribe — type @experimental

() => void

UnwrapOptions — interface @experimental

atlasSize: number | undefined
maxChartAngleDegrees: number | undefined
paddingTexels: number | undefined

UnwrapQueryArg — type @public

T extends MutWrapper<infer C> ? C :
    T extends AddedWrapper<infer C> ? C :
    T extends ChangedWrapper<infer C> ? C :
    T

UnwrapResult — interface @experimental

charts: number
coverage: number
mesh: MeshData

UpdateStages — interface @experimental

applied: boolean
cached: boolean | null
persisted: boolean | null
verified: boolean

UpdateStatus — interface @experimental

applying: boolean
persistedRevision: string | null
revision: string | null
staged: { revision: string | null; assets: number; bytes: number; } | null

UploadedGpuFormat — type @experimental

CompressedTextureFormat | 'rgba8'

Upright — interface @experimental

amount: number
hx: number
hy: number
x: number
y: number

UvRect — interface @experimental

uvOffset: { x: number; y: number; }
uvScale: { x: number; y: number; }

VOXEL_MATERIALS — const @experimental

4

ValidatePrefabOptions — interface @experimental

instanceOverrides: readonly PrefabOverride[] | undefined
loadPrefab: ((path: string) => PrefabData | null) | undefined

ValidateResult — interface @experimental

duplicateIds: string[]
invalidIds: string[]
orphanedChildren: string[]
stale: StaleOverride[]

ValueTweenHandle — class @experimental

@internal manager: ValueTweenManager
bezier: (p1x: number, p1y: number, p2x: number, p2y: number) => ValueTweenHandle
cancel: () => void
id: number
pause: () => void
resume: () => void
state: TweenState
then: { (next: ValueTweenHandle): ValueTweenHandle; (next: { pause(): void; resume(): void; }): ValueTweenHandle; }
static new (manager: ValueTweenManager, id: number): ValueTweenHandle
static prototype: ValueTweenHandle

Vec2 — interface @public

x: number
y: number

Vec3 — interface @public

x: number
y: number
z: number

Vec4 — interface @public

w: number
x: number
y: number
z: number

Velocity — const @experimental

BuiltinComponentDef<VelocityData>

VelocityData — interface @experimental

angular: Vec3
linear: Vec3

VertexAttributeDescriptor — interface @experimental

name: string
type: DataType

VibrationIntensity — type @experimental

'light' | 'medium' | 'heavy'

VibrationOptions — interface @experimental

duration: "long" | "short" | undefined
intensity: VibrationIntensity | undefined

Video — const @experimental

ComponentDef<VideoData>

VideoAPI — class @experimental

backendName: string
baseUrl: string
dispose: () => void
play: (source: string, options?: VideoPlayOptions) => VideoStreamHandle
setRefResolver: (resolver: ((ref: string) => string) | null) => void
stop: (handle: VideoStreamHandle) => void
stopAll: () => void
update: (module: ESEngineModule | null) => void
static new (backend: PlatformVideoBackend, observeExecution?: (callback: (held: boolean) => void) => () => void): VideoAPI
static prototype: VideoAPI

VideoData — interface @experimental

autoplay: boolean
enabled: boolean
fitSize: boolean
loop: boolean
muted: boolean
playbackRate: number
source: string
volume: number

VideoHandle — type @experimental

VideoStreamHandle

VideoPlayOptions — type @experimental

VideoStreamOptions

VideoPlayer — const @experimental

ResourceDef<VideoAPI>

VideoPlugin — class @experimental

build: (app: App) => void
cleanup: (app?: App) => void
name: string
stopAll: () => void
static new (): VideoPlugin
static prototype: VideoPlugin

VideoStreamHandle — interface @experimental

bytes: number | undefined
currentTime: number
duration: number
height: number
id: number
isPlaying: boolean
isReady: boolean
onEnded: (() => void) | undefined
onError: ((error: unknown) => void) | undefined
onReady: (() => void) | undefined
pause: () => void
play: () => void
pump: (module: ESEngineModule | null) => void
seek: (timeSeconds: number) => void
setLoop: (loop: boolean) => void
setMuted: (muted: boolean) => void
setPlaybackRate: (rate: number) => void
setVolume: (volume: number) => void
stop: () => void
textureHandle: number
width: number

VideoStreamOptions — interface @experimental

audioTrackUrl: string | undefined
autoplay: boolean | undefined
loop: boolean | undefined
muted: boolean | undefined
playbackRate: number | undefined
volume: number | undefined

ViewShading — type @experimental

'shaded' | 'clay' | 'albedo' | 'wireframe' | 'directLighting' | 'indirectLighting'

Viewport — interface @experimental

h: number
w: number
x: number
y: number

Virtual — const @public

(id: string) => Binding

VirtualButton — const @experimental

ComponentDef<VirtualButtonData>

VirtualButtonData — interface @experimental

inputId: string
value: number

VirtualButtonOptions — interface @experimental

background: UIVisualInit | undefined
disabled: boolean | undefined
events: EntityEventQueue
fadeDuration: number | undefined
focusable: boolean | undefined
inputId: string | undefined
node: UINodeInit | undefined
onClick: ((entity: Entity) => void) | undefined
parent: number | undefined
states: Record<string, ButtonStateVisual> | undefined
tabIndex: number | undefined
text: string | TextInit | undefined
userGesture: boolean | undefined
value: number | undefined
world: World

VirtualJoystick — const @experimental

ComponentDef<VirtualJoystickData>

VirtualJoystickData — interface @experimental

base: number
deadZone: number
handle: number
inputId: string
mode: VirtualJoystickMode
radius: number
returnSpeed: number

VirtualJoystickMode — enum @experimental

Fixed = 0
Follow = 1

VirtualJoystickOptions — interface @experimental

baseVisual: UIVisualInit | undefined
deadZone: number | undefined
disabled: boolean | undefined
handleVisual: UIVisualInit | undefined
inputId: string | undefined
mode: VirtualJoystickMode | undefined
node: UINodeInit | undefined
parent: number | undefined
radius: number | undefined
returnSpeed: number | undefined
world: World

VoxelEditEvent — interface @experimental

entity: number
op: VoxelOp
result: VoxelEditResult
shape: VoxelShape

VoxelEditOptions — interface @experimental

keep: ((material: number) => boolean) | undefined
material: number | undefined
smooth: number | undefined

VoxelEditResult — interface @experimental

added: number
chunks: number
removed: number[]

VoxelField — class @experimental

apply: (shape: VoxelShape, op: VoxelOp, options?: VoxelEditOptions) => VoxelEditResult
cellSize: number
chunk: (cx: number, cy: number, cz: number) => VoxelChunk
chunkCells: number
distanceAt: (x: number, y: number, z: number) => number
held: { chunks: number; edited: number; }
materialAt: (x: number, y: number, z: number) => number
raycast: (origin: VoxelPoint, direction: VoxelPoint, maxDistance: number) => VoxelHit | null
restore: (data: VoxelFieldData, merge?: boolean, skipped?: string[]) => boolean
rowMax: number
rowMin: number
serialize: (changedOnly?: boolean) => VoxelFieldData
side: number
takeDirty: () => VoxelChunk[]
trim: (keep?: (chunk: VoxelChunk) => boolean) => void
static new (options: VoxelFieldOptions): VoxelField
static prototype: VoxelField

VoxelFieldData — interface @experimental

cellSize: number
chunkCells: number
chunks: Record<string, string>
version: 1

VoxelFieldOptions — interface @experimental

cached: number | undefined
cellSize: number
chunkCells: number
maxY: number
minY: number
source: VoxelSource

VoxelHit — interface @experimental

distance: number
material: number
normal: VoxelPoint
point: VoxelPoint

VoxelMaterial — const @experimental

{ readonly Topsoil: 0; readonly Soil: 1; readonly Rock: 2; readonly Ore: 3; }

VoxelNoiseParams — interface @experimental

caveScale: number
caveWidth: number
cellSize: number | undefined
hillHeight: number
hillScale: number
oreAmount: number
seed: number
soilDepth: number
surfaceHeight: number

VoxelOp — type @experimental

'subtract' | 'add' | 'paint'

VoxelPlugin — class @experimental

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

VoxelPoint — interface @experimental

x: number
y: number
z: number

VoxelSample — interface @experimental

distance: number
material: number

VoxelShape — type @experimental

| { kind: 'sphere'; center: VoxelPoint; radius: number }
    | { kind: 'box'; center: VoxelPoint; halfExtents: VoxelPoint }
    | { kind: 'capsule'; from: VoxelPoint; to: VoxelPoint; radius: number }

VoxelSource — type @experimental

(x: number, y: number, z: number, out: VoxelSample) => void

VoxelTerrain — const @experimental

ComponentDef<VoxelTerrainData>

VoxelTerrainData — interface @experimental

castShadows: boolean
caveScale: number
caveWidth: number
cellSize: number
chunkCells: number
collision: boolean
collisionDistance: number
collisionLayer: number
color0: Color
color1: Color
color2: Color
color3: Color
drawDistance: number
friction: number
hillHeight: number
hillScale: number
map0: number
map1: number
map2: number
map3: number
material: number
maxY: number
minY: number
oreAmount: number
seed: number
soilDepth: number
surfaceHeight: number
tile: number

VoxelTerrainStatus — interface @experimental

collidingChunks: number
drawnChunks: number
editedChunks: number
heldChunks: number
lastRebuildMs: number
triangles: number
waitingChunks: number

VoxelTerrains — class @experimental

@internal app_: App | null
@internal built_: Map<number, Built>
@internal ensure_: ((entity: Entity) => Built | null) | null
@internal sourceIds_: Map<VoxelSource, number>
@internal sources_: Map<number, VoxelSource>
carve: (entity: Entity, shape: VoxelShape, options?: VoxelEditOptions) => VoxelEditResult | null
collisionReadyAt: (entity: Entity, x: number, z: number) => boolean
distanceAt: (entity: Entity, at: VoxelPoint) => number | null
edit: (entity: Entity, shape: VoxelShape, op: VoxelOp, options?: VoxelEditOptions) => VoxelEditResult | null
fill: (entity: Entity, shape: VoxelShape, material?: number, options?: VoxelEditOptions) => VoxelEditResult | null
materialAt: (entity: Entity, at: VoxelPoint) => number | null
onEdit: (listener: (event: VoxelEditEvent) => void) => () => void
raycast: (origin: VoxelPoint, direction: VoxelPoint, maxDistance?: number) => (VoxelHit & { entity: Entity; }) | null
restore: (entity: Entity, data: VoxelFieldData, merge?: boolean) => boolean
serialize: (entity: Entity, changedOnly?: boolean) => VoxelFieldData | null
setSource: (entity: Entity, source: VoxelSource | null) => void
status: (entity: Entity) => VoxelTerrainStatus | null
static new (): VoxelTerrains
static prototype: VoxelTerrains

VoxelTerrainsRes — const @experimental

ResourceDef<VoxelTerrains>

WATERFALL_SHADER_TEMPLATE — const @experimental

BuiltinShaderTemplate

WAVE_SET — const @experimental

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

WEATHER_CLEAR — const @experimental

0

WEATHER_MIST — const @experimental

1

WEATHER_NONE — const @experimental

-1

WEATHER_OVERCAST — const @experimental

2

WEATHER_RAIN — const @experimental

3

WEATHER_SNOW — const @experimental

5

WEATHER_STORM — const @experimental

4

WORLD_DIR — const @experimental

"world"

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

WeChatRuntimeConfig — interface @experimental

aot: { module: string; manifest: AotManifest; } | undefined
audioConfig: AudioProjectConfig | undefined
colorSpace: "gamma" | "linear" | undefined
debugChannel: DebugChannelConfig | undefined
depthLayers: number | undefined
engineFactory: (opts: unknown) => Promise<ESEngineModule>
engineWasmPath: string | undefined
firstScene: string
hotUpdate: { remoteRoot?: string; persistUpdateKey?: string; } | undefined
physics3dBackend: Physics3DBackend | undefined
physics3dWorld: Partial<Physics3DWorldConfig> | undefined
physicsConfig: Physics2DPluginConfig | undefined
physicsEnabled: boolean | undefined
runtime: RuntimeBuildConfig | undefined
runtimeConfig: RuntimeBuildConfig | undefined
sceneNames: string[]
screenFit: { designWidth: number; designHeight: number; scaleMode: number; matchWidthOrHeight: number; } | undefined
sideModuleFactories: Partial<Record<SideModuleId, EmscriptenFactory>> | undefined
sideModuleSuffix: string | undefined
sideModules: { id: string; file: string; globalName?: string; }[] | undefined
uiTheme: "dark" | "light" | undefined
uiThemeOverrides: ThemeOverrides | undefined
ySortLayers: number | undefined

WeChatSideModuleFactories — type @experimental

Partial<Record<SideModuleId, EmscriptenFactory>>

WeChatSocket — class @experimental

close: (code?: number, reason?: string) => void
connect: () => void
delivery: "reliable-ordered"
on: <K extends keyof PlatformSocketEvents>(event: K, handler: (...args: PlatformSocketEvents[K]) => void) => () => void
readyState: PlatformSocketReadyState
send: (data: string | ArrayBuffer) => void
static new (options: GameSocketOptions): WeChatSocket
static prototype: WeChatSocket

Weather — const @experimental

ComponentDef<WeatherData>

WeatherData — interface @experimental

drive: number
duration: number
hold: number
preset: number
progress: number
sequence: string
soundSource: number
target: number

WeatherDrive — const @experimental

{ readonly Lights: 1; readonly Fog: 2; readonly Rain: 4; readonly Grade: 8; readonly Exposure: 16; readonly Reflections: 32; readonly Sound: 64; readonly Wind: 128; readonly All: 255; }

WeatherPreset — type @experimental

Partial<WeatherState>

WeatherState — interface @experimental

contrast: number
exposure: number
fogDensity: number
fogGlow: number
fogTint: [number, number, number]
fogTintAmount: number
overcast: number
puddles: number
rain: number
reflection: number
reflectionSaturation: number
saturation: number
shadowSoftness: number
shadowStrength: number
sky: number
skyFog: number
snow: number
sound: number
ssr: number
sun: number
sunTint: [number, number, number]
waves: number
wetness: number
wind: number

WebAppOptions — interface @experimental

colorSpace: "gamma" | "linear" | undefined
depthLayers: number | undefined
getViewportSize: (() => { width: number; height: number; }) | undefined
msaaSamples: number | undefined
outputTransform: OutputTransform | undefined
ownsSideModules: boolean | undefined
plugins: Plugin[] | undefined
quality: QualityConfig | undefined
randomSeed: number | undefined
renderSurface: RenderSurfaceSource | undefined
screenFit: ScreenScalingData | undefined
sideModules: SideModuleHost | undefined
ySortLayers: number | undefined

WebGPUAdapterLike — interface @experimental

features: { has(name: string): boolean; } | undefined

WebGPUBootResult — interface @experimental

adapter: string | undefined
device: unknown
reason: string | undefined

WheelJoint2D — const @experimental

ComponentDef<WheelJoint2DData>

WidgetInteractionInit — interface @experimental

disabled: boolean | undefined
focusable: boolean | undefined
tabIndex: number | undefined

With — function @experimental

(component: AnyComponentDef): FilterExpr

Without — function @experimental

(component: AnyComponentDef): FilterExpr

WorkJob — type @experimental

Generator<number, T, void>

World — class @public

@internal addressOfComponent: (component: AnyComponentDef, entity: Entity) => number | undefined
@internal addressResolver: (component: AnyComponentDef) => (entity: Entity) => number | undefined
@internal advanceMutationCursor: (component: AnyComponentDef, kind: "topology" | "write", reader: number, through: number) => void
@internal advanceRemovedCursorReader: (component: AnyComponentDef, readerId: number, through: number) => void
@internal advanceRemovedReader: (component: AnyComponentDef, readerId: number, lastRunTick: number) => void
@internal advanceTick: () => void
@internal advanceTopologyReader: (component: AnyComponentDef, readerId: number, lastRunTick: number) => void
@internal advanceWriteReader: (component: AnyComponentDef, readerId: number, lastRunTick: number) => void
@internal anyAddedAfterSequence: (component: AnyComponentDef, after: number) => boolean
@internal anyChangedAfterSequence: (component: AnyComponentDef, after: number) => boolean
@internal anyChangedSince: (component: AnyComponentDef, sinceTick: number) => boolean
@internal applyEntityOrder: (entities: readonly Entity[]) => void
@internal beginIteration: () => void
@internal bufferedWriteRows: (component: AnyComponentDef) => number
@internal builtin: BuiltinBridge
@internal changeAuditTotal: () => number
@internal changes_: ChangeTracker
@internal closeSpeculation: () => void
@internal commitReservedSpawn: (entity: Entity, name?: string) => void
@internal compositionChanges: () => CompositionDelta | null
@internal connectCpp: (cppRegistry: CppRegistry, module?: ESEngineModule, options?: BridgeConnectOptions) => void
@internal disconnectCpp: () => void
@internal disposeMutationCursor: (component: AnyComponentDef, kind: "topology" | "write", reader: number) => void
@internal disposeRemovedReader: (component: AnyComponentDef, readerId: number) => void
@internal disposeTopologyReader: (component: AnyComponentDef, readerId: number) => void
@internal disposeWriteReader: (component: AnyComponentDef, readerId: number) => void
@internal enableChangeSequenceTracking: (component: AnyComponentDef, added: boolean) => void
@internal enableChangeTracking: (component: AnyComponentDef) => void
@internal enableIncarnationTracking: (component: AnyComponentDef) => void
@internal endIteration: () => void
@internal ensureTransformsComposed: () => void
@internal flushEngineStamps: () => void
@internal getChangeSequence: () => number
@internal getComponentIncarnation: (entity: Entity, component: AnyComponentDef) => number
@internal getComponentTypesBatch: (entities: readonly Entity[]) => string[][]
@internal getCppRegistry: () => CppRegistry | null
@internal getQueryCacheStats: () => QueryCacheStats
@internal getRemovalSequence: () => number
@internal getRemovedEntitiesForReader: (component: AnyComponentDef, readerId: number) => Entity[]
@internal getRemovedEntitiesSince: (component: AnyComponentDef, sinceTick: number) => Entity[]
@internal getStorageSizes: () => { entities: number; indexSlots: number; spawnCallbacks: number; despawnCallbacks: number; coreDisconnectCallbacks: number; names: ReturnType<NameIndex["sizes"]>; scripts: ReturnType<ScriptStorage["sizes"]>; changes: ReturnType<ChangeTracker["sizes"]>; queryCacheEntries: number; }
@internal getTopologyChangedEntitiesSince: (component: AnyComponentDef, sinceTick: number) => Entity[]
@internal getWasmModule: () => ESEngineModule | null
@internal getWorldTick: () => number
@internal getWorldVersion: () => number
@internal getWrittenEntitiesSince: (component: AnyComponentDef, sinceTick: number) => Entity[]
@internal hasCpp: boolean
@internal hasPortableScriptAssetRefs: (component: AnyComponentDef) => boolean
@internal invalidateTransformComposition: () => void
@internal isAddedAfterSequence: (entity: Entity, component: AnyComponentDef, after: number) => boolean
@internal isAddedSince: (entity: Entity, component: AnyComponentDef, sinceTick: number) => boolean
@internal isChangeTracked: (component: AnyComponentDef) => boolean
@internal isChangedAfterSequence: (entity: Entity, component: AnyComponentDef, after: number) => boolean
@internal isChangedSince: (entity: Entity, component: AnyComponentDef, sinceTick: number) => boolean
@internal isDestructionPending: (entity: Entity) => boolean
@internal isIterating: () => boolean
@internal layoutEpoch: () => number | null
@internal markChanged: (entity: Entity, component: AnyComponentDef) => void
@internal mutationRevision: (component: AnyComponentDef, kind: "topology" | "write") => number
@internal mutationSequence: (kind: "topology" | "write") => number
@internal mutationsForCursor: (component: AnyComponentDef, kind: "topology" | "write", reader: number) => Entity[]
@internal onCoreDisconnect: (dispose: () => void) => () => void
@internal openSpeculation: (log: { record(world: World, entity: Entity, component: AnyComponentDef): void; }) => void
@internal queries_: QueryCache
@internal queryCostEnabled: boolean
@internal queryEntities: (components: AnyComponentDef[], withFilters?: AnyComponentDef[], withoutFilters?: AnyComponentDef[], precomputedKey?: string, filter?: QueryFilter, precomputedDepIds?: symbol[]) => readonly Entity[]
@internal refreshBuiltinMembership: (entity: Entity, component: AnyComponentDef) => void
@internal registerMutationCursor: (component: AnyComponentDef, kind: "topology" | "write") => number
@internal registerRemovedCursorReader: (component: AnyComponentDef) => number
@internal registerRemovedReader: (component: AnyComponentDef) => number
@internal registerRemovedReaderFrom: (component: AnyComponentDef, retainFromTick: number) => number
@internal registerTopologyReaderFrom: (component: AnyComponentDef, retainFromTick: number) => number
@internal registerWriteReaderFrom: (component: AnyComponentDef, retainFromTick: number) => number
@internal releaseScriptPools: () => void
@internal removedReaderCount: (component: AnyComponentDef) => number
@internal reserveEntity: () => Entity
@internal resetIterationDepth: () => void
@internal resetQueryCacheStats: () => void
@internal resetQueryPool: () => void
@internal resolveChangeSequenceMatcher: (component: AnyComponentDef, added: boolean) => (entity: Entity, after: number) => boolean
@internal resolveGetter: (component: AnyComponentDef, mode?: "borrowed" | "retained") => ((entity: Entity) => unknown) | null
@internal resolveHas: (component: AnyComponentDef) => ((entity: Entity) => boolean) | null
@internal resolveSetter: (component: AnyComponentDef) => ((entity: Entity, data: unknown) => void) | null
@internal resumeIteration: (depth: number) => void
@internal scriptLayoutEpoch: () => number
@internal scriptSpanOf: (component: AnyComponentDef) => { rows: number; stride: number; sparse: number; sparseCount: number; owners: number; ownerCount: number; } | undefined
@internal setAssetFieldResolver: (resolver: AssetFieldResolver | null) => void
@internal setChangeAudit: (enabled: boolean) => void
@internal setQueryCostEnabled: (enabled: boolean) => void
@internal setTransformChangeTracking: (on: boolean) => boolean
@internal speculating: boolean
@internal stampEngineWrite: (entity: Entity, component: AnyComponentDef) => void
@internal suspendIteration: () => number
@internal takeCompositionChanges: () => void
@internal topologyReaderCount: (component: AnyComponentDef) => number
@internal transformEpoch: () => number
@internal useScriptPoolMemory: (memory: PoolMemory, validateOnly?: boolean) => void
@internal writeReaderCount: (component: AnyComponentDef) => number
despawn: (entity: Entity) => void
entityCount: () => number
findEntityByName: (name: string) => Entity | null
get: <C extends AnyComponentDef>(entity: Entity, component: C) => ComponentData<C>
getAllEntities: () => Entity[]
getComponentTypes: (entity: Entity) => string[]
getEntitiesWithComponents: (components: AnyComponentDef[], withFilters?: AnyComponentDef[], withoutFilters?: AnyComponentDef[]) => readonly Entity[]
has: (entity: Entity, component: AnyComponentDef) => boolean
insert: <C extends AnyComponentDef>(entity: Entity, component: C, data?: Partial<ComponentData<C>>) => ComponentData<C>
isEntityActive: (entity: Entity) => boolean
isStale: (entity: Entity) => boolean
onDespawn: (callback: (entity: Entity) => void) => () => void
onSpawn: (callback: (entity: Entity) => void) => () => void
remove: (entity: Entity, component: AnyComponentDef) => void
removeParent: (entity: Entity) => void
set: <C extends AnyComponentDef>(entity: Entity, component: C, data: ComponentData<C>) => void
setParent: (child: Entity, parent: Entity) => void
spawn: (name?: string) => Entity
tryGet: <C extends AnyComponentDef>(entity: Entity, component: C) => ComponentData<C> | null
trySetParent: (child: Entity, parent: Entity) => boolean
update: <C extends AnyComponentDef>(entity: Entity, component: C, edit: (draft: ComponentData<C>) => void) => void
valid: (entity: Entity) => boolean
static new (): World
static prototype: World

WorldAxis — type @experimental

0 | 1 | 2

WorldCell — interface @experimental

entityCount: number
maxX: number
maxZ: number
minX: number
minZ: number
name: string
path: string
rootCount: number
x: number
z: number

WorldGen — const @experimental

ComponentDef<WorldGenData>

WorldGenData — interface @experimental

paintGround: boolean
rules: string
seaLevel: number
seed: number
surface: number
version: number
world: string

WorldGenPlugin — class @experimental

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

WorldGenRes — const @experimental

ResourceDef<WorldGens>

WorldGenStatus — interface @experimental

layers: Record<string, ChunkLayerStatus>
reason: string | undefined
state: "failed" | "loading" | "ready"

WorldGens — class @experimental

@internal app_: App | null
@internal authored_: Map<string, Set<string>>
@internal built_: Map<number, BuiltWorld>
@internal levelled_: Map<string, { signature: string; owners: Set<BuiltWorld>; }>
@internal objects_: Map<string, number>
diffs: (world?: string) => PlacementDiffs
objectOf: (id: string) => Entity | null
plan: (entity?: Entity) => WorldPlan | null
status: (entity: Entity) => WorldGenStatus | null
zones: (world?: string) => Zones
static new (): WorldGens
static prototype: WorldGens

WorldManifest — interface @experimental

cellSize: number
cells: WorldCell[]
persistentRefs: number[]
plane: "xy" | "xz" | undefined
scene: string
version: number

WorldPartition — interface @experimental

cellSize: number
cells: PartitionedCell[]
errors: string[]
persistent: SceneData
persistentRefs: number[]
plane: "xy" | "xz"
warnings: string[]

WorldPersistent — const @experimental

ComponentDef<{}>

WorldPlan — class @experimental

biomeAt: (x: number, z: number) => string | null
biomeWeights: (x: number, z: number) => { biome: string; weight: number; }[]
env: Environment
explain: (x: number, z: number) => { fields: FieldValues; biomes: { biome: string; weight: number; }[]; zones: { id: string; kind: string; weight: number; }[]; layers: { layer: string; cell: [number, number]; group: string | null; rejected: Rejection | null; detail?: string; }[]; }
group: (li: number, gx: number, gz: number) => Group | Rejection
groupsIn: (layer: string, x0: number, z0: number, x1: number, z1: number) => Group[]
invalidate: () => void
layerIndex: (id: string) => number
paint: (x: number, z: number, base: readonly number[]) => number[]
placementsIn: (x0: number, z0: number, x1: number, z1: number, layers?: readonly string[]) => Placement[]
rules: WorldRules
seed: number
stats: (layer: string, x0: number, z0: number, x1: number, z1: number) => Record<"placed" | Rejection, number>
world: string
zones: Zones
static new (rules: WorldRules, env: Environment, zones: Zones, seed: number, world: string): WorldPlan
static prototype: WorldPlan

WorldRay — interface @experimental

dir: Vec3
origin: Vec3

WorldRect — interface @experimental

bottom: number
left: number
right: number
top: number

WorldResidencyReport — interface @experimental

assetRefsByCell: Record<string, number>
authoredCellEntityCounts: Record<string, number>
cancelCount: number
cancelledRefs: number
cellCount: number
cellEntityCounts: Record<string, number>
cellRenderCounts: Record<string, number>
cellRows: Record<string, { id: number; entity: number; }[]>
cellSize: number
cells: { name: string; x: number; z: number; }[]
delivery: Record<string, CellDelivery>
desiredCells: string[]
lastDemandToResidentMs: number
loadCount: number
loadingCells: string[]
persistentEntities: number
persistentHandles: number[]
plane: "xy" | "xz"
prefetchCells: string[]
prefetchHits: number
prefetchMisses: number
prefetchRequests: number
prepareCount: number
preparedCells: string[]
preparedWithRenderClaim: string[]
renderClaims: Record<string, RenderReadinessStamp & { restamps: number; }>
residentCells: string[]
sourceCount: number
streamed: boolean
unloadCount: number
unloadingCells: string[]

WorldRules — interface @experimental

biomes: readonly BiomeDef[]
fields: Record<string, FieldFn> | undefined
id: string
layers: readonly PlacementLayer[]
noise: Partial<Record<string, NoiseField>> | undefined
plants: Readonly<Record<string, PlantKind>> | undefined
recipes: readonly Recipe[]
versions: readonly number[]

WorldSnapshot — interface @experimental

selected: SnapshotEntity | null
tree: { version: "1.0"; name: "live"; entities: SnapshotEntity[]; } | null

WorldSnapshotOptions — interface @experimental

assetPath: ((path: string) => string | null) | undefined
entryScene: string | undefined

WorldStreamHost — interface @experimental

discardPrepared: (name: string) => number
isLoaded: (name: string) => boolean
loadAdditive: (name: string) => Promise<unknown>
prepare: (name: string) => Promise<void>
readyRenderPrograms: ((name: string) => Promise<RenderReadiness>) | undefined
register: (config: SceneConfig) => void
unload: (name: string, options?: { keepPersistent?: boolean; }) => Promise<void>

WorldStreamer — class @experimental

clear: () => Promise<void>
delivery: () => Record<string, CellDelivery>
loadManifest: (manifest: WorldManifest, sceneConfig?: (cell: WorldCell) => SceneConfig) => Promise<void>
manifest: WorldManifest | null
recordPhase: (name: string, phase: string, ms: number) => void
renderReadinessOf: (name: string) => RenderReadinessStamp | null
residencyOf: (name: string) => CellResidency
restampsOf: (name: string) => number
status: () => WorldStreamerStatus
update: (sources: readonly ResidencySource[]) => void
static new (host: WorldStreamHost): WorldStreamer
static prototype: WorldStreamer

WorldStreamerStatus — interface @experimental

cancelCount: number
cancelledRefs: number
cellCount: number
desiredCells: string[]
lastDemandToResidentMs: number
loadCount: number
loadingCells: string[]
prefetchCells: string[]
prefetchHits: number
prefetchMisses: number
prefetchRequests: number
prepareCount: number
preparedCells: string[]
residentCells: string[]
sourceCount: number
unloadCount: number
unloadingCells: string[]

WorldStreaming — const @experimental

ResourceDef<WorldStreamer>

WorldStreamingSource — const @experimental

ComponentDef<WorldStreamingSourceData>

WorldStreamingSourceData — interface @experimental

enabled: boolean
loadRadius: number
prefetchRadius: number
unloadRadius: number

WorldTransform — const @experimental @deprecated

BuiltinComponentDef<TransformData>

WorldTransformData — type @experimental

TransformData

WorldZone — const @experimental

ComponentDef<WorldZoneData>

WorldZoneData — interface @experimental

biome: string
excludes: string
falloff: number
flatten: boolean
kind: string
priority: number
radius: number
shape: number
sizeX: number
sizeZ: number

WrapMode — type @experimental

(typeof WrapMode)[keyof typeof WrapMode]

ZoneDef — interface @experimental

biome: string | undefined
excludes: readonly string[]
falloff: number
fields: Readonly<Record<string, number>> | undefined
flatten: number | "ground" | undefined
id: string
kind: string
priority: number
shape: ZoneShape

ZoneShape — type @experimental

| { type: 'circle'; x: number; z: number; radius: number; y?: number }
    | { type: 'rect'; x: number; z: number; halfX: number; halfZ: number; yaw?: number; y?: number; facing?: readonly [number, number, number] }

ZoneShapeKind — const @experimental

{ readonly Circle: 0; readonly Box: 1; }

Zones — class @experimental

all: () => IterableIterator<ZoneDef>
at: (x: number, z: number, reach?: number) => { zone: ZoneDef; weight: number; }[]
delete: (id: string) => void
excluding: (x: number, z: number, radius: number, tags: readonly string[], seed: number) => ZoneDef | null
get: (id: string) => ZoneDef | undefined
onChange: ((bounds: [number, number, number, number], zone: ZoneDef) => void) | null
revision: number
set: (zone: ZoneDef) => void
subscribe: (listener: NonNullable<Zones["onChange"]>) => () => void
static new (): Zones
static prototype: Zones

acquireWebGPUDevice — function @beta

(requested: RenderBackendRequest, onError?: (message: string) => void): Promise<WebGPUBootResult>

activeRemoteRoot — function @experimental

(config: AssetGroupsConfig | null | undefined): string | undefined

addAnimatorIK — function @experimental

(def: AnimatorControllerDef, kind: AnimatorIKKind): AnimatorControllerDef

addAnimatorLayer — function @experimental

(def: AnimatorControllerDef, name: string): AnimatorControllerDef

addAnimatorParam — function @experimental

(def: AnimatorControllerDef, name: string, type: AnimatorParamType): AnimatorControllerDef

addAnimatorState — function @experimental

(def: AnimatorControllerDef, name: string, x?: number, y?: number, layer?: number): AnimatorControllerDef

addAnimatorTransition — function @experimental

(def: AnimatorControllerDef, from: string, to: string, layer?: number): AnimatorControllerDef

addNode — function @beta

(g: MaterialGraph, type: GraphNodeType, x: number, y: number): { graph: MaterialGraph; id: string; }

addPlugin — function @experimental

(plugin: Plugin): void

addPoseOver — function @experimental

(acc: Pose, layer: Pose, reference: Pose, weight: number, world: PoseWorld, reach: LayerReach | null): void

addStartupSystem — function @public

(system: SystemDef): void

addSystem — function @experimental

(system: SystemDef): void

addSystemSetToSchedule — function @public

(schedule: Schedule, set: SystemSet): void

addSystemToSchedule — function @public

(schedule: Schedule, system: SystemDef): void

aiRegistry — const @experimental

AiRegistry<AiContext>

alignRectAnchorsNow — function @experimental

(world: World, entity: Entity, screen: ScreenLayoutData | null): boolean

analyzeCensusSeries — function @experimental

(samples: readonly Census[], opts?: CensusSeriesOptions): CensusReport

anchorPresetFields — function @experimental

(preset: AnchorPreset): AnchorFields

animClipCellRect — function @experimental

(sheet: AnimClipSheetData, cell: number): { x: number; y: number; width: number; height: number; }

animClipCellUv — function @experimental

(sheet: AnimClipSheetData, cell: number): { uvOffset: { x: number; y: number; }; uvScale: { x: number; y: number; }; }

animClipDrivesPivot — function @experimental

(data: AnimClipAssetData): boolean

animClipDrivesSize — function @experimental

(data: AnimClipAssetData): boolean

animClipFramePivot — function @experimental

(data: AnimClipAssetData, frame: AnimClipFrameData, size?: AnimClipVec2 | null): AnimClipPivotData | null

animClipFrameSize — function @experimental

(data: AnimClipAssetData, frame: AnimClipFrameData, natural?: AnimClipVec2 | null): AnimClipVec2 | null

animClipSheetCols — function @experimental

(sheet: AnimClipSheetData): number

animClipSheetRows — function @experimental

(sheet: AnimClipSheetData): number

animationPlugin — const @experimental

AnimationPlugin

animatorEdges — function @experimental

(def: AnimatorControllerDef, layer?: number): AnimatorEdge[]

animatorLayer — function @experimental

(def: AnimatorControllerDef, index: number): AnimatorScope | null

animatorLayerCount — function @experimental

(def: AnimatorControllerDef): number

animatorScopes — function @experimental

(def: AnimatorControllerDef): AnimatorScope[]

applyAssetRefResolvers — function @experimental

(app: App, resolveRef: (ref: string) => string): void

applyAudioProjectConfig — function @experimental

(audio: AudioAPI, config: AudioProjectConfig | undefined): void

applyBuildRuntimeConfig — function @experimental

(app: { setMaxDeltaTime(v: number): void; setMaxFixedSteps(v: number): void; }, config: RuntimeBuildConfig): void

applyDeltaToSource — function @experimental

(source: PrefabData, delta: SourceDelta): PrefabData

applyOverrides — function @experimental

(entity: OverrideTarget, overrides: readonly PrefabOverride[] | undefined): void

applyOverridesToSource — function @experimental

(source: PrefabData, overrides: readonly PrefabOverride[]): PrefabData

applyTabViewSelection — function @experimental

(world: World, root: Entity, index: number): void

applyThemeToWorld — function @experimental

(world: World): void

applyWrapMode — function @experimental

(time: number, duration: number, mode: WrapMode): { time: number; stopped: boolean; }

arrayDataSource — function @experimental

<T>(items: readonly T[]): ArrayDataSource<T>

assetPlugin — const @experimental

AssetPlugin

atlasCatalogFields — function @experimental

(atlas: CookedAtlasInfo, pagePath: string): Pick<CatalogEntry, "atlas" | "frame" | "uv">

atlasLayout — function @experimental

(faceSize: number, mipCount: number): { width: number; height: number; offsets: number[]; }

attachTooltip — function @beta

(world: World, target: Entity, options?: Partial<UITooltipData>): void

audioPlugin — const @experimental

AudioPlugin

auto — const @experimental

() => Dimension

avatarResolver — function @experimental

(world: Pick<World, "tryGet">, avatar: AnimatorAvatar | null): JointResolver

bakeDecalMesh — function @experimental

(receivers: readonly DecalReceiver[], projectorWorld: ArrayLike<number>, options?: DecalBakeOptions): MeshData | null

bakeFingerprint — function @experimental

(inputs: BakeInputs): string

bakeHoldsStill — function @experimental

(mobility: BakeMobility): boolean

bakeLightForward — function @experimental

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

bakeLightOf — function @experimental

(authored: AuthoredLight | undefined, position: readonly [number, number, number], rotation: { x: number; y: number; z: number; w: number; }, linearColor?: boolean): BakeLightContribution | null

bakeLightmap — function @experimental

(surfaces: readonly BakeSurface[], lights: readonly BakeLight[], options?: BakeOptions): BakeResult

bakeLightmapSteps — function @experimental

(surfaces: readonly BakeSurface[], lights: readonly BakeLight[], options?: BakeOptions): Generator<BakeStep, BakeResult, void>

bakeRunner — function @experimental

(scene: BakeScene): (job: BakeJob, from: number, to: number) => void

bakesOf — function @experimental

(app: App): Bakes

bind — function @experimental

<C extends object, K extends keyof C>(world: World, entity: Entity, component: ComponentDef<C>, field: K, source: ReadonlySignal<C[K]>): () => void

bindControllerPage — function @experimental

(world: World, entity: Entity, controller: string, source: ReadonlySignal<string>): () => void

bindWidgetValue — function @experimental

<C extends object, K extends keyof C>(world: World, events: UIEventQueue, entity: Entity, component: ComponentDef<C>, field: K, signal: Signal<C[K]>, payloadKey?: string): () => void

blend1DMotionDriver — const @experimental

MotionDriver<AnimatorBlend1DMotion>

blend1DPair — function @experimental

(blend: AnimatorBlend1DMotion, value: number): Readonly<Blend1DPair>

blend2DMotionDriver — const @experimental

MotionDriver<AnimatorBlend2DMotion>

blend2DWeights — function @experimental

(blend: AnimatorBlend2DMotion, x: number, y: number, out: { weight: number; }[]): void

blendWeather — function @beta

(from: number, to: number, progress: number): WeatherState

blobAlpha — function @experimental

(mesh: MeshData, vertex: number): number

boxDistance — function @experimental

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

breakablePlugin — const @experimental

BreakablePlugin

bucketOverridesByEntity — function @experimental

(overrides: readonly PrefabOverride[]): Map<PrefabEntityId, PrefabOverride[]>

buildBillboardMesh — function @experimental

(plants: readonly Plant[], width: number, height: number, rect: CardRect, paint?: BladeParams["paint"], triangle?: boolean): MeshData

buildBlobMesh — function @experimental

(softness: number): MeshData

buildFrameProfile — function @experimental

(input: FrameProfileInput): FrameProfile

buildGrassMesh — function @experimental

(plants: readonly Plant[], blade: BladeParams): MeshData

buildInstancedMesh — function @experimental

(source: MeshData, plants: readonly Plant[], paint?: BladeParams["paint"], band?: number, seats?: boolean): MeshData

buildOceanMesh — function @experimental

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

buildPatchMesh — function @experimental

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

buildPathGeometry — function @experimental

(points: readonly Vec2[], style: PathStyle): MeshRendererGeometry

buildTerrainBand — function @experimental

(points: readonly SplinePoint[], closedCurve: boolean, band: TerrainBand2DData): TerrainBandBuild | null

buildText — function @experimental

(init?: TextInit): TextData

buildUINode — function @experimental

(init?: UINodeInit): UINodeData

buildUIVisual — function @experimental

(init?: UIVisualInit): UIVisualData

buildVariant — function @experimental

(base: PrefabData, baseRef: string, name: string, delta: { overrides: readonly PrefabOverride[]; added: readonly AddedEntity[]; }): PrefabData

buildWaterfall — function @experimental

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

builtinBusVolume — function @experimental

(name: string): number | null

builtinMeshTemplate — function @experimental

(ref: string): BuiltinMeshTemplate | undefined

builtinShaderTemplate — function @experimental

(id: string): BuiltinShaderTemplate | undefined

burstVelocity — function @experimental

(piece: Vec3, origin: Vec3, speed: number): Vec3

calculateAttenuation — function @experimental

(distance: number, config?: SpatialAudioConfig): number

calculatePanning — function @experimental

(source: Vec3, listener: Vec3, right: Vec3, maxDistance: number): number

cameraCommitChanged — function @beta

(): void

cameraFrustumCorners — function @beta

(camera: CameraFields, transform: CameraTransformFields, width: number, height: number, canvas: CanvasScale | null, result?: Float32Array): Float32Array

canCaptureFramePixels — function @experimental

(module: ESEngineModule): boolean

canvasRootEntities — function @experimental

<T>(entities: readonly T[], parentOf: (entity: T) => T | null): T[]

captureFingerPose — function @experimental

(world: World, hand: Entity): FingerPoseDef

captureFrame — function @experimental

(module: CaptureEngine, nextFrame: NextFrame, maxFrames?: number): Promise<FrameCaptureData | null>

captureFramePixels — function @beta

(module: ESEngineModule, width: number, height: number, advance?: () => void | Promise<void>): Promise<FramePixels | null>

captureFrameReport — function @experimental

(app: App, nextFrame: NextFrame, pathOf?: (path: string) => string | null): Promise<FrameDebugReport | null>

captureReflection — function @experimental

(at: readonly [number, number, number], bvh: Bvh, lookup: HitLookup, atlas: Float32Array, atlasSize: number, width: number, height: number, sky: SkyRadiance): CapturedPanorama

carriesEnvironment — function @experimental

(light: SceneAmbientLight): boolean

catalogFromManifest — function @experimental

(manifest: AddressableManifest): Catalog | undefined

cellAt — function @experimental

(x: number, z: number, cellSize: number): { x: number; z: number; }

cellDocumentPath — function @experimental

(cellName: string): string

cellSquare — function @experimental

(cellX: number, cellZ: number, cellSize: number): { minX: number; minZ: number; maxX: number; maxZ: number; }

censusProbeIds — function @experimental

(): string[]

chunksOf — function @experimental

(app: App): ProceduralChunks

circlePoints — function @experimental

(cx: number, cy: number, radius: number, segments?: number, startAngle?: number, endAngle?: number): Vec2[]

classifyBone — function @experimental

(name: string | undefined): BoneClass

clearAnimatorControllerStore — function @experimental

(): void

clearDrawCallbacks — function @experimental

(): void

clearPath — function @experimental

(app: App, entity: Entity): void

clearProjectSideModules — function @experimental

(): void

clearUserComponents — function @experimental

(): void

clipToProjector — function @experimental

(triangles: readonly ClipTriangle[], minCosine?: number): ClipTriangle[]

cloneComponentData — function @experimental

(data: Record<string, unknown>): Record<string, unknown>

cloneComponents — function @experimental

(components: ComponentData[]): ComponentData[]

cloneMetadata — function @experimental

(metadata: Record<string, unknown>): Record<string, unknown>

closeDialog — function @experimental

(world: World, events: UIEventQueue, root: Entity): void

closeDropdown — function @experimental

(world: World, e: Entity): void

col — const @experimental

{ readonly create: (r?: number, g?: number, b?: number, a?: number) => Color; readonly rgb: (r: number, g: number, b: number) => Color; readonly from255: (r: number, g: number, b: number, a?: number) => Color; readonly clone: (c: Color) => Color; readonly fromHsv: (h: number, s: number, v: number, a?: number) => Color; readonly toHsv: (color: Color, fallbackHue?: number) => { h: number; s: number; v: number; }; readonly lerp: (a: Color, b: Color, t: number) => Color; readonly withAlpha: (c: Color, a: number) => Color; readonly multiply: (a: Color, b: Color) => Color; readonly scaleRgb: (c: Color, s: number) => Color; readonly fromHex: (hex: string) => Color; readonly toHex: (c: Color, withAlpha?: boolean) => string; readonly equals: (a: Color, b: Color, epsilon?: number) => boolean; }

collapseEntry — function @experimental

(prefab: PrefabData, prefabRef: string, expanded: readonly ProcessedEntity[], rootId: number, sceneParent: number | null, loadPrefab?: SyncPrefabResolver): PrefabInstanceEntry

collapseInstance — function @experimental

(prefab: PrefabData, prefabRef: string, expanded: readonly ProcessedEntity[], loadPrefab?: SyncPrefabResolver): PrefabInstanceDelta

collectCustomEvents — function @experimental

(asset: TimelineAsset, runs: readonly PlayheadRun[], out: MotionEvent[]): void

collectExternalEntityRefs — function @experimental

(entities: readonly ExtractEntity[]): ExternalEntityRef[]

collectGarbage — function @experimental

(): boolean

collectNestedPrefabPaths — function @experimental

(prefab: PrefabData, loadPrefab: (path: string) => PrefabData | null, visited?: Set<string>): string[]

collectSequenceLayers — function @experimental

(asset: TimelineAsset, time: number, root: Entity, resolveChild: ChildResolver, lookup: SequenceLookup, chain?: readonly string[], keyPrefix?: string, depth?: number): SequenceLayer[]

collider2DOutline — function @experimental

(shape: Collider2DShape, center: Vec2, angle: number, ppu: number): Collider2DOutline

collider3DWireframe — function @experimental

(shape: Collider3DShape, segments?: number): Vec3[][]

collisionGeometryOf — function @experimental

(app: App): CollisionGeometry

color — const @experimental

(r?: number, g?: number, b?: number, a?: number) => Color

compareDrawRank — function @experimental

(a: DrawRank, b: DrawRank): number

compileMaterialGraph — function @beta

(source: MaterialGraph, resolve?: SubgraphResolver): string

composeTRS — function @experimental

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

compositeBatchPlugin — const @experimental

Plugin

compressedUploadDecision — function @experimental

(target: CompressedTextureFormat | null, transcoded: boolean): TextureUploadDecision

computeEffectiveOrthoSize — function @experimental

(baseOrthoSize: number, designAspect: number, actualAspect: number, scaleMode: number, matchWidthOrHeight: number): number

computePolygonHull — function @experimental

(vertices: readonly Vec2[]): Vec2[]

computeStreaming — function @experimental

(cells: readonly StreamCell[], focusX: number, focusY: number, loadRadius: number, unloadRadius: number, active: ReadonlySet<string>, focusZ?: number): StreamDecision

connect — function @beta

(g: MaterialGraph, fromId: string, toId: string, toSlot: string): MaterialGraph

contentHashHex — function @experimental

(data: Uint8Array): string

contentHashOf — function @experimental

(data: Uint8Array | string): string

contentRectPlugin — const @experimental

ContentRectPlugin

controllerState — function @experimental

(name: string, pages: string[], current?: string): ControllerState

convolveCosine — function @experimental

(coefficients: Float32Array, at?: number): void

corePlugin — const @experimental

Plugin

coveredGround — function @experimental

(sprite: SpriteData, transform: TransformData): { centre: { x: number; y: number; }; half: { x: number; y: number; }; }

coversPoint — function @experimental

(px: number, py: number, centre: { x: number; y: number; }, half: { x: number; y: number; }, margin: number, round: boolean): boolean

createAnimClip — function @experimental

(texture: string, cellWidth: number, cellHeight: number, pageWidth: number, pageHeight: number): AnimClipAssetData

createAnimClipFromTextures — function @experimental

(textures: string[]): AnimClipAssetData

createButton — function @experimental

(opts: ButtonOptions): ButtonHandle

createCanvasTexture — function @experimental

(app: App | null | undefined, source: GlImageSource): CanvasTexture | null

createColorPicker — function @beta

(opts: ColorPickerOptions): ColorPickerHandle

createDialog — function @experimental

(opts: DialogOptions): DialogHandle

createDropdown — function @experimental

<T>(opts: DropdownOptions<T>): DropdownHandle<T>

createEmbeddedSideModuleHost — function @experimental

(registry: EmbeddedSideModuleRegistry): SideModuleHost

createFetchSideModuleHost — function @experimental

(baseUrl: string): SideModuleHost

createHeadlessApp — function @beta

(module: ESEngineModule, options?: HeadlessAppOptions): App

createListView — function @experimental

<T>(opts: CreateListViewOptions<T>): ListViewHandle<T>

createLocalAchievements — function @experimental

(): AchievementProvider

createMockAdProvider — function @experimental

(options?: MockAdProviderOptions): AdProvider

createPackagedAssetSource — function @experimental

(index: PackagedAssetIndex, options?: PackagedAssetSourceOptions): RuntimeAssetSource

createProgress — function @experimental

(opts: ProgressOptions): ProgressHandle

createRng — function @experimental

(seed: RngSeed): Rng

createRootPlacement — function @experimental

(): RootPlacement

createRuntimeSceneConfig — function @experimental

(name: string, sceneData: SceneData | undefined, options: Omit<LoadRuntimeSceneOptions, "sceneData" | "sceneName">, scenePath?: string): SceneConfig

createScrollView — function @experimental

(opts: ScrollViewOptions): ScrollViewHandle

createSlider — function @experimental

(opts: SliderOptions): SliderHandle

createSocket — function @experimental

(options: GameSocketOptions): PlatformSocket

createTabView — function @beta

(opts: TabViewOptions): TabViewHandle

createTakeover — function @experimental

(host: TakeoverHost): Takeover

createTextInput — function @experimental

(opts: TextInputOptions): TextInputHandle

createTimelineMotionDriver — function @experimental

(timeline: TimelineAPI, effects?: TimelineMotionEffects): MotionDriver<AnimatorClipMotion>

createToggle — function @experimental

(opts: ToggleOptions): ToggleHandle

createTooltip — function @beta

(opts: TooltipOptions): TooltipHandle

createTreeView — function @beta

<T = TreeViewNode>(opts: TreeViewOptions<T>): TreeViewHandle<T>

createVirtualButton — function @experimental

(options: VirtualButtonOptions): ButtonHandle

createVirtualJoystick — function @experimental

(options: VirtualJoystickOptions): { entity: number; baseEntity: number; handleEntity: number; setDisabled: (disabled: boolean) => void; dispose: () => void; }

createWeChatSideModuleHost — function @experimental

(factories: MiniGameSideModuleFactories, binarySuffix?: string): SideModuleHost

createWebApp — function @experimental

(module: ESEngineModule, options?: CreateWebAppOptions): App

cubicBezier — function @experimental

(p0: Vec2, p1: Vec2, p2: Vec2, p3: Vec2, tolerance?: number): Vec2[]

currentShare — function @experimental

(width: number, widest: number): number

currentSightRings — function @experimental

(): readonly SightRing[]

currentTimeOfDay — function @beta

(): TimeOfDayState | null

currentWeather — function @beta

(): WeatherState | null

cutWorld — function @experimental

(scene: SceneData, sceneName: string, options: PartitionOptions): CutWorld | null

debug — function @experimental

(category: string, message: string, data?: unknown): void

decidePower — function @experimental

(state: PowerState, policy: PowerPolicy): PowerDecision

decodeImageBitmap — function @experimental

(src: ImageBitmapSource | PlatformImage, flip: boolean): Promise<ImageBitmap>

decodeImagePixels — function @experimental

(src: ImageBitmapSource, maxEdge?: number): Promise<DecodedPixels>

decodeLightmap — function @experimental

(pixels: ArrayLike<number>, i: number): [number, number, number]

decodeMesh — function @experimental

(bytes: Uint8Array): MeshData

decodeRgbm — function @experimental

(r: number, g: number, b: number, a: number, maxRange: number): [number, number, number]

decomposePolygon2D — function @experimental

(vertices: readonly Vec2[]): PolygonDecomposition

defaultFrameStats — function @experimental

(): FrameStats

defaultPluralSelector — const @experimental

PluralSelector

defaultQualityMode — function @experimental

(handheld: boolean): QualityMode

defaultQualityProfile — function @experimental

(level: QualityLevel): QualityProfile

deferredEntities — function @experimental

(world: World): Entity[]

deferredRecord — function @experimental

(world: World, entity: Entity): DeferredRecord | undefined

defineBehavior — function @experimental

<S extends object>(name: string, def: BehaviorDef<S>): ComponentDef<S>

defineComponent — function @public

<T extends object>(name: string, defaults: T, metadata?: ComponentMetadata): ComponentDef<T>

defineEvent — function @public

<T>(name: string, payload?: T & object): EventDef<T>

defineInputMap — function @public

(actions: Record<string, ActionDef>): InputMap

defineResource — function @public

<T>(defaultValue: T, name?: string): ResourceDef<T>

defineSkyEffect — function @experimental

(src: SkyEffectSource): void

defineSystem — function @public

<P extends readonly SystemParam[]>(params: [...P], fn: (...args: InferParams<P>) => void | Promise<void>, options?: SystemOptions): SystemDef

defineSystemSet — function @public

(name: string, options: SystemSetOptions): SystemSet

defineTag — function @public

(name: string): ComponentDef<{}>

derived — function @experimental

<T>(sources: ReadonlySignal<unknown>[], compute: () => T): ReadonlySignal<T>

desiredResidency — function @experimental

(cells: readonly WorldCell[], sources: readonly ResidencySource[], resident: ReadonlySet<string>): ResidencyDecision

detectAnchor — function @experimental

(node: UINodeData): AnchorPreset | null

detectAnchorAxes — function @experimental

(node: UINodeData): { h: AnchorAxis | null; v: AnchorAxis | null; }

deviceGeneration — function @experimental

(): number

diagnosticsPlugin — const @experimental

DiagnosticsPlugin

diffAgainstSource — function @experimental

(source: PrefabData, instance: readonly ProcessedEntity[], options?: DiffOptions): { overrides: PrefabOverride[]; untracked: ProcessedEntity[]; orphanedSourceIds: PrefabEntityId[]; }

diffCensus — function @experimental

(before: Census, after: Census): CensusDelta[]

direction — function @experimental

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

disconnect — function @beta

(g: MaterialGraph, toId: string, toSlot: string): MaterialGraph

discoverSceneAssets — function @experimental

(sceneData: SceneData, refResolver?: RefResolver): SceneAssetRefs

distanceToCell — function @experimental

(cell: WorldCell, x: number, z: number): number

dominantBlendPoint — function @experimental

(blend: AnimatorBlend2DMotion, x: number, y: number): AnimatorBlendPoint | null

dragPlugin — const @experimental

DragPlugin

dragonBonesPlugin — const @experimental

() => DragonBonesPlugin

drainPath — function @experimental

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

drawBudgetReport — function @experimental

(gpuDraws: number, budget: number, counters: Readonly<Record<string, number>>, listDraws?: number): DrawBudgetReport

drawPhysics3DDebug — function @experimental

(app: App, contacts?: readonly Contact3D[]): void

drynessOf — function @experimental

(alpha: number): number

editorViewAxes — function @experimental

(view: EditorViewData): { x: ScreenAxis; y: ScreenAxis; z: ScreenAxis; }

editorViewAxisAngles — function @experimental

(axis: "x" | "y" | "z", sign: 1 | -1): { yaw: number; pitch: number; }

editorViewBasis — function @experimental

(view: EditorViewData): EditorViewBasis

editorViewBoxExtent — function @experimental

(view: EditorViewData, half: Vec3): { right: number; up: number; }

editorViewClipFar — function @experimental

(view: EditorViewData): number

editorViewClipNear — function @experimental

(view: EditorViewData): number

editorViewEye — function @experimental

(view: EditorViewData): Vec3

editorViewGridPlane — function @experimental

(view: EditorViewData): EditorWorkPlane

editorViewHalfExtent — function @experimental

(view: EditorViewData, aspect: number): { halfW: number; halfH: number; }

editorViewHalfHeight — function @experimental

(view: EditorViewData): number

editorViewIsOrbited — function @experimental

(view: EditorViewData): boolean

editorViewLightingArgs — function @experimental

(data: EditorViewLightingData, viewActive: boolean): { mode: number; rotation: number; key: number; fill: number; sky: number; showSky: boolean; exposure: number; }

editorViewLightingIsOverriding — function @experimental

(data: EditorViewLightingData): boolean

editorViewShadingMode — function @experimental

(data: EditorViewShadingData, viewActive: boolean): ViewShading

editorViewStandoff — function @experimental

(view: EditorViewData): number

editorViewWorkPlane — function @experimental

(view: EditorViewData): EditorWorkPlane

editorViewWorldPerPixel — function @experimental

(view: EditorViewData, heightPx: number, at?: Vec3): number

ellipseStripsOf — function @experimental

(size: number): number

emptyAnimatorController — function @experimental

(): AnimatorControllerDef

emptyAvatar — function @experimental

(): AnimatorAvatar & { version: number; }

enableSceneOrigins — function @experimental

(app: App): void

encodeChannelTable — function @experimental

(channels: MeshChannelDesc[]): Uint8Array

encodeLightmap — function @experimental

(rgb: Float32Array, count: number): Uint8Array

encodeMesh — function @experimental

(data: MeshData): Uint8Array

encodeRgbm — function @experimental

(r: number, g: number, b: number, maxRange: number, out: Uint8Array, at: number): void

engineWebGPUFeatures — function @experimental

(adapter: WebGPUAdapterLike): string[]

enterStatePath — function @experimental

(scope: AnimatorScope, name: string): string[]

entityBoxCorners — function @experimental

(b: EntityBox): Vec3[]

entityBoxRayHit — function @experimental

(b: EntityBox, origin: Vec3, dir: Vec3): number | null

entityWorldBox — function @experimental

(world: ReadableWorld, entity: Entity, opts?: EntityBoxOptions): EntityBox | null

enumOptions — function @experimental

(obj: Record<string, unknown>, only?: readonly string[]): ReadonlyArray<{ label: string; value: number; }>

erodeHeightfield — function @experimental

(field: Heightfield, p: ErosionParams): Eroded

erosionJob — function @experimental

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

error — function @experimental

(category: string, message: string, data?: unknown): void

evalGuard — function @experimental

(bb: Blackboard, guard: BlackboardGuard): boolean

evalGuards — function @experimental

(bb: Blackboard, guards: BlackboardGuard | BlackboardGuard[]): boolean

evalIrradianceSH — function @experimental

(coefficients: ArrayLike<number>, dx: number, dy: number, dz: number, at?: number): [number, number, number]

evaluateAnimatorPath — function @experimental

(def: AnimatorScope, currentPath: string, params: AnimatorParamValues, triggers: ReadonlySet<string>, clipFinished?: boolean): AnimatorPathEvalResult

evaluateAnimatorTransitions — function @experimental

(def: AnimatorScope, currentState: string, params: AnimatorParamValues, triggers: ReadonlySet<string>, clipFinished?: boolean): AnimatorEvalResult

evaluateChannel — function @experimental

(channel: PropertyChannel, time: number): number

eventBindingPlugin — const @experimental

EventBindingPlugin

evictTextureDimensions — function @experimental

(handle: number): void

exact — const @beta

{ sin(x: number): number; cos(x: number): number; }

expandEntry — function @experimental

(prefab: PrefabData, entry: PrefabInstanceEntry, allocateId: () => number, loadPrefab?: SyncPrefabResolver, deferred?: DeferredRecord[]): { entities: ProcessedEntity[]; rootId: number; unresolved: PrefabOverride[]; }

expandInstance — function @experimental

(prefab: PrefabData, delta: PrefabInstanceDelta, allocateId: () => number, loadPrefab?: SyncPrefabResolver, deferred?: DeferredRecord[]): { entities: ProcessedEntity[]; rootId: number; unresolved: PrefabOverride[]; }

exploredFromString — function @experimental

(text: string): boolean

exploredToString — function @experimental

(): string

extendPlatform — function @experimental

(extra: Partial<PlatformAdapter>): void

extractAnimClipTexturePaths — function @experimental

(data: AnimClipAssetData): string[]

extractPrefab — function @experimental

(entities: readonly ExtractEntity[], rootId: number, name: string, makeId?: (sourceId: number) => PrefabEntityId): PrefabData

extractSubgraph — function @beta

(g: MaterialGraph, ids: readonly string[], ref: string, name?: string): ExtractedSubgraph

faceOf — function @experimental

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

fanDistances — function @experimental

(origin: SightPoint, radius: number, rings: readonly SightRing[], rays: number): Float32Array

fetchDecodePixels — function @experimental

(url: string, maxEdge?: number): Promise<DecodedPixels>

findBasins — function @experimental

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

findControllerOwner — function @experimental

(world: World, entity: Entity, name: string): Entity | null

findEntityByName — function @experimental

(world: World, name: string): Entity | null

fingerPose — function @experimental

(name: string): FingerPoseDef | undefined

fingerprint — function @experimental

(report: DiagnosticReport): string

finish — function @experimental

<T>(job: WorkJob<T>): T

flatSky — function @experimental

(colour: readonly [number, number, number]): SkyRadiance

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

flattenPrefab — function @experimental

(prefab: PrefabData, overrides: PrefabOverride[], ctx: FlattenContext): FlattenResult

flattenSubgraphs — function @beta

(graph: MaterialGraph, resolve: SubgraphResolver, stack?: readonly string[]): MaterialGraph

flushPendingRegistrations — function @experimental

(app: App): void

focusPlugin — const @experimental

FocusPlugin

folderAlwaysInclude — function @experimental

(config: AssetGroupsConfig | null | undefined, folder: string): boolean

folderGroupMode — function @experimental

(config: AssetGroupsConfig | null | undefined, folder: string): AssetGroupMode

foliagePlugin — const @experimental

Plugin

footAt — function @experimental

(x: number, y: number, heading: number, width: number, left: boolean): { x: number; y: number; }

formatActionArg — function @experimental

(params: Readonly<Record<string, AiParamValue>> | undefined, defs: readonly AiParamDef[], separator?: string): string | undefined

formatCensusDiff — function @experimental

(before: Census, after: Census, all?: boolean): string

formatCensusReport — function @experimental

(report: CensusReport): string

forwardConsole — function @experimental

(send: (level: ConsoleLevel, line: string) => void): () => void

frameDebugReport — function @experimental

(data: FrameCaptureData, nameOf: (entity: number) => string | null, assets?: FrameAssetNames): FrameDebugReport

frameProfileOf — function @experimental

(frame: CapturedFrame): FrameProfile

frameStatsReport — function @experimental

(app: App): FrameStatsReport

fxPreviewOrPlayMode — function @experimental

(): boolean

gearBinding — function @experimental

(controller: string, component: string, property: string, pages: Record<string, GearValue>, tween?: GearTween): GearBinding

getAddressableType — function @experimental

(path: string): AddressableAssetType | null

getAddressableTypeByEditorType — function @experimental

(editorType: string): AddressableAssetType | null

getAllAssetExtensions — function @experimental

(): Set<string>

getAllEffectDefs — function @experimental

(): EffectDef[]

getAssetMimeType — function @experimental

(ext: string): string | undefined

getAssetTypeEntry — function @experimental

(extensionOrPath: string): AssetTypeEntry | undefined

getComponent — function @experimental

(name: string): AnyComponentDef | undefined

getComponentAssetFieldDescriptors — function @experimental

(componentType: string): readonly { field: string; type: AssetFieldType; }[]

getComponentAssetFields — function @experimental

(componentType: string): string[]

getComponentDefaults — function @experimental

(typeName: string): Record<string, unknown> | null

getComponentFieldMeta — function @experimental

(name: string): Readonly<Record<string, FieldMeta>>

getComponentRegistry — function @experimental

(): Map<string, AnyComponentDef>

getComponentSkeletalFieldDescriptor — function @experimental

(componentType: string): { skeletonField: string; atlasField: string; runtime: string; } | null

getContextLossGuardInfo — function @experimental

(): { target: string; lostEventsSeen: number; }

getControllerPage — function @experimental

(world: World, entity: Entity, name: string): string | null

getCustomExtensions — function @experimental

(): string[]

getDefaultContext — function @experimental

(): AppContext

getDeviceIdentity — function @experimental

(source?: ESEngineModule | null): DeviceIdentity | null

getDeviceLostReport — function @experimental

(): string

getDeviceStatus — function @experimental

(): number

getEditorType — function @experimental

(path: string): EditorAssetType

getEffectDef — function @experimental

(type: string): EffectDef | undefined

getEffectTypes — function @experimental

(): string[]

getLogger — function @experimental

(): Logger

getPlatform — function @experimental

(): PlatformAdapter

getPlatformType — function @experimental

(): PlatformAdapter["name"] | null

getRegisteredAnimatorController — function @experimental

(key: string): AnimatorControllerDef | undefined

getReplicatedFields — function @experimental

(name: string): readonly string[]

getResourceManager — function @experimental

(): CppResourceManager | null

getResourceStats — function @experimental

(): ResourceStats | null

getTheme — function @experimental

(): ThemeTokens

getUserComponent — function @experimental

(name: string): ComponentDef<any> | undefined

getUserComponentFingerprint — function @experimental

(): string

getUserComponents — function @experimental

(): Map<string, AnyComponentDef>

getWeChatPackOptions — function @experimental

(): Array<{ type: string; value: string; }>

glContextAttributes — function @experimental

(preserveDrawingBuffer?: boolean): WebGLContextAttributes

gripHandJoints — function @experimental

(app: App, rig: Entity): { right: GripJoint[]; left: GripJoint[]; } | null

gripHolderStatus — function @experimental

(app: App, rig: Entity): { right: boolean; left: boolean; amount: number; held: Entity; short: { main: number; support: number; }; mirrored: boolean; palm: number; } | null

gripPose — function @experimental

(name: string): GripPoseDef | undefined

gripPoseByJoint — function @experimental

(pose: GripPoseDef): GripPoseDef

gripPoseFromJson — function @experimental

(text: string): GripPoseDef | null

gripPoseNames — function @experimental

(): string[]

gripPoseStatus — function @experimental

(app: App, rig: Entity): { right: GripHandStatus; left: GripHandStatus; } | null

gripSurfaceLines — function @experimental

(world: World, object: Entity): { x: number; y: number; z: number; }[][]

hasPlayableCta — function @experimental

(): boolean

hasVisibility — function @experimental

(world: World, entity: Entity): boolean

hashSeed — function @experimental

(seed: RngSeed): number

headlessBasePlugins — const @experimental

() => Plugin[]

heightVoxelSource — function @experimental

(heightAt: (x: number, z: number) => number | null, material?: (depth: number, sample: VoxelSample) => void): VoxelSource

heightfieldFromPixels — function @experimental

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

holdShaderWarmup — function @experimental

(app: App, busy: () => boolean | number): () => void

imageBitmapOptions — function @experimental

(flip: boolean): ImageBitmapOptions

impostorDecode — function @experimental

(u: number, v: number): Vec3

impostorEncode — function @experimental

(d: Vec3): [number, number]

impostorFrameDirection — function @experimental

(i: number, j: number, frames: number): Vec3

impostorKindKey — function @experimental

(mr: MeshRendererData, imp: ImpostorData): string

impostorPictureUp — function @experimental

(d: Vec3): Vec3

impostorPlugin — const @experimental

Plugin

indexPackagedManifest — function @experimental

(manifest: AddressableManifest): PackagedAssetIndex

info — function @experimental

(category: string, message: string, data?: unknown): void

initPlayRealmRuntime — function @experimental

(config: PlayRealmRuntimeConfig): Promise<void>

initPlayableRuntime — function @experimental

(config: PlayableRuntimeConfig): Promise<void>

initRuntime — function @experimental

(config: RuntimeInitConfig): Promise<void>

initWeChatPlatform — function @experimental

(): void

initWeChatRuntime — function @experimental

(config: WeChatRuntimeConfig): Promise<void>

inputEventCallbacks — function @experimental

(state: InputState): InputEventCallbacks

inputPlugin — const @experimental

InputPlugin

inputRouter — const @experimental

InputRouter

inspectFocusTraversal — function @experimental

(world: FocusInspectionWorld): FocusTraversalInspection

inspectTextLayout — function @experimental

(text: string, opts: TextInspectionOptions): TextInspection

inspectableTypes — function @experimental

(world: World, entity: number, includeTransient?: boolean): string[]

installEditorGrid — function @experimental

(app: App): void

instantiatePrefab — function @experimental

(world: World, prefab: PrefabData, options?: InstantiatePrefabOptions): Promise<InstantiatePrefabResult>

interactionController — function @experimental

(pages?: string[]): ControllerState

interpolate — function @experimental

(template: string, params?: TParams): string

intersectRects — function @experimental

(a: ScreenRect, b: ScreenRect): ScreenRect

invertMatrix4 — function @experimental

(m: Float32Array, result?: Float32Array): Float32Array

invokeAction — function @experimental

<Ctx>(registry: AiRegistry<Ctx>, name: string, ctx: Ctx, bb: Blackboard, input?: AiActionInput, out?: AiOutputs): void | Status

isAuto — const @experimental

(d: Dimension) => boolean

isBlend1D — function @experimental

(m: AnimatorMotion): m is AnimatorBlend1DMotion

isBlend2D — function @experimental

(m: AnimatorMotion): m is AnimatorBlend2DMotion

isBuiltinComponent — function @experimental

(comp: AnyComponentDef): comp is BuiltinComponentDef<any>

isBuiltinMeshRef — function @experimental

(ref: string): boolean

isCustomExtension — function @experimental

(path: string): boolean

isDialogOpen — function @experimental

(world: Pick<World, "get" | "has">, root: Entity): boolean

isDropdownOpen — function @experimental

(world: World, e: Entity): boolean

isEditor — function @experimental

(): boolean

isEntityActive — function @experimental

(world: World, entity: Entity): boolean

isEntityVisible — function @experimental

(world: World, entity: Entity): boolean

isFxEditPreview — function @experimental

(): boolean

isKnownAssetExtension — function @experimental

(ext: string): boolean

isNative — function @experimental

(): boolean

isPlatformInitialized — function @experimental

(): boolean

isPlayMode — function @experimental

(): boolean

isPointerBlockedInTree — function @experimental

(world: Pick<World, "get" | "has" | "valid">, entity: Entity): boolean

isPrefabEntry — function @experimental

(e: SceneEntry): e is PrefabInstanceEntry

isRootPlacementChannel — function @experimental

(childPath: string, component: string, property: string): boolean

isRuntime — function @experimental

(): boolean

isScreenEntity — function @experimental

(world: PickableWorld, entity: Entity): boolean

isTextureRef — function @experimental

(v: UniformValue): v is TextureRef

isWeChat — function @experimental

(): boolean

isWeb — function @experimental

(): boolean

joint3DSettingsError — function @experimental

(d: SwingTwistJoint3DData | SixDOFJoint3DData): string | null

judgeFrames — function @experimental

(avg: Readonly<Required<QualitySample>>, budgetMs: number): FrameVerdict

layerFrontness — function @experimental

(order: LayerOrder, worldY: number, worldZ: number): number

layerOrderOf — function @experimental

(layer: number, ySortMask: number, depthMask: number): LayerOrder

layerState — function @experimental

(a: AnimatorData, index: number): string

leafStateOf — function @experimental

(def: AnimatorScope, path: string): AnimatorState | null

levelRange — function @experimental

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

levelsFor — function @experimental

(radius: number, leafSize: number): number

lifecyclePlugin — const @experimental

LifecyclePlugin

lightAimOf — function @experimental

(rotation: Quat): Vec3

lightAimRotation — function @experimental

(aim: Vec3): Quat

lightmapImage — function @experimental

(pixels: Uint8Array, size: number): Uint8Array

linearKey — function @experimental

(time: number, value: number): Keyframe

loadComponent — function @experimental

(world: World, entity: Entity, compData: SceneComponentData, entityName?: string): void

loadInputMapAsset — function @experimental

(asset: InputMapAsset): InputMap

loadPackagedAssetIndex — function @experimental

(manifestPath?: string): Promise<PackagedAssetIndex>

loadPhysicsModule — function @experimental

(wasmUrl: string, factory?: PhysicsModuleFactory): Promise<PhysicsWasmModule>

loadRuntimeScene — function @experimental

(options: LoadRuntimeSceneOptions): Promise<void>

loadSceneData — function @experimental

(world: World, sceneData: SceneData, external?: ReadonlyMap<number, Entity>, onPhase?: ScenePhaseSink): Map<number, Entity>

loadSceneWithAssets — function @experimental

(world: World, sceneData: SceneData, options?: SceneLoadOptions): Promise<Map<number, Entity>>

localizationPlugin — const @experimental

LocalizationPlugin

log — const @experimental

Logger

looksLikeAssetPath — function @experimental

(value: unknown): value is string

makePage — function @experimental

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

makeWidgetInteractable — function @experimental

(world: World, entity: Entity, init?: WidgetInteractionInit): void

manifestPlane — function @experimental

(manifest: { plane?: "xy" | "xz"; } | null): "xy" | "xz"

markThemed — function @experimental

(world: World, entity: Entity, style: ThemeStyleData): void

maskRects — function @experimental

(shelters: readonly Shelter[], view: { left: number; bottom: number; right: number; top: number; }, strips?: number): MaskRect[]

matchLocale — function @experimental

(tag: string, available: readonly string[]): string | null

meanFrameProfile — function @experimental

(profiles: readonly FrameProfile[]): FrameProfile

measureText — function @experimental

(text: string, opts: MeasureTextOptions): TextMetrics

mergeGeometry — function @experimental

(parts: readonly MeshRendererGeometry[]): MeshRendererGeometry

mergeMeshes — function @experimental

(parts: readonly BatchPart[]): MeshData

meshRendererPlugin — const @experimental

MeshRendererPlugin

meshWorldBox — function @experimental

(world: LayoutWorld, entity: Entity): EntityBox | null

messageOf — function @experimental

(error: unknown): string

migrateAnimatorController — function @experimental

(raw: unknown): AnimatorMigration

migratePrefabData — function @experimental

(raw: unknown): MigrationResult

migrateSaveData — function @experimental

(version: number, data: unknown, currentVersion: number, migrations: Record<number, SaveMigration>): unknown

migrateSceneData — function @experimental

(raw: SceneData): SceneMigrationResult

modeToDelivery — function @experimental

(mode: AssetGroupMode): BundleMode

motionOf — function @experimental

(st: AnimatorState): AnimatorMotion | null

moveAnimatorLayer — function @experimental

(def: AnimatorControllerDef, index: number, to: number): AnimatorControllerDef

moveAnimatorState — function @experimental

(def: AnimatorControllerDef, name: string, x: number, y: number, layer?: number): AnimatorControllerDef

moveEditorViewFocus — function @experimental

(view: EditorViewData, right: number, up: number, forward?: number): void

moveNode — function @beta

(g: MaterialGraph, id: string, x: number, y: number): MaterialGraph

nearestPushers — function @experimental

(bodies: readonly { x: number; y: number; radius: number; strength: number; }[], focus: { x: number; y: number; }): PushValue[]

newMaterialGraph — function @beta

(): MaterialGraph

newMaterialSubgraph — function @beta

(): MaterialGraph

noInput — const @experimental

() => InputState

nodeAt — function @experimental

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

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; }

noiseProvider — function @experimental

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

noiseVoxelSource — function @experimental

(params: VoxelNoiseParams): VoxelSource

noised — function @experimental

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

normalizeBundleMode — function @experimental

(mode: string | undefined | null): BundleMode

oceanReach — function @experimental

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

oceanSnap — function @experimental

(rings: number, cellSize: number): number

octDecode — function @experimental

(u: number, v: number): [number, number, number]

octEncode — function @experimental

(dx: number, dy: number, dz: number): [number, number]

onCameraCommitChanged — function @beta

(fn: CameraCommitListener): () => void

onDeviceRestored — function @experimental

(listener: DeviceRestoredListener): () => void

openDialog — function @experimental

(world: World, events: UIEventQueue, root: Entity): void

openDropdown — function @experimental

(world: World, events: UIEventQueue, e: Entity): void

overlayPose — function @experimental

(acc: Pose, layer: Pose, weight: number, world: PoseWorld, reach: LayerReach | null): void

packChannels — function @experimental

(semantics: { semantic: number; components: number; type: number; }[]): { channels: MeshChannelDesc[]; vertexStride: number; }

packLayers — function @experimental

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

packagedAppOptions — function @experimental

(config: Pick<PackagedGameConfig, "colorSpace" | "depthLayers" | "msaaSamples" | "outputTransform" | "quality" | "screenFit" | "ySortLayers">): { ySortLayers?: number; depthLayers?: number; colorSpace?: "gamma" | "linear"; outputTransform?: "aces" | "neutral" | "none"; msaaSamples?: number; quality?: QualityConfig; renderBackend?: "webgl2" | "webgpu"; screenFit?: PackagedGameConfig["screenFit"]; }

packagedRuntimeInit — function @experimental

(config: Pick<PackagedGameConfig, "achievements" | "aot" | "audioConfig" | "debugChannel" | "physics3dBackend" | "physics3dWorld" | "physicsConfig" | "physicsEnabled" | "runtime" | "screenFit" | "steamAppId" | "uiTheme" | "uiThemeColors">): { physicsEnabled?: boolean; physicsConfig?: Physics2DPluginConfig; physics3dBackend?: Physics3DBackend; physics3dWorld?: Partial<Physics3DWorldConfig>; audioConfig?: AudioProjectConfig; runtime?: RuntimeBuildConfig; uiTheme?: "light"; uiThemeOverrides?: ThemeOverrides; achievements?: string[]; steamAppId?: number; screenFit?: PackagedGameConfig["screenFit"]; aot?: PackagedGameConfig["aot"]; debugChannel?: DebugChannelConfig; }

paintWeights — function @experimental

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

panoramaDirection — function @experimental

(u: number, v: number): [number, number, number]

panoramaUV — function @experimental

(dx: number, dy: number, dz: number): [number, number]

paramDefaultValue — function @experimental

(param: ShaderParam): unknown

parentOf — function @experimental

(n: TerrainNode, leafSize: number): TerrainNode

parseActionArg — function @experimental

(arg: string | undefined, params: readonly AiParamDef[], separator?: string): Record<string, AiParamValue>

parseAnimClipAsset — function @experimental

(rawJson: unknown): AnimClipAssetData

parseAnimClipData — function @experimental

(clipPath: string, data: AnimClipAssetData, textureHandles: Map<string, number>, textureSizes?: Map<string, AnimClipVec2>): SpriteAnimClip

parseAnimationClip — function @experimental

(rawJson: unknown): TimelineAsset

parseAudioProjectConfig — function @experimental

(raw: unknown): AudioProjectConfig

parseAvatar — function @experimental

(raw: unknown): AnimatorAvatar

parseBusEffects — function @experimental

(raw: unknown): BusEffectDef[]

parseLocaleTable — function @experimental

(text: string, path: string): LocaleTableAsset

parseProfileCapture — function @experimental

(text: string): { capture: ProfileCapture; } | { error: string; }

parseQualityConfig — function @experimental

(value: unknown): QualityConfig

parseRichText — function @experimental

(input: string): RichTextRun[]

parseRuntimeBuildConfig — function @experimental

(value: unknown): RuntimeBuildConfig

parseSoundEvent — function @beta

(value: unknown): SoundEventAsset

parseTerrainLayer — function @experimental

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

parseTerrainTiles — function @experimental

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

parseThemeOverrides — function @experimental

(colors?: Record<string, string>): ThemeOverrides | undefined

parseTimelineAsset — function @experimental

(rawJson: unknown): TimelineAsset

particlePlugin — const @experimental

ParticlePlugin

partitionWorld — function @experimental

(scene: SceneData, sceneName: string, options: PartitionOptions): WorldPartition | null

pathPlace — function @experimental

(travelled: number, length: number, mode: number, forward?: boolean): { s: number; done: boolean; }

pendingShaders — function @experimental

(source: App | ESEngineModule | null): number

percent — const @public

(n: number) => Dimension

percentile — function @experimental

(values: readonly number[], p: number): number

persistentEntityRows — function @experimental

(app: App, manifest: WorldManifest): ReadonlyMap<number, Entity>

physics3DInstallConfig — function @experimental

(world: Partial<Physics3DWorldConfig> | undefined, shared: { fixedTimestep?: number; collisionLayerMasks?: number[]; } | undefined): Partial<Physics3DConfig>

physics3DPluginConfigOf — function @experimental

(world: Partial<Physics3DWorldConfig> | undefined): Partial<Physics3DConfig>

physics3dModuleId — function @experimental

(backend?: Physics3DBackend): BuiltinSideModuleId

pickEntitiesByRay — function @experimental

(world: PickWorld, ray: WorldRay, opts?: EntityPickOptions): Entity[]

placeCollider3DWireframe — function @experimental

(lines: Vec3[][], position: Vec3, rotation: Quat): Vec3[][]

placeOnScreen — function @experimental

(point: Vec3, lens: AnchorLens, box: { width: number; height: number; }, clamp: boolean, margin: number): AnchorPlacement

planComposite — function @experimental

(parts: readonly CompositePart[], limits?: CompositeLimits, cellSize?: number): CompositePlan

planStaticBatches — function @experimental

(candidates: readonly StaticBatchCandidate[], limits?: StaticBatchLimits): StaticBatchPlan

planStreaming — function @experimental

(entries: readonly StreamedTexture[], now: number, options: TextureStreamingOptions): StreamMove[]

planarReflectionStatus — function @experimental

(app: App, entity: Entity, view?: Entity): PlanarReflectionStatus

planeSecond — function @experimental

(position: { y: number; z?: number; }, plane: "xy" | "xz"): number

planetPlugin — const @experimental

PlanetPlugin

planetProvider — function @experimental

(id: string): PlanetProvider | undefined

platformCanOpenData — function @experimental

(): boolean

platformCanPay — function @experimental

(): boolean

platformCanShare — function @experimental

(): boolean

platformCreateCanvas — function @experimental

(width: number, height: number): PlatformCanvas

platformDevicePixelRatio — function @experimental

(): number

platformFetch — function @experimental

(url: string, options?: PlatformRequestOptions): Promise<PlatformResponse>

platformFileExists — function @experimental

(path: string): Promise<boolean>

platformInstantiateWasm — function @experimental

(pathOrBuffer: string | ArrayBuffer, imports: WebAssembly.Imports): Promise<WasmInstantiateResult>

platformOnShareRequest — function @experimental

(provide: () => PlatformShareOptions): boolean

platformOpenDataCanvas — function @experimental

(): PlatformCanvas | null

platformOpenDataPostMessage — function @experimental

(message: Record<string, unknown>): boolean

platformReadFile — function @experimental

(path: string): Promise<ArrayBuffer>

platformReadTextFile — function @experimental

(path: string): Promise<string>

platformRequestPayment — function @experimental

(request: PlatformPaymentRequest): Promise<void>

platformScreenRecorder — function @experimental

(): PlatformScreenRecorder | null

platformSetCloudKeyValues — function @experimental

(entries: Readonly<Record<string, string>>): boolean

platformShare — function @experimental

(options: PlatformShareOptions): boolean

playModeOnly — function @experimental

(): boolean

playableCta — function @experimental

(url?: string): void

playableGameEnd — function @experimental

(): void

playableRetry — function @experimental

(): void

playheadRuns — function @experimental

(from: number, to: number, duration: number, mode: WrapMode, inclusiveStart: boolean): PlayheadRun[]

pointInHitArea — function @experimental

(px: number, py: number, area: HitAreaShape): boolean

pointInOBB — function @experimental

(px: number, py: number, worldX: number, worldY: number, worldW: number, worldH: number, pivotX: number, pivotY: number, rotationZ: number, rotationW: number): boolean

pointInWorldRect — function @experimental

(px: number, py: number, worldX: number, worldY: number, worldW: number, worldH: number, pivotX: number, pivotY: number): boolean

polygonSdf — function @experimental

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

postProcessPlugin — const @experimental

PostProcessPlugin

prefabRootOf — function @experimental

(document: unknown): PrefabRoot | null

prefabsPlugin — const @experimental

PrefabsPlugin

prefilterOctahedral — function @experimental

(env: Panorama, faceSize: number, mipCount: number, maxRange: number): { width: number; height: number; rgba: Uint8Array; }

preloadGlyphs — function @experimental

(app: App, entity: Entity, text: string, options?: GlyphPreloadOptions): GlyphPreload

preloadNestedPrefabs — function @experimental

(prefab: PrefabData, loadPrefab: (path: string) => Promise<PrefabData>, cache: Map<string, PrefabData>, visited?: Set<string>, depth?: number): Promise<void>

presentedCameraView — const @beta

(app: App) => CameraViewAPI

previewTooltip — function @experimental

(world: World, target: Entity): () => void

probeRegistrations — function @experimental

(register: () => Promise<void>): Promise<ProbedRegistrations>

proceduralHeightfield — function @experimental

(p: ProceduralParams): Heightfield

projectIrradianceSH — function @experimental

(env: Panorama): Float32Array

projectSideModuleIds — function @experimental

(): string[]

projectorUV — function @experimental

(v: ClipVertex): [number, number]

pseudoLocalize — function @experimental

(template: string, options?: PseudoLocalizationOptions): string

px — const @public

(n: number) => Dimension

q — const @experimental

{ create(w?: number, x?: number, y?: number, z?: number): Quat; clone(a: Quat): Quat; mul(a: Quat, b: Quat): Quat; axis(axis: "x" | "y" | "z", rad: number): Quat; normalize(a: Quat): Quat; dot(a: Quat, b: Quat): number; neg(a: Quat): Quat; conjugate(a: Quat): Quat; rotate(a: Quat, v: Vec3): Vec3; toEuler(a: Quat): [number, number, number]; fromEuler(deg: readonly number[]): Quat; rotationTo(from: Vec3, to: Vec3): Quat; setAngleZ(a: Quat | undefined, deg: number): Quat; angleZ(a: Pick<Quat, "w" | "z">): number; scaled(a: Quat, t: number): Quat; }

quadraticBezier — function @experimental

(p0: Vec2, p1: Vec2, p2: Vec2, tolerance?: number): Vec2[]

quat — const @experimental

(w?: number, x?: number, y?: number, z?: number) => Quat

quaternionToAngle2D — function @experimental

(rz: number, rw: number): number

ragdollPlan — function @experimental

(world: World, entity: Entity, data: RagdollData): RagdollPlan | null

rankPickCandidates — function @experimental

<T>(candidates: ReadonlyArray<PickCandidate<T>>): T[]

rayPlaneHit — function @experimental

(ray: WorldRay, point: Vec3, normal: Vec3): Vec3 | null

readCollider2DShapes — function @experimental

(world: World, entity: number): Collider2DInstance[]

readCollider3DShapes — function @experimental

(world: World, entity: number): Collider3DInstance[]

readFieldPath — function @experimental

(data: Record<string, unknown>, path: string): unknown

readJoint3D — function @experimental

(world: World, entity: number): Joint3DShape | null

readPtrField — function @experimental

(f32: Float32Array, u32: Uint32Array, u8: Uint8Array, ptr: number, field: PtrFieldDesc): unknown

rebuildChildren — function @experimental

(entities: ProcessedEntity[]): void

receiverFromMesh — function @experimental

(mesh: MeshData, transform: ArrayLike<number>): DecalReceiver | null

recordSceneOrigins — function @experimental

(app: App, entityMap: ReadonlyMap<number, Entity>): void

recoverDevice — function @experimental

(): boolean

reflectEsshader — function @experimental

(source: string): ShaderReflection

refreshPlanarReflection — function @experimental

(app: App, entity: Entity): void

registerAction — function @experimental

(name: string, fn: AiAction<AiContext> | AiActionSpec<AiContext>): void

registerAnimatorController — function @experimental

(key: string, def: AnimatorControllerDef): void

registerCensusProbe — function @experimental

(probe: CensusProbe): () => void

registerComponent — function @experimental

(name: string, def: AnyComponentDef): void

registerCondition — function @experimental

(name: string, fn: AiCondition<AiContext>): void

registerDrawCallback — function @experimental

(id: string, fn: DrawCallback, scene?: string): void

registerEffect — function @experimental

(def: EffectDef): void

registerFingerPose — function @experimental

(name: string, pose: FingerPoseDef): void

registerGripPose — function @experimental

(name: string, pose: GripPoseDef): void

registerPackagedSideModules — function @experimental

(config: Pick<PackagedGameConfig, "sideModules">): void

registerPlanetProvider — function @experimental

(provider: PlanetProvider): void

registerPreSceneDrawCallback — function @experimental

(id: string, fn: PreSceneDrawCallback): void

registerSceneComponentCodec — function @experimental

(type: string, codec: SceneComponentCodec): void

registerSideModule — function @experimental

(id: string, descriptor: SideModuleDescriptor): void

registerTerrainProvider — function @experimental

(provider: TerrainProvider): void

registerValue — function @experimental

(name: string, spec: AiValueSpec<AiContext>): void

registerWeatherPreset — function @beta

(name: string, preset: WeatherPreset): number

registerWorldRules — function @experimental

(rules: WorldRules): void

registryEntityFields — function @experimental

(): (componentType: string) => readonly string[]

releaseGripHolds — function @experimental

(app: App): void

remapComponentEntityRefs — function @experimental

(components: ComponentData[], idMapping: Map<PrefabEntityId, number>): void

remapEntityFields — function @experimental

(compData: SceneComponentData, entityMap: Map<number, Entity>, external?: ReadonlyMap<number, Entity>): void

removeAnimatorIK — function @experimental

(def: AnimatorControllerDef, index: number): AnimatorControllerDef

removeAnimatorLayer — function @experimental

(def: AnimatorControllerDef, index: number): AnimatorControllerDef

removeAnimatorParam — function @experimental

(def: AnimatorControllerDef, name: string): AnimatorControllerDef

removeAnimatorState — function @experimental

(def: AnimatorControllerDef, name: string, layer?: number): AnimatorControllerDef

removeAnimatorTransition — function @experimental

(def: AnimatorControllerDef, from: string, index: number, layer?: number): AnimatorControllerDef

removeNode — function @beta

(g: MaterialGraph, id: string): MaterialGraph

renameAnimatorState — function @experimental

(def: AnimatorControllerDef, oldName: string, newName: string, layer?: number): AnimatorControllerDef

renderCameraFrame — function @experimental

(app: App, width: number, height: number, entity?: number): boolean

renderMeshPreview — function @experimental

(module: unknown, mesh: number, w: number, h: number): Promise<ImageData | null>

renderOrigin — function @experimental

(): Readonly<RenderOriginState>

replay — function @experimental

(scope: SpeculationScope, body: (commands: CommandsInstance) => SpeculationOutcome): ReplayReport

replayDraw — function @experimental

(module: CaptureEngine, drawCallIndex: number, nextFrame: NextFrame, maxFrames?: number): Promise<ReplaySnapshot | null>

replayFrameDraw — function @experimental

(app: App, drawIndex: number, nextFrame: NextFrame): Promise<FrameReplayImage | null>

reportDeviceLost — function @experimental

(reason: number, message: string): void

requireResourceManager — function @experimental

(): CppResourceManager

resetEditorViewLighting — function @experimental

(data: EditorViewLightingData): EditorViewLightingData

resetWorldTo — function @experimental

(world: World, sceneData: SceneData): Map<number, Entity>

resolveActiveShot — function @experimental

(asset: TimelineAsset, time: number, root: Entity, resolveChild: ChildResolver, lookup: SequenceLookup): ActiveShot | null

resolveAssetGroup — function @experimental

(projectRelPath: string, config: AssetGroupsConfig | null | undefined): ResolvedAssetGroup

resolveAtlas — function @experimental

(projectRelPath: string, config: AssetGroupsConfig | null | undefined): ResolvedAtlas | null

resolveBindingTarget — function @experimental

(world: World, from: Entity, name: string): Entity | null

resolveChildEntity — function @experimental

(world: Pick<World, "tryGet">, rootEntity: Entity, childPath: string): Entity | null

resolveDocumentRef — function @experimental

(documentPath: string, ref: string): string

resolveParams — function @experimental

(def: AnimatorControllerDef, overrides: ReadonlyMap<string, number | boolean>): Record<string, number | boolean>

resolvePrefabRoots — function @experimental

(scene: SceneData, read: (ref: string) => Promise<unknown | null>): Promise<(ref: string) => PrefabRoot | null>

resolveQualityProfile — function @experimental

(level: QualityLevel, overrides?: Partial<QualityProfile>): QualityProfile

resolveShot — function @experimental

(clips: readonly CameraClip[], time: number): ShotState | null

resolveThemeTokens — function @experimental

(base: "dark" | "light", overrides?: ThemeOverrides): ThemeTokens

ringContains — function @experimental

(ring: SightRing, p: SightPoint): boolean

rng — function @experimental

(seed: number): () => number

rootLocalMatrix — function @experimental

(chain: readonly TRS[]): Mat4

rotateVec3ByQuat — function @experimental

(rot: Quat, v: Vec3): Vec3

runCrosses — function @experimental

(run: PlayheadRun, at: number): boolean

runHeadless — function @beta

(app: App, options?: { fps?: number; }): () => void

safeAreaPlugin — const @experimental

SafeAreaPlugin

sampleHeight — function @experimental

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

sampleKeyframes — function @experimental

(keys: readonly Keyframe[], at: number): number

samplePanorama — function @experimental

(env: Panorama, dx: number, dy: number, dz: number, out: Float32Array): void

sampleRootPlacement — function @experimental

(asset: TimelineAsset, time: number, out: RootPlacement): boolean

sampleTimeline — function @experimental

(asset: TimelineAsset, time: number, rootEntity: Entity, deps: SampleDeps, opts?: SampleOptions): void

sampleTimelineInWorld — function @experimental

(asset: TimelineAsset, time: number, world: SampleWorld & Pick<World, "tryGet">, rootEntity: Entity, opts?: SampleOptions): void

scalar — const @experimental

{ readonly clamp: (x: number, min: number, max: number) => number; readonly clamp01: (x: number) => number; readonly lerp: (a: number, b: number, t: number) => number; readonly inverseLerp: (a: number, b: number, value: number) => number; readonly remap: (value: number, inMin: number, inMax: number, outMin: number, outMax: number) => number; readonly deg2rad: (deg: number) => number; readonly rad2deg: (rad: number) => number; readonly approximately: (a: number, b: number, epsilon?: number) => boolean; readonly smoothstep: (edge0: number, edge1: number, x: number) => number; readonly mod: (x: number, n: number) => number; readonly sign: (x: number) => number; }

scatterCell — function @experimental

(p: ScatterParams, ground: Ground): Plant[]

sceneAmbientLights — function @experimental

(entities: readonly EnvironmentLightEntity[], exists: (ref: string) => boolean): SceneAmbientLight[]

sceneEnvironment — function @experimental

(lights: readonly SceneAmbientLight[]): { effective: SceneAmbientLight | null; shadowed: SceneAmbientLight[]; }

sceneManagerPlugin — const @experimental

Plugin

sceneOriginOf — function @experimental

(app: App, entity: Entity): number | undefined

sceneOriginsEnabled — function @experimental

(app: App): boolean

sceneOutOfBandFields — function @experimental

(type: string): readonly string[]

sceneUses3DPhysics — function @experimental

(sceneData: SceneData): boolean

sceneUsesI18n — function @experimental

(sceneData: SceneData): boolean

sceneUsesPhysics — function @experimental

(sceneData: SceneData): boolean

scopeDomain — function @experimental

(name: string): string

screenRay — function @experimental

(screenX: number, screenY: number, inverseVP: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number): WorldRay

screenToUiLayout — function @experimental

(overlay: ScreenOverlayData, screenGLX: number, screenGLY: number): { x: number; y: number; }

screenToUiWorld — function @experimental

(camera: UICameraData, screenGLX: number, screenGLY: number): { x: number; y: number; }

screenToWorld — function @experimental

(screenX: number, screenY: number, inverseVP: Float32Array, vpX: number, vpY: number, vpW: number, vpH: number, planeZ?: number): { x: number; y: number; }

screenWorkAxes — function @experimental

(view: EditorViewData): { right: { axis: WorldAxis; sign: number; }; up: { axis: WorldAxis; sign: number; }; }

seesPoint — function @experimental

(viewer: SightPoint, radius: number, target: SightPoint, rings: readonly SightRing[]): boolean

segmentBlocked — function @experimental

(from: SightPoint, to: SightPoint, rings: readonly SightRing[]): boolean

selectBlendClip — function @experimental

(blend: AnimatorBlend1D, value: number): AnimatorBlendThreshold

selectBlendStop — function @experimental

(blend: AnimatorBlend1DMotion, value: number): AnimatorBlendStop | null

selectNodes — function @experimental

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

selectPluralForm — function @experimental

(forms: PluralForms, count: number, selector: PluralSelector): string

selectSphereNodes — function @experimental

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

serializeAnimClip — function @experimental

(asset: AnimClipAssetData): Record<string, unknown>

serializeScene — function @experimental

(world: World, sceneName?: string): SceneData

serializeTimelineAsset — function @experimental

(asset: TimelineAsset): Record<string, unknown>

serializeTimelineToJson — function @experimental

(asset: TimelineAsset, indent?: number): string

servicesPlugin — const @experimental

ServicesPlugin

setAnimatorConditions — function @experimental

(def: AnimatorControllerDef, from: string, index: number, conditions: AnimatorCondition[], layer?: number): AnimatorControllerDef

setAnimatorInitial — function @experimental

(def: AnimatorControllerDef, name: string, layer?: number): AnimatorControllerDef

setAnimatorStateClip — function @experimental

(def: AnimatorControllerDef, name: string, clip: string, layer?: number): AnimatorControllerDef

setAnimatorStateMotion — function @experimental

(def: AnimatorControllerDef, name: string, motion: AnimatorMotion | null, layer?: number): AnimatorControllerDef

setAnimatorStateProps — function @experimental

(def: AnimatorControllerDef, name: string, patch: { speed?: number; loop?: boolean; rootMotion?: boolean; speedParameter?: string; }, layer?: number): AnimatorControllerDef

setBlobShadowGround — function @experimental

(app: App, sample: BlobShadowGround | null): void

setBodyPusher — function @experimental

(push: BodyPusher | null): void

setButtonState — function @experimental

(world: World, entity: Entity, state: string): void

setControllerPage — function @experimental

(world: World, entity: Entity, name: string, page: string): boolean

setDefaultContext — function @experimental

(ctx: AppContext): void

setEditorMode — function @experimental

(active: boolean): void

setEditorViewHalfHeight — function @experimental

(view: EditorViewData, halfH: number): void

setEntityActive — function @experimental

(world: World, entity: Entity, active: boolean): void

setEntityVisible — function @experimental

(world: World, entity: Entity, visible: boolean): void

setFxEditPreview — function @experimental

(enabled: boolean): void

setLayerState — function @experimental

(a: AnimatorData, index: number, path: string): void

setLogLevel — function @experimental

(level: LogLevel): void

setPath — function @experimental

(app: App, entity: Entity, points: readonly Vec2[], style: PathStyle): void

setPlayMode — function @experimental

(active: boolean): void

setRenderOriginStep — function @experimental

(step: number): void

setRetainedBudget — function @experimental

(bytes: number): void

setSkyClockState — function @experimental

(next: Partial<SkyClockState> | null): void

setTextureBudget — function @experimental

(bytes: number): void

setTextureFilter — function @experimental

(textureId: number, filter: TextureFilter): void

setTextureParams — function @experimental

(textureId: number, minFilter: TextureFilter, magFilter: TextureFilter, wrapS: TextureWrap, wrapT: TextureWrap): void

setTextureSliceBorder — function @experimental

(textureId: number, left: number, right: number, top: number, bottom: number): void

setTextureWrap — function @experimental

(textureId: number, wrap: TextureWrap): void

setTheme — function @experimental

(tokens: ThemeTokens): void

setTimelineShot — function @experimental

(host: CameraDirectorHost, owner: number, shot: TimelineShot | null): void

setTreeViewData — function @beta

<T>(world: World, entity: Entity, data: TreeDataSource<T>, options?: Pick<TreeViewOptions<T>, "canDrop" | "dragHandle" | "item" | "onDrop">): () => void

setUIVisible — function @experimental

(world: World, entity: Entity, visible: boolean): void

setViewTarget — function @experimental

(host: CameraDirectorHost, entity: number, opts?: { time?: number; curve?: number; }): void

setWasmErrorHandler — function @experimental

(handler: WasmErrorHandler | null): void

setWorldUnitsPerMeter — function @experimental

(value: number): void

shBasis — function @experimental

(dx: number, dy: number, dz: number, out: Float32Array): void

shadersCompiled — function @experimental

(module: ESEngineModule | null, timeoutMs?: number): Promise<boolean>

shakeCamera — function @experimental

(host: CameraDirectorHost, opts?: { amplitude?: number; rotation?: number; frequency?: number; duration?: number; }): void

shapeCenter — function @experimental

(shape: Collider2DShape, worldPos: Vec2, angle: number, ppu: number): Vec2

shapeOffset — function @experimental

(shape: Collider2DShape): Vec2

sheetCellCount — function @experimental

(grid: SheetGrid): number

sheetCellRect — function @experimental

(grid: SheetGrid, cell: number): { x: number; y: number; width: number; height: number; }

sheetCellUv — function @experimental

(grid: SheetGrid, cell: number): { uvOffset: { x: number; y: number; }; uvScale: { x: number; y: number; }; }

sheetCols — function @experimental

(grid: SheetGrid): number

sheetRows — function @experimental

(grid: SheetGrid): number

shelterMaskSizeOf — function @experimental

(asked: number, allowed: number | null): number

shippedOptionalSubsystems — function @experimental

(): string[]

shoreDamp — function @experimental

(reach: number, width: number): number

shutdownDrawAPI — function @experimental

(): void

shutdownGLDebugAPI — function @experimental

(): void

shutdownGeometryAPI — function @experimental

(): void

shutdownMaterialAPI — function @experimental

(): void

shutdownRendererAPI — function @experimental

(): void

shutdownResourceManager — function @experimental

(): void

sideModuleDescriptor — function @experimental

(id: SideModuleId): SideModuleDescriptor | undefined

sightRingOf — function @experimental

(caster: ShadowCaster2DData, transform: TransformData): SightRing | null

signal — function @experimental

<T>(initial: T): Signal<T>

skyClockState — function @experimental

(): SkyClockState

skyRadiance — function @experimental

(spec: SkySpec): SkyRadiance

slerpQuat — function @experimental

(a: Quat, b: Quat, t: number): Quat

solveAnimatorIK — function @experimental

(world: World, rigRoot: Entity, pose: Pose, constraints: readonly AnimatorIK[], params: MotionParams, resolveJoint?: JointResolver, ground?: GroundContext): void

spatialDistance — function @experimental

(source: Vec3, listener: Vec3): number

spawnUIEntity — function @beta

(init: UIEntityInit): Entity

sphereNodeKey — const @experimental

(n: SphereNode) => string

spineCullingContractFrom — function @experimental

(importer: Record<string, unknown> | undefined | null): SpineCullingContract | undefined

spineManifestContractFrom — function @experimental

(importer: Record<string, unknown> | undefined | null, keyOfRef: (ref: string) => string | undefined): SpineManifestContract | undefined

spineModuleId — function @experimental

(version: SpineVersion): SideModuleId

splinePlugin — const @experimental

Plugin

springBonePlugin — const @experimental

SpringBonePlugin

spriteMotionDriver — const @experimental

MotionDriver<AnimatorClipMotion>

stableEntityId — function @experimental

(app: App, entity: Entity): number | undefined

stackOf — function @experimental

(error: unknown): string | undefined

stampLook — function @experimental

(kind: StepKind, age: number, life: number): { scale: number; alpha: number; }

startDebugChannel — function @experimental

(config: DebugChannelConfig): void

staticBatchKey — function @experimental

(state: StaticBatchState, layout: string): string

staticBatchLayout — function @experimental

(channels: readonly MeshChannelDesc[], stride: number): string

staticBatchLayoutRefusal — function @experimental

(mesh: MeshData): StaticBatchRefusal | null

staticBatchPlugin — const @experimental

Plugin

statsPlugin — const @experimental

StatsPlugin

stepFade — function @experimental

(current: number, goal: number, dt: number, fadeTime: number): number

stopSoundEventSource — function @beta

(world: World, entity: Entity): void

streamTargetEdge — function @experimental

(fullEdge: number, wanted: number, minEdge: number): number

streamedBytes — function @experimental

(fullWidth: number, fullHeight: number, edge: number): number

streamingSourcesOf — function @experimental

(app: App): ChunkSource[]

studioPreviewReport — function @experimental

(entities: readonly EnvironmentLightEntity[], exists: (ref: string) => boolean): StudioPreviewReport

subgraphInputs — function @beta

(sub: MaterialGraph): SubgraphInput[]

subgraphOutputType — function @beta

(sub: MaterialGraph): GraphType

subgraphRefs — function @beta

(graph: MaterialGraph): string[]

summarizeCapture — function @experimental

(capture: ProfileCapture): CaptureSummary

summarizeFrames — function @experimental

(frames: readonly CapturedFrame[], budgetMs?: number): CaptureSummary

sunPosition — function @experimental

(hour: number, latitude: number, declination: number, north: number): { elevation: number; azimuth: number; }

surfaceAt — function @experimental

(x: number, y: number, surfaces: readonly { kind: StepKind; layer: number; centre: { x: number; y: number; }; half: { x: number; y: number; }; margin: number; round: boolean; }[]): StepKind | null

switchTheme — function @experimental

(world: World, tokens: ThemeTokens): void

takeCensus — function @experimental

(ctx?: CensusContext): Census

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

textInputPlugin — const @experimental

TextInputPlugin

textPlugin — const @experimental

TextPlugin

textureFormatOf — function @experimental

(report: TextureFormatReport | null, path: string): TextureFormatRecord | null

textureImportSettingsFrom — function @experimental

(importer: Record<string, unknown> | undefined | null): ParsedTextureImportSettings | undefined

textureStreamingPlugin — const @experimental

Plugin

themeButtonStates — function @experimental

(): Record<string, ButtonStateVisual>

themeColors — function @beta

(): ThemeColors

themeType — function @experimental

(): ThemeType

timeOfDayAt — function @beta

(hour: number, latitude?: number, declination?: number, north?: number): TimeOfDayState

timelinePlugin — const @experimental

TimelinePlugin

timerPlugin — const @experimental

Plugin

trailPlugin — const @experimental

TrailPlugin

transitionTo — function @beta

(host: App | SceneManagerState, targetScene: string, config: TransitionConfig): Promise<void>

translateAssetHandles — function @experimental

(components: readonly SnapshotComponent[], pathForHandle: (kind: string, handle: number) => string | null): SnapshotComponent[]

travelRatio — function @experimental

(source: AnimatorAvatar | null, target: AnimatorAvatar | null): number

triggerSoundEventSource — function @beta

(world: World, entity: Entity): Promise<SoundEventHandle | null>

trimTextureCache — function @experimental

(): number

uiHitAtScreen — function @experimental

(world: PickableWorld, camera: UICameraData, overlay: ScreenOverlayData, screenGLX: number, screenGLY: number): Entity | null

uiHitTestWorld — function @experimental

(world: PickableWorld, ray: WorldRay, screenRay?: WorldRay): Entity | null

uiInteractionPlugin — const @experimental

UIInteractionPlugin

uiLayoutPlugin — const @experimental

UILayoutPlugin

uiLayoutRect — function @experimental

(cam: CameraExtents, fit: CanvasScale | null, width: number, height: number, previewAspect?: number): WorldRect

uiLayoutToScreen — function @experimental

(overlay: ScreenOverlayData, x: number, y: number): { x: number; y: number; }

uiMaskPlugin — const @experimental

UIMaskPlugin

uiNodeWorldBox — function @experimental

(world: LayoutWorld, entity: Entity): EntityBox | null

uiPickAllWorld — function @experimental

(world: PickableWorld, worldX: number, worldY: number): Entity[]

uiPickWorld — function @experimental

(world: PickableWorld, worldX: number, worldY: number): Entity | null

uiPlugin — const @experimental

UIPlugin

uiPlugins — const @experimental

Plugin[]

uiRenderOrderPlugin — const @experimental

UIRenderOrderPlugin

uiVisibilityPlugin — const @experimental

UIVisibilityPlugin

uiWorldToScreen — function @experimental

(camera: UICameraData, worldX: number, worldY: number): { x: number; y: number; }

uniformInUnits — function @experimental

(u: EffectUniformDef): EffectUniformDef

unregisterComponent — function @experimental

(name: string): void

unregisterDrawCallback — function @experimental

(id: string): void

unregisterPreSceneDrawCallback — function @experimental

(id: string): void

unwrapLightmapUV — function @experimental

(mesh: MeshData, options?: UnwrapOptions): UnwrapResult

updateAnimatorIK — function @experimental

(def: AnimatorControllerDef, index: number, patch: Partial<AnimatorIK>): AnimatorControllerDef

updateAnimatorLayer — function @experimental

(def: AnimatorControllerDef, index: number, patch: Pick<Partial<AnimatorLayer>, "blend" | "mask" | "name" | "weight">): AnimatorControllerDef

updateAnimatorParam — function @experimental

(def: AnimatorControllerDef, name: string, patch: Partial<AnimatorParam>): AnimatorControllerDef

updateAnimatorTransition — function @experimental

(def: AnimatorControllerDef, from: string, index: number, patch: Partial<AnimatorTransition>, layer?: number): AnimatorControllerDef

updateCameraAspectRatio — function @experimental

(world: World, aspectRatio: number): void

uprightOf — function @experimental

(sprite: SpriteData, transform: TransformData, data: RainUprightData): Upright | null

uprightRects — function @experimental

(uprights: readonly Upright[], view: { left: number; bottom: number; right: number; top: number; }): MaskRect[]

uvRectFromPixels — function @experimental

(rect: { x: number; y: number; width: number; height: number; }, textureWidth: number, textureHeight: number): UvRect

v2 — const @experimental

{ readonly create: (x?: number, y?: number) => Vec2; readonly clone: (a: Vec2) => Vec2; readonly add: (a: Vec2, b: Vec2) => Vec2; readonly sub: (a: Vec2, b: Vec2) => Vec2; readonly scale: (a: Vec2, s: number) => Vec2; readonly mul: (a: Vec2, b: Vec2) => Vec2; readonly neg: (a: Vec2) => Vec2; readonly dot: (a: Vec2, b: Vec2) => number; readonly cross: (a: Vec2, b: Vec2) => number; readonly len: (a: Vec2) => number; readonly len2: (a: Vec2) => number; readonly dist: (a: Vec2, b: Vec2) => number; readonly dist2: (a: Vec2, b: Vec2) => number; readonly normalize: (a: Vec2) => Vec2; readonly lerp: (a: Vec2, b: Vec2, t: number) => Vec2; readonly angle: (a: Vec2) => number; readonly fromAngle: (radians: number, length?: number) => Vec2; readonly rotate: (a: Vec2, radians: number) => Vec2; readonly perp: (a: Vec2) => Vec2; readonly equals: (a: Vec2, b: Vec2, epsilon?: number) => boolean; }

v3 — const @experimental

{ readonly create: (x?: number, y?: number, z?: number) => Vec3; readonly clone: (a: Vec3) => Vec3; readonly add: (a: Vec3, b: Vec3) => Vec3; readonly sub: (a: Vec3, b: Vec3) => Vec3; readonly scale: (a: Vec3, s: number) => Vec3; readonly mul: (a: Vec3, b: Vec3) => Vec3; readonly neg: (a: Vec3) => Vec3; readonly dot: (a: Vec3, b: Vec3) => number; readonly cross: (a: Vec3, b: Vec3) => Vec3; readonly len: (a: Vec3) => number; readonly len2: (a: Vec3) => number; readonly dist: (a: Vec3, b: Vec3) => number; readonly normalize: (a: Vec3) => Vec3; readonly lerp: (a: Vec3, b: Vec3, t: number) => Vec3; readonly equals: (a: Vec3, b: Vec3, epsilon?: number) => boolean; }

validateOverrides — function @experimental

(prefab: PrefabData, options?: { instanceOverrides?: readonly PrefabOverride[]; loadPrefab?: (path: string) => PrefabData | null; }): ValidateResult

validatePrefab — function @experimental

(prefab: PrefabData, options?: ValidatePrefabOptions): PrefabDiagnostic[]

validateScene — function @experimental

(scene: SceneData): DocumentDiagnostic[]

validateSubgraph — function @beta

(sub: MaterialGraph, resolve: SubgraphResolver): void

vec2 — const @experimental

(x?: number, y?: number) => Vec2

vec3 — const @experimental

(x?: number, y?: number, z?: number) => Vec3

vec4 — const @experimental

(x?: number, y?: number, z?: number, w?: number) => Vec4

velocityPlugin — const @experimental

Plugin

velocitySystem — const @experimental

SystemDef

videoPlugin — const @experimental

VideoPlugin

voxelPlugin — const @experimental

VoxelPlugin

warmShaders — function @experimental

(app: App, options?: ShaderWarmupOptions): Promise<ShaderWarmup>

warn — function @experimental

(category: string, message: string, data?: unknown): void

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]

weatherPresetId — function @beta

(name: string): number | undefined

weatherPresetNames — function @beta

(): string[]

wechatProfile — const @experimental

MiniGameProfile

widgetToPrefab — function @experimental

(build: (world: World) => Entity, name: string): PrefabData

withActiveRemoteRoot — function @experimental

(config: AssetGroupsConfig | null | undefined, remoteRoot: string): AssetGroupsConfig

withFolderAlwaysInclude — function @experimental

(config: AssetGroupsConfig | null | undefined, folder: string, on: boolean): AssetGroupsConfig

withFolderGroup — function @experimental

(config: AssetGroupsConfig | null | undefined, folder: string, mode: AssetGroupMode): AssetGroupsConfig

worldAxisVector — function @experimental

(axis: WorldAxis): Vec3

worldGenPlugin — const @experimental

Plugin

worldManifestPath — function @experimental

(sceneName: string): string

worldResidencyPlugin — const @experimental

Plugin

worldResidencyReport — function @experimental

(app: App): WorldResidencyReport

worldResidencySystem — const @experimental

SystemDef

worldRules — function @experimental

(id: string): WorldRules | undefined

worldSnapshot — function @experimental

(app: App, selectedId: number | null, withTree: boolean, opts?: WorldSnapshotOptions): WorldSnapshot

worldUnitScale — function @experimental

(): number

worldUnitsPerMeter — function @experimental

(): number

wouldNestCycle — function @experimental

(host: string, ref: string, lookup: SequenceLookup): boolean

wrapSceneSystem — function @experimental

(app: App, sceneName: string, system: SystemDef): SystemDef

writeFieldPath — function @experimental

(data: Record<string, unknown>, path: string, value: unknown): boolean

writePtrField — function @experimental

(f32: Float32Array, u32: Uint32Array, u8: Uint8Array, ptr: number, field: PtrFieldDesc, value: PtrFieldValue | unknown): void

wxFileExists — function @experimental

(path: string): Promise<boolean>

wxFileExistsSync — function @experimental

(path: string): boolean

wxGetImagePixels — function @experimental

(img: MiniGameImage): ImageLoadResult

wxLoadImage — function @experimental

(path: string): Promise<MiniGameImage>

wxLoadImagePixels — function @experimental

(path: string): Promise<ImageLoadResult>

wxReadFile — function @experimental

(path: string): Promise<ArrayBuffer>

wxReadTextFile — function @experimental

(path: string, encoding?: "utf-8" | "utf8"): Promise<string>

wxWriteFile — function @experimental

(path: string, data: string | ArrayBuffer): Promise<void>