Skip to main content

excalibur

Index

Classes

Enumerations

Functions

Interfaces

Namespaces

Type Aliases

Variables

Type Aliases

activate

activate: activate

ActorArgs

ActorArgs: ActorOptions

Actor constructor options

@deprecated

use ActorOptions

ActorOptions

ActorOptions: ColliderArgs & { acc?: Vector; anchor?: Vector; angularVelocity?: number; canPause?: boolean; collisionGroup?: CollisionGroup; collisionType?: CollisionType; color?: Color; coordPlane?: CoordPlane; graphic?: Graphic; isVisible?: boolean; material?: Material; name?: string; offset?: Vector; opacity?: number; pos?: Vector; rotation?: number; scale?: Vector; vel?: Vector; x?: number; y?: number; z?: number }

Actor constructor options

add

add: add

AnyString

AnyString: {} & string

AudioBusBuilder

AudioBusBuilder: (ctx: AudioBusContext) => void

Lifecycle hook that wires a bus (SoundChannel or the SoundManager master) when it is created, replacing the default input → output edge. Use it to insert effects that apply to every sound on the bus:

const manager = new ex.SoundManager({
  channels: [
    'sfx',
    {
      name: 'music',
      onConnect: ({ audioContext, input, output }) => {
        const muffle = audioContext.createBiquadFilter();
        muffle.type = 'lowpass';
        input.connect(muffle).connect(output);
      }
    }
  ],
  onConnect: ({ audioContext, input, output }) => {
    input.connect(audioContext.createDynamicsCompressor()).connect(output);
  },
  sounds: [...]
});

Type declaration

AudioGraphBuilder

AudioGraphBuilder: (ctx: AudioGraphContext) => void

Hook that wires the Web Audio graph for one playback of a Sound.

It runs every time a track (re)starts a buffer source: on a fresh play(), and again when a paused or seeked track resumes, because Web Audio buffer sources are single use. Nodes you create outside the hook can be reused freely (connecting the same two nodes twice is a no-op in Web Audio), and Excalibur never disconnects nodes it did not create.

If no hook is provided Excalibur wires source → destination directly.

// A low-pass filter shared by every playback of this sound
const muffle = ex.AudioContextFactory.create().createBiquadFilter();
muffle.type = 'lowpass';
muffle.frequency.value = 400;

const sound = new ex.Sound({
  paths: ['/sfx/explosion.ogg'],
  onPlay: ({ source, destination }) => {
    source.connect(muffle).connect(destination);
  }
});

// Spatial audio positioned per play
sound.play({
  onPlay: ({ audioContext, source, destination }) => {
    const panner = audioContext.createPanner();
    panner.positionX.value = enemy.pos.x;
    source.connect(panner).connect(destination);
  }
});

Type declaration

axis

axis: axis

BodyConfig

BodyConfig: DeepRequired<Pick<PhysicsConfig, bodies>[bodies]>

button

button: button

cancel

cancel: cancel

CircleOccluder

CircleOccluder:

A shadow volume silhouette approximated by a circle in screen space

center

center: Vector

kind

kind: circle

radius

radius: number

ColliderCreationData

ColliderCreationData: BoxColliderData | CircleColliderData | PolygonColliderData | EdgeColliderData | CompositeColliderData | CapsuleColliderData

ColliderType

ColliderType: box | polygon | circle | edge | capsule | composite

collisionend

collisionend: collisionend

collisionstart

collisionstart: collisionstart

ComponentCtor

ComponentCtor<TComponent>: new (...args: any[]) => TComponent

Component Constructor Types

Type parameters

Type declaration

    • new (...args: any[]): TComponent

    • Parameters

      • rest...args: any[]

      Returns TComponent

ComponentInstance

ComponentInstance<T>: T extends ComponentCtor<infer R> ? R : never

Type parameters

  • T

CompositeStrategy

CompositeStrategy: separate | together

connect

connect: connect

CoroutineGenerator

CoroutineGenerator: () => Generator<any | number | Promise<any> | undefined, void, number>

Type declaration

    • (): Generator<any | number | Promise<any> | undefined, void, number>

    • Returns Generator<any | number | Promise<any> | undefined, void, number>

deactivate

deactivate: deactivate

DestinationSize

