excalibur 0.25.1 → 0.25.2

package/build/esm/Engine.d.ts

@@ -11,13 +11,13 @@ import { Loader } from './Loader';
 import { VisibleEvent, HiddenEvent, GameStartEvent, GameStopEvent, PreUpdateEvent, PostUpdateEvent, PreFrameEvent, PostFrameEvent, GameEvent, PreDrawEvent, PostDrawEvent } from './Events';
 import { Color } from './Color';
 import { Scene } from './Scene';
-import { PostProcessor } from './PostProcessing/PostProcessor';
 import { Debug, DebugStats } from './Debug/Debug';
 import { Class } from './Class';
 import * as Input from './Input/Index';
 import * as Events from './Events';
 import { BrowserEvents } from './Util/Browser';
 import { ExcaliburGraphicsContext } from './Graphics';
+import { Clock } from './Util/Clock';
 /**
  * Enum representing the different mousewheel event bubble prevention
  */
@@ -59,6 +59,12 @@ export interface EngineOptions {
     resolution?: ScreenDimension;
     /**
      * Optionally specify antialiasing (smoothing), by default true (smooth pixels)
+     *
+     *  * `true` - useful for high resolution art work you would like smoothed, this also hints excalibur to load images
+     * with [[ImageFiltering.Blended]]
+     *
+     *  * `false` - useful for pixel art style art work you would like sharp, this also hints excalibur to load images
+     * with [[ImageFiltering.Pixel]]
      */
     antialiasing?: boolean;
     /**
@@ -124,6 +130,13 @@ export interface EngineOptions {
      * Optionally set the background color
      */
     backgroundColor?: Color;
+    /**
+     * Optionally set the maximum fps if not set Excalibur will go as fast as the device allows.
+     *
+     * You may want to constrain max fps if your game cannot maintain fps consistently, it can look and feel better to have a 30fps game than
+     * one that bounces between 30fps and 60fps
+     */
+    maxFps?: number;
 }
 /**
  * The Excalibur Engine
@@ -134,7 +147,7 @@ export interface EngineOptions {
  */
 export declare class Engine extends Class implements CanInitialize, CanUpdate, CanDraw {
     /**
-     *
+     * Excalibur browser events abstraction used for wiring to native browser events safely
      */
     browser: BrowserEvents;
     /**
@@ -147,13 +160,28 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     canvas: HTMLCanvasElement;
     /**
      * Direct access to the engine's 2D rendering context
+     * @deprecated Will be removed in v0.26.0, use Engine.graphicsContext
      */
     ctx: CanvasRenderingContext2D;
+    /**
+     * Direct access to the ExcaliburGraphicsContext used for drawing things to the screen
+     */
     graphicsContext: ExcaliburGraphicsContext;
     /**
      * Direct access to the canvas element ID, if an ID exists
      */
     canvasElementId: string;
+    /**
+     * Optionally set the maximum fps if not set Excalibur will go as fast as the device allows.
+     *
+     * You may want to constrain max fps if your game cannot maintain fps consistently, it can look and feel better to have a 30fps game than
+     * one that bounces between 30fps and 60fps
+     */
+    maxFps: number;
+    /**
+     * Direct access to the excalibur clock
+     */
+    clock: Clock;
     /**
      * The width of the game canvas in pixels (physical width component of the
      * resolution of the canvas element)
@@ -199,16 +227,17 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     private _hasStarted;
     /**
      * Access Excalibur debugging functionality.
+     *
+     * Useful when you want to debug different aspects of built in engine features like
+     *   * Transform
+     *   * Graphics
+     *   * Colliders
      */
     debug: Debug;
     /**
      * Access [[stats]] that holds frame statistics.
      */
     get stats(): DebugStats;
-    /**
-     * Gets or sets the list of post processors to apply at the end of drawing a frame (such as [[ColorBlindCorrector]])
-     */
-    postProcessors: PostProcessor[];
     /**
      * The current [[Scene]] being drawn and updated on screen
      */
@@ -225,7 +254,7 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     };
     /**
      * @hidden
-     * @deprecated
+     * @deprecated will be removed in v0.26.0
      */
     private _animations;
     /**
@@ -243,6 +272,7 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     get pixelRatio(): number;
     /**
      * Indicates the current position of the engine. Valid only when DisplayMode is DisplayMode.Position
+     * @deprecated will be removed in v0.26.0
      */
     position: string | AbsolutePosition;
     /**
@@ -254,6 +284,10 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
      */
     private _isDebug;
     get isDebug(): boolean;
