littlejsengine 1.16.1 → 1.16.2

package/dist/littlejs.d.ts

@@ -283,37 +283,20 @@ declare module "littlejsengine" {
     /** Trigger debug system to take a screenshot
      *  @memberof Debug */
     export function debugScreenshot(): void;
-    /** Save a canvas to disk
-     *  @param {HTMLCanvasElement|OffscreenCanvas} canvas
-     *  @param {string} [filename]
-     *  @param {string} [type]
-     *  @memberof Debug */
-    export function debugSaveCanvas(canvas: HTMLCanvasElement | OffscreenCanvas, filename?: string, type?: string): void;
-    /** Save a text file to disk
-     *  @param {string}     text
-     *  @param {string}     [filename]
-     *  @param {string}     [type]
-     *  @memberof Debug */
-    export function debugSaveText(text: string, filename?: string, type?: string): void;
-    /** Save a data url to disk
-     *  @param {string}     dataURL
-     *  @param {string}     filename
-     *  @memberof Debug */
-    export function debugSaveDataURL(dataURL: string, filename: string): void;
     /** Breaks on all asserts/errors, hides the canvas, and shows message in plain text
      *  This is a good function to call at the start of your game to catch all errors
      *  In release builds this function has no effect
      *  @memberof Debug */
     export function debugShowErrors(): void;
-    /** Check if video capture is active
-     *  @memberof Debug */
-    export function debugVideoCaptureIsActive(): boolean;
     /** Start capturing video
      *  @memberof Debug */
     export function debugVideoCaptureStart(): void;
     /** Stop capturing video and save to disk
      *  @memberof Debug */
     export function debugVideoCaptureStop(): void;
+    /** Check if video capture is active
+     *  @memberof Debug */
+    export function debugVideoCaptureIsActive(): boolean;
     /**
      * LittleJS Engine Settings
      * - All settings for the engine are here
@@ -340,7 +323,7 @@ declare module "littlejsengine" {
      *  @default
      *  @memberof Settings */
     export let canvasColorTiles: boolean;
-    /** Color to clear the canvas to before render
+    /** Color to clear the canvas to before render, does not clear if alpha is 0
      *  @type {Color}
      *  @memberof Draw */
     export let canvasClearColor: Color;
@@ -560,7 +543,7 @@ declare module "littlejsengine" {
      *  @param {boolean} colorTiles
      *  @memberof Settings */
     export function setCanvasColorTiles(colorTiles: boolean): void;
-    /** Set color to clear the canvas to before render
+    /** Set color to clear the canvas to before render, does not clear if alpha is 0
      *  @param {Color} color
      *  @memberof Settings */
     export function setCanvasClearColor(color: Color): void;
@@ -744,105 +727,105 @@ declare module "littlejsengine" {
      * - Color - holds a rgba color with some math functions
      * - Timer - tracks time automatically
      * - RandomGenerator - seeded random number generator
-     * @namespace Utilities
+     * @namespace Math
      */
     /** The value of PI
      *  @type {number}
      *  @default Math.PI
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const PI: number;
     /** Returns absolute value of value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const abs: (x: number) => number;
     /** Returns floored value of value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const floor: (x: number) => number;
     /** Returns ceiled value of value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const ceil: (x: number) => number;
     /** Returns rounded value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const round: (x: number) => number;
     /** Returns lowest value passed in
      *  @param {...number} values
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const min: (...values: number[]) => number;
     /** Returns highest value passed in
      *  @param {...number} values
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const max: (...values: number[]) => number;
     /** Returns the sign of value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const sign: (x: number) => number;
     /** Returns hypotenuse of values passed in
      *  @param {...number} values
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const hypot: (...values: number[]) => number;
     /** Returns log2 of value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const log2: (x: number) => number;
     /** Returns sin of value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const sin: (x: number) => number;
     /** Returns cos of value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const cos: (x: number) => number;
     /** Returns tan of value passed in
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const tan: (x: number) => number;
     /** Returns atan2 of values passed in
      *  @param {number} y
      *  @param {number} x
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const atan2: (y: number, x: number) => number;
     /** Returns first parm modulo the second param, but adjusted so negative numbers work as expected
      *  @param {number} dividend
      *  @param {number} [divisor]
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function mod(dividend: number, divisor?: number): number;
     /** Clamps the value between max and min
      *  @param {number} value
      *  @param {number} [min]
      *  @param {number} [max]
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function clamp(value: number, min?: number, max?: number): number;
     /** Returns what percentage the value is between valueA and valueB
      *  @param {number} value
      *  @param {number} valueA
      *  @param {number} valueB
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function percent(value: number, valueA: number, valueB: number): number;
     /** Returns signed wrapped distance between the two values passed in
      *  @param {number} valueA
      *  @param {number} valueB
      *  @param {number} [wrapSize]
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function distanceWrap(valueA: number, valueB: number, wrapSize?: number): number;
     /** Linearly interpolates between values passed in with wrapping
      *  @param {number} valueA
@@ -850,37 +833,37 @@ declare module "littlejsengine" {
      *  @param {number} percent
      *  @param {number} [wrapSize]
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function lerpWrap(valueA: number, valueB: number, percent: number, wrapSize?: number): number;
     /** Returns signed wrapped distance between the two angles passed in
      *  @param {number} angleA
      *  @param {number} angleB
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function distanceAngle(angleA: number, angleB: number): number;
     /** Linearly interpolates between the angles passed in with wrapping
      *  @param {number} angleA
      *  @param {number} angleB
      *  @param {number} percent
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function lerpAngle(angleA: number, angleB: number, percent: number): number;
     /** Linearly interpolates between values passed in using percent
      *  @param {number} valueA
      *  @param {number} valueB
      *  @param {number} percent
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function lerp(valueA: number, valueB: number, percent: number): number;
     /** Applies smoothstep function to the percentage value
      *  @param {number} percent
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function smoothStep(percent: number): number;
     /** Returns the nearest power of two not less than the value
      *  @param {number} value
      *  @return {number}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function nearestPowerOfTwo(value: number): number;
     /** Returns true if two axis aligned bounding boxes are overlapping
      *  this can be used for simple collision detection between objects
@@ -889,7 +872,7 @@ declare module "littlejsengine" {
      *  @param {Vector2} posB          - Center of box B
      *  @param {Vector2} [sizeB=(0,0)] - Size of box B, uses a point if undefined
      *  @return {boolean}              - True if overlapping
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function isOverlapping(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB?: Vector2): boolean;
     /** Returns true if a line segment is intersecting an axis aligned box
      *  @param {Vector2} start - Start of raycast
@@ -897,7 +880,7 @@ declare module "littlejsengine" {
      *  @param {Vector2} pos   - Center of box
      *  @param {Vector2} size  - Size of box
      *  @return {boolean}      - True if intersecting
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function isIntersecting(start: Vector2, end: Vector2, pos: Vector2, size: Vector2): boolean;
     /** Returns an oscillating wave between 0 and amplitude with frequency of 1 Hz by default
      *  @param {number} [frequency] - Frequency of the wave in Hz
@@ -905,8 +888,17 @@ declare module "littlejsengine" {
      *  @param {number} [t=time]    - Value to use for time of the wave
      *  @param {number} [offset]    - Value to use for time offset of the wave
      *  @return {number}            - Value waving between 0 and amplitude
-     *  @memberof Utilities */
+     *  @memberof Math */
     export function wave(frequency?: number, amplitude?: number, t?: number, offset?: number): number;
+    /**
+     * LittleJS Utility Classes and Functions
+     * - General purpose math library
+     * - Vector2 - fast, simple, easy 2D vector class
+     * - Color - holds a rgba color with some math functions
+     * - Timer - tracks time automatically
+     * - RandomGenerator - seeded random number generator
+     * @namespace Utilities
+     */
     /** Formats seconds to mm:ss style for display purposes
      *  @param {number} t - time in seconds
      *  @return {string}
@@ -917,6 +909,24 @@ declare module "littlejsengine" {
      *  @return {Promise<object>}
      *  @memberof Utilities */
     export function fetchJSON(url: string): Promise<object>;
+    /** Save a text file to disk
+     *  @param {string} text
+     *  @param {string} [filename]
+     *  @param {string} [type]
+     *  @memberof Utilities */
+    export function saveText(text: string, filename?: string, type?: string): void;
+    /** Save a canvas to disk
+     *  @param {HTMLCanvasElement|OffscreenCanvas} canvas
+     *  @param {string} [filename]
+     *  @param {string} [type]
+     *  @memberof Utilities */
+    export function saveCanvas(canvas: HTMLCanvasElement | OffscreenCanvas, filename?: string, type?: string): void;
+    /** Save a data url to disk
+     *  @param {string} url
+     *  @param {string} [filename]
+     *  @param {number} [revokeTime] - how long before revoking the url
+     *  @memberof Utilities */
+    export function saveDataURL(url: string, filename?: string, revokeTime?: number): void;
     /** Random global functions
      *  @namespace Random */
     /** Returns a random value between the two values passed in
@@ -1319,7 +1329,7 @@ declare module "littlejsengine" {
      * let a = vec2(0, 1); // vector with coordinates (0, 1)
      * a = vec2(5);        // set a to (5, 5)
      * b = vec2();         // set b to (0, 0)
-     * @memberof Utilities */
+     * @memberof Math */
     export function vec2(x?: number, y?: number): Vector2;
     /**
      * Create a color object with RGBA values, white by default
@@ -1328,7 +1338,7 @@ declare module "littlejsengine" {
      * @param {number} [b=1] - blue
      * @param {number} [a=1] - alpha
      * @return {Color}
-     * @memberof Utilities
+     * @memberof Math
      */
     export function rgb(r?: number, g?: number, b?: number, a?: number): Color;
     /**
@@ -1338,89 +1348,89 @@ declare module "littlejsengine" {
      * @param {number} [l=1] - lightness
      * @param {number} [a=1] - alpha
      * @return {Color}
-     * @memberof Utilities */
+     * @memberof Math */
     export function hsl(h?: number, s?: number, l?: number, a?: number): Color;
     /**
      * Check if object is a valid Color
      * @param {any} c
      * @return {boolean}
-     * @memberof Utilities */
+     * @memberof Math */
     export function isColor(c: any): boolean;
     /**
      * Check if object is a valid Vector2
      * @param {any} v
      * @return {boolean}
-     * @memberof Utilities */
+     * @memberof Math */
     export function isVector2(v: any): boolean;
     /**
      * Check if object is a valid number, not NaN or undefined, but it may be infinite
      * @param {any} n
      * @return {boolean}
-     * @memberof Utilities */
+     * @memberof Math */
     export function isNumber(n: any): boolean;
     /**
      * Check if object is a valid string or can be converted to one
      * @param {any} s
      * @return {boolean}
-     * @memberof Utilities */
+     * @memberof Math */
     export function isString(s: any): boolean;
     /**
      * Check if object is an array
      * @param {any} a
      * @return {boolean}
-     * @memberof Utilities */
+     * @memberof Math */
     export function isArray(a: any): boolean;
     /** Color - White #ffffff
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const WHITE: Color;
     /** Color - Clear White #757474ff with 0 alpha
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const CLEAR_WHITE: Color;
     /** Color - Black #000000
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const BLACK: Color;
     /** Color - Clear Black #000000 with 0 alpha
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const CLEAR_BLACK: Color;
     /** Color - Gray #808080
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const GRAY: Color;
     /** Color - Red #ff0000
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const RED: Color;
     /** Color - Orange #ff8000
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const ORANGE: Color;
     /** Color - Yellow #ffff00
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const YELLOW: Color;
     /** Color - Green #00ff00
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const GREEN: Color;
     /** Color - Cyan #00ffff
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const CYAN: Color;
     /** Color - Blue #0000ff
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const BLUE: Color;
     /** Color - Purple #8000ff
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const PURPLE: Color;
     /** Color - Magenta #ff00ff
      *  @type {Color}
-     *  @memberof Utilities */
+     *  @memberof Math */
     export const MAGENTA: Color;
     /**
      * Create a tile info object using a grid based system
@@ -1535,10 +1545,6 @@ declare module "littlejsengine" {
      *  @type {CanvasRenderingContext2D}
      *  @memberof Draw */
     export let mainContext: CanvasRenderingContext2D;
-    /** The default canvas to use for drawing, usually mainCanvas
-     *  @type {HTMLCanvasElement|OffscreenCanvas}
-     *  @memberof Draw */
-    export let drawCanvas: HTMLCanvasElement | OffscreenCanvas;
     /** The default 2d context to use for drawing, usually mainContext
      *  @type {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D}
      *  @memberof Draw */
@@ -1591,6 +1597,13 @@ declare module "littlejsengine" {
      *  @return {Vector2}
      *  @memberof Draw */
     export function worldToScreenDelta(worldDelta: Vector2): Vector2;
+    /** Convert screen space transform to world space
+     *  @param {Vector2} screenPos
+     *  @param {Vector2} screenSize
+     *  @param {number} [screenAngle]
+     *  @return {[Vector2, Vector2, number]} - [pos, size, angle]
+     *  @memberof Draw */
+    export function screenToWorldTransform(screenPos: Vector2, screenSize: Vector2, screenAngle?: number): [Vector2, Vector2, number];
     /** Draw textured tile centered in world space, with color applied if using WebGL
      *  @param {Vector2}  pos                 - Center of the tile in world space
      *  @param {Vector2}  [size=(1,1)]        - Size of the tile in world space
@@ -1728,7 +1741,7 @@ declare module "littlejsengine" {
      *  @param {string}  [fontStyle]
      *  @param {number}  [maxWidth]
      *  @param {number}  [angle]
-     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=mainContext]
+     *  @param {CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D} [context=drawContext]
      *  @memberof Draw */
     export function drawTextScreen(text: string | number, pos: Vector2, size?: number, color?: Color, lineWidth?: number, lineColor?: Color, textAlign?: CanvasTextAlign, font?: string, fontStyle?: string, maxWidth?: number, angle?: number, context?: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D): void;
     /** Enable normal or additive blend mode
@@ -2723,8 +2736,8 @@ declare module "littlejsengine" {
          *  @param {Vector2} layerPos - Local position in array
          *  @return {TileLayerData} */
         getData(layerPos: Vector2): TileLayerData;
-        /** @type {[HTMLCanvasElement|OffscreenCanvas, CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D, Vector2, Vector2, number, Color]} */
-        savedRenderSettings: [HTMLCanvasElement | OffscreenCanvas, CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, Vector2, Vector2, number, Color];
+        /** @type {[CanvasRenderingContext2D|OffscreenCanvasRenderingContext2D, Vector2, Vector2, number, Color]} */
+        savedRenderSettings: [CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D, Vector2, Vector2, number, Color];
     }
     /**
      * Tile Collision Layer - a tile layer with collision