excalibur 0.25.1 → 0.25.2

package/build/dist/Graphics/DebugGraphicsComponent.d.ts

@@ -0,0 +1,13 @@
+import { ExcaliburGraphicsContext } from '.';
+import { Component } from '../EntityComponentSystem/Component';
+/**
+ * Provide arbitrary drawing for the purposes of debugging your game
+ *
+ * Will only show when the Engine is set to debug mode [[Engine.showDebug]] or [[Engine.toggleDebug]]
+ *
+ */
+export declare class DebugGraphicsComponent extends Component<'ex.debuggraphics'> {
+    draw: (ctx: ExcaliburGraphicsContext) => void;
+    readonly type = "ex.debuggraphics";
+    constructor(draw: (ctx: ExcaliburGraphicsContext) => void);
+}

package/build/dist/Graphics/Filtering.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Describes the different image filtering modes
+ */
+export declare enum ImageFiltering {
+    /**
+     * Pixel is useful when you do not want smoothing aka antialiasing applied to your graphics.
+     *
+     * Useful for Pixel art aesthetics.
+     */
+    Pixel = "Pixel",
+    /**
+     * Blended is useful when you have high resolution artwork and would like it blended and smoothed
+     */
+    Blended = "Blended"
+}

package/build/dist/Graphics/Font.d.ts

@@ -3,19 +3,40 @@ import { BoundingBox } from '../Collision/Index';
 import { Color } from '../Color';
 import { ExcaliburGraphicsContext } from './Context/ExcaliburGraphicsContext';
 import { BaseAlign, Direction, FontOptions, FontStyle, FontUnit, TextAlign, FontRenderer } from './FontCommon';