DestinationSize:

height

height: number

width

width: number

disconnect

disconnect: disconnect

DistributeEntity

DistributeEntity<T>: T extends infer U ? Entity<U> : never

Turns Entity<A | B> into Entity<A> | Entity<B>

Type parameters

  • T

down

down: down

Easing

Easing: (currentTime: number, ...args: number[]) => number

Type declaration

    • (currentTime: number, ...args: number[]): number

    • Parameters

      • currentTime: number

        time value between 0 and 1

      • rest...args: number[]

      Returns number

      scale of the final value between 0 and 1

enter

enter: enter

entertrigger

entertrigger: enter

enterviewport

enterviewport: enterviewport

EventKey

EventKey<T>: string & keyof T

Type parameters

EventMap

EventMap: Record<string, any>

exittrigger

exittrigger: exit

exitviewport

exitviewport: exitviewport

G_UUID

G_UUID: string & { __brand: unique symbol }

A unique identifier for a graph node or edge.

Handler

Handler<EventType>: (event: EventType) => void

Type parameters

  • EventType

Type declaration

    • (event: EventType): void

    • Parameters

      • event: EventType

      Returns void

hidden

hidden: hidden

hold

hold: hold

HTMLImageSource

HTMLImageSource: HTMLImageElement | HTMLCanvasElement

Id

Id<T>:

Type parameters

  • T: string

type

type: T

value

value: number

initialize

initialize: initialize

kill

kill: kill

leave

leave: leave

LoaderConstructor

LoaderConstructor: new (...args: any[]) => DefaultLoader

Type declaration

MaterialOptions

MaterialOptions: MaterialShaderOptions & MaterialSharedOptions

MaterialOptionsWithoutContext

MaterialOptionsWithoutContext: MaterialShaderOptions & Omit<MaterialSharedOptions, graphicsContext>

MaterialOptions without the graphics context, preserving the valid fragmentSource/passes combinations, used by ExcaliburGraphicsContextWebGL.createMaterial

MaybeKnownComponent

MaybeKnownComponent<Component, TKnownComponents>: Component extends TKnownComponents ? Component : Component | undefined

Type parameters

  • Component
  • TKnownComponents

MaybeObserver

MaybeObserver<T>: Partial<Observer<T>>

Defines an interface for something that might be an observer if a notify() is present

Type parameters

  • T

move

move: move

NativeMouseEvent

NativeMouseEvent: globalThis.MouseEvent

NativePointerEvent

NativePointerEvent: globalThis.PointerEvent

NativeTouchEvent

NativeTouchEvent: globalThis.TouchEvent

NativeWheelEvent

NativeWheelEvent: globalThis.WheelEvent

NineSliceConfig

NineSliceConfig: GraphicOptions & { destinationConfig: { drawCenter: boolean; horizontalStretch: NineSliceStretch; verticalStretch: NineSliceStretch }; height: number; source: ImageSource; sourceConfig: { bottomMargin: number; height: number; leftMargin: number; rightMargin: number; topMargin: number; width: number }; width: number }

Occluder

Occluder: PolyOccluder | CircleOccluder

World/screen-space occluder geometry consumed by LightingSystem to cast shadows

OccluderShape

OccluderShape: { anchor?: Vector; height: number; kind: box; width: number } | { kind: polygon; vertices: Vector[] } | { kind: circle; radius: number }

ParticleEmitterArgs

ParticleEmitterArgs: ParticleEmitterOptions
@deprecated

use ParticleEmitterOptions

pointercancel

pointercancel: pointercancel

pointerdown

pointerdown: pointerdown

pointerdragend

pointerdragend: pointerdragend

pointerdragenter

pointerdragenter: pointerdragenter

pointerdragleave

pointerdragleave: pointerdragleave

pointerdragmove

pointerdragmove: pointerdragmove

pointerdragstart

pointerdragstart: pointerdragstart

pointerenter

pointerenter: pointerenter

pointerleave

pointerleave: pointerleave

pointermove

pointermove: pointermove

pointerup

pointerup: pointerup

pointerwheel

pointerwheel: pointerwheel

PolyOccluder

PolyOccluder:

A shadow volume silhouette approximated by a closed polygon in screen space

kind

kind: poly

verts