+    /**
+     * No longer used
+     * @deprecated will be removed in v0.26.0
+     */
     debugColor: Color;
     /**
      * Sets the background color for the engine.
@@ -263,6 +297,11 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
      * Sets the Transparency for the engine.
      */
     enableCanvasTransparency: boolean;
+    /**
+     * Hints the graphics context to truncate fractional world space coordinates
+     */
+    get snapToPixel(): boolean;
+    set snapToPixel(shouldSnapToPixel: boolean);
     /**
      * The action to take when a fatal exception is thrown
      */
@@ -276,7 +315,6 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     private _compatible;
     private _timescale;
     private _loader;
-    private _isLoading;
     private _isInitialized;
     private _deferredGoTo;
     on(eventName: Events.initialize, handler: (event: Events.InitializeEvent<Engine>) => void): void;
@@ -555,13 +593,28 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
      * Returns true when loading is totally complete and the player has clicked start
      */
     get loadingComplete(): boolean;
+    private _isReady;
+    get ready(): boolean;
+    private _isReadyResolve;
+    private _isReadyPromise;
+    isReady(): Promise<void>;
     /**
      * Starts the internal game loop for Excalibur after loading
      * any provided assets.
      * @param loader  Optional [[Loader]] to use to load resources. The default loader is [[Loader]], override to provide your own
      * custom loader.
+     *
+     * Note: start() only resolves AFTER the user has clicked the play button
      */
     start(loader?: Loader): Promise<void>;
+    private _mainloop;
+    /**
+     *
+     * @param game
+     * @param raf
+     * @param nowFn
+     * @deprecated Use [[Clock]] to run the mainloop, will be removed in v0.26.0
+     */
     static createMainLoop(game: Engine, raf: (func: Function) => number, nowFn: () => number): () => void;
     /**
      * Stops Excalibur's main loop, useful for pausing the game.
@@ -569,8 +622,13 @@ export declare class Engine extends Class implements CanInitialize, CanUpdate, C
     stop(): void;
     /**
      * Returns the Engine's Running status, Useful for checking whether engine is running or paused.
+     * @deprecated will be removed in v0.26.0, use isRunning()
      */
     isPaused(): boolean;
+    /**
+     * Returns the Engine's running status, Useful for checking whether engine is running or paused.
+     */
+    isRunning(): boolean;
     /**
      * Takes a screen shot of the current viewport and returns it as an
      * HTML Image Element.

package/build/esm/EntityComponentSystem/Component.d.ts

@@ -9,9 +9,9 @@ export declare type ComponentType<ComponentToParse> = ComponentToParse extends C
  */
 export declare type ComponentStringType<T> = T extends Component<infer R> ? R : string;
 /**
- * Components are containers for state in Excalibur, the are meant to convey capabilities that an Entity posesses
+ * Components are containers for state in Excalibur, the are meant to convey capabilities that an Entity possesses
  *
- * Implementations of Component must have a zero-arg constructor to support dependecies
+ * Implementations of Component must have a zero-arg constructor to support dependencies
  *
  * ```typescript
  * class MyComponent extends ex.Component<'my'> {
@@ -47,7 +47,7 @@ export declare abstract class Component<TypeName extends string = string> {
      */
     onAdd?(owner: Entity): void;
     /**
-     * Opitonal callback called when acomponent is added to an entity
+     * Optional callback called when a component is added to an entity
      */
     onRemove?(previousOwner: Entity): void;
 }

package/build/esm/EntityComponentSystem/Components/MotionComponent.d.ts

