All symbols A-Z

Shared base class for all built-in AssetFactory implementations. Manages a pool of object URLs created during asset loading s…

Base class for all text rendering nodes. Provides the common `text` property and the on-demand dirty protocol used by the ren…

Fades only the alpha channel over a particle's lifetime, leaving RGB untouched. Pair with a spawn-time tint or a separate `Co…

A Sprite that advances through a sequence of texture-frame Rectangles over time to produce frame-based animation. Multiple na…

Top-level engine instance. Owns the canvas, render backend, scene-stack controller, the app system registry (input, interacti…

Adds a constant 2D acceleration to every live particle's velocity each frame. Use for gravity (`new ApplyForce(0, 980)`), win…

Mapping for generic arcade-stick controllers. Covers the standard 8-button + shoulder/trigger layout common to most fightstic…

Thrown when an Aseprite JSON document does not match the expected shape. `source` is the URL of the file being parsed.

Parsed representation of an Aseprite JSON sprite sheet export. `AsepriteSheet.parse(data, texture)` converts the raw JSON doc…

Pulls every live particle toward a fixed point in the system's local coordinate space. Acceleration magnitude is `strength` (…

Lightweight visualisation analyser backed by a Web Audio AnalyserNode. Accepts any of: AudioBus, Voice, MediaStream, AudioNod…

Hierarchical mixer node in the engine's audio routing graph. Each bus owns three Web Audio nodes (input gain, optional effect…

Abstract base for all insertable audio effects in ExoJS. Each effect exposes stable inputNode and outputNode AudioNodes that…

Procedural tone generator — produces audio from an `OscillatorNode` without any decoded asset. Good for prototyping, game-jam…

A live audio capture source — a microphone or WebRTC `MediaStream` obtained via `getUserMedia`. **Not a Playable**: you don't…

Singleton observer position fed to the Web Audio panner nodes used by spatial sounds. Sets the listener orientation once at s…

Per-Application owner of the audio mix: three pre-configured AudioBus instances (`master` ← `music` + `sound`), a single Audi…

Streaming long-form audio backed by an `HTMLAudioElement` — background tracks, voice-over, **and internet radio** (same mecha…

Auto-wah effect that uses an amplitude envelope follower to modulate a bandpass filter, creating the characteristic "wah" swe…

Real-time tempo + beat tracker. Splits work between the audio-rendering thread (an AudioWorklet that runs onset detection, te…

Dispatch token for binary data loading. `loader.load(BinaryAsset, 'data.bin')` returns `Promise<ArrayBuffer>`.

AssetFactory implementation that loads arbitrary binary files and exposes them as raw ArrayBuffer instances. Use this for any…

Native biquad filter effect backed by a single `BiquadFilterNode` — the most common audio-shaping need, covering `lowpass` /…

Lo-fi bit-crusher effect implemented as a WorkletEffect. Applies two classic degradation stages in series: 1. **Bit-depth red…

Text node that renders from an offline-generated atlas — either a BMFont (AngelCode .fnt + .png) or an MSDF atlas (msdf-atlas…

Compositing blend modes applied when drawing a Drawable over the current render target. Modes 0–4 are implemented as fixed-fu…

Box-blur Filter implemented as multiple additive sprite passes. The blur is approximated by rendering the input texture `qual…

A loaded BMFont asset: the parsed descriptor plus all page textures. Loaded by the built-in BMFont factory — no extra setup r…

Factory that loads a BmFont bundle: parses the `.fnt` descriptor and loads all referenced page textures via the owning Loader…

Debug layer that draws a bounding-box outline around every visible RenderNode in the scene. Colours cycle by zIndex (HSL hue)…

Mutable axis-aligned bounding box accumulator. Starts as the empty bounds (`-Infinity..Infinity` reversed) and grows monotoni…

Random point inside an axis-aligned box. With `mode: 'edge'` the result lies on the perimeter (uniform along all four edges c…

Axis-aligned box of `width × height` centred on the collider's local origin — a convenience over PolygonShape. The result is…

GPU buffer binding targets. Values are WebGL2 GLenum constants used when calling `gl.bindBuffer`.

Hints describing expected buffer access pattern, allowing the driver to optimise allocation. Values are WebGL2 GLenum constan…

Thrown by Loader.loadBundle when one or more assets in the bundle fail to load. The `failures` array contains every entry tha…

Discrete-burst spawner. Fires at scheduled times with a fixed count per burst. Useful for explosions, hit-impacts, level-up e…

Clickable button with a rounded background, a centered label, hover/pressed visual states, and keyboard activation (Enter / S…

CacheStrategy that checks every provided CacheStore before falling back to the network. On a cache hit the stored value is fe…

Runs a user callback as one pass. The callback receives a PassContext scoped to the active target: `pass.render(node)`, `pass…

Frozen snapshot of host-environment feature support: which renderer backends are available, which input modalities are presen…

Base offsets of each input category inside the unified channels buffer. Add a per-key/per-slot value to one of these to get a…

Slot-count constants for the unified channels buffer. The buffer is split into three categories (`Keyboard`, `Pointers`, `Gam…

Chorus effect using native WebAudio nodes (no worklet required). The signal splits into a dry path and a wet path. The wet pa…

Mutable circle shape defined by a centre position and radius. Implements ShapeLike for use in the collision pipeline. For SAT…

Random point on or inside a circle of radius `radius`, centred at `(centerX, centerY)`. With `mode: 'edge'` the result lies e…

A circle of the given `radius` centred on the collider's local origin. The cheapest shape for both broad- and narrow-phase.

High-precision wall-clock that accumulates elapsed time while running. Reads from performance.now via `getPreciseTime`. Use C…

Geometry attached to a PhysicsBody: a Shape plus a body-local offset/rotation, material (friction/restitution/density) and a…

Discriminant tag carried by every Collidable so that intersection and collision routines can dispatch to the correct algorith…

32-bit RGBA color value with channel-wise accessors. Red, green, and blue are integers in 0..255; alpha is a float in 0..1. O…

A Filter that multiplies the input texture by a solid Color. Useful for tinting, fade-to-black/white, flash effects, and colo…

Piecewise-linear color gradient sampled by lifetime ratio `t` in `[0, 1]`. Keyframes are stored sorted by `t`; sampling outsi…

Per-frame, per-particle color sampler. Each live particle's tint is set to the gradient evaluated at the particle's current `…

Per-frame, per-particle color sampler driven by velocity magnitude rather than lifetime ratio. Each live particle's tint is s…

Dynamic-range compressor backed by a Web Audio `DynamicsCompressorNode`. Reduces the volume of loud signals above a threshold…

Random unit vector inside a cone, scaled by a speed magnitude. The cone is centred on `directionAngle` (in radians, 0 = +X, π…

Distribution that always returns the same value. Implements both Distribution and LifetimeFunction so it can stand in whereve…

Scene-graph node that owns child RenderNodes. Renders its subtree in document order with local `zIndex` ordering resolved ins…

Convolution effect that convolves the input signal with a user-supplied impulse response (IR). Unlike ReverbEffect, which gen…

Dispatch token for CSV loading. `loader.load(CsvAsset, 'table.csv')` returns `Promise<string[][]>`. Each inner array is one r…

AssetFactory implementation that loads CSV (and TSV) files and produces a two-dimensional array of strings. Parsing is RFC 41…

Piecewise-linear keyframe curve sampled by lifetime ratio `t` in `[0, 1]`. Keyframes are stored sorted by `t` and clamped at…

A 2D texture whose pixels live in a CPU-side typed array. Mutate the `buffer` directly and call commit to upload the whole ar…

Per-particle hook invoked exactly once when a particle expires, before its slot is recycled by the compaction pass. The dying…

Abstract base for a single diagnostic overlay layer. Subclasses produce a visual (outlines, text panels, sparklines, etc.) th…

Canvas-native debug overlay. Instantiate AFTER Application is constructed: import { DebugOverlay } from '@codexo/exojs/debug'…

Echo/delay effect using a Web Audio `DelayNode` with a feedback loop and dry/wet mix. The feedback path feeds the delayed sig…

Ownership container for Destroyable resources. Items registered with track are destroyed in reverse registration order when t…

Holds the anchor points on two bodies at a target length along their connecting axis. With `hertz === 0` it is rigid; with `h…

Distortion effect built from native Web Audio nodes — no worklet required. The input signal is split into a dry path and a we…

Exponential velocity damping. Each frame multiplies every live particle's velocity by `(1 - drag * dt)`, simulating linear ai…

Base class for every renderable scene object. Extends RenderNode with a per-object tint colour and blend mode. Concrete drawa…

Sidechain compressor (ducker) implemented as an WorkletEffect. Attenuates the main audio signal whenever the `sidechain` Audi…

Standard Robert Penner easing functions as static methods. Each function accepts a normalized time `t` in [0, 1] and returns…

Mutable axis-aligned ellipse shape defined by a centre position and separate horizontal (`rx`) and vertical (`ry`) half-radii…

ADSR (Attack-Decay-Sustain-Release) envelope generator. Schedules a gain curve on a target `AudioParam`: attack: 0 → 1.0 (pea…

Three-band equalizer (low shelf / peaking mid / high shelf) built from a series chain of `BiquadFilterNode` instances. Gain v…

Abstract base class for post-process filters applied to a drawable's render output. Filters are rendered into a temporary Ren…

Type-safe bitfield utility for managing sets of numeric enum flags. `T` should be a numeric const-enum or a type whose values…

Flanger effect using native WebAudio nodes (no worklet required). A flanger is a very short LFO-modulated delay (1–10 ms) wit…

Per-Application keyboard-focus service. Tracks the single focused RenderNode, routes keyboard input from the InputManager to…

Dispatch token for font loading. `loader.load(FontAsset, 'font.woff2', { family: 'MyFont' })` returns `Promise<FontFace>`.

AssetFactory implementation that loads web-font binary data (WOFF, WOFF2, TTF, OTF) and produces a parsed FontFace. By defaul…

Mapping for Nintendo GameCube controllers (typically connected via a USB adapter such as the official Nintendo adapter for Wi…

One of four stable gamepad slots. Lives for the entire `Application` lifetime even when no physical pad is attached — a "mail…

Single mappable analog axis on a physical gamepad. Holds the raw browser `Gamepad.axes[]` index, the canonical channel the va…

Single mappable button on a physical gamepad. Holds the raw browser `Gamepad.buttons[]` index, the canonical channel the valu…

Abstract translation layer between the browser's raw Gamepad API indices and ExoJS-canonical channel buffers. Each concrete s…

Discriminant tag identifying which device family a GamepadMapping belongs to. Used to select the correct mapping at runtime w…

Static utility that drives in-game controller-prompt UI. Provides the canonical set of prompt controls, their normalised [x,…

Baseline mapping for dual-analog controllers that follow the standard W3C Gamepad API layout (axes 0–3 for both sticks, axes…

Non-renderable geometry data object used by advanced rendering paths. Geometry owns only vertex/index data and its layout met…

A per-font-variant glyph atlas with automatic multi-page growth. In `'sdf'` mode (default) each atlas page is a single-channe…

CPU-rasterized gradient base. A Color-like paint value (not a Drawable): it owns a normalized list of color stops plus subcla…

Granular synthesis filter — slices input into small Hann-windowed grains and replays them with randomized parameters. Use cas…

Immediate-mode 2D shape API backed by Mesh children. Each draw call (e.g. `drawCircle`, `drawRectangle`, `drawLine`) appends…

High-pass filter backed by a `BiquadFilterNode` in `highpass` mode. Attenuates frequencies below the cutoff and passes everyt…

Debug layer that draws outlines around interactive scene nodes. - Magenta: interactive but idle. - Yellow: currently hovered.…

Text node that renders arbitrary HTML+CSS into a canvas texture via an SVG `<foreignObject>` pass and displays the result as…

Dispatch token for image loading. `loader.load(ImageAsset, 'img.png')` returns `Promise<HTMLImageElement>`.

AssetFactory implementation that loads PNG, JPG, WebP, AVIF, and other browser-supported raster image formats and produces a…

A data-only image layer: a single image (texture + resolved URL) placed as a background or foreground layer. Image layers are…

Database implementation backed by the browser's IndexedDB API. Each object store is created with a `keyPath` of `"name"`, so…

KeyValueStore over IndexedDB (via IndexedDbStore), using the **structured-clone** algorithm. Unlike WebStorageStore, values a…

CacheStore implementation that persists processed asset data in an IndexedDB database via IndexedDbDatabase. Pass an instance…

Owns the unified input pipeline for an Application: keyboard events, pointer (mouse/touch/pen) events with multi-touch slot m…

DOM-Event-shaped envelope dispatched by InteractionManager to interactive scene nodes. Bubbles up the parent chain — `target`…

Routes pointer events from the InputManager to interactive scene-graph nodes via DOM-style event bubbling. Maintains a persis…

A closed scalar interval `[min, max]` used by the SAT collision solver to represent the projection of a shape onto a separati…

Base class for a two-body constraint solved alongside contacts in the sub-step loop. Concrete joints (distance, revolute, wel…

Mapping for the Nintendo Joy-Con (L) held horizontally as a solo controller. Declares only channels that physically exist on…

Mapping for the Nintendo Joy-Con (R) held horizontally as a solo controller. Declares only channels that physically exist on…

Dispatch token for generic JSON loading. `loader.load(Json, 'config.json')` returns `Promise<unknown>`. Narrow via generic: `…

AssetFactory implementation that parses JSON files and exposes them as plain JavaScript values. The parsed value is typed as…

Channel indices for keyboard keys, derived from the legacy `KeyboardEvent.keyCode` map. Pass any value to the Input construct…

Envelope dispatched by FocusManager to the focused RenderNode for keyboard input. `channel` is the input channel of the key —…

Text label widget. Wraps a Text node and keeps the widget's layout size in sync with the measured text, so it anchors and sta…

A parsed LDtk world document: holds the raw JSON data and the converted runtime TileMap for each level. `LdtkMap` is the pars…

Brick-wall limiter backed by a Web Audio `DynamicsCompressorNode` configured for hard limiting: a fixed high ratio (~20), zer…

Mutable line segment defined by two endpoint positions. Implements ShapeLike for intersection tests against all shape types.…

Linear gradient in UV space projected from `start` to `end`.

Random point on a line segment between `(x0, y0)` and `(x1, y1)`. Uniform parameter distribution: `t = Math.random()` then `l…

Central asset management hub for ExoJS applications. The `Loader` orchestrates fetching, processing, caching, and retrieval o…

An awaitable, progress-aware load operation. Implements `PromiseLike<T>` so it can be `await`ed directly and composed with `P…

Low-pass filter backed by a `BiquadFilterNode` in `lowpass` mode. Attenuates frequencies above the cutoff and passes everythi…

A Filter that maps every pixel of the input through a Look-Up Table texture. Two storage modes: - **1D LUT** (`N×1`, default…

Describes the look of a renderable — shader, uniforms, textures, blend mode, and sampling state — independent of its geometry…

Mutable 3×3 row-major affine transformation matrix used throughout the rendering and physics pipeline. Layout (row, column):…

In-memory KeyValueStore backed by a `Map`. Holds values **by reference** — no cloning, no serialization — so it accepts any v…

Arbitrary 2D triangle-mesh primitive. `Mesh` lives alongside Sprite as a public Drawable: it has the same transform (position…

Material specialization for Mesh drawables. Carries the mesh contract conceptually: fixed vertex attribute locations (0 = pos…

Softly pulls a single body's grab point toward a movable **target** point (typically the mouse cursor). The grab point is fix…

AssetFactory implementation that loads streaming audio assets (MP3, OGG, WAV, AAC, and other browser-supported formats) and p…

CacheStrategy that always fetches from the network and never reads from or writes to any CacheStore. Useful for assets that m…

A scalable nine-slice (9-patch) sprite. Corners stay pixel-perfect; edges/center fill by stretch, repeat, or mirror-repeat.

A data-only layer of TileMapObjects — spawn points, trigger zones, collision regions, markers. Object layers are not rendered…

A Size subclass that fires a callback whenever `width` or `height` changes. Used internally by layout-aware types to invalida…

An AbstractVector subclass that notifies an owner whenever its components change. Used internally by Rectangle, `SceneNode`,…

Applies a tangential acceleration around a center point — perpendicular to the radial vector `(particle − center)`. Combined…

Rectangular background container with rounded corners and an optional border. The base building block for HUD boxes, dialogs,…

The central coordinator of the particle pipeline. `ParticleSystem` is a Drawable that owns: - **SoA particle storage** — one…

Pass-scoped DrawContext: the active render target and view for a CallbackRenderPass callback. `clear`/`render`/`renderTo` rou…

Debug layer that renders a compact screen-space HUD (top-left) showing rolling-average FPS, per-frame time in milliseconds, d…

Phaser effect implemented with native Web Audio nodes (no worklet required). The wet signal passes through a cascade of allpa…

A link between a PhysicsBody and a SceneNode. After each PhysicsWorld.step, the body's world position **and rotation** are wr…

A rigid body: a world transform plus mass properties aggregated from its colliders. Dynamic bodies integrate under gravity, a…

The collision/query world: owns bodies, colliders, the detection backend, bindings, the query engine and the fixed-step accum…

Stereo ping-pong delay effect using two cross-fed DelayNodes that bounce the signal alternately between left and right channe…

Real-time pitch shifter (WorkletEffect) using SOLA — synchronized overlap-add. Each synthesis grain is realigned by waveform…

Mapping for Sony PlayStation controllers, covering DualShock 4 and DualSense (PS4 / PS5) when connected via USB or Bluetooth.…

Unified mouse / touch / pen pointer. Wraps a single browser `PointerEvent.pointerId` and writes its state (position, buttons,…

Debug layer that shows a screen-space panel (top-right corner) listing all RenderNodes under the current pointer position, so…

High-level lifecycle state of a Pointer.

Bit flags accumulated on a Pointer between frames so consumers can detect transient events (entered the canvas, was released,…

A 2D vector expressed in polar coordinates: `radius` (magnitude) and `phi` (angle in radians, measured from the positive X-ax…

Mutable convex polygon defined by a world-space offset `(x, y)` and an array of local-space vertex Vectors. Implements ShapeL…

A convex polygon defined by ≥3 local-space vertices. Input vertices may be given in either winding; they are canonicalised to…

A reusable, data-driven template captured from a configured scene-graph subtree. Capture once with Prefab.from; stamp out ind…

Constrains a body to **slide along a single axis** relative to another: the perpendicular translation and the relative rotati…

Horizontal progress / health bar. ProgressBar.value is the fill fraction in `[0, 1]`; setting it redraws only the fill.

Generic recursive spatial index used by the engine's `InteractionManager` to accelerate per-frame hit-testing of scene nodes.…

Radial gradient in UV space around `center` with normalized radius.

Seedable pseudo-random number generator using the xoshiro128** algorithm. xoshiro128** (Blackman & Vigna, 2018) keeps a compa…

Uniform random number in `[min, max]`. Each `sample()` returns a fresh roll; the bounds are inclusive on both ends (modulo th…

Continuous, rate-based spawner. Emits a RateSpawnConfig.rate sample per second; sub-frame fractions accumulate so low rates (…

Mutable axis-aligned rectangle defined by a top-left origin `(x, y)` and dimensions `(width, height)`. Implements ShapeLike w…

Identifies the active GPU backend used by the engine. Passed to renderers and shaders so they can select backend-specific cod…

Explicit instanced draw submission: **one** Geometry + MeshMaterial drawn **once** with **N** per-instance `(transform, tint)…

Owns rendering orchestration: builds, optimizes and plays the internal RenderPlan for a RenderNode subtree, manages render-ta…

GPU primitive topology used when issuing draw calls. Values are WebGL2 GLenum constants (e.g. `gl.TRIANGLES`).

SceneNode that can produce visual output. Adds the rendering pipeline features on top of the structural transform/bounds carr…

Renders a scene subtree (a RenderNode) as one pass — into the active target, or off-screen when `options.target` is set. The…

One high-level phase of a frame. Subclass and implement execute, or use a stock subclass (RenderNodePass, CallbackRenderPass,…

Debug layer that lists every RenderNode with an active filter chain each frame. Renders a compact text panel with per-drawabl…

An ordered list of RenderPass steps, played once per frame against a RenderingContext. A `RenderPipeline` is **itself a `Rend…

Renderable destination — either the on-screen canvas (the `root` target owned by the backend) or an offscreen texture (a Rend…

An off-screen render target that can also be sampled as a texture. Combines RenderTarget (framebuffer attachment) with the sa…

A sprite that fills its destination by repeating, mirroring, or stretching a source texture or atlas region. Supports indepen…

Pushes every live particle away from a fixed point in the system's local coordinate space. Acceleration magnitude is `strengt…

Convolution reverb using a procedurally-generated impulse response loaded into a `ConvolverNode`. The impulse response is a s…

Pins a shared anchor point on two bodies (a hinge): the bodies may rotate freely about the pivot but the anchor points stay c…

Ring modulator effect using native Web Audio nodes (no worklet required). A carrier `OscillatorNode` is connected directly to…

Adds a constant angular acceleration to every live particle each frame (analogous to the legacy `TorqueAffector`). The system…

WebGL2 sampler object wrapper that controls texture filtering and wrapping. Creates a `WebGLSampler` on construction and upda…

Texture magnification and minification filter modes. Values are WebGL2 GLenum constants and are passed directly to the GPU sa…

Sets every live particle's scale to a curve sampled at the particle's current lifetime ratio. Both axes share one curve; non-…

A scene's lifecycle host. Subclass to define scene behavior: class GameScene extends Scene { override init(loader: Loader): v…

Single-active-scene controller owned by Application. Holds at most one active Scene (the current "screen"); SceneManager.setS…

Transform-bearing leaf in the scene-graph hierarchy. Carries position, rotation, scale, skew, origin, and a 2-component Vecto…

Clipped container that scrolls its content via the mouse wheel. Add child nodes to ScrollContainer.content rather than to the…

Mutable line segment defined by start and end Vectors. Unlike Line this type does not implement ShapeLike — it is a lightweig…

Bidirectional name ↔ constructor ↔ NodeSerializer registry backing the scene serializer. Serialize resolves a node to its ser…

Backend-agnostic shader program descriptor. Holds raw GLSL source strings and, after connect is called, a live ShaderProgram…

Metadata for a single vertex attribute declared in a GLSL vertex shader. Populated by the backend during Shader.connect using…

GLSL primitive type tokens used to describe ShaderAttribute and ShaderUniform data types. Values are WebGL2 GLenum constants…

Immutable shader source pair shared by Material instances. `ShaderSource` owns only the GLSL/WGSL text and its stable identit…

Metadata and current value for a single GLSL uniform variable. Populated by the backend during Shader.connect. The `dirty` fl…

Immutable local-space collision geometry. A `Shape` carries no transform — a Collider positions it in a body. Shapes also exp…

Lightweight typed event emitter. Each `Signal` represents one named notification channel (e.g. `onResize`, `onFrame`). Listen…

Mutable 2D size (width × height) value type. All arithmetic methods mutate in place and return `this` for chaining. When `hei…

Pre-decoded short audio clip backed by an `AudioBuffer`. Sound is a **data descriptor** — it holds the decoded audio buffer,…

AssetFactory implementation that loads short audio assets (MP3, OGG, WAV, AAC, and other Web Audio API-supported formats), fu…

Eviction strategy used when the pool is full and a new play is requested. At the per-Sound level all pooled instances share t…

Per-frame particle spawner. Subclasses decide how many particles to emit each tick (rate-based, burst, on-demand) and write t…

Sub-emitter: triggers a child SpawnModule on a target system at the dying particle's position. Use for explosion-on-impact, s…

The primary 2D drawable for textured quads and the foundation of the rendering hierarchy. A Sprite wraps a Texture (or Render…

Material specialization for Sprite drawables. API shell for the sprite custom-material path; the renderer integration and ins…

Slices a single Texture into named frames and optional named animation sequences. Each frame is stored as both a Rectangle (t…

Linear layout container that flows its children in a row or column with even spacing and optional padding, then sizes itself…

Mapping for the Valve Steam Controller when operating in gamepad-emulation mode (i.e. Steam Input is configured to present it…

Mapping for the Valve Steam Deck (and the new Valve Controller via vendor fallback) when its raw HID gamepad is exposed direc…

Dispatch token for subtitle loading (WebVTT and SRT). `loader.load(SubtitleAsset, 'subs.vtt')` returns `Promise<VTTCue[]>`. `…

AssetFactory implementation that parses WebVTT (`.vtt`) and SubRip (`.srt`) subtitle files and produces an array of VTTCue in…

Dispatch token for SVG loading. `loader.load(SvgAsset, 'icon.svg')` returns `Promise<HTMLImageElement>`.

AssetFactory implementation that loads SVG markup and produces a rasterised HTMLImageElement. The SVG source text is wrapped…

Mapping for the Nintendo Switch Pro Controller connected via USB or Bluetooth. Inherits the full GenericDualAnalogGamepadMapp…

Ordered registry of per-frame Systems, shared by Scene (as `scene.systems`) and `Application` (as `app.systems`). Systems tic…

GPU-accelerated text node that rasterizes individual glyphs into a shared per-font-variant GlyphAtlas using the SDF (Signed D…

Dispatch token for plain text loading. `loader.load(TextAsset, 'greeting.txt')` returns `Promise<string>`.

AssetFactory implementation that loads plain-text files (TXT, CSV, GLSL shaders, HTML fragments, and any other UTF-8 text) an…

Describes how a Text node renders its string. Every setter marks the style dirty with a StyleChangeHint so that the owning no…

A static GPU texture sourced from an image, canvas, or video element. Holds the pixel source and sampling parameters (ScaleMo…

AssetFactory implementation that loads PNG, JPG, WebP, AVIF, and other browser-supported raster image formats and produces a…

An immutable descriptor for a rectangular sub-region of a Texture. Stores the pixel-space source rectangle, pre-computed norm…

Drives per-tile animations on one or more TileLayers, RPG-Maker style. On construction it scans the given layer(s) once and r…

Thrown when a Tiled JSON document does not match the expected shape. `source` is the URL of the file being parsed; `path` is…

A group layer, recursively containing further parsed layers.

An image layer. image is the path to the layer's image exactly as written in the Tiled JSON (relative to the map's location);…

Base class for the four parsed Tiled layer types. Holds the fields shared by every layer (`tilelayer`, `objectgroup`, `imagel…

A parsed and validated Tiled map (`.tmj`). `TiledMap` represents the parsed Tiled source format. `TileMap` is the format-inde…

A parsed Tiled object, placed in an TiledObjectLayer or a tile's collision `objectgroup`. The shape of the object is determin…

An object layer: a flat list of TiledObjects.

A tile layer. On a finite map, data holds the flat row-major array of GIDs (`width * height` entries). On an infinite map, ch…

A parsed Tiled tileset — either embedded inline in a map's `tilesets` array, or parsed from an external `.tsj` file reference…

A generic, format-independent tile layer with chunk-first storage. Tile data is stored in fixed-size TileChunks indexed by si…

A scene node that renders one generic TileLayer as a Container of per-chunk TileChunkNode drawables. Each non-empty loaded ch…

A generic, format-independent tile map. Owns a finite grid of TileLayers and a shared set of TileSets. Tile data is stored in…

A named, ordered group of TileLayerNodes produced by a TileMapView for ergonomic actor interleaving. A band is a plain Contai…

A convenience scene node that renders a whole TileMap as a Container of one TileLayerNode per tile layer, in map layer order…

Groups a TileMap's layers into independently placeable scene nodes so application actors can be interleaved **between** tile…

A resolved tileset: a uniform grid of tiles within a texture atlas. Does **not** own its texture — the Loader or application…

Time-duration value object stored internally in milliseconds. Provides unit-converted accessors (`seconds`, `minutes`, `hours…

Clock variant with a fixed limit. Inherits start/stop/reset/restart semantics; adds Timer.expired (true once `elapsedTime >=…

Fixed-timestep accumulator (package-owned; no engine clock dependency). Each frame, advance adds the variable frame delta to…

Hover tooltip attached to a RenderNode. Shows a small text label near the pointer after a short delay when the pointer enters…

Tremolo effect that amplitude-modulates the signal with a sine LFO using native WebAudio nodes. A sine-wave LFO drives a `Gai…

Adds a smooth pseudo-random force field that animates over time. Implemented as 2D value noise with cubic Hermite smoothing —…

Animates numeric properties of `target` from their current value to a configured end value over a duration in seconds. Suppor…

Owns and advances a collection of Tween instances, driving them once per frame from Application.update. Created tweens are tr…

Composes multiple Tween instances into a multi-stage animation. Each stage added via TweenSequencer.then plays after the prev…

Lifecycle states of a TweenSequencer. Mirrors TweenState semantics: starts `Idle`, becomes `Active` on TweenSequencer.start,…

Lifecycle states of a Tween. A tween starts in `Idle`, transitions to `Active` once Tween.start is called, and ends in `Compl…

Root of a scene's screen-fixed UI layer. Reached through Scene.ui; you do not construct it directly. Unlike Scene.root, the U…

Per-frame, per-batch mutator. Operates on the system's SoA storage directly — typically a single tight loop over `[0, system.…

Concrete mutable 2D vector with full AbstractVector arithmetic and ShapeLike collision support (treated as a point collider).…

Uniform random vector with each axis sampled independently in its own `[min, max]` range. Each `sample()` writes into the pro…

Multiplies every live particle's velocity by a curve sampled at the particle's current `elapsed / lifetime` ratio. The same s…

Renders an `HTMLVideoElement` as a live texture on a Sprite. `Video` wraps a video element, manages playback (play/pause/stop…

AssetFactory implementation that loads video files (MP4, WebM, OGG, and other browser-supported container formats) and produc…

2D camera that defines what region of the world is visible on screen. Maintains a center position, a visible area size, a rot…

Phase-vocoder-style effect implemented as a WorkletEffect. Analyzes the spectral envelope of a `modulator` AudioBus across a…

Describes a Wang autotile set: a mapping from a neighbor bitmask to a local tile ID within a specific tileset. Blob bitmask b…

Dispatch token for WebAssembly module loading. `loader.load(WasmAsset, 'module.wasm')` returns `Promise<WebAssembly.Module>`.

AssetFactory implementation that loads WebAssembly binary (`.wasm`) files and produces a compiled WebAssembly.Module. The mod…

A high-level Filter subclass that renders the input texture through a user-provided GLSL fragment shader on the **WebGL2** ba…

A high-level Filter subclass that renders the input texture through a user-provided WGSL fragment shader on the **WebGPU** ba…

KeyValueStore over the Web Storage API (`localStorage` or `sessionStorage`). Web Storage holds only strings, so values are JS…

Rigidly fixes the relative position and orientation of two bodies (they move as one rigid body). A 2-DOF point constraint (li…

A wheel attached to a chassis: free to **spin** (no rotation lock) and sprung along a **suspension axis** (a soft spring), bu…

Base class for UI widgets — a Container with an explicit layout size (independent of child bounds / scale), an `enabled` flag…

Base class for filters implemented as AudioWorkletProcessors. Subclasses declare the worklet's name, source code, and node op…

Texture coordinate wrap behaviour when UV values fall outside [0, 1]. Values are WebGL2 GLenum constants passed directly to t…

Mapping for Microsoft Xbox controllers (Xbox One, Xbox Series X/S, and compatible third-party XInput devices) connected via U…

Dispatch token for XML document loading. `loader.load(XmlAsset, 'data.xml')` returns `Promise<Document>`. Throws if the file…

AssetFactory implementation that loads XML files and produces a parsed Document via the browser's built-in DOMParser. Throws…