verts: Vector[]

PossibleStates

PossibleStates<TMachine>: TMachine extends StateMachineDescription ? Extract<keyof TMachine[states], string> : never

Type parameters

  • TMachine

postcollision

postcollision: postcollision

postdebugdraw

postdebugdraw: postdebugdraw

postdraw

postdraw: postdraw

postframe

postframe: postframe

postkill

postkill: postkill

postupdate

postupdate: postupdate

precollision

precollision: precollision

predebugdraw

predebugdraw: predebugdraw

predraw

predraw: predraw

preframe

preframe: preframe

prekill

prekill: prekill

press

press: press

preupdate

preupdate: preupdate

QueryEntity

QueryEntity<TAllComponentCtors, TAnyComponentCtors>: [TAnyComponentCtors] extends [never] ? Entity<ComponentInstance<TAllComponentCtors>> : Entity<ComponentInstance<TAllComponentCtors>> | DistributeEntity<ComponentInstance<TAnyComponentCtors>>

Type parameters

release

release: release

remove

remove: remove

SceneConstructor

SceneConstructor: new (...args: any[]) => Scene

Type declaration

    • new (...args: any[]): Scene

    • Parameters

      • rest...args: any[]

      Returns Scene

SceneMap

SceneMap<TKnownScenes>: Record<TKnownScenes, Scene | SceneConstructor | SceneWithOptions>

Type parameters

  • TKnownScenes: string = any

ScheduledCallbackTiming

ScheduledCallbackTiming: preframe | postframe | preupdate | postupdate | predraw | postdraw

ScheduleId

ScheduleId: number

Unique identifier for a scheduled callback

ShaderPassDestination

ShaderPassDestination: Framebuffer | null

Where a ShaderPass renders to: a Framebuffer, or null for the canvas backbuffer.

Inside an engine frame use ExcaliburGraphicsContextWebGL.drawTarget to composite into the frame.

ShaderPassLike

ShaderPassLike: string | ShaderPass

A ShaderPass, or a bare fragment source string that wraps into one

ShaderPassSource

ShaderPassSource: Framebuffer | ImageSource | WebGLTexture

Anything a ShaderPass can sample from: a Framebuffer, a loaded ImageSource, or a raw premultiplied WebGLTexture

SourceView

SourceView:

height

height: number

width

width: number

x

x: number

y

y: number

start

start: start

stop

stop: stop

subscribe

subscribe: subscribe

UniformDictionary

UniformDictionary: Record<string, number | boolean | Vector | Vector3 | Vector4 | Color | AffineMatrix | Matrix | Float32Array | [uniformData: Float32Array, bindingPoint: number]>

UniformTypeNames

UniformTypeNames: uniform1f | uniform1i | uniform1ui | uniform2f | uniform2i | uniform2ui | uniform3f | uniform3i | uniform3ui | uniform4f | uniform4i | uniform4ui | uniform1fv | uniform1iv | uniform1uiv | uniform2fv | uniform2iv | uniform2uiv | uniform3fv | uniform3iv | uniform3uiv | uniform4fv | uniform4iv | uniform4uiv | uniformMatrix2fv | uniformMatrix2x3fv | uniformMatrix2x4fv | uniformMatrix3fv | uniformMatrix3x2fv | uniformMatrix3x4fv | uniformMatrix4fv | uniformMatrix4x2fv | uniformMatrix4x3fv

unsubscribe

unsubscribe: unsubscribe

up

up: up

ViewportUnit

ViewportUnit: pixel | percent

visible

visible: visible

wheel

wheel: wheel

WithRoot

WithRoot<TScenes>: TScenes | root

Type parameters

  • TScenes

Variables

ActorEvents

ActorEvents: { ActionComplete: actioncomplete; ActionStart: actionstart; CollisionEnd: collisionend; CollisionStart: collisionstart; EnterViewport: enterviewport; ExitViewport: exitviewport; Kill: kill; PointerCancel: pointercancel; PointerDown: pointerdown; PointerDrag: pointerdragstart; PointerDragEnd: pointerdragend; PointerDragEnter: pointerdragenter; PointerDragLeave: pointerdragleave; PointerDragMove: pointerdragmove; PointerEnter: pointerenter; PointerLeave: pointerleave; PointerMove: pointermove; PointerUp: pointerup; PostCollision: postcollision; PostDebugDraw: postdebugdraw; PostDraw: postdraw; PostKill: postkill; PostTransformDraw: posttransformdraw; PreCollision: precollision; PreDebugDraw: predebugdraw; PreDraw: predraw; PreKill: prekill; PreTransformDraw: pretransformdraw; Wheel: pointerwheel }