@@ -22,7 +22,7 @@ export interface Motion {
      */
     torque: number;
     /**
-     * Inerita can be thought of as the resistance to motion
+     * Inertia can be thought of as the resistance to motion
      */
     inertia: number;
 }
@@ -49,7 +49,7 @@ export declare class MotionComponent extends Component<'ex.motion'> {
      */
     torque: number;
     /**
-     * Inerita can be thought of as the resistance to motion
+     * Inertia can be thought of as the resistance to motion
      */
     inertia: number;
 }

package/build/esm/EntityComponentSystem/Entity.d.ts

@@ -152,7 +152,7 @@ export declare class Entity extends Class implements OnInitialize, OnPreUpdate,
     /**
      * Adds a copy of all the components from another template entity as a "prefab"
      * @param templateEntity Entity to use as a template
-     * @param force Force component replacement if it aleady exists on the target entity
+     * @param force Force component replacement if it already exists on the target entity
      */
     addTemplate(templateEntity: Entity, force?: boolean): Entity;
     /**
@@ -197,20 +197,20 @@ export declare class Entity extends Class implements OnInitialize, OnPreUpdate,
     /**
      * Initializes this entity, meant to be called by the Scene before first update not by users of Excalibur.
      *
-     * It is not recommended that internal excalibur methods be overriden, do so at your own risk.
+     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
      *
      * @internal
      */
     _initialize(engine: Engine): void;
     /**
-     * It is not recommended that internal excalibur methods be overriden, do so at your own risk.
+     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
      *
      * Internal _preupdate handler for [[onPreUpdate]] lifecycle event
      * @internal
      */
     _preupdate(engine: Engine, delta: number): void;
     /**
-     * It is not recommended that internal excalibur methods be overriden, do so at your own risk.
+     * It is not recommended that internal excalibur methods be overridden, do so at your own risk.
      *
      * Internal _preupdate handler for [[onPostUpdate]] lifecycle event
      * @internal

package/build/esm/EntityComponentSystem/System.d.ts

@@ -42,7 +42,7 @@ export declare abstract class System<ComponentTypeUnion extends Component = Comp
     /**
      * System can execute in priority order, by default all systems are priority 0. Lower values indicated higher priority.
      * For a system to execute before all other a lower priority value (-1 for example) must be set.
-     * For a system to exectue after all other a higher priority value (10 for example) must be set.
+     * For a system to execute after all other a higher priority value (10 for example) must be set.
      */
     priority: number;
     /**

package/build/esm/EntityComponentSystem/SystemManager.d.ts

@@ -21,7 +21,6 @@ export declare class SystemManager<ContextType> {
     /**
      * Get a system registered in the manager by type
      * @param systemType
-     * @returns
      */
     get<T extends System>(systemType: SystemCtor<T>): T | null;
     /**
@@ -34,6 +33,12 @@ export declare class SystemManager<ContextType> {
      * @param system
      */
     removeSystem(system: System<any, ContextType>): void;
+    /**
+     * Initialize all systems in the manager
+     *
+     * Systems added after initialize() will be initialized on add
+     */
+    initialize(): void;
     /**
      * Updates all systems
      * @param type whether this is an update or draw system

package/build/esm/EventDispatcher.d.ts

@@ -3,11 +3,6 @@ import { Eventable } from './Interfaces/Evented';
 export declare class EventDispatcher<T = any> implements Eventable {
     private _handlers;
     private _wiredEventDispatchers;
-    private _target;
-    /**
-     * @param target  The object that will be the recipient of events from this event dispatcher
-     */
-    constructor(target: T);
     /**
      * Clears any existing handlers or wired event dispatchers on this event dispatcher
      */

package/build/esm/Events/ExEvent.d.ts

@@ -0,0 +1,6 @@
+export declare abstract class ExEvent<TName extends string> {
+    abstract readonly type: TName;
+    private _active;
+    get active(): boolean;
+    cancel(): void;
+}

package/build/esm/Events/PointerEvents.d.ts