-import { Raster, RasterOptions } from './Raster';
-export declare class Font extends Raster implements FontRenderer {
-    constructor(options?: FontOptions & RasterOptions);
+import { Graphic, GraphicOptions } from './Graphic';
+import { RasterOptions } from './Raster';
+import { ImageFiltering } from './Filtering';
+/**
+ * Represents a system or web font in Excalibur
+ *
+ * If no options specified, the system sans-serif 10 pixel is used
+ *
+ * If loading a custom web font be sure to have the font loaded before you use it https://erikonarheim.com/posts/dont-test-fonts/
+ */
+export declare class Font extends Graphic implements FontRenderer {
+    /**
+     * Set the font filtering mode, by default set to [[ImageFiltering.Blended]] regardless of the engine default smoothing
+     *
+     * If you have a pixel style font that may be a reason to switch this to [[ImageFiltering.Pixel]]
+     */
+    filtering: ImageFiltering;
+    constructor(options?: FontOptions & GraphicOptions & RasterOptions);
     clone(): Font;
     /**
-     * Font quality determines the size of the underlying rastered text, higher quality means less jagged edges.
+     * Font quality determines the size of the underlying raster text, higher quality means less jagged edges.
      * If quality is set to 1, then just enough raster bitmap is generated to render the text.
      *
      * You can think of quality as how zoomed in to the text you can get before seeing jagged edges.
      *
-     * (Default 4)
+     * (Default 2)
      */
     quality: number;
+    padding: number;
+    smoothing: boolean;
+    lineWidth: number;
+    lineDash: number[];
+    color: Color;
+    strokeColor: Color;
     family: string;
     style: FontStyle;
     bold: boolean;
@@ -30,28 +51,45 @@ export declare class Font extends Raster implements FontRenderer {
         color?: Color;
     };
     get fontString(): string;
-    private _text;
-    private _lines;
     private _textBounds;
-    private _textWidth;
-    private _textHeight;
-    get width(): number;
-    set width(value: number);
-    get height(): number;
-    set height(value: number);
-    private get _rasterWidth();
-    private get _rasterHeight();
-    private get _halfRasterWidth();
-    private get _halfRasterHeight();
     get localBounds(): BoundingBox;
-    protected _drawImage(ex: ExcaliburGraphicsContext, x: number, y: number): void;
+    protected _drawImage(_ex: ExcaliburGraphicsContext, _x: number, _y: number): void;
     protected _rotate(ex: ExcaliburGraphicsContext): void;
     protected _flip(ex: ExcaliburGraphicsContext): void;
-    updateText(text: string): void;
-    private _updateDimensions;
-    protected _preDraw(ex: ExcaliburGraphicsContext, x: number, y: number): void;
+    /**
+     * Returns a BoundingBox that is the total size of the text including multiple lines
+     *
+     * Does not include any padding or adjustment
+     * @param text
+     * @returns BoundingBox
+     */
+    measureText(text: string): BoundingBox;
+    private _setDimension;
     protected _postDraw(ex: ExcaliburGraphicsContext): void;
+    /**
+     * We need to identify bitmaps with more than just the text content
+     *
+     * Any properties that can change the rendering of the text
+     */
+    private _getRasterPropertiesHash;
+    protected _applyRasterProperties(ctx: CanvasRenderingContext2D, color: Color): void;
     private _applyFont;
-    execute(ctx: CanvasRenderingContext2D): void;
-    render(ex: ExcaliburGraphicsContext, text: string, x: number, y: number): void;
+    private _drawText;
+    private _textToBitmap;
+    private _bitmapUsage;
+    private _getTextBitmap;
+    render(ex: ExcaliburGraphicsContext, text: string, colorOverride: Color, x: number, y: number): void;
+    /**
+     * Get the internal cache size of the font
+     * This is useful when debugging memory usage, these numbers indicate the number of cached in memory text bitmaps
+     */
+    get cacheSize(): number;
+    /**
+     * Force clear all cached text bitmaps
+     */
+    clearCache(): void;
+    /**
+     * Remove any expired cached text bitmaps
+     */
+    checkAndClearCache(): void;
 }

package/build/dist/Graphics/FontCommon.d.ts

@@ -1,3 +1,4 @@
+import { BoundingBox } from '../Collision/BoundingBox';
 import { Color } from '../Color';
 import { Vector } from '../Math/vector';
 import { ExcaliburGraphicsContext } from './Context/ExcaliburGraphicsContext';
@@ -97,27 +98,67 @@ export declare enum FontStyle {
     Italic = "italic",
     Oblique = "oblique"
 }
+/**
+ * Enum representing the text direction, useful for other languages, or writing text in reverse
+ */
 export declare enum Direction {
     LeftToRight = "ltr",
     RightToLeft = "rtl"
 }
+/**
+ * Font rendering option
+ */
 export interface FontOptions {
+    /**
+     * Optionally the size of the font in the specified [[FontUnit]] by default 10.
+     */
     size?: number;
+    /**
+     * Optionally specify unit to measure fonts in, by default Pixels
+     */
     unit?: FontUnit;
-    lineHeight?: number;
+    /**
+     * Optionally specify the font family, by default 'sans-serif'
+     */
     family?: string;
+    /**
+     * Optionally specify the font style, by default Normal
+     */
     style?: FontStyle;
+    /**
+     * Optionally set whether the font is bold, by default false
+     */
     bold?: boolean;
+    /**
+     * Optionally specify the text align, by default Left
+     */
     textAlign?: TextAlign;
+    /**
+     * Optionally specify the text base align, by default Alphabetic
+     */
     baseAlign?: BaseAlign;
+    /**
+     * Optionally specify the text direction, by default LeftToRight
+     */
     direction?: Direction;
+    /**
+     * Optionally specify the quality of the text bitmap, it is a multiplier on the size size, by default 2.
+     * Higher quality text has a higher memory impact
+     */
     quality?: number;
+    /**
+     * Optionally specify a text shadow, by default none is specified
+     */
     shadow?: {
         blur?: number;
         offset?: Vector;
         color?: Color;
     };
 }
+/**
+ * @internal
+ */
 export interface FontRenderer {
-    render(ex: ExcaliburGraphicsContext, text: string, x: number, y: number): void;
+    measureText(text: string): BoundingBox;
+    render(ex: ExcaliburGraphicsContext, text: string, color: Color, x: number, y: number): void;
 }

package/build/dist/Graphics/Graphic.d.ts

@@ -1,6 +1,7 @@
 import { Vector } from '../Math/vector';
 import { ExcaliburGraphicsContext } from './Context/ExcaliburGraphicsContext';
 import { BoundingBox } from '../Collision/BoundingBox';
+import { Matrix } from '..';
 export interface GraphicOptions {
     /**
      * The width of the graphic
@@ -46,34 +47,47 @@ export interface GraphicOptions {
 export declare abstract class Graphic {
     private static _ID;
     readonly id: number;
+    transform: Matrix;
+    private _transformStale;
+    isStale(): boolean;
     /**
      * Gets or sets wether to show debug information about the graphic
      */
     showDebug: boolean;
+    private _flipHorizontal;
     /**
      * Gets or sets the flipHorizontal, which will flip the graphic horizontally (across the y axis)
      */
-    flipHorizontal: boolean;
+    get flipHorizontal(): boolean;
+    set flipHorizontal(value: boolean);
+    private _flipVertical;
     /**
      * Gets or sets the flipVertical, which will flip the graphic vertically (across the x axis)
      */
-    flipVertical: boolean;
+    get flipVertical(): boolean;
+    set flipVertical(value: boolean);
+    private _rotation;
     /**
      * Gets or sets the rotation of the graphic
      */
-    rotation: number;
+    get rotation(): number;
+    set rotation(value: number);
     /**
      * Gets or sets the opacity of the graphic, 0 is transparent, 1 is solid (opaque).
      */
     opacity: number;
+    private _scale;
     /**
      * Gets or sets the scale of the graphic, this affects the width and
      */
-    scale: Vector;
+    get scale(): Vector;
+    set scale(value: Vector);
+    private _origin;
     /**
      * Gets or sets the origin of the graphic, if not set the center of the graphic is the origin
      */
-    origin: Vector | null;
+    get origin(): Vector | null;
+    set origin(value: Vector | null);
     constructor(options?: GraphicOptions);
     cloneGraphicOptions(): GraphicOptions;
     private _width;
@@ -100,7 +114,7 @@ export declare abstract class Graphic {
      */
     draw(ex: ExcaliburGraphicsContext, x: number, y: number): void;
     /**
-     * Meant to be overriden by the graphic implementation to draw the underlying image (HTMLCanvasElement or HTMLImageElement)
+     * Meant to be overridden by the graphic implementation to draw the underlying image (HTMLCanvasElement or HTMLImageElement)
      * to the graphics context without transform. Transformations like position, rotation, and scale are handled by [[Graphic._preDraw]]
      * and [[Graphic._postDraw]]
      * @param ex The excalibur graphics context
@@ -115,10 +129,10 @@ export declare abstract class Graphic {
      * @param y
      */
     protected _preDraw(ex: ExcaliburGraphicsContext, x: number, y: number): void;
-    protected _rotate(ex: ExcaliburGraphicsContext): void;
-    protected _flip(ex: ExcaliburGraphicsContext): void;
+    protected _rotate(ex: ExcaliburGraphicsContext | Matrix): void;
+    protected _flip(ex: ExcaliburGraphicsContext | Matrix): void;
     /**
-     * Apply any addtional work after [[Graphic._drawImage]] and restore the context state.
+     * Apply any additional work after [[Graphic._drawImage]] and restore the context state.
      * @param ex
      */
     protected _postDraw(ex: ExcaliburGraphicsContext): void;

package/build/dist/Graphics/GraphicsSystem.d.ts

@@ -14,7 +14,6 @@ export declare class GraphicsSystem extends System<TransformComponent | Graphics
     initialize(scene: Scene): void;
     sort(a: Entity, b: Entity): number;
     update(entities: Entity[], delta: number): void;
-    private _clearScreen;
     private _isOffscreen;
     private _drawGraphicsComponent;
     /**

package/build/dist/Graphics/ImageSource.d.ts

@@ -1,10 +1,12 @@
 import { Texture } from '../Drawing/Texture';
 import { Sprite } from './Sprite';
 import { Loadable } from '../Interfaces/Index';
+import { ImageFiltering } from './Filtering';
 export declare class ImageSource implements Loadable<HTMLImageElement> {
     readonly path: string;
     private _logger;
     private _resource;
+    private _filtering;
     /**
      * The original size of the source image in pixels
      */
@@ -13,13 +15,14 @@ export declare class ImageSource implements Loadable<HTMLImageElement> {
      * The original height of the source image in pixels
      */
     get height(): number;
+    private _src;
     /**
      * Returns true if the Texture is completely loaded and is ready
      * to be drawn.
      */
     isLoaded(): boolean;
     /**
-     * Access to the underlying html image elmeent
+     * Access to the underlying html image element
      */
     data: HTMLImageElement;
     get image(): HTMLImageElement;
@@ -30,9 +33,11 @@ export declare class ImageSource implements Loadable<HTMLImageElement> {
     private _loadedResolve;
     /**
      * The path to the image, can also be a data url like 'data:image/'
-     * @param path
+     * @param path {string} Path to the image resource relative from the HTML document hosting the game, or absolute
+     * @param bustCache {boolean} Should excalibur add a cache busting querystring?
+     * @param filtering {ImageFiltering} Optionally override the image filtering set by [[EngineOptions.antialiasing]]
      */
-    constructor(path: string, bustCache?: boolean);
+    constructor(path: string, bustCache?: boolean, filtering?: ImageFiltering);
     /**
      * Begins loading the image and returns a promise that resolves when the image is loaded
      */

package/build/dist/Graphics/Polygon.d.ts

@@ -5,6 +5,8 @@ export interface PolygonOptions {
 }
 /**
  * A polygon [[Graphic]] for drawing arbitrary polygons to the [[ExcaliburGraphicsContext]]
+ *
+ * Polygons default to [[ImageFiltering.Blended]]
  */
 export declare class Polygon extends Raster {
     private _points;

package/build/dist/Graphics/PostProcessor/ColorBlindnessMode.d.ts

@@ -0,0 +1,5 @@
+export declare enum ColorBlindnessMode {
+    Protanope = "Protanope",
+    Deuteranope = "Deuteranope",
+    Tritanope = "Tritanope"
+}

package/build/dist/Graphics/PostProcessor/ColorBlindnessPostProcessor.d.ts

@@ -0,0 +1,17 @@
+import { PostProcessor } from './PostProcessor';
+import { ColorBlindnessMode } from './ColorBlindnessMode';
+import { Shader } from '../Context/shader';
+import { VertexLayout } from '../Context/vertex-layout';
+export declare class ColorBlindnessPostProcessor implements PostProcessor {
+    private _colorBlindnessMode;
+    private _shader;
+    private _simulate;
+    constructor(_colorBlindnessMode: ColorBlindnessMode, simulate?: boolean);
+    initialize(_gl: WebGLRenderingContext): void;
+    getShader(): Shader;
+    getLayout(): VertexLayout;
+    set colorBlindnessMode(colorBlindMode: ColorBlindnessMode);
+    get colorBlindnessMode(): ColorBlindnessMode;
+    set simulate(value: boolean);
+    get simulate(): boolean;
+}

package/build/dist/Graphics/PostProcessor/PostProcessor.d.ts

@@ -0,0 +1,7 @@
+import { VertexLayout } from '..';
+import { Shader } from '../Context/shader';
+export interface PostProcessor {
+    initialize(gl: WebGLRenderingContext): void;
+    getShader(): Shader;
+    getLayout(): VertexLayout;
+}

package/build/dist/Graphics/PostProcessor/ScreenShader.d.ts

@@ -0,0 +1,16 @@
+import { Shader } from '../Context/shader';
+import { VertexLayout } from '../Context/vertex-layout';
+/**
+ * Helper that defines a whole screen renderer, just provide a fragment source!
+ *
+ * Currently supports 1 varying
+ * - vec2 a_texcoord between 0-1 which corresponds to screen position
+ */
+export declare class ScreenShader {
+    private _shader;
+    private _buffer;
+    private _layout;
+    constructor(fragmentSource: string);
+    getShader(): Shader;
+    getLayout(): VertexLayout;
+}

package/build/dist/Graphics/PostProcessor/color-blind-fragment.glsl

@@ -0,0 +1,62 @@
+precision mediump float;
+// our texture
+uniform sampler2D u_image;
+// the texCoords passed in from the vertex shader.
+varying vec2 v_texcoord;
+
+// color blind type
+uniform int u_type;
+
+// simulation?
+uniform bool u_simulate;
+
+void main() {
+  vec4 o =  texture2D(u_image, v_texcoord);
+  // RGB to LMS matrix conversion
+  float L = (17.8824 * o.r) + (43.5161 * o.g) + (4.11935 * o.b);
+  float M = (3.45565 * o.r) + (27.1554 * o.g) + (3.86714 * o.b);
+  float S = (0.0299566 * o.r) + (0.184309 * o.g) + (1.46709 * o.b);
+  // Simulate color blindness
+  float l;
+  float m;
+  float s;
+  //MODE CODE//
+  if (u_type == 0) {
+    // Protanope
+    l = 0.0 * L + 2.02344 * M + -2.52581 * S;
+    m = 0.0 * L + 1.0 * M + 0.0 * S;
+    s = 0.0 * L + 0.0 * M + 1.0 * S;;
+  } else if (u_type == 1) {
+    // Deuteranope
+    l = 1.0 * L + 0.0 * M + 0.0 * S;
+    m = 0.494207 * L + 0.0 * M + 1.24827 * S;
+    s = 0.0 * L + 0.0 * M + 1.0 * S;
+  } else if (u_type == 2) {
+    // Tritanope
+    l = 1.0 * L + 0.0 * M + 0.0 * S;
+    m = 0.0 * L + 1.0 * M + 0.0 * S;
+    s = -0.395913 * L + 0.801109 * M + 0.0 * S;
+  }
+
+  // LMS to RGB matrix conversion
+  vec4 error; // simulate the colors
+  error.r = (0.0809444479 * l) + (-0.130504409 * m) + (0.116721066 * s);
+  error.g = (-0.0102485335 * l) + (0.0540193266 * m) + (-0.113614708 * s);
+  error.b = (-0.000365296938 * l) + (-0.00412161469 * m) + (0.693511405 * s);
+  error.a = 1.0;
+  vec4 diff = o - error;
+  vec4 correction; // correct the colors
+  correction.r = 0.0;
+  correction.g =  (diff.r * 0.7) + (diff.g * 1.0);
+  correction.b =  (diff.r * 0.7) + (diff.b * 1.0);
+  correction = o + correction;
+  correction.a = o.a;
+  //SIMULATE//
+
+  // sim 
+  if (u_simulate) {
+    gl_FragColor = error.rgba;
+  } else {
+    gl_FragColor = correction.rgba;
+  }
+}

package/build/dist/Graphics/Raster.d.ts

@@ -2,21 +2,48 @@ import { Graphic, GraphicOptions } from './Graphic';
 import { ExcaliburGraphicsContext } from './Context/ExcaliburGraphicsContext';
 import { Color } from '../Color';
 import { BoundingBox } from '../Collision/BoundingBox';
+import { ImageFiltering } from './Filtering';
 export interface RasterOptions {
+    /**
+     * Optionally specify "smoothing" if you want antialiasing to apply to the raster's bitmap context, by default `false`
+     */
     smoothing?: boolean;
+    /**
+     * Optionally specify the color of the raster's bitmap context, by default [[Color.Black]]
+     */
     color?: Color;
+    /**
+     * Optionally specify the stroke color of the raster's bitmap context, by default undefined
+     */
     strokeColor?: Color;
+    /**
+     * Optionally specify the line width of the raster's bitmap, by default 1 pixel
+     */
     lineWidth?: number;
+    /**
+     * Optionally specify the line dash of the raster's bitmap, by default `[]` which means none
+     */
     lineDash?: number[];
+    /**
+     * Optionally specify the padding to apply to the bitmap
+     */
     padding?: number;
+    /**
+     * Optionally specify what image filtering mode should be used, [[ImageFiltering.Pixel]] for pixel art,
+     * [[ImageFiltering.Blended]] for hi-res art
+     *
+     * By default unset, rasters defer to the engine antialiasing setting
+     */
+    filtering?: ImageFiltering;
 }
 /**
  * A Raster is a Graphic that needs to be first painted to a HTMLCanvasElement before it can be drawn to the
  * [[ExcaliburGraphicsContext]]. This is useful for generating custom images using the 2D canvas api.
  *
- * Implementors must implemenet the [[Raster.execute]] method to rasterize their drawing.
+ * Implementors must implement the [[Raster.execute]] method to rasterize their drawing.
  */
 export declare abstract class Raster extends Graphic {
+    filtering: ImageFiltering;
     _bitmap: HTMLCanvasElement;
     protected _ctx: CanvasRenderingContext2D;
     private _dirty;
@@ -28,7 +55,7 @@ export declare abstract class Raster extends Graphic {
     get dirty(): boolean;
     /**
      * Flags the graphic as dirty, meaning it must be re-rasterized before draw.
-     * This should be called any time the graphics state changes such that it affects the outputed drawing
+     * This should be called any time the graphics state changes such that it affects the outputted drawing
      */
     flagDirty(): void;
     private _originalWidth;
@@ -90,14 +117,14 @@ export declare abstract class Raster extends Graphic {
     get padding(): number;
     set padding(value: number);
     /**
-     * Rasterize the graphic to a bitmap making it usuable as in excalibur. Rasterize is called automatically if
+     * Rasterize the graphic to a bitmap making it usable as in excalibur. Rasterize is called automatically if
      * the graphic is [[Raster.dirty]] on the next [[Graphic.draw]] call
      */
     rasterize(): void;
-    protected _applyRasterProperites(ctx: CanvasRenderingContext2D): void;
+    protected _applyRasterProperties(ctx: CanvasRenderingContext2D): void;
     protected _drawImage(ex: ExcaliburGraphicsContext, x: number, y: number): void;
     /**
-     * Executes drawing implemenation of the graphic, this is where the specific drawing code for the graphic
+     * Executes drawing implementation of the graphic, this is where the specific drawing code for the graphic
      * should be implemented. Once `rasterize()` the graphic can be drawn to the [[ExcaliburGraphicsContext]] via `draw(...)`
      * @param ctx Canvas to draw the graphic to
      */

package/build/dist/Graphics/Sprite.d.ts

@@ -38,8 +38,13 @@ export declare class Sprite extends Graphic {
     image: ImageSource;
     sourceView: SourceView;
     destSize: DestinationSize;
+    private _dirty;
     static from(image: ImageSource): Sprite;
     constructor(options: GraphicOptions & SpriteOptions);
+    get width(): number;
+    get height(): number;
+    set width(newWidth: number);
+    set height(newHeight: number);
     private _updateSpriteDimensions;
     protected _preDraw(ex: ExcaliburGraphicsContext, x: number, y: number): void;
     _drawImage(ex: ExcaliburGraphicsContext, x: number, y: number): void;

package/build/dist/Graphics/SpriteFont.d.ts

@@ -4,9 +4,10 @@ import { ExcaliburGraphicsContext } from './Context/ExcaliburGraphicsContext';
 import { FontRenderer } from './FontCommon';
 import { Graphic, GraphicOptions } from './Graphic';
 import { SpriteSheet } from './SpriteSheet';
+import { BoundingBox, Color } from '..';
 export interface SpriteFontOptions {
     /**
-     * Alphabet string in spritsheet order (default is row column order)
+     * Alphabet string in spritesheet order (default is row column order)
      * example: 'abcdefghijklmnopqrstuvwxyz'
      */
     alphabet: string;
@@ -31,7 +32,6 @@ export interface SpriteFontOptions {
 }
 export declare class SpriteFont extends Graphic implements FontRenderer {
     private _text;
-    private _dirty;
     alphabet: string;
     spriteSheet: SpriteSheet;
     shadow: {
@@ -42,12 +42,11 @@ export declare class SpriteFont extends Graphic implements FontRenderer {
     private _logger;
     static fromLegacySpriteFont(spriteFont: LegacySpriteFont): SpriteFont;
     constructor(options: SpriteFontOptions & GraphicOptions);
-    private _sprites;
+    private _alreadyWarnedAlphabet;
+    private _alreadyWarnedSpriteSheet;
     private _getCharacterSprites;
-    private _updateDimensions;
-    updateText(text: string): void;
-    protected _preDraw(ex: ExcaliburGraphicsContext, x: number, y: number): void;
+    measureText(text: string): BoundingBox;
     protected _drawImage(ex: ExcaliburGraphicsContext, x: number, y: number): void;
-    render(ex: ExcaliburGraphicsContext, text: string, x: number, y: number): void;
+    render(ex: ExcaliburGraphicsContext, text: string, _color: Color, x: number, y: number): void;
     clone(): SpriteFont;
 }

package/build/dist/Graphics/SpriteSheet.d.ts

@@ -53,7 +53,7 @@ export interface SpriteSheetGridOptions {
         spriteHeight: number;
     };
     /**
-     * Optionally specifiy any spacing information between sprites
+     * Optionally specify any spacing information between sprites
      */
     spacing?: SpriteSheetSpacingDimensions;
 }
@@ -99,7 +99,6 @@ export declare class SpriteSheet {
     /**
      * @deprecated
      * @param spriteSheet
-     * @returns
      */
     static toLegacySpriteSheet(spriteSheet: SpriteSheet): LegacySpriteSheet;
     /**

package/build/dist/Graphics/Text.d.ts

@@ -5,23 +5,39 @@ import { Graphic, GraphicOptions } from './Graphic';
 import { Color } from '../Color';
 import { Font } from './Font';
 export interface TextOptions {
+    /**
+     * Text to draw
+     */
     text: string;
+    /**
+     * Optionally override the font color, currently unsupported by SpriteFont
+     */
     color?: Color;
+    /**
+     * Optionally specify a font, if none specified a default font is used (System sans-serif 10 pixel)
+     */
     font?: Font | SpriteFont;
 }
+/**
+ * Represent Text graphics in excalibur
+ *
+ * Useful for in game labels, ui, or overlays
+ */
 export declare class Text extends Graphic {
+    color?: Color;
     constructor(options: TextOptions & GraphicOptions);
     clone(): Text;
     private _text;
     get text(): string;
     set text(value: string);
-    get color(): Color;
-    set color(color: Color);
     private _font;
     get font(): Font | SpriteFont;
     set font(font: Font | SpriteFont);
+    private _textWidth;
     get width(): number;
+    private _textHeight;
     get height(): number;
+    private _calculateDimension;
     get localBounds(): BoundingBox;
     protected _rotate(_ex: ExcaliburGraphicsContext): void;
     protected _flip(_ex: ExcaliburGraphicsContext): void;