Type declaration

  • readonlyActionComplete: actioncomplete
  • readonlyActionStart: actionstart
  • readonlyCollisionEnd: collisionend
  • readonlyCollisionStart: collisionstart
  • readonlyEnterViewport: enterviewport
  • readonlyExitViewport: exitviewport
  • readonlyKill: kill
  • readonlyPointerCancel: pointercancel
  • readonlyPointerDown: pointerdown
  • readonlyPointerDrag: pointerdragstart
  • readonlyPointerDragEnd: pointerdragend
  • readonlyPointerDragEnter: pointerdragenter
  • readonlyPointerDragLeave: pointerdragleave
  • readonlyPointerDragMove: pointerdragmove
  • readonlyPointerEnter: pointerenter
  • readonlyPointerLeave: pointerleave
  • readonlyPointerMove: pointermove
  • readonlyPointerUp: pointerup
  • readonlyPostCollision: postcollision
  • readonlyPostDebugDraw: postdebugdraw
  • readonlyPostDraw: postdraw
  • readonlyPostKill: postkill
  • readonlyPostTransformDraw: posttransformdraw
  • readonlyPreCollision: precollision
  • readonlyPreDebugDraw: predebugdraw
  • readonlyPreDraw: predraw
  • readonlyPreKill: prekill
  • readonlyPreTransformDraw: pretransformdraw
  • readonlyWheel: pointerwheel

AnimationEvents

AnimationEvents: { End: end; Frame: frame; Loop: loop }

Type declaration

  • readonlyEnd: end
  • readonlyFrame: frame
  • readonlyLoop: loop

CameraEvents

CameraEvents: { Initialize: initialize; PostUpdate: postupdate; PreUpdate: preupdate }

Type declaration

  • readonlyInitialize: initialize
  • readonlyPostUpdate: postupdate
  • readonlyPreUpdate: preupdate

constClosestLineJumpTable

ClosestLineJumpTable: { CircleCircleClosestLine: any; CircleEdgeClosestLine: any; EdgeEdgeClosestLine: any; PolygonCircleClosestLine: any; PolygonEdgeClosestLine: any; PolygonPolygonClosestLine: any } = ...

Type declaration

ColliderEvents

ColliderEvents: { AfterCollisionResolve: aftercollisionresolve; BeforeCollisionResolve: beforecollisionresolve; CollisionEnd: collisionend; CollisionStart: collisionstart; ContactEnd: contactend; ContactStart: contactstart; PostCollision: postcollision; PreCollision: precollision }

Type declaration

  • readonlyAfterCollisionResolve: aftercollisionresolve
  • readonlyBeforeCollisionResolve: beforecollisionresolve
  • readonlyCollisionEnd: collisionend
  • readonlyCollisionStart: collisionstart
  • readonlyContactEnd: contactend
  • readonlyContactStart: contactstart
  • readonlyPostCollision: postcollision
  • readonlyPreCollision: precollision

constCollisionJumpTable

CollisionJumpTable: { CollideCircleCircle: any; CollideCircleEdge: any; CollideCirclePolygon: any; CollideEdgeEdge: any; CollidePolygonEdge: any; CollidePolygonPolygon: any; FindContactSeparation: any } = ...

Type declaration

constDefaultAntialiasOptions

DefaultAntialiasOptions: Required<AntialiasOptions> = ...

constDefaultGarbageCollectionOptions

DefaultGarbageCollectionOptions: GarbageCollectionOptions = ...

constDefaultPixelArtOptions

DefaultPixelArtOptions: Required<AntialiasOptions> = ...

DirectorEvents

DirectorEvents: { Navigation: navigation; NavigationEnd: navigationend; NavigationStart: navigationstart }

Type declaration

  • readonlyNavigation: navigation
  • readonlyNavigationEnd: navigationend
  • readonlyNavigationStart: navigationstart