@@ -0,0 +1,37 @@
+import { GlobalCoordinates } from '..';
+import { WheelDeltaMode } from '../Input/WheelDeltaMode';
+import { ExEvent } from './ExEvent';
+export declare abstract class PointerEvent extends ExEvent<'down' | 'up' | 'move' | 'cancel'> {
+    pointerId: number;
+    coordinates: GlobalCoordinates;
+    nativeEvent: Event;
+    constructor(pointerId: number, coordinates: GlobalCoordinates, nativeEvent: Event);
+}
+export declare class PointerUp extends PointerEvent {
+    readonly type = "up";
+}
+export declare class PointerDown extends PointerEvent {
+    readonly type = "down";
+}
+export declare class PointerMove extends PointerEvent {
+    readonly type = "move";
+}
+export declare class PointerCancel extends PointerEvent {
+    readonly type = "cancel";
+}
+export declare class Wheel extends ExEvent<'wheel'> {
+    x: number;
+    y: number;
+    pageX: number;
+    pageY: number;
+    screenX: number;
+    screenY: number;
+    index: number;
+    deltaX: number;
+    deltaY: number;
+    deltaZ: number;
+    deltaMode: WheelDeltaMode;
+    ev: Event;
+    readonly type = "wheel";
+    constructor(x: number, y: number, pageX: number, pageY: number, screenX: number, screenY: number, index: number, deltaX: number, deltaY: number, deltaZ: number, deltaMode: WheelDeltaMode, ev: Event);
+}

package/build/esm/Graphics/Animation.d.ts

@@ -48,7 +48,7 @@ export interface Frame {
      */
     graphic?: Graphic;
     /**
-     * Optionally specify the number of ms the frame should be visible, overrids the animation duration (default 100 ms)
+     * Optionally specify the number of ms the frame should be visible, overrides the animation duration (default 100 ms)
      */
     duration?: number;
 }
@@ -103,6 +103,8 @@ export declare class Animation extends Graphic implements HasTick {
     private _playing;
     constructor(options: GraphicOptions & AnimationOptions);
     clone(): Animation;
+    get width(): number;
+    get height(): number;
     /**
      * Create an Animation from a [[SpriteSheet]], a list of indices into the sprite sheet, a duration per frame
      * and optional [[AnimationStrategy]]
@@ -184,6 +186,5 @@ export declare class Animation extends Graphic implements HasTick {
      * @param idempotencyToken Prevents double ticking in a frame by passing a unique token to the frame
      */
     tick(elapsedMilliseconds: number, idempotencyToken?: number): void;
-    private _updateDimensions;
     protected _drawImage(ctx: ExcaliburGraphicsContext, x: number, y: number): void;
 }

package/build/esm/Graphics/Circle.d.ts

