excalibur 0.33.0-alpha.99 → 1.1.0-alpha.310

package/build/{dist → esm/src/engine}/graphics/context/shader.d.ts

@@ -1,7 +1,7 @@
 import type { ExcaliburGraphicsContext, ImageSource } from '../..';
-import { AffineMatrix, Color, Vector } from '../..';
-import type { Matrix } from '../../math/matrix';
-export type UniformDictionary = Record<string, number | boolean | Vector | Color | AffineMatrix | Float32Array | [uniformData: Float32Array, bindingPoint: number]>;
+import { AffineMatrix, Color, Vector, Vector3, Vector4 } from '../..';
+import { Matrix } from '../../math/matrix';
+export type UniformDictionary = Record<string, number | boolean | Vector | Vector3 | Vector4 | Color | AffineMatrix | Matrix | Float32Array | [uniformData: Float32Array, bindingPoint: number]>;
 export type 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';
 /**
  *
@@ -65,7 +65,7 @@ export interface ShaderOptions {
     /**
      * Set initial uniforms
      */
-    uniforms?: UniformDictionary;
+    uniforms?: UniformDictionary | null;
     /**
      * Set initial images as uniform sampler2D
      */
@@ -98,6 +98,12 @@ export declare class Shader {
     };
     private _uniforms;
     private _uniformBuffers;
+    private _uniformBufferBindingPoints;
+    private _uniformBlockIndexCache;
+    private _uniformBlockBindingSet;
+    private _boundBufferBase;
+    private _nextUniformBufferBindingPoint;
+    private _affineMatrixCache;
     private _compiled;
     private _onPreLink?;
     private _onPostCompile?;