EngineEvents

EngineEvents: { FallbackGraphicsContext: fallbackgraphicscontext; Hidden: hidden; Initialize: initialize; Navigation: navigation; NavigationEnd: navigationend; NavigationStart: navigationstart; PostDraw: postdraw; PostFrame: postframe; PostUpdate: postupdate; PreDraw: predraw; PreFrame: preframe; PreUpdate: preupdate; Start: start; Stop: stop; Visible: visible }

Type declaration

  • readonlyFallbackGraphicsContext: fallbackgraphicscontext
  • readonlyHidden: hidden
  • readonlyInitialize: initialize
  • readonlyNavigation: navigation
  • readonlyNavigationEnd: navigationend
  • readonlyNavigationStart: navigationstart
  • readonlyPostDraw: postdraw
  • readonlyPostFrame: postframe
  • readonlyPostUpdate: postupdate
  • readonlyPreDraw: predraw
  • readonlyPreFrame: preframe
  • readonlyPreUpdate: preupdate
  • readonlyStart: start
  • readonlyStop: stop
  • readonlyVisible: visible

EntityEvents

EntityEvents: { Add: add; Initialize: initialize; Kill: kill; PostUpdate: postupdate; PreUpdate: preupdate; Remove: remove }

Type declaration

  • readonlyAdd: add
  • readonlyInitialize: initialize
  • readonlyKill: kill
  • readonlyPostUpdate: postupdate
  • readonlyPreUpdate: preupdate
  • readonlyRemove: remove

constEX_VERSION

EX_VERSION: string = process.env.__EX_VERSION

The current Excalibur version string

@description

process.env.__EX_VERSION gets replaced by Webpack on build

GamepadEvents

GamepadEvents: { GamepadAxis: axis; GamepadButton: button; GamepadButtonDown: buttondown; GamepadButtonUp: buttonup; GamepadConnect: connect; GamepadDisconnect: disconnect }

Type declaration

  • readonlyGamepadAxis: axis
  • readonlyGamepadButton: button
  • readonlyGamepadButtonDown: buttondown
  • readonlyGamepadButtonUp: buttonup
  • readonlyGamepadConnect: connect
  • readonlyGamepadDisconnect: disconnect

constgaussianBlurFragmentSource

gaussianBlurFragmentSource: string = ...

Blurring premultiplied colors directly is the correct alpha handling for a weighted average, so this fragment opts out of the glsl tag's straight-alpha authoring space.

Expects u_direction (e.g. vec(1, 0) for horizontal) and u_strength uniforms.

constgetDefaultLightingConfig

getDefaultLightingConfig: () => DeepRequired<LightingConfig> = ...

Type declaration

constgetDefaultPhysicsConfig

getDefaultPhysicsConfig: () => DeepRequired<PhysicsConfig> = ...

Type declaration

constHorizontalFirst

HorizontalFirst: ContactBias = ...

Horizontal First contact solve bias Used by the ArcadeSolver to sort contacts

constImageSourceAttributeConstants

ImageSourceAttributeConstants: { Filtering: filtering; ForceUpload: forceUpload; WrappingX: wrapping-x; WrappingY: wrapping-y } = ...

Type declaration

  • readonlyFiltering: filtering
  • readonlyForceUpload: forceUpload
  • readonlyWrappingX: wrapping-x
  • readonlyWrappingY: wrapping-y

LoaderEvents

LoaderEvents: { AfterLoad: afterload; BeforeLoad: beforeload; LoadResourceEnd: loadresourceend; LoadResourceStart: loadresourcestart; UserAction: useraction }

Type declaration

  • readonlyAfterLoad: afterload
  • readonlyBeforeLoad: beforeload
  • readonlyLoadResourceEnd: loadresourceend
  • readonlyLoadResourceStart: loadresourcestart
  • readonlyUserAction: useraction

constNone

None: ContactBias = ...

None value, ArcadeSolver sorts contacts using distance by default

constPauseComponentTag

PauseComponentTag: ex.paused = ...

Tag added to entities while they are paused, systems exclude paused entities by querying { not: [PauseComponentTag] }

constpixelSnapEpsilon

pixelSnapEpsilon: 0.0001 = 0.0001

ResourceEvents