@@ -4,6 +4,8 @@ export interface CircleOptions {
 }
 /**
  * A circle [[Graphic]] for drawing circles to the [[ExcaliburGraphicsContext]]
+ *
+ * Circles default to [[ImageFiltering.Blended]]
  */
 export declare class Circle extends Raster {
     private _radius;

package/build/esm/Graphics/Context/ExcaliburGraphicsContext.d.ts

@@ -1,5 +1,8 @@
 import { Vector } from '../../Math/vector';
+import { Matrix } from '../../Math/matrix';
 import { Color } from '../../Color';
+import { ScreenDimension } from '../../Screen';
+import { PostProcessor } from '../PostProcessor/PostProcessor';
 export declare type HTMLImageSource = HTMLImageElement | HTMLCanvasElement;
 export interface ExcaliburGraphicsContextOptions {
     canvasElement: HTMLCanvasElement;
@@ -55,7 +58,7 @@ export interface ExcaliburGraphicsContext {
     width: number;
     height: number;
     /**
-     * Snaps all drawings to the nearest pixel trucated down, by default false
+     * Snaps all drawings to the nearest pixel truncated down, by default false
      */
     snapToPixel: boolean;
     /**
@@ -74,10 +77,19 @@ export interface ExcaliburGraphicsContext {
      * Resets the current transform to the identity matrix
      */
     resetTransform(): void;
+    /**
+     * Gets the current transform
+     */
+    getTransform(): Matrix;
+    /**
+     * Multiplies the current transform by a matrix
+     * @param m
+     */
+    multiply(m: Matrix): void;
     /**
      * Update the context with the current viewport dimensions (used in resizing)
      */
-    updateViewport(): void;
+    updateViewport(resolution: ScreenDimension): void;
     /**
      * Access the debug drawing api
      */
@@ -112,14 +124,16 @@ export interface ExcaliburGraphicsContext {
      * @param height
      * @param color
      */
-    drawRectangle(pos: Vector, width: number, height: number, color: Color): void;
+    drawRectangle(pos: Vector, width: number, height: number, color: Color, stroke?: Color, strokeThickness?: number): void;
     /**
-     * Draw a solid circle to the Excalibur Graphics context
+     * Draw a circle to the Excalibur Graphics context
      * @param pos
      * @param radius
      * @param color
+     * @param stroke Optionally specify the stroke color
+     * @param thickness
      */
-    drawCircle(pos: Vector, radius: number, color: Color): void;
+    drawCircle(pos: Vector, radius: number, color: Color, stroke?: Color, thickness?: number): void;
     /**
      * Save the current state of the canvas to the stack (transforms and opacity)
      */
@@ -144,6 +158,22 @@ export interface ExcaliburGraphicsContext {
      * @param y
      */
     scale(x: number, y: number): void;
+    /**
+     * Add a post processor to the graphics context
+     *
+     * Post processors are run in the order they were added.
+     * @param postprocessor
+     */
+    addPostProcessor(postprocessor: PostProcessor): void;
+    /**
+     * Remove a specific post processor from the graphics context
+     * @param postprocessor
+     */
+    removePostProcessor(postprocessor: PostProcessor): void;
+    /**
+     * Remove all post processors from the graphics context
+     */
+    clearPostProcessors(): void;
     /**
      * Clears the screen with the current background color
      */
@@ -152,4 +182,6 @@ export interface ExcaliburGraphicsContext {
      * Flushes the batched draw calls to the screen
      */
     flush(): void;
+    beginDrawLifecycle(): void;
+    endDrawLifecycle(): void;
 }

package/build/esm/Graphics/Context/ExcaliburGraphicsContext2DCanvas.d.ts

@@ -1,6 +1,9 @@
 import { ExcaliburGraphicsContext, LineGraphicsOptions, PointGraphicsOptions, ExcaliburGraphicsContextOptions, DebugDraw, HTMLImageSource } from './ExcaliburGraphicsContext';
 import { Vector } from '../../Math/vector';
 import { Color } from '../../Color';
+import { Matrix } from '../../Math/matrix';
+import { ScreenDimension } from '../../Screen';
+import { PostProcessor } from '../PostProcessor/PostProcessor';
 declare class ExcaliburGraphicsContext2DCanvasDebug implements DebugDraw {
     private _ex;
     private _debugText;
@@ -34,7 +37,7 @@ export declare class ExcaliburGraphicsContext2DCanvas implements ExcaliburGraphi
     set smoothing(value: boolean);
     constructor(options: ExcaliburGraphicsContextOptions);
     resetTransform(): void;
-    updateViewport(): void;
+    updateViewport(_resolution: ScreenDimension): void;
     /**
      * Draw an image to the Excalibur Graphics context at an x and y coordinate using the images width and height
      */
@@ -52,7 +55,7 @@ export declare class ExcaliburGraphicsContext2DCanvas implements ExcaliburGraphi
     drawImage(image: HTMLImageSource, sx: number, sy: number, swidth?: number, sheight?: number, dx?: number, dy?: number, dwidth?: number, dheight?: number): void;
     drawLine(start: Vector, end: Vector, color: Color, thickness?: number): void;
     drawRectangle(pos: Vector, width: number, height: number, color: Color): void;
-    drawCircle(pos: Vector, radius: number, color: Color): void;
+    drawCircle(pos: Vector, radius: number, color: Color, stroke?: Color, thickness?: number): void;
     debug: ExcaliburGraphicsContext2DCanvasDebug;
     /**
      * Save the current state of the canvas to the stack (transforms and opacity)
@@ -78,6 +81,13 @@ export declare class ExcaliburGraphicsContext2DCanvas implements ExcaliburGraphi
      * @param y
      */
     scale(x: number, y: number): void;
+    getTransform(): Matrix;
+    multiply(_m: Matrix): void;
+    addPostProcessor(_postprocessor: PostProcessor): void;
+    removePostProcessor(_postprocessor: PostProcessor): void;
+    clearPostProcessors(): void;
+    beginDrawLifecycle(): void;
+    endDrawLifecycle(): void;
     clear(): void;
     /**
      * Flushes the batched draw calls to the screen

package/build/esm/Graphics/Context/ExcaliburGraphicsContextWebGL.d.ts

@@ -4,10 +4,10 @@ import { TransformStack } from './transform-stack';
 import { Vector } from '../../Math/vector';
 import { Color } from '../../Color';
 import { StateStack } from './state-stack';
-import { LineRenderer } from './line-renderer';
-import { ImageRenderer } from './image-renderer';
-import { PointRenderer } from './point-renderer';
 import { ScreenDimension } from '../../Screen';
+import { PostProcessor } from '../PostProcessor/PostProcessor';
+import { RendererPlugin } from './renderer';
+import { LineRenderer } from './line-renderer/line-renderer';
 declare class ExcaliburGraphicsContextWebGLDebug implements DebugDraw {
     private _webglCtx;
     private _debugText;
@@ -38,9 +38,17 @@ declare class ExcaliburGraphicsContextWebGLDebug implements DebugDraw {
 export interface WebGLGraphicsContextInfo {
     transform: TransformStack;
     state: StateStack;
-    matrix: Matrix;
+    ortho: Matrix;
+    context: ExcaliburGraphicsContextWebGL;
 }
 export declare class ExcaliburGraphicsContextWebGL implements ExcaliburGraphicsContext {
+    private _logger;
+    private _renderers;
+    private _isDrawLifecycle;
+    private _renderTarget;
+    private _postProcessTargets;
+    private _screenRenderer;
+    private _postprocessors;
     /**
      * Meant for internal use only. Access the internal context at your own risk and no guarantees this will exist in the future.
      * @internal
@@ -58,11 +66,6 @@ export declare class ExcaliburGraphicsContextWebGL implements ExcaliburGraphicsC
     private _transform;
     private _state;
     private _ortho;
-    /**
-     * Meant for internal use only. Access the internal context at your own risk and no guarantees this will exist in the future.
-     * @internal
-     */
-    __pointRenderer: PointRenderer;
     /**
      * Meant for internal use only. Access the internal context at your own risk and no guarantees this will exist in the future.
      * @internal
@@ -72,7 +75,6 @@ export declare class ExcaliburGraphicsContextWebGL implements ExcaliburGraphicsC
      * Meant for internal use only. Access the internal context at your own risk and no guarantees this will exist in the future.
      * @internal
      */
-    __imageRenderer: ImageRenderer;
     snapToPixel: boolean;
     smoothing: boolean;
     backgroundColor: Color;
@@ -80,6 +82,7 @@ export declare class ExcaliburGraphicsContextWebGL implements ExcaliburGraphicsC
     set opacity(value: number);
     get width(): number;
     get height(): number;
+    get ortho(): Matrix;
     /**
      * Checks the underlying webgl implementation if the requested internal resolution is supported
      * @param dim
@@ -87,14 +90,22 @@ export declare class ExcaliburGraphicsContextWebGL implements ExcaliburGraphicsC
     checkIfResolutionSupported(dim: ScreenDimension): boolean;
     constructor(options: ExcaliburGraphicsContextOptions);
     private _init;
+    register<T extends RendererPlugin>(renderer: T): void;
+    get(rendererName: string): RendererPlugin;
+    private _currentRenderer;
+    private _isCurrentRenderer;
+    beginDrawLifecycle(): void;
+    endDrawLifecycle(): void;
+    private _alreadyWarnedDrawLifecycle;
+    draw<TRenderer extends RendererPlugin>(rendererName: TRenderer['type'], ...args: Parameters<TRenderer['draw']>): void;
     resetTransform(): void;
-    updateViewport(): void;
+    updateViewport(resolution: ScreenDimension): void;
     drawImage(image: HTMLImageSource, x: number, y: number): void;
     drawImage(image: HTMLImageSource, x: number, y: number, width: number, height: number): void;
     drawImage(image: HTMLImageSource, sx: number, sy: number, swidth?: number, sheight?: number, dx?: number, dy?: number, dwidth?: number, dheight?: number): void;
     drawLine(start: Vector, end: Vector, color: Color, thickness?: number): void;
-    drawRectangle(pos: Vector, width: number, height: number, color: Color): void;
-    drawCircle(pos: Vector, radius: number, color: Color): void;
+    drawRectangle(pos: Vector, width: number, height: number, color: Color, stroke?: Color, strokeThickness?: number): void;
+    drawCircle(pos: Vector, radius: number, color: Color, stroke?: Color, thickness?: number): void;
     debug: ExcaliburGraphicsContextWebGLDebug;
     save(): void;
     restore(): void;
@@ -102,6 +113,11 @@ export declare class ExcaliburGraphicsContextWebGL implements ExcaliburGraphicsC
     rotate(angle: number): void;
     scale(x: number, y: number): void;
     transform(matrix: Matrix): void;
+    getTransform(): Matrix;
+    multiply(m: Matrix): void;
+    addPostProcessor(postprocessor: PostProcessor): void;
+    removePostProcessor(postprocessor: PostProcessor): void;
+    clearPostProcessors(): void;
     clear(): void;
     /**
      * Flushes all batched rendering to the screen

package/build/esm/Graphics/Context/circle-renderer/circle-renderer.d.ts

@@ -0,0 +1,22 @@
+import { Color } from '../../../Color';
+import { Vector } from '../../../Math/vector';
+import { ExcaliburGraphicsContextWebGL } from '../ExcaliburGraphicsContextWebGL';
+import { RendererPlugin } from '../renderer';
+export declare class CircleRenderer implements RendererPlugin {
+    readonly type = "ex.circle";
+    priority: number;
+    private _maxCircles;
+    private _shader;
+    private _context;
+    private _gl;
+    private _buffer;
+    private _layout;
+    private _quads;
+    private _circleCount;
+    private _vertexIndex;
+    initialize(gl: WebGLRenderingContext, context: ExcaliburGraphicsContextWebGL): void;
+    private _isFull;
+    draw(pos: Vector, radius: number, color: Color, stroke?: Color, strokeThickness?: number): void;
+    hasPendingDraws(): boolean;
+    flush(): void;
+}

package/build/esm/Graphics/Context/image-renderer/image-renderer.d.ts

@@ -0,0 +1,27 @@
+import { HTMLImageSource } from '../ExcaliburGraphicsContext';
+import { ExcaliburGraphicsContextWebGL } from '../ExcaliburGraphicsContextWebGL';
+import { RendererPlugin } from '../renderer';
+export declare class ImageRenderer implements RendererPlugin {
+    readonly type = "ex.image";
+    priority: number;
+    private _maxImages;
+    private _maxTextures;
+    private _context;
+    private _gl;
+    private _shader;
+    private _buffer;
+    private _layout;
+    private _quads;
+    private _imageCount;
+    private _textures;
+    private _vertexIndex;
+    initialize(gl: WebGLRenderingContext, context: ExcaliburGraphicsContextWebGL): void;
+    private _transformFragmentSource;
+    private _addImageAsTexture;
+    private _bindTextures;
+    private _getTextureIdForImage;
+    private _isFull;
+    draw(image: HTMLImageSource, sx: number, sy: number, swidth?: number, sheight?: number, dx?: number, dy?: number, dwidth?: number, dheight?: number): void;
+    hasPendingDraws(): boolean;
+    flush(): void;
+}