@@ -155,6 +161,7 @@ export declare class Shader {
      * @param texture
      */
     setTexture(slotNumber: number, texture: WebGLTexture): void;
+    private _getUniformBlockIndex;
     /**
      * Set a uniform buffer block with a Float32Array
      * @param name The of the binding block
@@ -234,7 +241,7 @@ export declare class Shader {
      * @param name
      * @param value
      */
-    setUniformFloatArray(name: string, value: number[]): void;
+    setUniformFloatArray(name: string, value: Float32Array | number[]): void;
     /**
      * Set a float array uniform for the current shader, WILL NOT THROW on error.
      *
@@ -242,7 +249,7 @@ export declare class Shader {
      * @param name
      * @param value
      */
-    trySetUniformFloatArray(name: string, value: number[]): boolean;
+    trySetUniformFloatArray(name: string, value: Float32Array | number[]): boolean;
     /**
      * Set a {@apilink Vector} uniform for the current shader
      *
@@ -259,6 +266,36 @@ export declare class Shader {
      * @param value
      */
     trySetUniformFloatVector(name: string, value: Vector): boolean;
+    /**
+     * Set a {@apilink Vector3} uniform for the current shader
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     * @param name
+     * @param value
+     */
+    setUniformFloatVector3(name: string, value: Vector3): void;
+    /**
+     * Set a {@apilink Vector3} uniform for the current shader, WILL NOT THROW on error.
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     * @param name
+     * @param value
+     * @returns
+     */
+    trySetUniformFloatVector3(name: string, value: Vector3): boolean;
+    /**
+     * Set a {@apilink Vector4} uniform for the current shader
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     * @param name
+     * @param value
+     */
+    setUniformFloatVector4(name: string, value: Vector4): void;
+    /**
+     * Set a {@apilink Vector4} uniform for the current shader, WILL NOT THROW on error.
+     * **Important** Must call ex.Shader.use() before setting a uniform!
+     * @param name
+     * @param value
+     * @returns
+     */
+    trySetUniformFloatVector4(name: string, value: Vector4): boolean;
     /**
      * Set a {@apilink Color} uniform for the current shader
      *

package/build/{dist → esm/src/engine}/graphics/context/texture-loader.d.ts

@@ -11,7 +11,7 @@ export declare class TextureLoader {
     constructor(gl: WebGL2RenderingContext, _garbageCollector?: {
         garbageCollector: GarbageCollector;
         collectionInterval: number;
-    });
+    } | undefined);
     dispose(): void;
     /**
      * Sets the default filtering for the Excalibur texture loader, default {@apilink ImageFiltering.Blended}

package/build/{dist → esm/src/engine}/graphics/context/webgl-util.d.ts

@@ -22,14 +22,14 @@ export declare function getGLTypeFromSource(gl: WebGLRenderingContext, source: s
  * @param gl
  * @param type
  */
-export declare function getAttributeComponentSize(gl: WebGLRenderingContext, type: number): number;
+export declare function getAttributeComponentSize(gl: WebGL2RenderingContext, type: number): number;
 /**
  * Based on the attribute return the corresponding supported attrib pointer type
  * https://developer.mozilla.org/en-US/docs/Web/API/WebGLRenderingContext/vertexAttribPointer
  * @param gl
  * @param type
  */
-export declare function getAttributePointerType(gl: WebGLRenderingContext, type: number): 5126 | 5122 | 5123 | 5120 | 5121;
+export declare function getAttributePointerType(gl: WebGL2RenderingContext, type: number): 5124 | 5125 | 5126 | 5122 | 5123 | 5120 | 5121;
 /**
  *
  */

package/build/{dist → esm/src/engine}/graphics/debug-graphics-component.d.ts

@@ -10,5 +10,6 @@ import { Component } from '../entity-component-system/component';
 export declare class DebugGraphicsComponent extends Component {
     draw: (ctx: ExcaliburGraphicsContext, debugFlags: DebugConfig) => void;
     useTransform: boolean;
+    private static _NAME;
     constructor(draw: (ctx: ExcaliburGraphicsContext, debugFlags: DebugConfig) => void, useTransform?: boolean);
 }

package/build/{dist → esm/src/engine}/graphics/filtering.d.ts

@@ -16,4 +16,4 @@ export declare enum ImageFiltering {
 /**
  * Parse the image filtering attribute value, if it doesn't match returns null
  */
-export declare function parseImageFiltering(val: string): ImageFiltering | undefined;
+export declare function parseImageFiltering(val: string): ImageFiltering | null;

package/build/{dist → esm/src/engine}/graphics/font-common.d.ts

@@ -101,7 +101,7 @@ export declare enum FontStyle {
 /**
  * Enum representing the text direction, useful for other languages, or writing text in reverse
  */
-export declare enum Direction {
+export declare enum TextDirection {
     LeftToRight = "ltr",
     RightToLeft = "rtl"
 }
@@ -140,7 +140,7 @@ export interface FontOptions {
     /**
      * Optionally specify the text direction, by default LeftToRight
      */
-    direction?: Direction;
+    direction?: TextDirection;
     /**
      * Optionally override the text line height in pixels, useful for multiline text. If unset will use default.
      */

package/build/{dist → esm/src/engine}/graphics/font-text-instance.d.ts

@@ -6,11 +6,11 @@ export declare class FontTextInstance {
     readonly font: Font;
     readonly text: string;
     readonly color: Color;
-    readonly maxWidth?: number;
-    canvas: HTMLCanvasElement;
-    ctx: CanvasRenderingContext2D;
+    readonly maxWidth?: number | undefined;
+    canvas: HTMLCanvasElement | null;
+    ctx: CanvasRenderingContext2D | null;
     private _textFragments;
-    dimensions: BoundingBox;
+    dimensions: BoundingBox | null;
     disposed: boolean;
     private _lastHashCode;
     /**
@@ -21,7 +21,7 @@ export declare class FontTextInstance {
      * Total height including all lines, in text space
      */
     private _totalHeight;
-    constructor(font: Font, text: string, color: Color, maxWidth?: number);
+    constructor(font: Font, text: string, color: Color, maxWidth?: number | undefined);
     measureText(text: string, maxWidth?: number): BoundingBox;
     private _setDimension;
     static getHashCode(font: Font, text: string, color?: Color): number;

package/build/{dist → esm/src/engine}/graphics/font.d.ts

@@ -3,7 +3,7 @@ import { BoundingBox } from '../collision/index';
 import { Color } from '../color';
 import type { ExcaliburGraphicsContext } from './context/excalibur-graphics-context';
 import type { FontOptions, FontRenderer } from './font-common';
-import { BaseAlign, Direction, FontStyle, FontUnit, TextAlign } from './font-common';
+import { BaseAlign, TextDirection, FontStyle, FontUnit, TextAlign } from './font-common';
 import type { GraphicOptions } from './graphic';
 import { Graphic } from './graphic';
 import type { RasterOptions } from './raster';
@@ -46,11 +46,11 @@ export declare class Font extends Graphic implements FontRenderer {
     unit: FontUnit;
     textAlign: TextAlign;
     baseAlign: BaseAlign;
-    direction: Direction;
+    direction: TextDirection;
     /**
      * Font line height in pixels, default line height if unset
      */
-    lineHeight: number | undefined;
+    lineHeight: number | null;
     size: number;
     shadow?: {
         blur?: number;

package/build/{dist → esm/src/engine}/graphics/graphics-component.d.ts

@@ -29,7 +29,7 @@ export interface GraphicsComponentData {
                 x: number;
                 y: number;
             };
-        } | undefined;
+        } | null;
     };
     isVisible: boolean;
     opacity: number;
@@ -51,6 +51,7 @@ export interface GraphicsComponentData {
     flipVertical: boolean;
     copyGraphics: boolean;
     forceOnScreen: boolean;
+    shouldAlwaysTick: boolean;
     tint?: {
         r: number;
         g: number;
@@ -105,11 +106,17 @@ export interface GraphicsComponentOptions {
      * Optional anchor
      */
     anchor?: Vector;
+    /**
+     * Optionally tick graphics even when offscreen, default false. When true, the current graphic will tick every frame
+     * regardless of whether the owning entity is offscreen.
+     */
+    shouldAlwaysTick?: boolean;
 }
 /**
  * Component to manage drawings, using with the position component
  */
 export declare class GraphicsComponent extends Component {
+    private static _NAME;
     private _logger;
     private _current;
     private _graphics;
@@ -122,7 +129,7 @@ export declare class GraphicsComponent extends Component {
     /**
      * Draws after the entity transform has been applied, and after graphics component graphics has been drawn
      */
-    onPostDraw?: (ctx: ExcaliburGraphicsContext, elapsed: number) => void;
+    onPostDraw: ((ctx: ExcaliburGraphicsContext, elapsed: number) => void) | null;
     /**
      * Draws before the entity transform has been applied before any any graphics component drawing
      */
@@ -132,16 +139,6 @@ export declare class GraphicsComponent extends Component {
      */
     onPostTransformDraw?: (ctx: ExcaliburGraphicsContext, elapsed: number) => void;
     private _color?;
-    /**
-     * Sets or gets wether any drawing should be visible in this component
-     * @deprecated use isVisible
-     */
-    get visible(): boolean;
-    /**
-     * Sets or gets wether any drawing should be visible in this component
-     * @deprecated use isVisible
-     */
-    set visible(val: boolean);
     /**
      * Sets or gets wether any drawing should be visible in this component
      */
@@ -150,6 +147,14 @@ export declare class GraphicsComponent extends Component {
      * Optionally force the graphic onscreen, default false. Not recommend to use for perf reasons, only if you known what you're doing.
      */
     forceOnScreen: boolean;
+    /**
+     * Optionally tick graphics even when offscreen, default false. When true, the current graphic will tick every frame
+     * regardless of whether the owning entity is offscreen. This is useful for keeping animations synchronized
+     * across your game scene.
+     *
+     * Can also be set per-graphic via {@apilink Animation.shouldAlwaysTick} or {@apilink GraphicsGroup.shouldAlwaysTick}.
+     */
+    shouldAlwaysTick: boolean;
     /**
      * Sets or gets wither all drawings should have an opacity applied
      */
@@ -186,7 +191,7 @@ export declare class GraphicsComponent extends Component {
     copyGraphics: boolean;
     constructor(options?: GraphicsComponentOptions);
     getGraphic(name: string): Graphic | undefined;
-    getOptions(name: string): GraphicsShowOptions | undefined;
+    getOptions(name: string): GraphicsShowOptions | null;
     /**
      * Get registered graphics names
      */
@@ -198,7 +203,7 @@ export declare class GraphicsComponent extends Component {
     /**
      * Returns the currently displayed graphic offsets
      */
-    get currentOptions(): GraphicsShowOptions | undefined;
+    get currentOptions(): GraphicsShowOptions | null;
     /**
      * Returns all graphics associated with this component
      */
@@ -209,7 +214,7 @@ export declare class GraphicsComponent extends Component {
      * Returns all graphics options associated with this component
      */
     get options(): {
-        [graphicName: string]: GraphicsShowOptions | undefined;
+        [graphicName: string]: GraphicsShowOptions | null;
     };
     /**
      * Adds a named graphic to this component, if the name is "default" or not specified, it will be shown by default without needing to call
@@ -241,6 +246,7 @@ export declare class GraphicsComponent extends Component {
      * Get local bounds of graphics component
      */
     get localBounds(): BoundingBox;
+    private _scratchWorldBounds;
     /**
      * Get world bounds of graphics component
      */
@@ -251,6 +257,13 @@ export declare class GraphicsComponent extends Component {
      * @internal
      */
     update(elapsed: number, idempotencyToken?: number): void;
+    /**
+     * Update underlying graphics when offscreen, only ticks if opted in via shouldAlwaysTick on the component or current graphic.
+     * Called internally by GraphicsSystem.
+     * @param elapsed
+     * @internal
+     */
+    updateOffscreen(elapsed: number, idempotencyToken?: number): void;
     clone(): GraphicsComponent;
     /**
      * Custom serialization - stores graphic references instead of graphic data

package/build/{dist → esm/src/engine}/graphics/graphics-group.d.ts

@@ -13,6 +13,11 @@ export interface GraphicsGroupingOptions {
      * positioning graphics in the group is done with the `offset` property.
      */
     useAnchor?: boolean;
+    /**
+     * Optionally tick this graphics group even when offscreen, default false. Useful for keeping animations synchronized
+     * across your game scene.
+     */
+    shouldAlwaysTick?: boolean;
 }
 export interface GraphicsGrouping {
     offset: Vector;
@@ -31,6 +36,7 @@ export interface GraphicsGrouping {
 export declare class GraphicsGroup extends Graphic implements HasTick {
     private _logger;
     useAnchor: boolean;
+    shouldAlwaysTick: boolean;
     members: (GraphicsGrouping | Graphic)[];
     constructor(options: GraphicsGroupingOptions & GraphicOptions);
     clone(): GraphicsGroup;

package/build/{dist → esm/src/engine}/graphics/graphics-system.d.ts

@@ -15,11 +15,11 @@ export declare class GraphicsSystem extends System {
     query: Query<typeof TransformComponent | typeof GraphicsComponent>;
     get sortedTransforms(): TransformComponent[];
     constructor(world: World);
-    initialize(world: World, scene: Scene): void;
+    onInitialize(world: World, scene: Scene): void;
     private _zHasChanged;
     private _zIndexUpdate;
-    preupdate(): void;
-    update(elapsed: number): void;
+    onPreUpdate(): void;
+    onUpdate(elapsed: number): void;
     private _drawGraphicsComponent;
     private _targetInterpolationTransform;
     /**

package/build/{dist → esm/src/engine}/graphics/image-source.d.ts

@@ -5,7 +5,7 @@ import { ImageFiltering } from './filtering';
 import { ImageWrapping } from './wrapping';
 import type { GraphicOptions } from './graphic';
 export interface ImageSourceOptions {
-    filtering?: ImageFiltering;
+    filtering?: ImageFiltering | null;
     wrapping?: ImageWrapConfiguration | ImageWrapping;
     bustCache?: boolean;
 }

package/build/{dist → esm/src/engine}/graphics/index.d.ts

@@ -30,12 +30,20 @@ export * from './context/particle-renderer/particle-renderer';
 export * from './context/debug-text';
 export type * from './post-processor/post-processor';
 export * from './post-processor/screen-shader';
+export * from './post-processor/shader-pipeline-post-processor';
 export * from './post-processor/color-blindness-mode';
 export * from './post-processor/color-blindness-post-processor';
 export * from './context/texture-loader';
 export * from './filtering';
 export * from './wrapping';
+export * from './context/glsl';
 export * from './context/shader';
+export * from './context/framebuffer';
+export * from './context/shader-pipeline/shader-pass';
+export * from './context/shader-pipeline/shader-pipeline';
+export * from './context/shader-pipeline/effects/blur-passes';
+export * from './context/shader-pipeline/effects/bloom-effect';
+export * from './context/shader-pipeline/effects/glow-passes';
 export * from './context/vertex-buffer';
 export * from './context/uniform-buffer';
 export * from './context/vertex-layout';

package/build/{dist → esm/src/engine}/graphics/offscreen-system.d.ts

@@ -12,7 +12,7 @@ export declare class OffscreenSystem extends System {
     private _worldBounds;
     query: Query<typeof TransformComponent | typeof GraphicsComponent>;
     constructor(world: World);
-    initialize(world: World, scene: Scene): void;
-    update(): void;
+    onInitialize(world: World, scene: Scene): void;
+    onUpdate(): void;
     private _isOffscreen;
 }

package/build/{dist → esm/src/engine}/graphics/parallax-component.d.ts

@@ -1,6 +1,7 @@
 import { Component } from '../entity-component-system/component';
 import type { Vector } from '../math/vector';
 export declare class ParallaxComponent extends Component {
+    private static _NAME;
     parallaxFactor: Vector;
     constructor(parallaxFactor?: Vector);
 }

package/build/{dist → esm/src/engine}/graphics/post-processor/color-blindness-post-processor.d.ts

@@ -1,16 +1,14 @@
 import type { PostProcessor } from './post-processor';
 import { ColorBlindnessMode } from './color-blindness-mode';
-import type { Shader } from '../context/shader';
-import type { VertexLayout } from '../context/vertex-layout';
 import type { ExcaliburGraphicsContextWebGL } from '../context/excalibur-graphics-context-webgl';
+import type { Framebuffer } from '../context/framebuffer';
 export declare class ColorBlindnessPostProcessor implements PostProcessor {
     private _colorBlindnessMode;
-    private _shader;
+    private _pass;
     private _simulate;
     constructor(_colorBlindnessMode: ColorBlindnessMode, simulate?: boolean);
     initialize(graphicsContext: ExcaliburGraphicsContextWebGL): void;
-    getShader(): Shader;
-    getLayout(): VertexLayout;
+    process(source: Framebuffer, destination: Framebuffer): void;
     set colorBlindnessMode(colorBlindMode: ColorBlindnessMode);
     get colorBlindnessMode(): ColorBlindnessMode;
     set simulate(value: boolean);

package/build/esm/src/engine/graphics/post-processor/post-processor.d.ts

@@ -0,0 +1,66 @@
+import type { VertexLayout } from '../context/vertex-layout';
+import type { Shader } from '../context/shader';
+import type { ExcaliburGraphicsContextWebGL } from '../context/excalibur-graphics-context-webgl';
+import type { Framebuffer } from '../context/framebuffer';
+/**
+ * PostProcessors apply a shader effect to the entire screen at the end of the frame.
+ *
+ * Implement {@apilink PostProcessor.process}: the current (MSAA-resolved) screen arrives as
+ * `source` and the result must be rendered into `destination` — typically with a
+ * {@apilink ShaderPass} or {@apilink ShaderPipeline}. Because the shape matches
+ * {@apilink ShaderPipelineLike}, effect objects like {@apilink BloomEffect} or
+ * {@apilink BlurEffect} can be added as post processors directly:
+ *
+ * ```typescript
+ * game.graphicsContext.addPostProcessor(new ex.BloomEffect({ graphicsContext }));
+ * ```
+ *
+ * Use {@apilink ShaderPipelinePostProcessor} to build one from a list of fragment sources.
+ *
+ * Fragment shaders in a {@apilink ShaderPass}/{@apilink ShaderPipeline} get these built-ins:
+ *
+ * * `uniform sampler2D u_image` - the current screen (or previous pass output)
+ * * `uniform vec2 u_resolution` - the destination resolution (in pixels)
+ * * `uniform vec2 u_texelSize` - `1.0 / source resolution`
+ * * `uniform float u_time_ms` - total time in milliseconds
+ * * `uniform float u_elapsed_ms` - elapsed milliseconds since the last frame
+ * * `in vec2 v_uv` - 0-1 UV over the screen
+ *
+ * The deprecated single-pass path receives `u_image` at slot 0 plus `u_time_ms`,
+ * `u_elapsed_ms`, and `u_resolution` when declared; custom uniforms can be updated in
+ * {@apilink PostProcessor.onUpdate}.
+ */
+export interface PostProcessor {
+    /**
+     * Called once when the post processor is added to the graphics context
+     */
+    initialize?(graphicsContext: ExcaliburGraphicsContextWebGL): void;
+    /**
+     * `source` is the current (MSAA-resolved) screen framebuffer, render the result into
+     * `destination`, for example with a {@apilink ShaderPass} or {@apilink ShaderPipeline}.
+     */
+    process?(source: Framebuffer, destination: Framebuffer): void;
+    /**
+     * @deprecated implement {@apilink PostProcessor.process} instead, the single-pass
+     * shader/layout path will be removed in v1.x. The screen texture is bound to slot 0 as
+     * `uniform sampler2D u_image` and default uniforms (`u_time_ms`, `u_elapsed_ms`,
+     * `u_resolution`) are set when declared.
+     */
+    getShader?(): Shader;
+    /**
+     * @deprecated implement {@apilink PostProcessor.process} instead, the single-pass
+     * shader/layout path will be removed in v1.x.
+     */
+    getLayout?(): VertexLayout;
+    /**
+     * Use the onUpdate hook to update any uniforms in the postprocessors shader
+     *
+     * The shader has already been bound so there is no need to call shader.use();
+     * @param elapsed
+     */
+    onUpdate?(elapsed: number): void;
+    /**
+     * Use the onDraw hook to upload any textures or command that need to run right before draw
+     */
+    onDraw?(): void;
+}

package/build/esm/src/engine/graphics/post-processor/shader-pipeline-post-processor.d.ts

@@ -0,0 +1,45 @@
+import type { ExcaliburGraphicsContextWebGL } from '../context/excalibur-graphics-context-webgl';
+import type { Framebuffer } from '../context/framebuffer';
+import type { ShaderPassLike, ShaderPipelineLike } from '../context/shader-pipeline/shader-pipeline';
+import type { PostProcessor } from './post-processor';
+export interface ShaderPipelinePostProcessorOptions {
+    /**
+     * Name the post processor for debugging
+     */
+    name?: string;
+    /**
+     * Multipass pipeline run over the screen, mirroring {@apilink Material}'s `passes`.
+     *
+     * Provide an ordered list of passes (bare fragment strings or {@apilink ShaderPass}), or any
+     * {@apilink ShaderPipelineLike} implementation ({@apilink BloomEffect}, {@apilink GlowEffect},
+     * {@apilink BlurEffect}, or your own pass graph).
+     */
+    passes: ShaderPassLike[] | ShaderPipelineLike;
+}
+/**
+ * A fullscreen multipass {@apilink PostProcessor} built on {@apilink ShaderPipeline}.
+ *
+ * ```typescript
+ * game.graphicsContext.addPostProcessor(new ex.ShaderPipelinePostProcessor({
+ *   passes: [thresholdGlsl, blurHorizontalPass, blurVerticalPass]
+ * }));
+ * ```
+ *
+ * Each frame the screen is run through the passes and the final pass renders back into the
+ * engine's post processing chain, composing with any other post processors in order.
+ */
+export declare class ShaderPipelinePostProcessor implements PostProcessor {
+    readonly name: string;
+    private _passes;
+    private _pipeline;
+    private _elapsed;
+    constructor(options: ShaderPipelinePostProcessorOptions);
+    /**
+     * The pipeline run over the screen, available after the post processor is added to the context
+     */
+    get pipeline(): ShaderPipelineLike;
+    initialize(graphicsContext: ExcaliburGraphicsContextWebGL): void;
+    onUpdate(elapsed: number): void;
+    process(source: Framebuffer, destination: Framebuffer): void;
+    dispose(): void;
+}

package/build/{dist → esm/src/engine}/graphics/sprite-font.d.ts

@@ -39,12 +39,12 @@ export declare class SpriteFont extends Graphic implements FontRenderer {
     private _text;
     alphabet: string;
     spriteSheet: SpriteSheet;
-    shadow?: {
+    shadow: {
         offset: Vector;
-    };
+    } | null;
     caseInsensitive: boolean;
     spacing: number;
-    lineHeight: number | undefined;
+    lineHeight: number | null;
     private _logger;
     constructor(options: SpriteFontOptions & GraphicOptions);
     protected _getCharacterSprites(text: string): Sprite[];

package/build/{dist → esm/src/engine}/index.d.ts

@@ -16,10 +16,12 @@ export * from './event-emitter';
 export * from './events/media-events';
 export * from './events';
 export * from './label';
-export { FontStyle, FontUnit, TextAlign, BaseAlign } from './graphics/font-common';
+export { FontStyle, FontUnit, TextAlign, BaseAlign, TextDirection } from './graphics/font-common';
 export * from './particles/index';
 export * from './scene';
+export * from './plugin';
 export * from './tile-map/index';
+export * from './lighting/index';
 export * from './timer';
 export * from './trigger';
 export * from './screen-element';
@@ -47,7 +49,7 @@ export { PointerSystem } from './input/pointer-system';
 export { PointerType } from './input/pointer-type';
 export { PointerScope } from './input/pointer-scope';
 export type { NavigatorGamepads, NavigatorGamepad, NavigatorGamepadButton, NavigatorGamepadEvent, GamepadConfiguration } from './input/gamepad';
-export { Gamepads, Gamepad, Buttons, Axes } from './input/gamepad';
+export { Gamepads, Gamepad, Buttons, Axes, GamepadEvents } from './input/gamepad';
 export type { KeyboardInitOptions } from './input/keyboard';
 export { Keys, KeyEvent, Keyboard } from './input/keyboard';
 export * from './input/input-host';
@@ -55,12 +57,10 @@ export * from './input/input-mapper';
 import * as util from './util/index';
 export { util as Util };
 export * from './util/browser';
-export * from './util/decorators';
 export * from './util/detector';
-export * from './util/easing-functions';
 export * from './util/observable';
 export * from './util/log';
-export * from './util/pool';
+export * from './util/arena-pool';
 export * from './util/fps';
 export * from './util/clock';
 export * from './util/web-audio';

package/build/{dist → esm/src/engine}/input/gamepad.d.ts

@@ -5,12 +5,16 @@ export interface GamepadEvents {
     connect: GamepadConnectEvent;
     disconnect: GamepadDisconnectEvent;
     button: GamepadButtonEvent;
+    buttondown: GamepadButtonEvent;
+    buttonup: GamepadButtonEvent;
     axis: GamepadAxisEvent;
 }
 export declare const GamepadEvents: {
     GamepadConnect: string;
     GamepadDisconnect: string;
     GamepadButton: string;
+    GamepadButtonDown: string;
+    GamepadButtonUp: string;
     GamepadAxis: string;
 };
 /**
@@ -100,13 +104,6 @@ export declare class Gamepad {
     private _buttonsDown;
     constructor();
     update(): void;
-    /**
-     * Whether or not the given button is pressed
-     * @deprecated will be removed in v0.28.0. Use isButtonHeld instead
-     * @param button     The button to query
-     * @param threshold  The threshold over which the button is considered to be pressed
-     */
-    isButtonPressed(button: Buttons | number, threshold?: number): boolean;
     /**
      * Tests if a certain button is held down. This is persisted between frames.
      * @param button     The button to query

package/build/{dist → esm/src/engine}/input/keyboard.d.ts

@@ -192,14 +192,14 @@ export declare enum Keys {
  */
 export declare class KeyEvent extends Events.GameEvent<any> {
     key: Keys;
-    value?: string;
-    originalEvent?: KeyboardEvent;
+    value?: string | undefined;
+    originalEvent?: KeyboardEvent | undefined;
     /**
      * @param key  The key responsible for throwing the event
      * @param value The key's typed value the browser detected
      * @param originalEvent The original keyboard event that Excalibur handled
      */
-    constructor(key: Keys, value?: string, originalEvent?: KeyboardEvent);
+    constructor(key: Keys, value?: string | undefined, originalEvent?: KeyboardEvent | undefined);
 }
 export interface KeyboardInitOptions {
     global: GlobalEventHandlers | (() => GlobalEventHandlers);