ResourceEvents: { Complete: complete; Error: error; Load: load; LoadStart: loadstart; Progress: progress }

Type declaration

  • readonlyComplete: complete
  • readonlyError: error
  • readonlyLoad: load
  • readonlyLoadStart: loadstart
  • readonlyProgress: progress

SceneEvents

SceneEvents: { Activate: activate; Deactivate: deactivate; EntityAdded: entityadded; EntityRemoved: entityremoved; Initialize: initialize; Pause: pause; PostDebugDraw: postdebugdraw; PostDraw: postdraw; PostUpdate: postupdate; PreDebugDraw: predebugdraw; PreDraw: predraw; PreLoad: preload; PreUpdate: preupdate; Resume: resume; TransitionEnd: transitionend; TransitionStart: transitionstart }

Type declaration

  • readonlyActivate: activate
  • readonlyDeactivate: deactivate
  • readonlyEntityAdded: entityadded
  • readonlyEntityRemoved: entityremoved
  • readonlyInitialize: initialize
  • readonlyPause: pause
  • readonlyPostDebugDraw: postdebugdraw
  • readonlyPostDraw: postdraw
  • readonlyPostUpdate: postupdate
  • readonlyPreDebugDraw: predebugdraw
  • readonlyPreDraw: predraw
  • readonlyPreLoad: preload
  • readonlyPreUpdate: preupdate
  • readonlyResume: resume
  • readonlyTransitionEnd: transitionend
  • readonlyTransitionStart: transitionstart

ScreenEvents

ScreenEvents: { FullscreenChange: fullscreen; PixelRatioChange: pixelratio; ScreenResize: resize }

Type declaration

  • readonlyFullscreenChange: fullscreen
  • readonlyPixelRatioChange: pixelratio
  • readonlyScreenResize: resize

SoundEvents

SoundEvents: { Pause: pause; PlaybackEnd: playbackend; PlaybackStart: playbackstart; Processed: processed; Resume: resume; Stop: stop; VolumeChange: volumechange }

Type declaration

  • readonlyPause: pause
  • readonlyPlaybackEnd: playbackend
  • readonlyPlaybackStart: playbackstart
  • readonlyProcessed: processed
  • readonlyResume: resume
  • readonlyStop: stop
  • readonlyVolumeChange: volumechange

constSystemPriority

SystemPriority: { Average: 0; Higher: -5; Highest: number; Lower: 5; Lowest: number } = ...

Higher priorities run earlier than others in the system update

Type declaration

  • readonlyAverage: 0
  • readonlyHigher: -5
  • readonlyHighest: number
  • readonlyLower: 5
  • readonlyLowest: number

TileMapEvents

TileMapEvents: { PointerCancel: pointercancel; PointerDown: pointerdown; PointerEnter: pointerenter; PointerLeave: pointerleave; PointerMove: pointermove; PointerUp: pointerup; PostDraw: postdraw; PostUpdate: postupdate; PreDraw: predraw; PreUpdate: preupdate }

Type declaration

  • readonlyPointerCancel: pointercancel
  • readonlyPointerDown: pointerdown
  • readonlyPointerEnter: pointerenter
  • readonlyPointerLeave: pointerleave
  • readonlyPointerMove: pointermove
  • readonlyPointerUp: pointerup
  • readonlyPostDraw: postdraw
  • readonlyPostUpdate: postupdate
  • readonlyPreDraw: predraw
  • readonlyPreUpdate: preupdate

TimerEvents

TimerEvents: { Action: action; Cancel: cancel; Complete: complete; Pause: pause; Resume: resume; Start: start; Stop: stop }

Type declaration

  • readonlyAction: action
  • readonlyCancel: cancel
  • readonlyComplete: complete
  • readonlyPause: pause
  • readonlyResume: resume
  • readonlyStart: start
  • readonlyStop: stop

TriggerEvents

TriggerEvents: { EnterTrigger: enter; ExitTrigger: exit }

Type declaration

  • readonlyEnterTrigger: enter
  • readonlyExitTrigger: exit

constTwoPI

TwoPI: number = ...

Two PI constant

constVerticalFirst

VerticalFirst: ContactBias = ...

Vertical First contact solve bias Used by the ArcadeSolver to sort contacts

Page Options