littlejsengine 1.18.28 → 1.19.3

package/dist/littlejs.d.ts

@@ -23,6 +23,13 @@ declare module "littlejsengine" {
      * - A function that draws to a 2D canvas context
      */
     export type Canvas2DDrawFunction = (context: CanvasRenderingContext2D | OffscreenCanvasRenderingContext2D) => any;
+    /**
+     * Anything with input and output audio nodes, like an effect from the audio effects plugin
+     */
+    export type AudioEffectNodes = {
+        input: AudioNode;
+        output: AudioNode;
+    };
     /**
      * - Function called when a sound ends
      */
@@ -163,6 +170,7 @@ declare module "littlejsengine" {
     export function engineObjectsUpdate(): void;
     /** Destroy and remove all objects
      *  - This can be used to clear out all objects when restarting a level
+     *  - Objects with the persistent flag set are left alone, for things that outlive a level
      *  - Objects can override their destroy function to do cleanup or stick around
      *  @param {boolean} [immediate] - should attached effects be allowed to die off?
      *  @memberof Engine */
@@ -202,8 +210,9 @@ declare module "littlejsengine" {
      *  @param {PluginCallback} [render]
      *  @param {PluginCallback} [glContextLost]
      *  @param {PluginCallback} [glContextRestored]
+     *  @param {PluginCallback} [preRender] - Called after the canvas is cleared and before gameRender
      *  @memberof Engine */
-    export function engineAddPlugin(update?: PluginCallback, render?: PluginCallback, glContextLost?: PluginCallback, glContextRestored?: PluginCallback): void;
+    export function engineAddPlugin(update?: PluginCallback, render?: PluginCallback, glContextLost?: PluginCallback, glContextRestored?: PluginCallback, preRender?: PluginCallback): void;
     /**
      * LittleJS Debug System
      * - Press Esc to toggle debug overlay with object picking
@@ -371,9 +380,10 @@ declare module "littlejsengine" {
      *  @type {Color}
      *  @memberof Settings */
     export let canvasClearColor: Color;
-    /** The max size of the canvas, centered if window is larger
+    /** The max size of the canvas in css pixels, centered if window is larger
+     *  - Not affected by canvasPixelRatio, the backing store may be larger than this
      *  @type {Vector2}
-     *  @default Vector2(1920,1080)
+     *  @default Vector2(3840,2160)
      *  @memberof Settings */
     export let canvasMaxSize: Vector2;
     /** Minimum aspect ratio of the canvas (width/height), unused if 0
@@ -388,8 +398,9 @@ declare module "littlejsengine" {
      *  @default
      *  @memberof Settings */
     export let canvasMaxAspect: number;
-    /** Fixed size of the canvas, if enabled canvas size never changes
+    /** Fixed size of the canvas in css pixels, if enabled canvas size never changes
      * - you may also need to set mainCanvasSize if using screen space coords in startup
+     * - canvasPixelRatio still applies, it only scales the backing store
      *  @type {Vector2}
      *  @default Vector2()
      *  @memberof Settings */
@@ -407,8 +418,13 @@ declare module "littlejsengine" {
      *  @default
      *  @memberof Settings */
     export let tilesPixelated: boolean;
-    /** Scale factor applied to the canvas backing store for native-resolution rendering.
+    /** Scale factor applied to the canvas resolution for sharper rendering
      *  Pass 1 for no scaling, a number for an explicit ratio, or undefined to track devicePixelRatio each frame.
+     *  - Only the backing store scales, so this changes sharpness and nothing else
+     *  - mainCanvasSize, cameraScale, mousePos and screen space stay in css pixels,
+     *    so the same code draws the same size at any ratio
+     *  - Pixel art usually looks best left at 1 or set to whole numbers,
+     *    a fractional ratio samples texels unevenly
      *  @type {number|undefined}
      *  @default
      *  @memberof Settings */
@@ -645,6 +661,13 @@ declare module "littlejsengine" {
      *  @default
      *  @memberof Settings */
     export let soundDefaultTaper: number;
+    /** Pause all sound while the page is hidden, and pick up where it was when it shows again
+     *  - A hidden page stops the game, so without this a looping sound plays on over a frozen game
+     *  - Turn it off to keep music playing in a background tab
+     *  @type {boolean}
+     *  @default
+     *  @memberof Settings */
+    export let soundPauseWhenHidden: boolean;
     /** Set position of camera in world space
      *  @param {Vector2} pos
      *  @memberof Settings */
@@ -697,11 +720,24 @@ declare module "littlejsengine" {
      *  @param {boolean} pixelated
      *  @memberof Settings */
     export function setTilesPixelated(pixelated: boolean): void;
-    /** Set the canvas pixel ratio.
+    /** Set the canvas pixel ratio, scales the render resolution for sharper output
      *  Pass a number for an explicit ratio, or call with no argument to track devicePixelRatio each frame.
+     *  - The canvas stays the same size on screen and everything draws the same
+     *    size, it just renders at a higher resolution so nothing looks blurry
+     *  - Game code is unaffected, it always works in css pixels
      *  @param {number} [pixelRatio]
+     *  @example
+     *  // render at native resolution, capped so phones don't pay for 3x
+     *  setCanvasPixelRatio(min(devicePixelRatio, 2));
      *  @memberof Settings */
     export function setCanvasPixelRatio(pixelRatio?: number): void;
+    /** Get the pixel ratio currently applied to the canvas backing store
+     *  - Resolves canvasPixelRatio, falling back to devicePixelRatio when it is undefined
+     *  - Game code works in css pixels so this is rarely needed, it is for sizing
+     *    render targets and viewports that must match the backing store
+     *  @return {number}
+     *  @memberof Settings */
+    export function getCanvasPixelRatio(): number;
     /** Set default font used for text rendering
      *  @param {string} font
      *  @memberof Settings */
@@ -870,6 +906,10 @@ declare module "littlejsengine" {
      *  @param {number} taper
      *  @memberof Settings */
     export function setSoundDefaultTaper(taper: number): void;
+    /** Set if all sound pauses while the page is hidden
+     *  @param {boolean} pause
+     *  @memberof Settings */
+    export function setSoundPauseWhenHidden(pause: boolean): void;
     /** Set if watermark with FPS should be shown
      *  @param {boolean} show
      *  @memberof Debug */
@@ -1061,6 +1101,31 @@ declare module "littlejsengine" {
      *  @return {boolean}      - True if intersecting
      *  @memberof Math */
     export function isIntersecting(start: Vector2, end: Vector2, pos: Vector2, size: Vector2): boolean;
+    /** Returns the vector to move circle A by so it no longer overlaps circle B, or undefined
+     *  @param {Vector2} posA - Center of circle A
+     *  @param {number} radiusA
+     *  @param {Vector2} posB - Center of circle B
+     *  @param {number} radiusB
+     *  @return {Vector2|undefined}
+     *  @memberof Math */
+    export function collideCircleCircle(posA: Vector2, radiusA: number, posB: Vector2, radiusB: number): Vector2 | undefined;
+    /** Returns the vector to move a circle out of an axis aligned box, or undefined
+     *  @param {Vector2} pos - Center of the circle
+     *  @param {number} radius
+     *  @param {Vector2} boxPos - Center of the box
+     *  @param {Vector2} boxSize - Full size of the box
+     *  @return {Vector2|undefined}
+     *  @memberof Math */
+    export function collideCircleBox(pos: Vector2, radius: number, boxPos: Vector2, boxSize: Vector2): Vector2 | undefined;
+    /** Returns the vector to move box A by so it no longer overlaps box B, the shortest way out, or undefined
+     *  - isOverlapping is the yes or no version of this
+     *  @param {Vector2} posA - Center of box A
+     *  @param {Vector2} sizeA - Full size of box A
+     *  @param {Vector2} posB - Center of box B
+     *  @param {Vector2} sizeB - Full size of box B
+     *  @return {Vector2|undefined}
+     *  @memberof Math */
+    export function collideBoxBox(posA: Vector2, sizeA: Vector2, posB: Vector2, sizeB: Vector2): Vector2 | undefined;
     /**
      * @callback LineTestFunction - Checks if a position is colliding
      * @param {Vector2} pos
@@ -1100,6 +1165,14 @@ declare module "littlejsengine" {
      *  @param {string} [type]
      *  @memberof Utilities */
     export function saveText(text: string, filename?: string, type?: string): void;
+    /** Create an offscreen canvas to draw into, and return its 2D context
+     *  - The canvas is context.canvas, which is what TextureInfo and the like take
+     *  @param {number} width - In pixels
+     *  @param {number} [height] - In pixels, defaults to the width for a square
+     *  @param {boolean} [willReadFrequently] - Keep it in software, faster when getImageData is called on it often
+     *  @return {OffscreenCanvasRenderingContext2D}
+     *  @memberof Utilities */
+    export function createCanvasContext(width: number, height?: number, willReadFrequently?: boolean): OffscreenCanvasRenderingContext2D;
     /** Save a canvas to disk
      *  @param {HTMLCanvasElement|OffscreenCanvas} canvas
      *  @param {string} [filename]
@@ -1310,6 +1383,7 @@ declare module "littlejsengine" {
          * @return {number} */
         distanceSquared(v: Vector2): number;
         /** Returns a new vector in same direction as this one with the length passed in
+         * - A zero vector has no direction, so it normalizes to straight up
          * @param {number} [length]
          * @return {Vector2} */
         normalize(length?: number): Vector2;
@@ -1764,8 +1838,9 @@ declare module "littlejsengine" {
         size: Vector2;
         /** @property {Vector2} - inverse of the size, cached for rendering */
         sizeInverse: Vector2;
-        /** @property {WebGLTexture} - WebGL texture */
-        glTexture: any;
+        /** @property {WebGLTexture|undefined} - WebGL texture
+         *  @type {WebGLTexture|undefined} */
+        glTexture: WebGLTexture | undefined;
         /** @property {boolean} - true for REPEAT wrap mode, false for CLAMP_TO_EDGE */
         wrap: boolean;
         /** Creates the WebGL texture, updates if already created */
@@ -1779,6 +1854,105 @@ declare module "littlejsengine" {
          *  @param {boolean} [wrap] - true for REPEAT, false for CLAMP_TO_EDGE */
         setWrap(wrap?: boolean): void;
     }
+    /**
+     * SpriteAnimation - Steps a tile through its frames over time: looping, once, or there and back
+     * - Driven by the engine time like a Timer, so it pauses with the game and needs no update call
+     * - Read tileInfo each frame for the frame to draw, from an object's update or before a drawTile
+     * - loop, play and pingPong each start over from the first frame; stop holds the current one
+     * - Frames follow each other along the row, as tileInfo.frame counts them
+     * @example
+     * const walk = new SpriteAnimation(tile(0, 16), 4, .1); // four frames, a tenth of a second each
+     * const attack = new SpriteAnimation(tile(4, 16), 3, .05).play(); // once, then holds the last frame
+     * // in update: this.tileInfo = (attack.isDone ? walk : attack).tileInfo;
+     * @memberof Draw
+     */
+    export class SpriteAnimation {
+        /** Create an animation over a run of frames, looping from the start
+         *  @param {TileInfo} tileInfo - The first frame
+         *  @param {number} frameCount - How many frames, one or more
+         *  @param {number} [frameTime] - Seconds each frame shows for */
+        constructor(tileInfo: TileInfo, frameCount: number, frameTime?: number);
+        /** @property {TileInfo} - The first frame, the others follow it along the row */
+        firstTile: TileInfo;
+        /** @property {number} - How many frames */
+        frameCount: number;
+        /** @property {number} - Seconds each frame shows for */
+        frameTime: number;
+        /** @property {number} - Rate multiplier, 2 plays twice as fast; set it before starting */
+        speed: number;
+        /** @property {string} - How it runs: 'loop', 'once' or 'pingPong', set by loop, play and pingPong */
+        mode: string;
+        /** @property {number} - Engine time it started at */
+        startTime: number;
+        /** @property {number|undefined} - The frame held by stop, undefined while running
+         *  @type {number|undefined} */
+        heldFrame: number | undefined;
+        /** Start over from the first frame and repeat forever
+         *  @return {SpriteAnimation} */
+        loop(): SpriteAnimation;
+        /** Start over from the first frame, run through once and hold the last frame
+         *  @return {SpriteAnimation} */
+        play(): SpriteAnimation;
+        /** Start over from the first frame and run there and back forever
+         *  @return {SpriteAnimation} */
+        pingPong(): SpriteAnimation;
+        /** Hold the current frame
+         *  @return {SpriteAnimation} */
+        stop(): SpriteAnimation;
+        /** Start over from the first frame in a mode
+         *  @param {string} [mode] - 'loop', 'once' or 'pingPong', the current mode when left out
+         *  @return {SpriteAnimation} */
+        restart(mode?: string): SpriteAnimation;
+        /** How many frames have gone by since the start, fractional
+         *  @return {number} */
+        get elapsedFrames(): number;
+        /** The frame showing now, 0 to frameCount-1
+         *  @return {number} */
+        get frame(): number;
+        /** The tile of the frame showing now
+         *  @return {TileInfo} */
+        get tileInfo(): TileInfo;
+        /** True once a play has shown its last frame for its time
+         *  @return {boolean} */
+        get isDone(): boolean;
+    }
+    /**
+     * Shader - A custom fragment shader for objects and draws, 2D or 3D
+     * - Write a mainImage function in the post processing style, the renderer wraps it with its own program
+     * - It gives the surface color, then the object's color and additive color apply in 2D, and the lighting,
+     *   shadows and fog in 3D; set emissive to 1 on a 3D object for the snippet's color to be final
+     * - Set it as obj.shader, or use setShader for 2D draws and render3D.shader for 3D draws
+     * - Draws that share a Shader share a batch; with no Shader set nothing changes
+     * - In 2D it shades textured draws, untextured ones like drawRect draw as they are
+     * - Compiled once per renderer by the first draw that needs it; a bad snippet throws with the GLSL log in debug
+     * - Make each Shader once, at init, and share it; every one made lives for the session with its programs
+     * - Names in both renderers: iChannel0 the texture, iTime, iResolution, and localUV, 0 to 1 across the sprite
+     *   or the mesh's own uv
+     * - Names in 3D only: worldPos, worldNormal, cameraPos, sunDirection, sunColor, ambientColor, lightCount,
+     *   lights[i], lightColors[i] and shadow()
+     * @example
+     * const fade = new Shader(`
+     * void mainImage(out vec4 c, vec2 uv)
+     * {
+     *     c = texture(iChannel0, uv);
+     *     c.a *= .5 + .5*sin(iTime);
+     * }`);
+     * obj.shader = fade;
+     * @memberof Draw
+     */
+    export class Shader {
+        /** Create a shader from a fragment snippet that defines void mainImage(out vec4 c, vec2 uv)
+         *  @param {string} fragmentCode */
+        constructor(fragmentCode: string);
+        /** @property {string} - The mainImage snippet */
+        fragmentCode: string;
+        /** @property {WebGLProgram|undefined} - The 2D program, compiled by the first draw that needs it, read only
+         *  @type {WebGLProgram|undefined} */
+        program: WebGLProgram | undefined;
+        /** @property {WebGLProgram|undefined} - The 3D program, compiled by the 3D plugin the same way, read only
+         *  @type {WebGLProgram|undefined} */
+        program3D: WebGLProgram | undefined;
+    }
     /**
      * LittleJS Drawing System
      * - Hybrid rendering with both Canvas2D and WebGL support
@@ -1805,6 +1979,9 @@ declare module "littlejsengine" {
      *  @memberof Draw */
     export let mainCanvas: HTMLCanvasElement;
     /** 2d context for mainCanvas
+     *  - Scaled by canvasPixelRatio, so drawing to it is in css pixels
+     *  - getImageData and putImageData ignore that scale and work in backing store
+     *    pixels, so use workReadCanvas to read pixels back instead of this
      *  @type {CanvasRenderingContext2D}
      *  @memberof Draw */
     export let mainContext: CanvasRenderingContext2D;
@@ -1833,7 +2010,9 @@ declare module "littlejsengine" {
      *  @type {HTMLCanvasElement}
      *  @memberof Draw */
     export let backgroundCanvas: HTMLCanvasElement;
-    /** The size of the main canvas (and other secondary canvases)
+    /** The size of the main canvas (and other secondary canvases) in css pixels
+     *  - This is the screen space coordinate system, matching mousePos
+     *  - With canvasPixelRatio set the backing store is larger than this
      *  @type {Vector2}
      *  @memberof Draw */
     export let mainCanvasSize: Vector2;
@@ -2066,6 +2245,11 @@ declare module "littlejsengine" {
      *  @param {boolean} [additive]
      *  @memberof Draw */
     export function setAdditiveBlendMode(additive?: boolean): void;
+    /** Set the Shader that 2D draws use from now on, none for the engine's own
+     *  - The object render loop sets each object's own shader, so this is for draws in gameRender and gameRenderPost
+     *  @param {Shader} [shader]
+     *  @memberof Draw */
+    export function setShader(shader?: Shader): void;
     /** Set an extra canvas to composite behind the engine canvases when combining
      *  Plugins that insert their own canvas below the LittleJS canvases should set
      *  this so it appears in screenshots and video capture
@@ -2528,16 +2712,31 @@ declare module "littlejsengine" {
      * - Speech synthesis for text-to-speech
      * - Music playback with ZzFXM support
      * - Web Audio API integration with master gain control
+     * - Sounds and the master bus can route through effects, see the audio effects plugin
      * @namespace Audio
      */
     /** Audio context used by the engine
      *  @type {AudioContext}
      *  @memberof Audio */
     export let audioContext: AudioContext;
-    /** Master gain node for all audio to pass through
+    /** Master gain node for all audio to pass through, made at load so effects can connect to it any time
      *  @type {GainNode}
      *  @memberof Audio */
     export let audioMasterGain: GainNode;
+    /** Anything with input and output audio nodes, like an effect from the audio effects plugin
+     *  @typedef {{input: AudioNode, output: AudioNode}} AudioEffectNodes
+     *  @memberof Audio */
+    /** Route all sound through an effect between the master gain and the speakers
+     *  - Pass a node or an effect, or the first and last of a chain, each a node or an effect
+     *  - With one argument a node is both ends, and an effect uses its own input and output
+     *  - The output node is disconnected from everything else first, so it only feeds the speakers
+     *  - The two ends of a chain must already be connected to each other, like effectA.connect(effectB)
+     *  - Call with no arguments to remove the effect, an effect that was the master goes back to feeding the master gain
+     *  - Debug video capture records the end of the master chain, but loses its tap if the effect changes mid-capture
+     *  @param {AudioNode|AudioEffectNodes} [input] - Node or effect the master gain connects to
+     *  @param {AudioNode|AudioEffectNodes} [output] - Node or effect that connects to the audio destination, defaults to the input's output
+     *  @memberof Audio */
+    export function setAudioMasterEffect(input?: AudioNode | AudioEffectNodes, output?: AudioNode | AudioEffectNodes): void;
     /** Default sample rate used for sounds
      *  @default 44100
      *  @memberof Audio */
@@ -2592,13 +2791,18 @@ declare module "littlejsengine" {
         /** @property {AudioBuffer} - Decoded audio shared by every play of this sound
          *  @type {AudioBuffer} */
         sampleBuffer: AudioBuffer;
-        /** @private @type {Array<Array<number>|Float32Array>} */
+        /** @private
+         *  @type {Array<Array<number>|Float32Array>} */
         private _sampleChannels;
         /** @property {number} - Percentage of this sound currently loaded, sounds
          *  fetched from a url stay at 0 until decoding completes */
         loadedPercent: number;
         /** @property {SoundLoadCallback} - function to call when sound is loaded */
         onloadCallback: (sound: Sound) => Sound;
+        /** @property {AudioNode|AudioEffectNodes} - Node or effect to route every play of this sound through instead of the master gain
+         *  - Where this sound's audio goes, unlike AudioEffect.output which is an effect's own node, effects chain with connect()
+         *  @type {AudioNode|AudioEffectNodes} */
+        output: AudioNode | AudioEffectNodes;
         /** @param {Array<Array<number>|Float32Array>} sampleChannels */
         set sampleChannels(arg: (number[] | Float32Array)[]);
         /** Sample data for each channel
@@ -2621,6 +2825,14 @@ declare module "littlejsengine" {
          *  @return {SoundInstance} - The sound instance, or undefined if sound is disabled, not loaded, or running in headless mode
          */
         play(pos?: Vector2, volume?: number, pitch?: number, randomnessScale?: number, loop?: boolean, paused?: boolean): SoundInstance;
+        /** Play the sound on a loop, the same as play with loop on; stop or change it through the SoundInstance returned
+         *  @param {Vector2} [pos] - World space position to play the sound if any
+         *  @param {number}  [volume] - How much to scale volume by
+         *  @param {number}  [pitch] - How much to scale pitch by
+         *  @param {number}  [randomnessScale] - How much to scale pitch randomness
+         *  @param {boolean} [paused] - Should the sound start paused
+         *  @return {SoundInstance} - The sound instance, or undefined if sound is disabled, not loaded, or running in headless mode */
+        playLoop(pos?: Vector2, volume?: number, pitch?: number, randomnessScale?: number, paused?: boolean): SoundInstance;
         /** Play a music track that loops by default
          *  @param {number} [volume] - Volume to play the music at
          *  @param {boolean} [loop] - Should the music loop?
@@ -2630,7 +2842,7 @@ declare module "littlejsengine" {
         playMusic(volume?: number, loop?: boolean, paused?: boolean): SoundInstance;
         /** Play the sound as a musical note with a semitone offset
          *  This can be used to play music with chromatic scales
-         *  @param {number}  [semitoneOffset=0] - How many semitones to offset pitch
+         *  @param {number}  [semitoneOffset] - How many semitones to offset pitch
          *  @param {Vector2} [pos] - World space position to play the sound if any
          *  @param {number}  [volume=1] - How much to scale volume by
          *  @return {SoundInstance} - The sound instance
@@ -2691,15 +2903,26 @@ declare module "littlejsengine" {
         gainNode: GainNode;
         /** @property {AudioBufferSourceNode} - Source node of the audio */
         source: AudioBufferSourceNode;
+        /** @property {AudioNode|AudioEffectNodes} - Node or effect to route this instance through, copied from the sound
+         *  @type {AudioNode|AudioEffectNodes} */
+        output: AudioNode | AudioEffectNodes;
         onendedCallback: (source: any) => void;
         /** Start playing the sound instance from the offset time
          *  @param {number} [offset] - Offset in seconds to start playback from
          */
         start(offset?: number): void;
-        /** Set the volume of this sound instance
-         *  @param {number} volume */
-        setVolume(volume: number): void;
-        /** Stop this sound instance and reset position to the start */
+        /** Set the volume of this sound instance, with an optional fade to it
+         *  - A fade ducks music under dialogue or cross fades two tracks without a click
+         *  @param {number} volume
+         *  @param {number} [fadeTime] - Seconds to fade to the new volume over */
+        setVolume(volume: number, fadeTime?: number): void;
+        /** Set the playback rate of this sound instance, its speed and pitch, while it plays
+         *  - A looping sound can follow something smoothly this way, like an engine with the speed
+         *  - A rate of 0 freezes the sound in place, its current time is not tracked until it moves again
+         *  @param {number} rate - 1 is normal, 2 is twice as fast and an octave up */
+        setRate(rate: number): void;
+        /** Stop this sound instance and reset position to the start
+         *  @param {number} [fadeTime] - Seconds to fade out over before stopping */
         stop(fadeTime?: number): void;
         /** Pause this sound instance */
         pause(): void;
@@ -2740,7 +2963,7 @@ declare module "littlejsengine" {
     export function speakStop(): void;
     /** Get frequency of a note on a musical scale
      *  @param {number} semitoneOffset - How many semitones away from the root note
-     *  @param {number} [rootFrequency=220] - Frequency at semitone offset 0
+     *  @param {number} [rootFrequency] - Frequency at semitone offset 0
      *  @return {number} - The frequency of the note
      *  @memberof Audio */
     export function getNoteFrequency(semitoneOffset: number, rootFrequency?: number): number;
@@ -2759,9 +2982,10 @@ declare module "littlejsengine" {
      *  @param {GainNode} [gainNode] - Optional gain node for volume control while playing (disconnected when the sound ends)
      *  @param {number}   [offset] - Offset in seconds to start playback from
      *  @param {AudioEndedCallback} [onended] - Callback for when the sound ends
+     *  @param {AudioNode|AudioEffectNodes} [output] - Node or effect to connect the gain to instead of the master gain
      *  @return {AudioBufferSourceNode} - The source node of the sound played, may be undefined if play fails
      *  @memberof Audio */
-    export function playSamples(sampleChannels: any[], volume?: number, rate?: number, pan?: number, loop?: boolean, sampleRate?: number, gainNode?: GainNode, offset?: number, onended?: AudioEndedCallback): AudioBufferSourceNode;
+    export function playSamples(sampleChannels: any[], volume?: number, rate?: number, pan?: number, loop?: boolean, sampleRate?: number, gainNode?: GainNode, offset?: number, onended?: AudioEndedCallback, output?: AudioNode | AudioEffectNodes): AudioBufferSourceNode;
     /** Play an audio buffer with given settings
      *  The buffer can be shared by any number of sounds playing at once
      *  @param {AudioBuffer} buffer - The audio buffer to play
@@ -2772,9 +2996,10 @@ declare module "littlejsengine" {
      *  @param {GainNode} [gainNode] - Optional gain node for volume control while playing (disconnected when the sound ends)
      *  @param {number}   [offset] - Offset in seconds to start playback from
      *  @param {AudioEndedCallback} [onended] - Callback for when the sound ends
+     *  @param {AudioNode|AudioEffectNodes} [output] - Node or effect to connect the gain to instead of the master gain
      *  @return {AudioBufferSourceNode} - The source node of the sound played, may be undefined if play fails
      *  @memberof Audio */
-    export function playAudioBuffer(buffer: AudioBuffer, volume?: number, rate?: number, pan?: number, loop?: boolean, gainNode?: GainNode, offset?: number, onended?: AudioEndedCallback): AudioBufferSourceNode;
+    export function playAudioBuffer(buffer: AudioBuffer, volume?: number, rate?: number, pan?: number, loop?: boolean, gainNode?: GainNode, offset?: number, onended?: AudioEndedCallback, output?: AudioNode | AudioEffectNodes): AudioBufferSourceNode;
     /** Copy arrays of samples into a new audio buffer
      *  @param {Array}  sampleChannels - Array of arrays of samples (for stereo playback)
      *  @param {number} [sampleRate=44100] - Sample rate for the sound
@@ -2873,6 +3098,9 @@ declare module "littlejsengine" {
         color: Color;
         /** @property {Color} - Additive color to apply when rendered */
         additiveColor: any;
+        /** @property {Shader|undefined} - Custom shader to render with, undefined for the engine's own
+         *  @type {Shader|undefined} */
+        shader: Shader | undefined;
         /** @property {boolean} - Should the rendered tile flip along the y axis. Affects rendering and the local→world transform of attached children (a mirrored parent flips its children's localPos.x and localAngle). Does not affect this object's own physics, collision, or localToWorld/worldToLocal. */
         mirror: boolean;
         /** @property {boolean} - Has object been destroyed? */
@@ -2917,6 +3145,9 @@ declare module "littlejsengine" {
         isSolid: boolean;
         /** @property {boolean} - Object collides with raycasts */
         collideRaycast: boolean;
+        /** @property {boolean} - Object is skipped by engineObjectsDestroy, for things that outlive a level like a camera
+         *  - Calling destroy on it still destroys it, and its children go with it either way */
+        persistent: boolean;
         /** Update the object transform, called automatically by engine even when paused */
         updateTransforms(): void;
         /** Update the object physics, called automatically by engine once each frame. Can be overridden to stop or change how physics works for an object. */
@@ -2949,9 +3180,10 @@ declare module "littlejsengine" {
         collideWithTile(tileData: number, pos: Vector2): boolean;
         /** Called by the engine to check if an object collision should be resolved. Return true for physics to resolve the collision or false to ignore and resolve it manually.
          *  @param {EngineObject} object - the object to test against
+         *  @param {Object} [push] - what it would take to move this object clear, a Vector3 from the 3D plugin, undefined in 2D
          *  @return {boolean} - true if the collision should be resolved by modifying it's position and velocity
          */
-        collideWithObject(object: EngineObject): boolean;
+        collideWithObject(object: EngineObject, push?: any): boolean;
         /** Get this object's up vector
          *  @param {number} [scale] - length of the vector
          *  @return {Vector2} */
@@ -3113,10 +3345,10 @@ declare module "littlejsengine" {
          *  @param {boolean}  [useWebGL] - Should this layer use WebGL for rendering
         */
         constructor(pos?: Vector2, size?: Vector2, angle?: number, renderOrder?: number, canvasSize?: Vector2, useWebGL?: boolean);
-        /** @property {HTMLCanvasElement} - The canvas used by this layer */
-        canvas: OffscreenCanvas;
         /** @property {OffscreenCanvasRenderingContext2D} - The 2D canvas context used by this layer */
         context: OffscreenCanvasRenderingContext2D;
+        /** @property {OffscreenCanvas} - The canvas used by this layer */
+        canvas: OffscreenCanvas;
         /** @property {TextureInfo} - Texture info to use for this object rendering */
         textureInfo: TextureInfo;
         /** Destroy this canvas layer */
@@ -3656,6 +3888,10 @@ declare module "littlejsengine" {
      * - Supports shadertoy style post processing shaders
      * - call new PostProcessPlugin() to setup post processing
      * - can be enabled to pass other canvases through a final shader
+     * - iResolution is the canvas backing store, so it grows with canvasPixelRatio
+     *   like shadertoy does. Effects that use it only for uv (p/iResolution.xy) are
+     *   unaffected, but ones that set a feature size from it, like scan lines, get
+     *   finer as the ratio rises. Divide by getCanvasPixelRatio() to pin them.
      * @namespace PostProcess
      */
     /** Global Post Process plugin object
@@ -3664,6 +3900,8 @@ declare module "littlejsengine" {
     export let postProcess: PostProcessPlugin;
     /**
      * Post Process Plugin - Applies a full screen shader to the rendered output
+     * - Create it after any plugin that draws, since plugins render in the order they are made
+     *   and this one shades what is on the canvas when its turn comes
      * @memberof PostProcess
      */
     export class PostProcessPlugin {
@@ -3676,13 +3914,38 @@ declare module "littlejsengine" {
         *  new PostProcessPlugin(shaderCode);
         */
         constructor(shaderCode: string, includeMainCanvas?: boolean, feedbackTexture?: boolean);
-        /** @property {WebGLProgram} - Shader for post processing */
-        shader: any;
-        /** @property {WebGLTexture} - Texture for post processing */
-        texture: any;
-        /** @property {WebGLVertexArrayObject} - Vertex array object */
-        vao: any;
+        /** @property {WebGLProgram|undefined} - Shader for post processing
+         *  @type {WebGLProgram|undefined} */
+        shader: WebGLProgram | undefined;
+        /** @property {WebGLTexture|undefined} - Texture for post processing
+         *  @type {WebGLTexture|undefined} */
+        texture: WebGLTexture | undefined;
+        /** @property {WebGLVertexArrayObject|undefined} - Vertex array object
+         *  @type {WebGLVertexArrayObject|undefined} */
+        vao: WebGLVertexArrayObject | undefined;
     }
+    /**
+     * Set up post processing with a bloom effect, so bright colors and lights glow
+     * @param {number} [threshold] - Brightness where the glow starts, 0 is everything and 1 is only pure white
+     * @param {number} [strength] - How much glow to add
+     * @param {number} [size] - How far the glow spreads in pixels
+     * @param {boolean} [includeMainCanvas] - Glow the 2D canvas too, off by default so HUD text stays crisp
+     * @return {PostProcessPlugin}
+     * @memberof PostProcess
+     * @example
+     * postProcessBloom(); // in gameInit, after any Render3DPlugin
+     */
+    export function postProcessBloom(threshold?: number, strength?: number, size?: number, includeMainCanvas?: boolean): PostProcessPlugin;
+    /**
+     * Shader code for a bloom effect, the bright parts of the image blurred back over it
+     * - Pass it to PostProcessPlugin, or edit the string to build an effect on top of it
+     * @param {number} [threshold] - Brightness where the glow starts, 0 is everything and 1 is only pure white
+     * @param {number} [strength] - How much glow to add
+     * @param {number} [size] - How far the glow spreads in pixels, which also sets how many samples it takes
+     * @return {string}
+     * @memberof PostProcess
+     */
+    export function postProcessBloomShader(threshold?: number, strength?: number, size?: number): string;
     /**
      * LittleJS Light System Plugin
      * - Adds 2D dynamic lighting to the scene
@@ -3713,7 +3976,7 @@ declare module "littlejsengine" {
      */
     export class LightSystemPlugin {
         /** Create the global light system plugin.
-         *  @param {Vector2} [textureSize]  - Size of the lightmap texture (defaults to mainCanvasSize)
+         *  @param {Vector2} [textureSize]  - Size of the lightmap texture (defaults to mainCanvasSize, which is css pixels, so the lightmap is not scaled by canvasPixelRatio; pass mainCanvasSize.scale(getCanvasPixelRatio()) for a full resolution lightmap)
          *  @param {Color}   [ambientColor] - Color applied to unlit areas of the scene (defaults to BLACK = pitch dark). Set a small RGB like rgb(0.1,0.1,0.15) for a faint "moonlight" baseline so unlit areas aren't fully black.
          *  @example
          *  // simplest usage
@@ -3724,7 +3987,7 @@ declare module "littlejsengine" {
         enabled: boolean;
         /** @property {Color} - Baseline color applied to unlit areas of the scene. Defaults to BLACK (pitch dark). Set to a small RGB for a faint ambient. The lightmap is cleared to this color each frame, then lights add on top, then the result multiplies the scene. */
         ambientColor: Color;
-        /** @property {Vector2} - Size of the lightmap texture (set at construction; falls back to mainCanvasSize at init time) */
+        /** @property {Vector2} - Size of the lightmap texture (set at construction; falls back to mainCanvasSize in css pixels at init time, so it is not scaled by canvasPixelRatio) */
         textureSize: Vector2;
         /** @property {WebGLTexture} - The lightmap texture */
         texture: any;
@@ -3774,7 +4037,7 @@ declare module "littlejsengine" {
      * @memberof ZzFXM
      * @example
      * // create some music
-     * const music_example = new Music(
+     * const music_example = new ZzFXMusic(
      * [
      *     [                         // instruments
      *       [,0,400]                // simple note
@@ -3795,21 +4058,14 @@ declare module "littlejsengine" {
      *     90            // BPM
      * ]);
      *
-     * // play the music
-     * music_example.play();
+     * // play the music on a loop
+     * music_example.playMusic();
      */
     export class ZzFXMusic extends Sound {
         /** Create a music object and cache the zzfx music samples for later use
          *  @param {[Array, Array, Array, number]} zzfxMusic - Array of zzfx music parameters
          */
         constructor(zzfxMusic: [any[], any[], any[], number]);
-        sampleChannels: any[];
-        /** Play the music that loops by default
-         *  @param {number}  [volume] - Volume to play the music at
-         *  @param {boolean} [loop] - Should the music loop?
-         *  @return {SoundInstance} - The sound instance
-         */
-        playMusic(volume?: number, loop?: boolean): SoundInstance;
     }
     /** Generate samples for a ZzFM song with given parameters
      *  @param {Array} instruments - Array of ZzFX sound parameters
@@ -3819,6 +4075,183 @@ declare module "littlejsengine" {
      *  @return {Array} - Left and right channel sample data
      *  @memberof ZzFXM */
     export function zzfxM(instruments: any[], patterns: any[], sequence: any[], BPM?: number): any[];
+    /**
+     * Base class for audio effects, an input and output with a wet/dry mix between them
+     * - Sounds connect to input, output goes to the master gain until connect() moves it
+     * - Subclasses put their nodes between input and the wet gain with connectEffect
+     * @memberof AudioEffects
+     * @example
+     * const cave = new AudioReverb(3, 2);
+     * footstep.output = cave; // every play of this sound is in the cave
+     */
+    export class AudioEffect {
+        /** Create an audio effect
+         *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
+        constructor(mix?: number);
+        /** @property {GainNode} - Connect sounds to this node */
+        input: GainNode;
+        /** @property {GainNode} - This node carries the mixed result, send it somewhere with connect(), never by assigning here
+         *  - Unlike sound.output, which is where a sound's audio goes and can be set to an effect */
+        output: GainNode;
+        /** @property {GainNode} - Level of the unprocessed signal */
+        dryGain: GainNode;
+        /** @property {GainNode} - Level of the processed signal */
+        wetGain: GainNode;
+        /** @property {number} - Wet/dry balance, 0 is fully dry and 1 is fully wet */
+        mix: number;
+        /** Set the wet/dry balance
+         *  @param {number} mix - 0 is fully dry and 1 is fully wet
+         *  @param {number} [fadeTime] - Seconds to ramp over so the change doesn't click */
+        setMix(mix: number, fadeTime?: number): void;
+        /** Ramp one of this effect's params, keeping the effect running until the ramp is done
+         *  - The browser drops an effect from rendering while nothing plays through it, which
+         *    would freeze a ramp partway, so a silent source feeds the input for the ramp's length
+         *  @param {AudioParam} param - The param to ramp
+         *  @param {number} value - Where to ramp to
+         *  @param {number} [fadeTime] - Seconds to ramp over, 0 sets the value at once
+         *  @protected */
+        protected rampParam(param: AudioParam, value: number, fadeTime?: number): void;
+        /** Send this effect's output into another effect or audio node instead of the speakers
+         *  @param {AudioEffect|AudioNode} target - The next effect in the chain, or any audio node
+         *  @return {AudioEffect|AudioNode} - The target, so chains read left to right */
+        connect(target: AudioEffect | AudioNode): AudioEffect | AudioNode;
+        /** Stop sending this effect's output anywhere */
+        disconnect(): void;
+        /** Wire nodes between the input and the wet gain, for subclasses
+         *  @param {AudioNode} first - Node the input connects to
+         *  @param {AudioNode} [last=first] - Node that connects to the wet gain
+         *  @protected */
+        protected connectEffect(first: AudioNode, last?: AudioNode): void;
+    }
+    /**
+     * Filter effect, muffle sounds underwater or behind a wall
+     * @extends AudioEffect
+     * @memberof AudioEffects
+     * @example
+     * const muffle = new AudioFilter('lowpass', 400);
+     * setAudioMasterEffect(muffle);
+     * muffle.setFrequency(20000, .5); // sweep back to clear
+     */
+    export class AudioFilter extends AudioEffect {
+        /** Create a filter effect
+         *  @param {BiquadFilterType} [type] - lowpass, highpass, bandpass, notch, etc.
+         *  @param {number} [frequency] - Cutoff or center frequency in Hz
+         *  @param {number} [q] - Resonance at the cutoff, higher is sharper
+         *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
+        constructor(type?: BiquadFilterType, frequency?: number, q?: number, mix?: number);
+        /** @property {BiquadFilterNode} - The filter node */
+        node: BiquadFilterNode;
+        /** Set the cutoff or center frequency
+         *  @param {number} frequency - Frequency in Hz
+         *  @param {number} [fadeTime] - Seconds to sweep over */
+        setFrequency(frequency: number, fadeTime?: number): void;
+        /** Set the resonance at the cutoff
+         *  @param {number} q - Higher is sharper
+         *  @param {number} [fadeTime] - Seconds to ramp over */
+        setQ(q: number, fadeTime?: number): void;
+    }
+    /**
+     * Reverb effect, puts sounds in a room, cave, or hall
+     * - The impulse response is generated, no audio file needed
+     * @extends AudioEffect
+     * @memberof AudioEffects
+     * @example
+     * const hall = new AudioReverb(4, 1.5, .4);
+     * footstep.output = hall;
+     */
+    export class AudioReverb extends AudioEffect {
+        /** Create a reverb effect
+         *  @param {number} [duration] - Seconds until the reverb tail is silent
+         *  @param {number} [decay] - How quickly the tail fades, higher is faster
+         *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
+        constructor(duration?: number, decay?: number, mix?: number);
+        /** @property {ConvolverNode} - The convolver node */
+        node: ConvolverNode;
+        /** Change the room by rebuilding the impulse response
+         *  @param {number} duration - Seconds until the reverb tail is silent
+         *  @param {number} [decay] - How quickly the tail fades, higher is faster */
+        setRoom(duration: number, decay?: number): void;
+        /** Build a stereo impulse response of decaying noise
+         *  @param {number} duration - Seconds until silence
+         *  @param {number} decay - How quickly it fades, higher is faster
+         *  @return {AudioBuffer} */
+        createImpulse(duration: number, decay: number): AudioBuffer;
+    }
+    /**
+     * Delay effect, echoes that repeat and fade
+     * @extends AudioEffect
+     * @memberof AudioEffects
+     * @example
+     * const canyon = new AudioDelay(.4, .5);
+     * shout.output = canyon;
+     */
+    export class AudioDelay extends AudioEffect {
+        /** Create a delay effect
+         *  @param {number} [time] - Seconds between echoes, up to 5
+         *  @param {number} [feedback] - How much of each echo repeats, 0 to .95
+         *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
+        constructor(time?: number, feedback?: number, mix?: number);
+        /** @property {DelayNode} - The delay node */
+        node: DelayNode;
+        /** @property {GainNode} - How much of the delayed signal feeds back in */
+        feedbackGain: GainNode;
+        /** Set the time between echoes
+         *  - Browsers hold a delay in a feedback loop to at least one render quantum, so 0 is not a bypass
+         *  @param {number} time - Seconds, up to 5
+         *  @param {number} [fadeTime] - Seconds to ramp over, pitch bends while it moves */
+        setTime(time: number, fadeTime?: number): void;
+        /** Set how much of each echo repeats, clamped below 1 so it always dies out
+         *  @param {number} feedback - 0 to .95
+         *  @param {number} [fadeTime] - Seconds to ramp over */
+        setFeedback(feedback: number, fadeTime?: number): void;
+    }
+    /**
+     * Distortion effect, overdrive for radios, damaged robots, and engines
+     * @extends AudioEffect
+     * @memberof AudioEffects
+     * @example
+     * const radio = new AudioDistortion(.8);
+     * voice.output = radio;
+     */
+    export class AudioDistortion extends AudioEffect {
+        /** Create a distortion effect
+         *  @param {number} [amount] - How hard to drive the signal, 0 is clean and 1 is crushed
+         *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
+        constructor(amount?: number, mix?: number);
+        /** @property {WaveShaperNode} - The wave shaper node */
+        node: WaveShaperNode;
+        /** @property {number} - How hard the signal is driven, 0 is clean and 1 is crushed */
+        amount: number;
+        /** Set how hard to drive the signal, rebuilds the shaping curve
+         *  @param {number} amount - 0 is clean and 1 is crushed */
+        setAmount(amount: number): void;
+    }
+    /**
+     * Compressor effect, evens out loud and quiet so many sounds at once don't clip
+     * - Meant for the master bus, it is not on by default
+     * @extends AudioEffect
+     * @memberof AudioEffects
+     * @example
+     * const compressor = new AudioCompressor;
+     * setAudioMasterEffect(compressor);
+     */
+    export class AudioCompressor extends AudioEffect {
+        /** Create a compressor effect
+         *  @param {number} [threshold] - Level in dB above which the signal is reduced
+         *  @param {number} [ratio] - How much to reduce it, 12 means 12 dB in becomes 1 dB out
+         *  @param {number} [mix] - Wet/dry balance, 0 is fully dry and 1 is fully wet */
+        constructor(threshold?: number, ratio?: number, mix?: number);
+        /** @property {DynamicsCompressorNode} - The compressor node */
+        node: DynamicsCompressorNode;
+        /** Set the level above which the signal is reduced
+         *  @param {number} threshold - Level in dB
+         *  @param {number} [fadeTime] - Seconds to ramp over */
+        setThreshold(threshold: number, fadeTime?: number): void;
+        /** Set how much the signal is reduced above the threshold
+         *  @param {number} ratio - 1 is no reduction, 20 is a hard limit
+         *  @param {number} [fadeTime] - Seconds to ramp over */
+        setRatio(ratio: number, fadeTime?: number): void;
+    }
     /**
      * LittleJS User Interface Plugin
      * - call new UISystemPlugin() to setup the UI system
@@ -5465,7 +5898,7 @@ declare module "littlejsengine" {
          *  any object exposing a `lerp(other, percent) => sameType` method. The
          *  callback receives the interpolated value (a number, or a fresh instance
          *  for lerp-able types). Both endpoints must be the same type.
-         *  @param {function(number|Vector2|Color):void} callback - Called with the interpolated value each frame
+         *  @param {function((number|Vector2|Color)):void} callback - Called with the interpolated value each frame
          *  @param {number|Vector2|Color} [start=0] - Starting value
          *  @param {number|Vector2|Color} [end=1] - Ending value
          *  @param {number} [duration=1] - Duration in seconds
@@ -5473,13 +5906,13 @@ declare module "littlejsengine" {
          *  @param {function(number):number} [options.ease] - Easing function (defaults to LINEAR)
          *  @param {boolean} [options.useRealTime=false] - Advance even when the game is paused (matches Timer's useRealTime)
          *  @param {boolean} [options.paused=false] - Start in paused state */
-        constructor(callback: (arg0: number | Vector2 | Color) => void, start?: number | Vector2 | Color, end?: number | Vector2 | Color, duration?: number, options?: {
+        constructor(callback: (arg0: (number | Vector2 | Color)) => void, start?: number | Vector2 | Color, end?: number | Vector2 | Color, duration?: number, options?: {
             ease?: (arg0: number) => number;
             useRealTime?: boolean;
             paused?: boolean;
         });
-        /** @property {function(number|Vector2|Color):void} - Called with the interpolated value each frame */
-        callback: (arg0: number | Vector2 | Color) => void;
+        /** @property {function((number|Vector2|Color)):void} - Called with the interpolated value each frame */
+        callback: (arg0: (number | Vector2 | Color)) => void;
         /** @property {number|Vector2|Color} - Starting value */
         start: number | Vector2 | Color;
         /** @property {number|Vector2|Color} - Ending value */
@@ -5494,9 +5927,11 @@ declare module "littlejsengine" {
         useRealTime: boolean;
         /** @property {boolean} - If true, stop advancing until cleared */
         paused: boolean;
-        /** @private completion callback set by then(), loop(), pingPong(). */
+        /** Completion callback set by then(), loop(), pingPong().
+         *  @private */
         private thenCallback;
-        /** @private remaining iterations including the current run (loop/pingPong only). */
+        /** Remaining iterations including the current run (loop/pingPong only).
+         *  @private */
         private loopRemaining;
         /** Set the easing curve and return this for chaining.
          *  @param {function(number):number} easeFn
@@ -5798,6 +6233,1622 @@ declare module "littlejsengine" {
         /** True if walkable and not blocked by cost. */
         isClear(): boolean;
     }
+    /**
+     * LittleJS 3D Math Plugin
+     * - Vector3 and Matrix4 for 3D games and plugins
+     * - Right handed, Y up, angles in radians
+     * - Used by the Render3D plugin, but has no rendering dependencies
+     * @namespace Math3D
+     */
+    /**
+     * Create a 3D vector, can take 0, 1, 2 or 3 numbers
+     * - vec3() is zero, vec3(s) fills all three, vec3(x, y) sets z to 0
+     * @param {number} [x]
+     * @param {number} [y]
+     * @param {number} [z]
+     * @return {Vector3}
+     * @memberof Math3D
+     */
+    export function vec3(x?: number, y?: number, z?: number): Vector3;
+    /**
+     * Check if the object is a valid Vector3
+     * @param {any} v
+     * @return {boolean}
+     * @memberof Math3D
+     */
+    export function isVector3(v: any): boolean;
+    /**
+     * Returns a random Vector3 of a given length, pointing any direction evenly, or within a cone around +Y
+     * @param {number} [length]
+     * @param {number} [coneAngle] - Half angle of the cone around +Y in radians, PI is every direction
+     * @return {Vector3}
+     * @memberof Math3D
+     */
+    export function randVector3(length?: number, coneAngle?: number): Vector3;
+    /**
+     * Returns a random Vector3 inside a sphere, spread evenly through its volume, the 3D twin of randInCircle
+     * @param {number} [radius]
+     * @param {number} [minRadius] - Leave a hollow middle this big
+     * @return {Vector3}
+     * @memberof Math3D
+     */
+    export function randInSphere(radius?: number, minRadius?: number): Vector3;
+    /**
+     * 3D Vector object, right handed with Y up
+     * - Methods return new vectors except set and setFrom
+     * @memberof Math3D
+     * @example
+     * const a = vec3(1, 2, 3);
+     * const b = a.add(vec3(0, 1, 0)).normalize();
+     */
+    export class Vector3 {
+        /** Create a 3D vector
+         *  @param {number} [x]
+         *  @param {number} [y]
+         *  @param {number} [z] */
+        constructor(x?: number, y?: number, z?: number);
+        /** @property {number} - X axis location */
+        x: number;
+        /** @property {number} - Y axis location */
+        y: number;
+        /** @property {number} - Z axis location */
+        z: number;
+        /** Sets values of this vector and returns self
+         *  @param {number} [x]
+         *  @param {number} [y]
+         *  @param {number} [z]
+         *  @return {Vector3} */
+        set(x?: number, y?: number, z?: number): Vector3;
+        /** Copies the values of another vector into this one and returns self
+         *  @param {Vector3} v
+         *  @return {Vector3} */
+        setFrom(v: Vector3): Vector3;
+        /** Returns a new vector that is a copy of this
+         *  @return {Vector3} */
+        copy(): Vector3;
+        /** Returns a copy of this vector plus the vector passed in
+         *  @param {Vector3} v
+         *  @return {Vector3} */
+        add(v: Vector3): Vector3;
+        /** Returns a copy of this vector minus the vector passed in
+         *  @param {Vector3} v
+         *  @return {Vector3} */
+        subtract(v: Vector3): Vector3;
+        /** Returns a copy of this vector times the vector passed in
+         *  @param {Vector3} v
+         *  @return {Vector3} */
+        multiply(v: Vector3): Vector3;
+        /** Returns a copy of this vector divided by the vector passed in
+         *  @param {Vector3} v
+         *  @return {Vector3} */
+        divide(v: Vector3): Vector3;
+        /** Returns a copy of this vector scaled by the number passed in
+         *  @param {number} s
+         *  @return {Vector3} */
+        scale(s: number): Vector3;
+        /** Returns the length of this vector
+         *  @return {number} */
+        length(): number;
+        /** Returns the length of this vector squared
+         *  @return {number} */
+        lengthSquared(): number;
+        /** Returns a copy of this vector reflected by a surface normal
+         *  @param {Vector3} normal - Surface normal, should be normalized
+         *  @param {number} [restitution] - How much to bounce, 1 is a perfect bounce, 0 slides along the surface
+         *  @return {Vector3} */
+        reflect(normal: Vector3, restitution?: number): Vector3;
+        /** Returns the distance from this vector to the vector passed in
+         *  @param {Vector3} v
+         *  @return {number} */
+        distance(v: Vector3): number;
+        /** Returns the distance squared from this vector to the vector passed in
+         *  @param {Vector3} v
+         *  @return {number} */
+        distanceSquared(v: Vector3): number;
+        /** Returns a new vector in the same direction with the length passed in, zero stays zero
+         *  @param {number} [length]
+         *  @return {Vector3} */
+        normalize(length?: number): Vector3;
+        /** Returns a new vector clamped to the length passed in
+         *  @param {number} [length]
+         *  @return {Vector3} */
+        clampLength(length?: number): Vector3;
+        /** Returns the dot product of this vector and the vector passed in
+         *  @param {Vector3} v
+         *  @return {number} */
+        dot(v: Vector3): number;
+        /** Returns a vector at right angles to both this and the one passed in
+         *  @param {Vector3} v
+         *  @return {Vector3} */
+        cross(v: Vector3): Vector3;
+        /** Returns a new vector interpolated between this and the vector passed in, percent is clamped to 0-1
+         *  @param {Vector3} v
+         *  @param {number} percent
+         *  @return {Vector3} */
+        lerp(v: Vector3, percent: number): Vector3;
+        /** Returns a new vector turned around an axis, counter clockwise when the axis points at you
+         *  @param {Vector3} axis - Unit length
+         *  @param {number} angle - Radians
+         *  @return {Vector3} */
+        rotate(axis: Vector3, angle: number): Vector3;
+        /** Returns a new vector turned around the X axis, the way a positive pitch in rotation3D turns things
+         *  @param {number} angle - Radians
+         *  @return {Vector3} */
+        rotateX(angle: number): Vector3;
+        /** Returns a new vector turned around the Y axis, the way a positive yaw in rotation3D turns things
+         *  @param {number} angle - Radians
+         *  @return {Vector3} */
+        rotateY(angle: number): Vector3;
+        /** Returns a new vector turned around the Z axis, the way a positive roll in rotation3D turns things
+         *  @param {number} angle - Radians
+         *  @return {Vector3} */
+        rotateZ(angle: number): Vector3;
+        /** Returns a new vector with the absolute value of each component
+         *  @return {Vector3} */
+        abs(): Vector3;
+        /** Returns a new vector with each component floored
+         *  @return {Vector3} */
+        floor(): Vector3;
+        /** Returns a new vector with each component rounded
+         *  @return {Vector3} */
+        round(): Vector3;
+        /** Returns a new vector snapped down to a grid, grid is the number of steps per unit like Vector2.snap
+         *  @param {number} grid - Snap steps per unit, 2 snaps to halves
+         *  @return {Vector3} */
+        snap(grid: number): Vector3;
+        /** Returns this point transformed by a matrix, translation included
+         *  @param {Matrix4} matrix
+         *  @return {Vector3} */
+        transform(matrix: Matrix4): Vector3;
+        /** Returns this direction transformed by a matrix, rotation and scale only
+         *  @param {Matrix4} matrix
+         *  @return {Vector3} */
+        transformDirection(matrix: Matrix4): Vector3;
+        /** Checks if this is a valid vector
+         *  @return {boolean} */
+        isValid(): boolean;
+        /** Returns a string representation of this vector for debugging
+         *  @param {number} [digits] - Number of digits to display
+         *  @return {string} */
+        toString(digits?: number): string;
+    }
+    /**
+     * 4x4 transform matrix for moving, rotating and scaling points in 3D
+     * - Static builders like Matrix4.translation return a new matrix
+     * - Methods on a matrix change it in place and return it, so calls can chain
+     * - a.multiply(b) means b happens first, then a
+     * - Stored the way WebGL wants it, so it can be sent to a shader as is
+     * @memberof Math3D
+     * @example
+     * const m = buildMatrix(vec3(0, 1, 0), vec3(0, PI/2, 0)); // rotate then move up
+     * const p = m.transformPoint(vec3(1, 0, 0));
+     */
+    export class Matrix4 {
+        /** Returns a new identity matrix
+         *  @return {Matrix4} */
+        static identity(): Matrix4;
+        /** Returns a new translation matrix
+         *  @param {Vector3} v
+         *  @return {Matrix4} */
+        static translation(v: Vector3): Matrix4;
+        /** Returns a new rotation matrix, rolled first, then pitched, then yawed
+         *  @param {Vector3} euler - vec3(pitch, yaw, roll) in radians
+         *  @return {Matrix4} */
+        static rotation(euler: Vector3): Matrix4;
+        /** Returns a new scale matrix
+         *  @param {Vector3} v
+         *  @return {Matrix4} */
+        static scaling(v: Vector3): Matrix4;
+        /** Returns a new perspective projection, camera looks down -Z
+         *  @param {number} fov - Vertical field of view in radians
+         *  @param {number} aspect - Width divided by height
+         *  @param {number} near - Closest visible distance
+         *  @param {number} far - Furthest visible distance, Infinity is allowed
+         *  @return {Matrix4} */
+        static perspective(fov: number, aspect: number, near: number, far: number): Matrix4;
+        /** Returns a new orthographic projection, camera looks down -Z
+         *  @param {number} left - Edge of the visible box
+         *  @param {number} right - Edge of the visible box
+         *  @param {number} bottom - Edge of the visible box
+         *  @param {number} top - Edge of the visible box
+         *  @param {number} near - Closest visible distance
+         *  @param {number} far - Furthest visible distance, Infinity is not allowed here
+         *  @return {Matrix4} */
+        static orthographic(left: number, right: number, bottom: number, top: number, near: number, far: number): Matrix4;
+        /** Returns the transform of something at eye turned to face target
+         *  - Invert it to get a view matrix for a camera there
+         *  @param {Vector3} eye
+         *  @param {Vector3} target
+         *  @param {Vector3} [up]
+         *  @return {Matrix4} */
+        static lookAt(eye: Vector3, target: Vector3, up?: Vector3): Matrix4;
+        /** Create a matrix, identity by default
+         *  @param {Float32Array|Array<number>} [m] - 16 column major values */
+        constructor(m?: Float32Array | Array<number>);
+        /** @property {Float32Array} - The 16 column major values */
+        m: Float32Array;
+        /** Returns a new matrix that is a copy of this
+         *  @return {Matrix4} */
+        copy(): Matrix4;
+        /** Multiply this matrix by another and return this, the other happens first
+         *  @param {Matrix4} matrix
+         *  @return {Matrix4} */
+        multiply(matrix: Matrix4): Matrix4;
+        /** Append a translation, returns self
+         *  @param {Vector3} v
+         *  @return {Matrix4} */
+        translate(v: Vector3): Matrix4;
+        /** Append a rotation, returns self
+         *  @param {Vector3} euler - vec3(pitch, yaw, roll) in radians
+         *  @return {Matrix4} */
+        rotate(euler: Vector3): Matrix4;
+        /** Append a scale, returns self
+         *  @param {Vector3} v
+         *  @return {Matrix4} */
+        scale(v: Vector3): Matrix4;
+        /** Transpose this matrix in place, returns self
+         *  @return {Matrix4} */
+        transpose(): Matrix4;
+        /** Flip this matrix so it undoes itself, returns this and does nothing if it cannot be inverted
+         *  @return {Matrix4} */
+        invert(): Matrix4;
+        /** Transform a point, translation included
+         *  @param {Vector3} v
+         *  @return {Vector3} */
+        transformPoint(v: Vector3): Vector3;
+        /** Transform a direction, rotation and scale only
+         *  @param {Vector3} v
+         *  @return {Vector3} */
+        transformDirection(v: Vector3): Vector3;
+        /** Returns the translation part of this matrix
+         *  @return {Vector3} */
+        getTranslation(): Vector3;
+        /** Returns a string representation of this matrix for debugging
+         *  @return {string} */
+        toString(): string;
+    }
+    /**
+     * Ray3D - A start point and a direction, what screenToRay returns and the raycast helpers take
+     * - The direction need not be unit length, the distances that come back are in units of it
+     * @memberof Math3D
+     * @example
+     * const ray = render3D.screenToRay(mousePosScreen);
+     * const distance = raycastPlane(ray, vec3(), vec3(0, 1, 0));
+     * if (distance !== undefined)
+     *     ball.pos3D = ray.getPosition(distance);
+     */
+    export class Ray3D {
+        /** Create a ray
+         *  @param {Vector3} [origin]
+         *  @param {Vector3} [direction] - Defaults to -Z, forward */
+        constructor(origin?: Vector3, direction?: Vector3);
+        /** @property {Vector3} - Where the ray starts */
+        origin: Vector3;
+        /** @property {Vector3} - Which way it goes */
+        direction: Vector3;
+        /** Returns the point a distance along the ray
+         *  @param {number} distance - What the raycast helpers return
+         *  @return {Vector3} */
+        getPosition(distance: number): Vector3;
+        /** Returns a new ray that is a copy of this
+         *  @return {Ray3D} */
+        copy(): Ray3D;
+    }
+    /**
+     * Build a transform for an object from its position, rotation and scale
+     * - A point is scaled first, then rotated, then moved, which is what you want for a game object
+     * @param {Vector3} [pos]
+     * @param {Vector3} [rotation] - vec3(pitch, yaw, roll) in radians
+     * @param {Vector3} [scale]
+     * @return {Matrix4}
+     * @memberof Math3D
+     */
+    export function buildMatrix(pos?: Vector3, rotation?: Vector3, scale?: Vector3): Matrix4;
+    /**
+     * Check if a point is inside an axis aligned box, boundary is inclusive
+     * @param {Vector3} point
+     * @param {Vector3} pos - Center of the box
+     * @param {Vector3} size - Full size of the box
+     * @return {boolean}
+     * @memberof Math3D
+     */
+    export function isPointInBox3D(point: Vector3, pos: Vector3, size: Vector3): boolean;
+    /**
+     * Check if two axis aligned boxes are overlapping, touching edges do not overlap
+     * @param {Vector3} posA
+     * @param {Vector3} sizeA - Full size of box A
+     * @param {Vector3} posB
+     * @param {Vector3} [sizeB] - Full size of box B, zero for a point
+     * @return {boolean}
+     * @memberof Math3D
+     */
+    export function isOverlapping3D(posA: Vector3, sizeA: Vector3, posB: Vector3, sizeB?: Vector3): boolean;
+    /**
+     * Returns the vector to move sphere A by so it no longer overlaps sphere B, or undefined
+     * @param {Vector3} posA
+     * @param {number} radiusA
+     * @param {Vector3} posB
+     * @param {number} radiusB
+     * @return {Vector3|undefined}
+     * @memberof Math3D
+     */
+    export function collideSphereSphere(posA: Vector3, radiusA: number, posB: Vector3, radiusB: number): Vector3 | undefined;
+    /**
+     * Returns the vector to move a sphere out of an axis aligned box, or undefined
+     * @param {Vector3} pos - Sphere center
+     * @param {number} radius
+     * @param {Vector3} boxPos
+     * @param {Vector3} boxSize - Full size of the box
+     * @return {Vector3|undefined}
+     * @memberof Math3D
+     */
+    export function collideSphereBox(pos: Vector3, radius: number, boxPos: Vector3, boxSize: Vector3): Vector3 | undefined;
+    /**
+     * Returns the vector to move a sphere back inside an axis aligned box, or undefined when it is all inside
+     * - The inside out twin of collideSphereBox, for keeping things in a room or an arena
+     * - A sphere too big for the box on some axis is held at the middle of it on that axis
+     * @param {Vector3} pos - Sphere center
+     * @param {number} radius
+     * @param {Vector3} boxPos
+     * @param {Vector3} boxSize - Full size of the box
+     * @return {Vector3|undefined}
+     * @memberof Math3D
+     */
+    export function collideSphereInBox(pos: Vector3, radius: number, boxPos: Vector3, boxSize: Vector3): Vector3 | undefined;
+    /**
+     * Returns the vector to move a sphere out of a vertical cylinder, or undefined
+     * @param {Vector3} pos - Sphere center
+     * @param {number} radius
+     * @param {Vector3} cylinderPos
+     * @param {number} cylinderRadius
+     * @param {number} cylinderHeight - Full height along Y
+     * @return {Vector3|undefined}
+     * @memberof Math3D
+     */
+    export function collideSphereCylinder(pos: Vector3, radius: number, cylinderPos: Vector3, cylinderRadius: number, cylinderHeight: number): Vector3 | undefined;
+    /**
+     * Returns the vector to move box A by so it no longer overlaps box B, the shortest way out, or undefined
+     * - The 3D twin of collideBoxBox
+     * @param {Vector3} posA
+     * @param {Vector3} sizeA - Full size of box A
+     * @param {Vector3} posB
+     * @param {Vector3} sizeB - Full size of box B
+     * @return {Vector3|undefined}
+     * @memberof Math3D
+     */
+    export function collideBoxBox3D(posA: Vector3, sizeA: Vector3, posB: Vector3, sizeB: Vector3): Vector3 | undefined;
+    /**
+     * Returns the distance along the ray to the first intersection with a sphere, or undefined
+     * - The hit is ray.getPosition(distance), a direction that is not unit length scales the distance
+     * - A ray starting inside the sphere is already there, so it gets back 0
+     * @param {Ray3D} ray
+     * @param {Vector3} pos - Sphere center
+     * @param {number} radius
+     * @return {number|undefined}
+     * @memberof Math3D
+     */
+    export function raycastSphere(ray: Ray3D, pos: Vector3, radius: number): number | undefined;
+    /**
+     * Returns the distance along the ray to a plane, or undefined if parallel or behind
+     * - The hit is ray.getPosition(distance), a direction that is not unit length scales the distance
+     * @param {Ray3D} ray
+     * @param {Vector3} planePos
+     * @param {Vector3} planeNormal
+     * @return {number|undefined}
+     * @memberof Math3D
+     */
+    export function raycastPlane(ray: Ray3D, planePos: Vector3, planeNormal: Vector3): number | undefined;
+    /**
+     * Returns the distance along the ray to the first intersection with an axis aligned box, or undefined
+     * - The hit is ray.getPosition(distance), a direction that is not unit length scales the distance
+     * - A ray starting inside the box is already there, so it gets back 0
+     * @param {Ray3D} ray
+     * @param {Vector3} pos - Center of the box
+     * @param {Vector3} size - Full size of the box
+     * @return {number|undefined}
+     * @memberof Math3D
+     */
+    export function raycastBox(ray: Ray3D, pos: Vector3, size: Vector3): number | undefined;
+    /**
+     * LittleJS 3D Rendering Plugin
+     * - Adds a 3D scene that draws into the same WebGL canvas as the 2D game
+     * - Call new Render3DPlugin() in gameInit, then move render3D.camera and make EngineObject3D objects
+     * - EngineObject3D is an EngineObject with a 3D position, rotation and mesh
+     * - The 3D scene draws under the 2D sprites, so HUD and text land on top
+     * - Lighting is the sun plus ambient, with optional extra lights, fog and shadows
+     * - Any object or draw can bring its own Shader, a mainImage snippet the lighting then applies to
+     * - Build shapes with buildBox, buildSphere and friends, or load a model with loadOBJ
+     * - Requires the Math3D plugin
+     * @namespace Render3D
+     */
+    /** Global Render3D plugin object
+     *  @type {Render3DPlugin}
+     *  @memberof Render3D */
+    export let render3D: Render3DPlugin;
+    /**
+     * Render3D Plugin - The 3D renderer, camera, lights, shadows and fog
+     * - There is one of these, in the global render3D
+     * - It draws the 3D scene before gameRender, so 2D drawing lands on top
+     * - Set renderAfter2D to draw the 3D scene over the 2D scene instead
+     * - Settings like lighting and specular are read as each thing draws
+     * - Every object sets them from its own flags, so you rarely touch them
+     * @memberof Render3D
+     * @example
+     * new Render3DPlugin;
+     * render3D.camera.pos = vec3(0, 5, 10);
+     * render3D.camera.lookAt(vec3());
+     * new EngineObject3D(vec3(), buildBox());
+     */
+    export class Render3DPlugin {
+        /** @property {Camera3D} - The camera */
+        camera: Camera3D;
+        /** @property {Vector3} - Direction toward the sun, where its light comes from, like a directional Light3D;
+         *  read at each draw, and any length will do, the shading and the shadows normalize it themselves;
+         *  the sun is the one light that casts shadows and makes specular highlights */
+        sunDirection: Vector3;
+        /** @property {Color} - Sunlight color */
+        sunColor: Color;
+        /** @property {Color} - Ambient light color */
+        ambientColor: Color;
+        /** @property {Color|undefined} - Fog color, uses canvasClearColor when undefined
+         *  @type {Color|undefined} */
+        fogColor: Color | undefined;
+        /** @property {number} - Distance from the camera where fog starts */
+        fogStart: number;
+        /** @property {number} - Distance from the camera where fog is total, 0 disables fog */
+        fogEnd: number;
+        /** @property {Vector3} - Added to the velocity3D of every object with a mass each frame, scaled by its gravityScale; sync2D objects use the 2D gravity */
+        gravity: Vector3;
+        /** @property {number|HeightMap|Function} - Floor for objects with a softShadow: a height, a HeightMap, or (x, z) => y
+         *  @type {number|HeightMap|Function} */
+        softShadowHeight: number | HeightMap | Function;
+        /** @property {boolean} - Default for every builder's smooth argument: true for smooth vertex normals, false for flat faces */
+        smoothShading: boolean;
+        /** @property {boolean} - Cast real shadows from the sun, off by default and free when off */
+        shadows: boolean;
+        /** @property {number} - Size of the shadow map in pixels, bigger is sharper and slower */
+        shadowMapSize: number;
+        /** @property {number} - World size the shadow map covers around shadowCenter, smaller is sharper; it is a square
+         *  facing the light, so it turns as the light does, and about 1.5 times an area's width covers it from any angle */
+        shadowRange: number;
+        /** @property {Vector3|undefined} - Center of the shadowed area, read each frame, undefined follows the camera
+         *  @type {Vector3|undefined} */
+        shadowCenter: Vector3 | undefined;
+        /** @property {number} - Stops surfaces shadowing themselves, raise for speckles, lower if shadows drift off */
+        shadowBias: number;
+        /** @property {number} - How much to blur the shadow edges */
+        shadowSoftness: number;
+        /** @property {boolean} - Apply lighting, when false draws plain vertex color times texture and casts no shadow;
+         *  off for billboards, lines, ribbons and soft discs, an object sets emissive instead */
+        lighting: boolean;
+        /** @property {number} - How much a surface lights itself, set per object by its emissive */
+        emissive: number;
+        /** @property {boolean} - Additive blending instead of alpha, in the transparent stage */
+        additive: boolean;
+        /** @property {boolean} - Test against the depth buffer, reset to true before each object and callback */
+        depthTest: boolean;
+        /** @property {boolean} - Write to the depth buffer, owned by the stages: on for opaque, off for transparent */
+        depthWrite: boolean;
+        cullBackFaces: boolean;
+        mirrored: boolean;
+        /** @property {number} - Strength of the highlight where the sunlight reflects, 0 is none and 1 adds the sun's full color at its brightest; its size is fixed */
+        specular: number;
+        /** @property {Shader|undefined} - Custom Shader for the next draws, set from each object's shader; undefined draws with the plugin's own
+         *  @type {Shader|undefined} */
+        shader: Shader | undefined;
+        /** @property {boolean} - Darken by the shadow map when shadows are on, turn it off for things that should stay lit inside a shadow */
+        receiveShadow: boolean;
+        /** @property {Function|undefined} - Draw solid world here, it runs again for shadows so only draw in it
+         *  @type {Function|undefined} */
+        onRenderOpaque: Function | undefined;
+        /** @property {Function|undefined} - Draw see through things here, like glows, billboards and soft shadows
+         *  @type {Function|undefined} */
+        onRenderTransparent: Function | undefined;
+        /** @property {Mesh|undefined} - Sky dome from buildSky or setSky, drawn around the camera behind everything
+         *  @type {Mesh|undefined} */
+        sky: Mesh | undefined;
+        /** @property {boolean} - Draw the 3D scene on top of the 2D scene instead of under it */
+        renderAfter2D: boolean;
+        /** @property {boolean} - Draw see through things far to near so they blend correctly */
+        sortTransparent: boolean;
+        /** @property {boolean} - Skip meshes whose bounding sphere is outside the view */
+        frustumCulling: boolean;
+        /** @property {boolean} - Draw every use of a mesh in the opaque stage as one instanced call, mesh.instanced overrides it per mesh */
+        instancing: boolean;
+        /** @property {boolean} - Sample textures through mipmaps so they do not shimmer in the distance, false uses each texture's own filtering like 2D */
+        mipmaps: boolean;
+        /** @property {boolean} - Draw state: keep texture pixels hard edged, no mipmaps and no blending between them, set per object by pixelated */
+        pixelated: boolean;
+        /** @property {number} - Anisotropic filtering for textures seen at an angle, 1 to 16, 1 is off; needs mipmaps */
+        anisotropy: number;
+        /** @property {Mesh} - A box of size 1 that drawBox uses, for any object that is a box; set the object's scale3D
+         *  and color instead of editing the mesh, which would change every box that uses it */
+        boxMesh: Mesh;
+        /** @property {Mesh} - A smooth sphere of diameter 1 that drawSphere uses, shared the same way as boxMesh */
+        sphereMesh: Mesh;
+        /** @property {Mesh} - A flat square of size 1 facing +Y, seen from above only, for floors, water and decals;
+         *  stand it up with the object's rotation3D, and size it with scale3D */
+        planeMesh: Mesh;
+        /** @property {Mesh} - The same square seen and lit from both sides, for signs, cards and leaves */
+        planeMeshDoubleSided: Mesh;
+        /** @property {boolean} - True while the 3D pass is running, 3D draws are only valid then */
+        isRendering: boolean;
+        /** @property {boolean} - True while the shadow map is being drawn, draws go to the depth only shader */
+        shadowPass: boolean;
+        /** @property {Matrix4} - This frame's view matrix */
+        viewMatrix: Matrix4;
+        /** @property {Matrix4} - This frame's projection matrix */
+        projectionMatrix: Matrix4;
+        /** @property {Matrix4} - This frame's combined view projection */
+        viewProjection: Matrix4;
+        /** @property {Matrix4} - This frame's light view projection for the shadow map */
+        shadowMatrix: Matrix4;
+        /** @property {Vector3} - Camera right axis this frame */
+        cameraRight: Vector3;
+        /** @property {Vector3} - Camera up axis this frame */
+        cameraUp: Vector3;
+        /** @property {Vector3} - Camera forward axis this frame */
+        cameraForward: Vector3;
+        cameraBack: Vector3;
+        blend: boolean;
+        frustumPlanes: any[];
+        shadowPlanes: any[];
+        program: any;
+        currentProgram: any;
+        lightCount: number;
+        shadowShader: any;
+        vao: any;
+        whiteTexture: any;
+        samplers: any[];
+        samplerKey: any;
+        mipmapped: WeakSet<object>;
+        shadowTexture: any;
+        shadowFramebuffer: any;
+        shadowTextureSize: number;
+        contextGeneration: number;
+        uniforms: Map<any, any>;
+        uniformValues: {};
+        shadowMapDrawn: boolean;
+        passIsDefault: boolean;
+        lightPositions: Float32Array;
+        lightColors: Float32Array;
+        streamBuffer: any;
+        instanceBuffers: any[];
+        instanceBufferIndex: number;
+        instanceMeshes: any[];
+        attribValues: any[];
+        streamData: ArrayBuffer;
+        streamFloats: Float32Array;
+        streamInts: Uint32Array;
+        streamCount: number;
+        streamTileInfo: any;
+        streamState: any;
+        capture: Mesh;
+        transparentQueue: any[];
+        /** Rebuild the view and projection matrices from the camera, called automatically each frame
+         *  @param {number} [aspect] - Width over height, defaults to the main canvas */
+        updateMatrices(aspect?: number): void;
+        /** Where a world point lands on screen as -1 to 1 across and up, with z as depth
+         *  - Uses this frame's camera, call updateMatrices first if the camera just moved
+         *  @param {Vector3} pos
+         *  @return {Vector3|undefined} - undefined when behind the camera or closer than the near plane */
+        worldToClip(pos: Vector3): Vector3 | undefined;
+        /** Project a world point to screen space pixels, same space as mousePosScreen
+         *  - The opposite of screenToRay, and it takes the same canvas so the pair agree
+         *  @param {Vector3} pos
+         *  @param {Vector2} [canvasSize] - Defaults to the main canvas size, as in screenToRay;
+         *    the projection is whatever updateMatrices last built, which screenToRay does for its canvas
+         *  @return {Vector2|undefined} - undefined when behind the camera or closer than the near plane */
+        worldToScreen(pos: Vector3, canvasSize?: Vector2): Vector2 | undefined;
+        /** Get the world ray under a screen position, for clicking on things in 3D
+         *  - Uses the camera where it is right now, so it is fine to call from gameUpdate
+         *  - It brings the view matrices up to date for that canvas, so worldToScreen stays its exact opposite
+         *  @param {Vector2} screenPos - Same space as mousePosScreen
+         *  @param {Vector2} [canvasSize] - Defaults to the main canvas size
+         *  @return {Ray3D} - Starts at the camera with a unit direction, or on the camera plane when orthographic */
+        screenToRay(screenPos: Vector2, canvasSize?: Vector2): Ray3D;
+        /** Where a screen position lands on a flat ground plane, for top down games; use HeightMap.raycast for terrain
+         *  @param {Vector2} screenPos - Same space as mousePosScreen
+         *  @param {number} [groundHeight] - World height of the ground plane
+         *  @param {Vector2} [canvasSize] - Defaults to the main canvas size, as in screenToRay
+         *  @return {Vector3|undefined} - undefined when the ray misses the plane */
+        screenToGround(screenPos: Vector2, groundHeight?: number, canvasSize?: Vector2): Vector3 | undefined;
+        /** Find the nearest object under a screen position or along a ray, for clicking on things
+         *  - Each object is tested as a sphere around its mesh, or around a sprite's size3D, not triangle by triangle
+         *  - engineObjectsRaycast3D is the other half of this, every object along a ray instead of the nearest
+         *  @param {Vector2|Ray3D} from - A screen position like mousePosScreen, or a ray to look along
+         *  @param {Array<EngineObject>} [objects] - Defaults to every object; only those with a mesh or a sprite count
+         *  @return {{object: EngineObject3D, distance: number}|undefined} */
+        pick(from: Vector2 | Ray3D, objects?: Array<EngineObject>): {
+            object: EngineObject3D;
+            distance: number;
+        } | undefined;
+        /** Play a sound at a 3D position, quieter with distance from the camera and panned by its side, like Sound.play with a 2D position
+         *  @param {Sound} sound
+         *  @param {Vector3} pos3D
+         *  @param {number} [volume]
+         *  @param {number} [pitch]
+         *  @param {number} [randomnessScale] - How much to scale pitch randomness
+         *  @param {boolean} [loop]
+         *  @return {SoundInstance|undefined} - undefined when out of range or sound is off */
+        playSound(sound: Sound, pos3D: Vector3, volume?: number, pitch?: number, randomnessScale?: number, loop?: boolean): SoundInstance | undefined;
+        /** Play a sound on a loop at a 3D position, the same as playSound with loop on
+         *  - Its volume and pan are set when it starts, change or stop it through the SoundInstance returned
+         *  @param {Sound} sound
+         *  @param {Vector3} pos3D
+         *  @param {number} [volume]
+         *  @param {number} [pitch]
+         *  @param {number} [randomnessScale] - How much to scale pitch randomness
+         *  @return {SoundInstance|undefined} - undefined when out of range or sound is off */
+        playSoundLoop(sound: Sound, pos3D: Vector3, volume?: number, pitch?: number, randomnessScale?: number): SoundInstance | undefined;
+        /** Is any part of a sphere on screen this frame, the test that skips meshes the camera cannot see
+         *  - While the shadow map is drawing it tests the shadow area instead
+         *  @param {Vector3} center
+         *  @param {number} radius
+         *  @return {boolean} */
+        isSphereVisible(center: Vector3, radius: number): boolean;
+        /** Draw a mesh with the current draw state, batched with its other uses in the opaque stage when instancing is on
+         *  @param {Mesh} mesh
+         *  @param {Matrix4|Vector3} [matrix] - Object transform, or just a position to draw it at
+         *  @param {TileInfo|TextureInfo} [tileInfo] - Texture, mesh uvs map across the tile or the whole texture
+         *  @param {Color} [color] - Tint */
+        drawMesh(mesh: Mesh, matrix?: Matrix4 | Vector3, tileInfo?: TileInfo | TextureInfo, color?: Color): any;
+        /** Draw a triangle strip, batched into the stream with the current draw state
+         *  - Strip order: the first three points make a triangle, then each point makes another with the two before it
+         *  - List the first three points counter clockwise as seen from the front, or the face points away
+         *    and may vanish when back faces are culled
+         *  - inside a bake the strip goes into the mesh instead, in the transparent stage it is queued for sorting
+         *  @param {Array<Vector3>} points - In strip order
+         *  @param {Vector3|Array<Vector3>} [normals] - One for all or one per point, default up
+         *  @param {Vector2|Array<Vector2>} [uvs] - One for all or one per point, 0-1 across the tile
+         *  @param {Color|Array<Color>} [colors] - One for all or one per point, vertex colors come before the texture
+         *  @param {TileInfo|TextureInfo} [tileInfo] - Texture for this strip */
+        drawStrip(points: Array<Vector3>, normals?: Vector3 | Array<Vector3>, uvs?: Vector2 | Array<Vector2>, colors?: Color | Array<Color>, tileInfo?: TileInfo | TextureInfo): any;
+        /** Draw a strip with lighting off, for camera facing shapes where the light direction means nothing
+         *  @param {Array<Vector3>} points - Strip order
+         *  @param {Vector3|Array<Vector3>} [normals]
+         *  @param {Vector2|Array<Vector2>} [uvs]
+         *  @param {Color|Array<Color>} [colors]
+         *  @param {TileInfo|TextureInfo} [tileInfo] */
+        drawStripUnlit(points: Array<Vector3>, normals?: Vector3 | Array<Vector3>, uvs?: Vector2 | Array<Vector2>, colors?: Color | Array<Color>, tileInfo?: TileInfo | TextureInfo): void;
+        /** Draw the pending stream vertices as one strip with the state they were drawn under, called automatically when needed */
+        flush(): void;
+        /** Build a mesh once out of draw calls, instead of redrawing the shapes every frame
+         *  - Call the same drawStrip, drawQuad and drawBox calls inside, and get a mesh back
+         *  - Strips inside a bake ignore their tileInfo, the finished mesh picks the texture when it draws
+         *  - drawMesh, drawBox and drawSphere copy their mesh in, moved and tinted, their tileInfo dropped too
+         *  - The mesh skips its back faces like any, set doubleSided when what was drawn is open
+         *  @param {Function} drawFunction
+         *  @return {Mesh} */
+        bake(drawFunction: Function): Mesh;
+        /** Draw a layer's objects, solid ones first and see through ones after, called automatically
+         *  - The main layer also draws the sky, the render callbacks and the debug shapes
+         *  @param {Array<EngineObject3D>} objects
+         *  @param {boolean} [isDefault] */
+        renderStages(objects: Array<EngineObject3D>, isDefault?: boolean): void;
+        /** Queue a draw for the transparent stage, replayed far to near with the current draw state, or draw it now when sorting is off
+         *  @param {Vector3} pos - Where the draw is, for sorting
+         *  @param {Function} draw */
+        queueTransparent(pos: Vector3, draw: Function): any;
+        /** Draw the queued transparent draws far to near with the state each was drawn under, called automatically at the end of the transparent stage */
+        flushTransparentQueue(): void;
+        /** Draw render3D.sky around the camera, unlit, unfogged and behind everything, called automatically by the pass */
+        drawSky(): void;
+        /** Rebuild the light's view projection around the shadow center, called automatically each frame shadows are on */
+        updateShadowMatrix(): void;
+        /** Build a sky dome, set it as the sky and set the fog color to the horizon color
+         *  @param {Color} [topColor] - Straight up
+         *  @param {Color} [horizonColor] - Level with the camera
+         *  @param {Color} [bottomColor] - Straight down, defaults to the horizon color
+         *  @return {Mesh} - The dome, also in render3D.sky */
+        setSky(topColor?: Color, horizonColor?: Color, bottomColor?: Color): Mesh;
+        /** Set where fog starts and ends, and its color
+         *  @param {number} fogStart - Distance from the camera where fog starts
+         *  @param {number} fogEnd - Distance where fog is total, 0 disables fog
+         *  @param {Color} [fogColor] - Leaves the color alone when not passed, setSky sets it to the horizon */
+        setFog(fogStart: number, fogEnd: number, fogColor?: Color): void;
+        /** Draw a box, untextured, for blocking out a scene without meshes or objects
+         *  @param {Vector3} pos - Center
+         *  @param {Vector3|number} [size] - Full size, a number for a cube
+         *  @param {Color} [color]
+         *  @param {Vector3} [rotation] - vec3(pitch, yaw, roll) */
+        drawBox(pos: Vector3, size?: Vector3 | number, color?: Color, rotation?: Vector3): void;
+        /** Draw a sphere, untextured and smooth shaded
+         *  @param {Vector3} pos - Center
+         *  @param {number} [size] - Diameter
+         *  @param {Color} [color] */
+        drawSphere(pos: Vector3, size?: number, color?: Color): void;
+        /** Draw a flat square that always faces the camera, unlit so it keeps its own colors
+         *  - Draw it from onRenderTransparent or a transparent object so it can fade
+         *  @param {Vector3} pos - Center
+         *  @param {Vector2} [size] - World units
+         *  @param {TileInfo|TextureInfo} [tileInfo]
+         *  @param {Color} [color]
+         *  @param {number} [angle] - Rotation in the camera plane, counter clockwise
+         *  @param {boolean} [upright] - Stand on world up and only turn to face the camera, for sprites on the ground */
+        drawBillboard(pos: Vector3, size?: Vector2, tileInfo?: TileInfo | TextureInfo, color?: Color, angle?: number, upright?: boolean): any;
+        /** Draw a quad from four corners in loop order, counter clockwise seen from the front, a is the top left of the texture
+         *  @param {Vector3} a
+         *  @param {Vector3} b
+         *  @param {Vector3} c
+         *  @param {Vector3} d
+         *  @param {TileInfo|TextureInfo} [tileInfo]
+         *  @param {Color|Array<Color>} [color] - One for all or one per corner */
+        drawQuad(a: Vector3, b: Vector3, c: Vector3, d: Vector3, tileInfo?: TileInfo | TextureInfo, color?: Color | Array<Color>): void;
+        /** Draw a triangle, counter clockwise from outside is the front
+         *  @param {Vector3} a
+         *  @param {Vector3} b
+         *  @param {Vector3} c
+         *  @param {Color} [color] */
+        drawTriangle(a: Vector3, b: Vector3, c: Vector3, color?: Color): void;
+        /** Draw a line as a camera facing ribbon, unlit
+         *  @param {Vector3} posA
+         *  @param {Vector3} posB
+         *  @param {number} [width]
+         *  @param {Color} [color] */
+        drawLine(posA: Vector3, posB: Vector3, width?: number, color?: Color): void;
+        /** Draw a ribbon along a path, unlit and visible from both sides; width and color can change along it
+         *  - The texture runs along the length, u from the first point to the last
+         *  - A path that ends where it starts is a loop, and joins with no seam
+         *  @param {Array<Vector3>} points - Center line in order, at least two
+         *  @param {number|Array<number>} [width] - Full width, one for all or one per point
+         *  @param {TileInfo|TextureInfo} [tileInfo]
+         *  @param {Color|Array<Color>} [color] - One for all or one per point
+         *  @param {Vector3|Array<Vector3>} [side] - Direction across the ribbon, one for all or one per point, default faces the camera */
+        drawRibbon(points: Array<Vector3>, width?: number | Array<number>, tileInfo?: TileInfo | TextureInfo, color?: Color | Array<Color>, side?: Vector3 | Array<Vector3>): void;
+        /** Draw a disc that fades to transparent at the rim, unlit, for glows, puffs and sky dots
+         *  @param {Vector3} pos - Center
+         *  @param {number} [size] - Diameter
+         *  @param {Color} [color]
+         *  @param {Vector3} [normal] - Facing direction, faces the camera by default
+         *  @param {number} [sides] */
+        drawSoftDisc(pos: Vector3, size?: number, color?: Color, normal?: Vector3, sides?: number): any;
+        /** Draw a soft round shadow on the ground under something, much cheaper than a real shadow
+         *  - Draw it from onRenderTransparent or from a transparent object
+         *  @param {Vector3} pos - Position of the thing casting the shadow
+         *  @param {number} [size] - Diameter
+         *  @param {number|HeightMap|Function} [floorHeight] - Height of the ground, a HeightMap, or (x, z) => y to follow terrain
+         *  @param {Color} [color]
+         *  @param {number} [lift] - How far above the ground to draw, raise it if the shadow cuts into rough ground */
+        drawSoftShadow(pos: Vector3, size?: number, floorHeight?: number | HeightMap | Function, color?: Color, lift?: number): any;
+    }
+    /**
+     * Camera3D - Position, rotation and lens for the 3D view
+     * - Looks down its -Z axis, rotation is vec3(pitch, yaw, roll)
+     * @memberof Render3D
+     */
+    export class Camera3D {
+        /** @property {Vector3} - World position */
+        pos: Vector3;
+        /** @property {Vector3} - Euler rotation, vec3(pitch, yaw, roll) in radians */
+        rotation: Vector3;
+        /** @property {number} - Vertical field of view in radians */
+        fov: number;
+        /** @property {number} - Near clip distance */
+        near: number;
+        /** @property {number} - Far clip distance, Infinity is allowed for a perspective view */
+        far: number;
+        /** @property {number} - Visible height in world units for an orthographic view, 0 is perspective */
+        orthographic: number;
+        /** @property {boolean} - Line the 3D camera up with the 2D camera, so 3D things at z=0 sit on the 2D sprites */
+        align2D: boolean;
+        /** Returns the camera's world transform
+         *  @return {Matrix4} */
+        getMatrix(): Matrix4;
+        /** Returns the view matrix, world to camera space
+         *  @return {Matrix4} */
+        getViewMatrix(): Matrix4;
+        /** Returns the projection matrix
+         *  @param {number} aspect - Width over height
+         *  @return {Matrix4} */
+        getProjectionMatrix(aspect: number): Matrix4;
+        /** Returns the direction the camera looks
+         *  @return {Vector3} */
+        getForward(): Vector3;
+        /** Returns the camera's right axis
+         *  @return {Vector3} */
+        getRight(): Vector3;
+        /** Returns the camera's up axis
+         *  @return {Vector3} */
+        getUp(): Vector3;
+        /** Point the camera at a target, sets pitch and yaw and clears roll
+         *  @param {Vector3} target */
+        lookAt(target: Vector3): void;
+        /** Put the camera on an orbit around a target, looking at it
+         *  @param {Vector3} target
+         *  @param {number} distance
+         *  @param {number} yaw - Radians around Y
+         *  @param {number} [pitch] - Radians above the horizon */
+        orbit(target: Vector3, distance: number, yaw: number, pitch?: number): void;
+        /** Chase a target from an offset, easing toward it, and look at it
+         *  @param {Vector3} target
+         *  @param {Vector3} offset - Where to sit relative to the target
+         *  @param {number} [percent] - How far to move toward the spot each call, 1 snaps */
+        follow(target: Vector3, offset: Vector3, percent?: number): void;
+        /** Line the 3D camera up with the 2D camera, called automatically when align2D is set
+         *  @param {number} [canvasHeight] - Defaults to the main canvas height */
+        update2D(canvasHeight?: number): void;
+    }
+    /**
+     * EngineObject3D - An EngineObject with a 3D transform and a mesh
+     * - Set pos3D, rotation3D and scale3D instead of the 2D pos, size and angle
+     * - Gets update, children, timers, destroy and renderOrder from EngineObject
+     * - velocity3D is added to pos3D each frame, along with render3D.gravity and damping once it has a mass
+     * - Objects face -Z, the same way the camera does, so lookAt turns them to face a point
+     * - The 2D pos and velocity are still there but nothing draws them
+     * - These inherited fields are 2D only and do nothing here: angle, angleVelocity, angleDamping,
+     *   additiveColor, drawSize, mirror, clampSpeed, friction and groundObject
+     * - The inherited shader works here as in 2D, and with emissive at 1 its snippet does its own lighting
+     * - Set sync2D for a 2D game with 3D looks, pos and angle then drive pos3D and rotation3D,
+     *   which is the one way those 2D fields reach a 3D object
+     * - setCollision takes the same flags as in 2D, but the solid collision happens in 3D against size3D
+     * - Its tile and raycast halves are 2D only so they default off here, and a child sits solid collision out
+     * - A sync2D object collides in 2D instead, which needs the 2D size set as well as size3D
+     * - setMesh swaps the mesh and frees the old one, for text and terrain that get built again
+     * - addChild attaches the 3D transform, and pos3D becomes an offset from the parent
+     * - The 2D offset arguments of addChild do nothing here, set the child's pos3D
+     * @extends EngineObject
+     * @memberof Render3D
+     * @example
+     * class Spinner extends EngineObject3D
+     * {
+     *     constructor(pos) { super(pos, buildBox(), undefined, RED); }
+     *     update() { this.rotation3D.y += .02; }
+     * }
+     */
+    export class EngineObject3D extends EngineObject {
+        /** Create a 3D object and add it to the object list
+         *  @param {Vector3} [pos3D] - World space position
+         *  @param {Mesh} [mesh] - Mesh to draw, undefined draws nothing
+         *  @param {TileInfo|TextureInfo} [tileInfo] - Texture, mesh uvs map across the tile; a whole TextureInfo becomes the tile that covers it
+         *  @param {Color} [color] - Tint */
+        constructor(pos3D?: Vector3, mesh?: Mesh, tileInfo?: TileInfo | TextureInfo, color?: Color);
+        /** @property {Vector3} - World space position, local to the parent when attached to an EngineObject3D */
+        pos3D: Vector3;
+        /** @property {Vector3} - Rotation vec3(pitch, yaw, roll) in radians, local to the parent when attached to an EngineObject3D */
+        rotation3D: Vector3;
+        /** @property {Vector3} - Scale, local to the parent when attached to an EngineObject3D */
+        scale3D: Vector3;
+        /** @property {Vector3} - Added to pos3D each frame by the engine before update, like the 2D velocity, no super call needed;
+         *  damping and render3D.gravity act on it once the object has a mass */
+        velocity3D: Vector3;
+        /** @property {Vector3} - Added to rotation3D each frame by the engine before update, angleDamping is 2D only */
+        angleVelocity3D: Vector3;
+        /** @property {Mesh|undefined} - Mesh to draw
+         *  @type {Mesh|undefined} */
+        mesh: Mesh | undefined;
+        /** @property {Vector3} - Size for the collect and callback helpers, and of the sprite when there is a tileInfo
+         *  and no mesh; scale3D and any parent's scale grow it, so drawing and picking agree */
+        size3D: Vector3;
+        /** @property {number} - Diameter of a soft shadow drawn under the object on render3D.softShadowHeight, 0 for none;
+         *  scale3D and a parent's scale grow it, so set it once for the unscaled object */
+        softShadow: number;
+        /** @property {boolean} - A sprite stands on world up instead of tilting toward the camera */
+        upright: boolean;
+        /** @property {boolean} - Keep this object's texture pixels hard edged, for pixel art that should not blur or bleed */
+        pixelated: boolean;
+        /** @property {boolean} - Copy the 2D pos and angle into pos3D and rotation3D each frame, for 2D games with 3D looks;
+         *  set mass to use 2D physics, and pos3D.z stays yours to set or move with velocity3D.z */
+        sync2D: boolean;
+        /** @property {boolean} - Draw in the transparent stage, blended and sorted far to near with depth writes off; on for a sprite */
+        transparent: boolean;
+        /** @property {boolean} - Additive blending, in the transparent stage */
+        additive: boolean;
+        /** @property {number} - How much it lights itself: 0 is lit as normal, 1 is its own color with no shading, for
+         *  lamps and glowing things, between is partly self lit, and above 1 is brighter than its color, for bloom */
+        emissive: number;
+        /** @property {number} - Strength of the highlight where the sunlight reflects, 0 is none and 1 adds the sun's full color at its brightest; its size is fixed */
+        specular: number;
+        /** @property {boolean} - Draw into the shadow map when render3D.shadows is on; sprites and cut out textures cast their outline, additive objects never cast */
+        castShadow: boolean;
+        /** @property {boolean} - Collide as the sphere that fits size3D instead of as the size3D box, so it rolls around corners */
+        collideAsSphere3D: boolean;
+        /** @property {boolean} - Darkened by the shadow map when render3D.shadows is on */
+        receiveShadow: boolean;
+        /** @property {boolean|undefined} - Draw this object over the 2D scene, undefined uses render3D.renderAfter2D
+         *  @type {boolean|undefined} */
+        renderAfter2D: boolean | undefined;
+        /** Returns the world position
+         *  @return {Vector3} */
+        getWorldPos3D(): Vector3;
+        /** Returns the direction the object faces, its -Z axis in the world
+         *  @return {Vector3} */
+        getForward3D(): Vector3;
+        /** Returns the object's right axis in the world
+         *  @return {Vector3} */
+        getRight3D(): Vector3;
+        /** Returns the object's up axis in the world
+         *  @return {Vector3} */
+        getUp3D(): Vector3;
+        /** Returns the object's world transform, relative to the parent's when attached to an EngineObject3D
+         *  @return {Matrix4} */
+        getMatrix(): Matrix4;
+        /** Turn the object so its -Z axis points at a world space target, sets pitch and yaw and clears roll
+         *  @param {Vector3} target */
+        lookAt(target: Vector3): void;
+        /** Draw a different mesh and free the GPU buffer of the one it replaces
+         *  - For a mesh built again when something changes, like a score, a rebuilt terrain or a loaded model
+         *  - A mesh another object is still drawing is left alone, since builders are often shared
+         *  - Freeing one held somewhere else only costs it an upload, the points it was built from stay
+         *  @param {Mesh} [mesh] - The mesh to draw from now on, undefined to draw nothing
+         *  @return {Mesh|undefined} - The mesh passed in */
+        setMesh(mesh?: Mesh): Mesh | undefined;
+        /** Draw the object in 3D, called by the 3D pass with the draw state set from this object's flags, draws the mesh by default */
+        render3D(): void;
+    }
+    /**
+     * Mesh - A triangle strip with positions, normals, uvs and colors, uploaded once and drawn by matrix
+     * - Build with addStrip, addQuad, combine or the shape builders, then render each frame
+     * - Its back faces are skipped unless doubleSided is set, which the open builders like buildGrid do for you
+     * - The GPU buffer is created lazily on first render and dropped by dispose, or freed once the mesh is garbage
+     *   collected, so dispose is only needed to free it right away, like for a mesh rebuilt often
+     * @memberof Render3D
+     * @example
+     * const mesh = buildLathe([[0, -1], [1, 0], [0, 1]], 4); // octahedron
+     * mesh.render(buildMatrix(vec3(0, 1, 0)), undefined, RED);
+     */
+    export class Mesh {
+        /** @property {Array<Vector3>} - Vertex positions in strip order
+         *  @type {Array<Vector3>} */
+        points: Array<Vector3>;
+        /** @property {Array<Vector3>} - Vertex normals
+         *  @type {Array<Vector3>} */
+        normals: Array<Vector3>;
+        /** @property {Array<Vector2>} - Vertex texture coords, 0-1 across the tile
+         *  @type {Array<Vector2>} */
+        uvs: Array<Vector2>;
+        /** @property {Array<Color>} - Vertex colors
+         *  @type {Array<Color>} */
+        colors: Array<Color>;
+        /** @property {WebGLBuffer|undefined} - GPU buffer, created by upload
+         *  @type {WebGLBuffer|undefined} */
+        buffer: WebGLBuffer | undefined;
+        /** @property {number} - Vertices in the GPU buffer */
+        bufferCount: number;
+        /** @property {boolean} - The mesh changed and needs uploading again, set it yourself if you edit the arrays */
+        dirty: boolean;
+        /** @property {boolean|undefined} - Draw every use of this mesh in the opaque stage as one instanced call, undefined follows render3D.instancing
+         *  @type {boolean|undefined} */
+        instanced: boolean | undefined;
+        /** @property {boolean} - Draw both sides, each lit as the side that is seen; off skips the faces pointing away,
+         *  which is faster and right for closed shapes, the open builders like buildGrid and buildRibbon turn it on */
+        doubleSided: boolean;
+        instanceCount: number;
+        instanceData: any;
+        /** @property {number} - Bounding sphere radius around the origin, for culling and picking, computed by upload */
+        radius: number;
+        contextGeneration: number;
+        /** Number of vertices in the mesh
+         *  @return {number} */
+        get vertexCount(): number;
+        /** Add a triangle strip, joined to the previous one by invisible flat triangles so one mesh holds many strips
+         *  - Strip order: the first three points make a triangle, then each point makes another with the two before it
+         *  - List the first three points counter clockwise as seen from the front, or the face points away
+         *    and may vanish when back faces are culled
+         *  @param {Array<Vector3>} points - Strip order
+         *  @param {Vector3|Array<Vector3>} [normals] - One for all or one per point, default up
+         *  @param {Vector2|Array<Vector2>} [uvs] - One for all or one per point, default zero
+         *  @param {Color|Array<Color>} [colors] - One for all or one per point, default white
+         *  @return {Mesh} */
+        addStrip(points: Array<Vector3>, normals?: Vector3 | Array<Vector3>, uvs?: Vector2 | Array<Vector2>, colors?: Color | Array<Color>): Mesh;
+        /** Add a flat quad from four corners in loop order, counter clockwise seen from the front, a is the top left of the texture
+         *  @param {Vector3} a
+         *  @param {Vector3} b
+         *  @param {Vector3} c
+         *  @param {Vector3} d
+         *  @param {Color|Array<Color>} [color] - One for all or one per corner
+         *  @param {Array<Vector2>} [uvs] - One per corner, default across the tile
+         *  @return {Mesh} */
+        addQuad(a: Vector3, b: Vector3, c: Vector3, d: Vector3, color?: Color | Array<Color>, uvs?: Array<Vector2>): Mesh;
+        /** Append another mesh transformed by a matrix, for building one shape out of several
+         *  @param {Mesh} mesh
+         *  @param {Matrix4|Vector3} [matrix] - Transform, or just a position to move it to
+         *  @param {Color} [color] - Multiplies the appended vertex colors
+         *  @return {Mesh} */
+        combine(mesh: Mesh, matrix?: Matrix4 | Vector3, color?: Color): Mesh;
+        /** Scale every uv, so a whole texture repeats across the mesh when its TextureInfo wraps
+         *  @param {Vector2|number} scale - Repeats across and up, a number for both
+         *  @return {Mesh} */
+        scaleUVs(scale: Vector2 | number): Mesh;
+        /** Move, turn or scale every vertex in place, normals follow along
+         *  @param {Matrix4|Vector3} matrix - Transform, or just an offset to move by
+         *  @return {Mesh} */
+        transform(matrix: Matrix4 | Vector3): Mesh;
+        /** Turn the mesh inside out so it is lit and drawn from within, for rooms and domes
+         *  @return {Mesh} */
+        flipNormals(): Mesh;
+        /** Set every vertex color
+         *  @param {Color} color
+         *  @return {Mesh} */
+        setColor(color: Color): Mesh;
+        /** Measure the axis aligned box around the vertices
+         *  @return {{min: Vector3, max: Vector3}} */
+        getBounds(): {
+            min: Vector3;
+            max: Vector3;
+        };
+        /** Move the mesh so the center of its bounds is on the origin
+         *  @return {Mesh} */
+        center(): Mesh;
+        /** Scale the mesh evenly so its largest extent is a size, for loaded models of unknown units
+         *  @param {number} [size]
+         *  @return {Mesh} */
+        fit(size?: number): Mesh;
+        /** Measure the bounding sphere around the origin into radius, called by upload
+         *  @return {number} */
+        computeRadius(): number;
+        /** Derive normals from the strip's triangles
+         *  @param {boolean} [smooth] - Round the lighting across faces instead of giving each face a hard edge
+         *  @return {Mesh} */
+        computeNormals(smooth?: boolean): Mesh;
+        /** Pack the vertices and create the GPU buffer, called automatically by render
+         *  @return {Mesh} */
+        upload(): Mesh;
+        /** Draw the mesh with the current draw state, batched with its other uses in the opaque stage
+         *  @param {Matrix4|Vector3} [matrix] - Object transform, or just a position to draw it at
+         *  @param {TileInfo|TextureInfo} [tileInfo] - Texture, mesh uvs map across the tile or the whole texture
+         *  @param {Color} [color] - Tint */
+        render(matrix?: Matrix4 | Vector3, tileInfo?: TileInfo | TextureInfo, color?: Color): void;
+        /** Delete the GPU buffer now, the CPU arrays stay so the mesh can be rendered again
+         *  - Optional, the buffer is freed anyway once the mesh is garbage collected, this frees it right away */
+        dispose(): void;
+    }
+    /**
+     * Spin a flat outline around the Y axis to make a round shape, like a vase or a wheel
+     * - profile is [[radius, y], ...] from bottom to top
+     * - A profile that ends where it starts makes a closed ring like a donut
+     * - An end left open, with a radius and no cap, makes the mesh doubleSided so its inside shows
+     * @param {Array<Array<number>>} profile
+     * @param {number} [sides] - Around the axis
+     * @param {boolean} [smooth] - Defaults to render3D.smoothShading
+     * @param {boolean} [capped] - Close the ends that have a radius with flat discs
+     * @return {Mesh}
+     * @memberof Render3D
+     * @example
+     * const vase = buildLathe([[0, -1], [.8, -.3], [.9, .2], [.4, .6], [0, 1]], 12);
+     */
+    export function buildLathe(profile: Array<Array<number>>, sides?: number, smooth?: boolean, capped?: boolean): Mesh;
+    /**
+     * Build a cylinder standing on the Y axis, centered on the origin
+     * @param {number} [size] - Diameter
+     * @param {number} [height]
+     * @param {number} [sides] - Around
+     * @param {boolean} [smooth] - Defaults to render3D.smoothShading
+     * @param {boolean} [capped] - Close the ends
+     * @return {Mesh}
+     * @memberof Render3D
+     */
+    export function buildCylinder(size?: number, height?: number, sides?: number, smooth?: boolean, capped?: boolean): Mesh;
+    /**
+     * Build a sphere centered on the origin
+     * @param {number} [size] - Diameter
+     * @param {number} [sides] - Around
+     * @param {number} [rings] - Top to bottom
+     * @param {boolean} [smooth] - Defaults to render3D.smoothShading
+     * @return {Mesh}
+     * @memberof Render3D
+     */
+    export function buildSphere(size?: number, sides?: number, rings?: number, smooth?: boolean): Mesh;
+    /**
+     * Build a cone standing on the Y axis, centered on the origin, the point up
+     * @param {number} [size] - Diameter of the base
+     * @param {number} [height]
+     * @param {number} [sides] - Around
+     * @param {boolean} [smooth] - Defaults to render3D.smoothShading
+     * @param {boolean} [capped] - Close the base
+     * @return {Mesh}
+     * @memberof Render3D
+     */
+    export function buildCone(size?: number, height?: number, sides?: number, smooth?: boolean, capped?: boolean): Mesh;
+    /**
+     * Build a capsule standing on the Y axis, centered on the origin: a cylinder with a half sphere on each end
+     * @param {number} [size] - Diameter
+     * @param {number} [height] - Total height including the rounded ends, at least the size
+     * @param {number} [sides] - Around
+     * @param {number} [rings] - On each end
+     * @param {boolean} [smooth] - Defaults to render3D.smoothShading
+     * @return {Mesh}
+     * @memberof Render3D
+     */
+    export function buildCapsule(size?: number, height?: number, sides?: number, rings?: number, smooth?: boolean): Mesh;
+    /**
+     * Build a donut lying flat around the Y axis
+     * @param {number} [size] - Diameter of the whole donut, outside edge to outside edge
+     * @param {number} [tubeSize] - Diameter of the tube
+     * @param {number} [sides] - Around the ring
+     * @param {number} [tubeSides] - Around the tube
+     * @param {boolean} [smooth] - Defaults to render3D.smoothShading
+     * @return {Mesh}
+     * @memberof Render3D
+     */
+    export function buildTorus(size?: number, tubeSize?: number, sides?: number, tubeSides?: number, smooth?: boolean): Mesh;
+    /**
+     * Build a box centered on the origin, six flat faces with uvs covering each face
+     * @param {Vector3|number} [size] - Full size, a number for a cube
+     * @return {Mesh}
+     * @memberof Render3D
+     */
+    export function buildBox(size?: Vector3 | number): Mesh;
+    /**
+     * Build a heightfield grid in the XZ plane centered on the origin
+     * - smooth rounds the lighting across cells and colors each corner
+     * - flat lights and colors each cell on its own, so a checkerboard stays crisp
+     * - doubleSided, a sheet seen from both sides; turn it off for ground only ever seen from above
+     * - One cell is a plain square, render3D.planeMesh and planeMeshDoubleSided are shared ones
+     * @param {Vector2} [size] - World size along X and Z
+     * @param {Vector2|number} [segments] - Cells along X and Z, a number for both
+     * @param {Color|Function} [color] - One Color for the whole grid, or (x, z) => Color
+     * @param {Function} [heightFunction] - (x, z) => y, default flat
+     * @param {boolean} [smooth] - Defaults to render3D.smoothShading
+     * @return {Mesh}
+     * @memberof Render3D
+     * @example
+     * const ground = buildGrid(vec2(20), 10, (x, z)=> (floor(x / 2) + floor(z / 2)) & 1 ? GRAY : WHITE); // 2 unit checks
+     */
+    export function buildGrid(size?: Vector2, segments?: Vector2 | number, color?: Color | Function, heightFunction?: Function, smooth?: boolean): Mesh;
+    /**
+     * Build a lit ribbon along a path, for roads, tracks and walls
+     * - Each segment is a flat quad, the sides are across the path in the plane of the up vector
+     * - doubleSided, so it is seen and lit from below as well
+     * @param {Array<Vector3>} points - Center line in order
+     * @param {number|Array<number>} [width] - Full width, one for all or one per point
+     * @param {Color|Array<Color>} [color] - One for all or one per point
+     * @param {boolean} [closed] - Join the last point back to the first
+     * @param {Vector3} [up] - Which way the ribbon faces
+     * @return {Mesh}
+     * @memberof Render3D
+     * @example
+     * const road = buildRibbon(trackPoints, 8, GRAY, true); // a loop of road
+     */
+    export function buildRibbon(points: Array<Vector3>, width?: number | Array<number>, color?: Color | Array<Color>, closed?: boolean, up?: Vector3): Mesh;
+    /**
+     * Build a hull from a row of diamond shaped slices along Z, for ships, planes and cars
+     * - Each slice is [z, width, top, bottom, sideHeight]
+     * - sideHeight is 0 to 1 and puts the side corners between the bottom and the top
+     * - List the slices nose first, with the nose at the largest z
+     * @param {Array<Array<number>>} stations
+     * @return {Mesh}
+     * @memberof Render3D
+     * @example
+     * const hull = buildLoft([[1.2, .4, .2, -.1], [0, 1.4, .5, -.4], [-1, 1, .3, -.3]]);
+     */
+    export function buildLoft(stations: Array<Array<number>>): Mesh;
+    /**
+     * Build a sky dome: a sphere colored by direction, wound to be seen from inside
+     * - set it as render3D.sky and the pass draws it around the camera behind everything
+     * @param {Color} [topColor] - Straight up
+     * @param {Color} [horizonColor] - Level with the camera
+     * @param {Color} [bottomColor] - Straight down, what a camera looking at the ground sees past its edge; defaults to the horizon color
+     * @param {number} [sides] - Around
+     * @param {number} [rings] - Top to bottom
+     * @return {Mesh}
+     * @memberof Render3D
+     */
+    export function buildSky(topColor?: Color, horizonColor?: Color, bottomColor?: Color, sides?: number, rings?: number): Mesh;
+    /**
+     * Turn a sprite into a 3D block model by giving its pixels thickness
+     * - A pixel counts as solid when it is more than half opaque
+     * - Each pixel keeps its own color, so white art takes the object's tint
+     * - Runs of matching pixels merge into one face, and side walls appear only at the sprite's edges
+     * - A texture's pixels are read once and kept, so redrawing a canvas texture will not change what this builds
+     * - Pixels can also be an array of rows, each a Color, a truthy value for white, or a falsy value for empty
+     * @param {TileInfo|Array<Array<Color|number|boolean>>} pixels - A tile from a loaded texture, or rows of pixels,
+     *  each a Color (empty when see through), a truthy value for white or a falsy value for empty
+     * @param {Vector2} [size] - World width and height of the whole tile, centered like buildBox
+     * @param {number} [depth] - Thickness along Z
+     * @return {Mesh}
+     * @memberof Render3D
+     * @example
+     * new EngineObject3D(vec3(), buildExtrude(tile(3, 16), vec2(2), .5)); // a chunky version of tile 3
+     */
+    export function buildExtrude(pixels: TileInfo | Array<Array<Color | number | boolean>>, size?: Vector2, depth?: number): Mesh;
+    /**
+     * Build a mesh of extruded text from an image font, the engine font by default so it needs no assets
+     * - Each glyph is extruded once per font and reused, the block is centered and faces +Z
+     * - Newlines stack downward, spaced a little wider than the character height so the sides do not collide
+     * - Every call builds a new mesh, dispose the old one when text changes often
+     * - Glyphs are white in the engine font, so the object's color tints the text
+     * @param {string|number} text
+     * @param {number} [size] - Character height in world units
+     * @param {number} [depth] - Thickness along Z
+     * @param {ImageFont} [font] - Defaults to engineImageFont
+     * @return {Mesh}
+     * @memberof Render3D
+     * @example
+     * new EngineObject3D(vec3(0, 2, 0), buildText3D('HELLO'), undefined, YELLOW);
+     */
+    export function buildText3D(text: string | number, size?: number, depth?: number, font?: ImageFont): Mesh;
+    /**
+     * HeightMap - Terrain built from a grid of heights, with a mesh, a height lookup and a raycast
+     * - heights is a 2D array [row][column] of 0 to 1 values
+     * - Row 0 is the far edge at -Z and column 0 is the left edge at -X
+     * - It can be an image instead, where the red channel is the height
+     * - colors is an optional 2D array of Colors or an image, sampled per vertex
+     * - images are read through a canvas, so they must be same origin or loaded with crossOrigin set
+     * @memberof Render3D
+     * @example
+     * const terrain = new HeightMap(heightImage, vec2(100, 100), 10, colorImage);
+     * new EngineObject3D(vec3(), terrain.buildMesh());
+     * const y = terrain.getHeight(x, z); // stand things on it
+     */
+    export class HeightMap {
+        /** Create a height map from an array or an image
+         *  @param {Array<Array<number>>|HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|TextureInfo} heights
+         *  @param {Vector2} [size] - World size along X and Z
+         *  @param {number} [height] - World height of a full value
+         *  @param {Array<Array<Color>>|HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|TextureInfo} [colors] */
+        constructor(heights: Array<Array<number>> | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | TextureInfo, size?: Vector2, height?: number, colors?: Array<Array<Color>> | HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | TextureInfo);
+        /** @property {Array<Array<number>>} - Heights 0-1 as [row][column], rows along Z */
+        heights: number[][];
+        /** @property {Array<Array<Color>>|undefined} - Vertex colors as [row][column], undefined for white
+         *  @type {Array<Array<Color>>|undefined} */
+        colors: Array<Array<Color>> | undefined;
+        /** @property {Vector2} - World size along X and Z */
+        size: Vector2;
+        /** @property {number} - World height of a full value */
+        height: number;
+        /** Number of rows, along Z
+         *  @return {number} */
+        get rows(): number;
+        /** Number of columns, along X
+         *  @return {number} */
+        get columns(): number;
+        /** World height at a position, exactly the height of the mesh buildMesh draws there, clamped at the edges
+         *  @param {number|Vector3} x - X, or a position to take X and Z from
+         *  @param {number} [z]
+         *  @return {number} */
+        getHeight(x: number | Vector3, z?: number): number;
+        /** Surface normal at a position, from the slope across a sample
+         *  @param {number|Vector3} x - X, or a position to take X and Z from
+         *  @param {number} [z]
+         *  @return {Vector3} */
+        getNormal(x: number | Vector3, z?: number): Vector3;
+        /** Color of the nearest sample to a position, white when there are no colors
+         *  @param {number|Vector3} x - X, or a position to take X and Z from
+         *  @param {number} [z]
+         *  @return {Color} */
+        getColor(x: number | Vector3, z?: number): Color;
+        /** Distance along a ray to where it crosses the terrain surface, or undefined for a miss
+         *  - Steps along the ray half a cell at a time, then narrows in on the exact spot
+         *  - A ray that starts under the ground crosses on its way out, so the hit is still on the surface
+         *  @param {Ray3D} ray - From screenToRay, or any ray
+         *  @return {number|undefined} */
+        raycast(ray: Ray3D): number | undefined;
+        /** Build the terrain mesh, one vertex per sample, centered on the origin
+         *  @param {boolean} [smooth] - Defaults to render3D.smoothShading
+         *  @return {Mesh} */
+        buildMesh(smooth?: boolean): Mesh;
+    }
+    /**
+     * Light3D - A light that is an EngineObject3D, so it can move, follow a parent or be destroyed like anything else
+     * - A point light: it lights what is near it and fades out by its radius, DirectionalLight3D shines from far away
+     * - Only the sun, render3D.sunDirection, casts shadows and makes highlights, these light without either
+     * - Only the 8 lights nearest the camera are used each frame
+     * - radius is where the light fades out, and it fades fast, so a small radius wants a higher intensity
+     * - intensity multiplies the color, above 1 for a light brighter than white
+     * - radius is a world distance, so scale3D does not change it
+     * - An alpha, an intensity or a radius of 0 switches it off, and a light that is off takes none of those slots
+     * - Draws nothing itself, add a glow with drawSoftDisc or a small emissive mesh if it should be seen
+     * @extends EngineObject3D
+     * @memberof Render3D
+     * @example
+     * const torch = new Light3D(vec3(0, 3, 0), 10, hsl(.1, 1, .65));
+     */
+    export class Light3D extends EngineObject3D {
+        /** Create a point light
+         *  @param {Vector3} [pos3D] - Where it is
+         *  @param {number} [radius] - Distance where the light fades to nothing
+         *  @param {Color} [color] - Light color, its alpha fades it
+         *  @param {number} [intensity] - Brightness, multiplies the color, above 1 is brighter than white */
+        constructor(pos3D?: Vector3, radius?: number, color?: Color, intensity?: number);
+        /** @property {number} - Distance where the light fades to nothing */
+        radius: number;
+        /** @property {number} - Brightness, multiplies the color, above 1 is brighter than white */
+        intensity: number;
+        /** @property {boolean} - Shine from far away, from its position toward the origin, instead of out from its
+         *  position with a falloff; DirectionalLight3D sets it */
+        directional: boolean;
+    }
+    /**
+     * DirectionalLight3D - A Light3D that shines from far away with no falloff, like sunlight
+     * - It shines from its position toward the origin, like a three.js DirectionalLight: only the direction to it
+     *   counts, so moving it or its parent swings the light around; parent it to a sun in the sky and it follows
+     * - It cannot sit on the origin, since that leaves no direction
+     * - Like every Light3D it casts no shadow and makes no highlight, only the sun, render3D.sunDirection, does
+     * @extends Light3D
+     * @memberof Render3D
+     * @example
+     * const fill = new DirectionalLight3D(vec3(-1, 1, 1), hsl(.6, .5, .3)); // from the back left and above
+     */
+    export class DirectionalLight3D extends Light3D {
+        /** Create a directional light
+         *  @param {Vector3} [pos3D] - Where it shines from, toward the origin
+         *  @param {Color} [color] - Light color, its alpha fades it
+         *  @param {number} [intensity] - Brightness, multiplies the color, above 1 is brighter than white */
+        constructor(pos3D?: Vector3, color?: Color, intensity?: number);
+    }
+    /**
+     * CameraControl3D - Drag to turn the camera around a point, roll the wheel to zoom
+     * - An EngineObject3D, so move its pos3D to follow something, or parent it to an object
+     * - Destroy it to hand the camera back, and it stops driving the camera
+     * - Set persistent to keep it when engineObjectsDestroy clears out a level
+     * - Every part of it is a field, so a game can change the buttons, speeds and limits
+     * @extends EngineObject3D
+     * @memberof Render3D
+     * @example
+     * new CameraControl3D(vec3(0, 1, 0), 15); // look at a point from 15 units away
+     */
+    export class CameraControl3D extends EngineObject3D {
+        /** Create a camera control, it drives render3D.camera every frame
+         *  @param {Vector3} [target] - The point to look at, its pos3D
+         *  @param {number} [distance] - How far the camera sits from the target
+         *  @param {number} [pitch] - Angle above the horizon, PI/2 looks straight down
+         *  @param {number} [idleSpin] - Turned each frame while not dragging, 0 holds still */
+        constructor(target?: Vector3, distance?: number, pitch?: number, idleSpin?: number);
+        /** @property {number} - How far the camera sits from the target */
+        distance: number;
+        /** @property {number} - Angle above the horizon */
+        pitch: number;
+        /** @property {number} - Turned each frame while not dragging */
+        idleSpin: number;
+        /** @property {number} - Angle around the target, dragging changes it */
+        yaw: number;
+        /** @property {number} - Mouse button that turns the camera, 0 is left and 2 is right */
+        dragButton: number;
+        /** @property {number} - How far dragging a pixel turns the camera */
+        dragSpeed: number;
+        /** @property {number} - How much one wheel notch zooms, 0 turns zooming off */
+        zoomSpeed: number;
+        /** @property {Vector2} - Closest and furthest the wheel can zoom to */
+        zoomRange: Vector2;
+        /** @property {Vector2} - Lowest and highest pitch, so it cannot tip over the top */
+        pitchRange: Vector2;
+    }
+    /**
+     * FirstPersonCamera3D - Look around with the mouse and move with the keys, with the camera at its position
+     * - Click to capture the mouse so looking needs no button held, Esc lets it go; holding the button looks too, for touch
+     * - WASD or the arrow keys walk level, or move the way it looks when fly is set
+     * - An EngineObject3D that moves by velocity3D, so give it a size3D and call setCollision to walk into solid
+     *   objects instead of through them; walking keeps velocity3D.y, so render3D.gravity can pull it down
+     * - Starts from wherever render3D.camera is, so it can take over from another camera without a jump
+     * - Destroy it to hand the camera back
+     * @extends EngineObject3D
+     * @memberof Render3D
+     * @example
+     * const player = new FirstPersonCamera3D(vec3(0, 1.5, 5));
+     * player.size3D = vec3(1); // bump into solid objects
+     * player.collideAsSphere3D = true;
+     * player.setCollision();
+     */
+    export class FirstPersonCamera3D extends EngineObject3D {
+        /** Create a first person camera, it drives render3D.camera every frame
+         *  @param {Vector3} [pos3D] - Where the eye is, defaults to where the camera is now
+         *  @param {number} [yaw] - Radians around Y, defaults to the camera's
+         *  @param {number} [pitch] - Radians up from level, defaults to the camera's */
+        constructor(pos3D?: Vector3, yaw?: number, pitch?: number);
+        /** @property {number} - Angle around Y, the mouse turns it */
+        yaw: number;
+        /** @property {number} - Angle up from level, the mouse tilts it */
+        pitch: number;
+        /** @property {number} - World units per frame at full speed */
+        moveSpeed: number;
+        /** @property {number} - How far a pixel of mouse movement turns the view */
+        lookSpeed: number;
+        /** @property {Vector2} - Lowest and highest pitch */
+        pitchRange: Vector2;
+        /** @property {boolean} - Move the way it looks, up and down included, instead of walking level */
+        fly: boolean;
+        /** @property {boolean} - Capture the mouse on a click, so looking needs no button held */
+        lockPointer: boolean;
+    }
+    /**
+     * ParticleEmitter3D - Spawns camera facing particles, the 3D twin of ParticleEmitter
+     * - Each particle is a flat square facing the camera, with a soft round dot when no tile is given
+     * - Set trailTime to draw each particle as a streak along where it has been, for sparks
+     * - Set angleSpeed to tumble them in the camera plane, which the 2D emitter takes as an argument
+     * - Particles shoot out along the emitter's own up axis, turned by rotation3D
+     * - emitConeAngle spreads them, PI sprays in every direction
+     * - Speeds are per frame and sizes are world units, the same as the 2D emitter
+     * - scale3D, its own or a parent's, grows the whole effect: the spawn area, the sizes, the speed and the fall
+     * - gravity here is its own number added to velocity y each frame: it is neither the engine's 2D
+     *   gravity nor render3D.gravity, so an effect keeps its own fall wherever it is used
+     * - An emitter with an emitTime destroys itself once its last particle is gone, like the 2D emitter
+     * @extends EngineObject3D
+     * @memberof Render3D
+     * @example
+     * // fire: a stream upward, yellow fading to transparent red, additive
+     * new ParticleEmitter3D(vec3(), .5, 0, 100, .3, undefined, hsl(.12, 1, .6), hsl(.08, 1, .5), hsl(0, 1, .5, 0), hsl(0, 1, .25, 0), 1, .5, 1.5, .05, .95, 0, .3, .2, true);
+     */
+    export class ParticleEmitter3D extends EngineObject3D {
+        /** Create a particle emitter
+         *  @param {Vector3} [pos3D] - World space position of the emitter
+         *  @param {number|Vector3} [emitSize] - Spawn area, a number for a sphere diameter or a vec3 for a box
+         *  @param {number} [emitTime] - How long to keep emitting, 0 is forever
+         *  @param {number} [emitRate] - Particles per second, 0 does not emit
+         *  @param {number} [emitConeAngle] - Half angle around the emit direction, PI is every direction
+         *  @param {TileInfo|TextureInfo} [tileInfo] - Tile to render particles with, or a whole texture, undefined is untextured
+         *  @param {Color} [colorStartA] - Color at start of life, randomized between the start colors
+         *  @param {Color} [colorStartB]
+         *  @param {Color} [colorEndA] - Color at end of life, randomized between the end colors
+         *  @param {Color} [colorEndB]
+         *  @param {number} [particleTime] - How long particles live in seconds
+         *  @param {number} [sizeStart] - Particle size at start of life
+         *  @param {number} [sizeEnd] - Particle size at end of life
+         *  @param {number} [speed] - Spawn speed in world units per frame
+         *  @param {number} [damping] - Per frame velocity multiplier, 1 is none
+         *  @param {number} [gravity] - Per frame change to velocity y, negative pulls down; its own number,
+         *    not render3D.gravity, so the 2D emitter's gravityScale has no equivalent here
+         *  @param {number} [fadeRate] - Fraction of life spent fading, half in and half out
+         *  @param {number} [randomness] - Extra randomness applied to speed, size and life
+         *  @param {boolean} [additive] - Additive blending */
+        constructor(pos3D?: Vector3, emitSize?: number | Vector3, emitTime?: number, emitRate?: number, emitConeAngle?: number, tileInfo?: TileInfo | TextureInfo, colorStartA?: Color, colorStartB?: Color, colorEndA?: Color, colorEndB?: Color, particleTime?: number, sizeStart?: number, sizeEnd?: number, speed?: number, damping?: number, gravity?: number, fadeRate?: number, randomness?: number, additive?: boolean);
+        /** @property {number|Vector3} - Spawn area, a number for a sphere diameter or a vec3 for a box */
+        emitSize: number | Vector3;
+        /** @property {number} - How long to keep emitting, 0 is forever */
+        emitTime: number;
+        /** @property {number} - Particles per second, 0 does not emit */
+        emitRate: number;
+        /** @property {number} - Half angle around the emit direction, PI is every direction */
+        emitConeAngle: number;
+        /** @property {Color} - Color at start of life, randomized between the start colors */
+        colorStartA: Color;
+        /** @property {Color} - Color at start of life, randomized between the start colors */
+        colorStartB: Color;
+        /** @property {Color} - Color at end of life, randomized between the end colors */
+        colorEndA: Color;
+        /** @property {Color} - Color at end of life, randomized between the end colors */
+        colorEndB: Color;
+        /** @property {number} - How long particles live in seconds */
+        particleTime: number;
+        /** @property {number} - Particle size at start of life */
+        sizeStart: number;
+        /** @property {number} - Particle size at end of life */
+        sizeEnd: number;
+        /** @property {number} - Spawn speed in world units per frame */
+        speed: number;
+        /** @property {number} - Per frame change to velocity y, its own number and not render3D.gravity */
+        gravity: number;
+        /** @property {number} - Fraction of life spent fading, half in and half out */
+        fadeRate: number;
+        /** @property {number} - Extra randomness applied to speed, size and life */
+        randomness: number;
+        /** @property {number} - Seconds of each particle's path to draw as a ribbon behind it, 0 draws billboards */
+        trailTime: number;
+        /** @property {number} - Radians per frame each particle turns in the camera plane, either way; 0 is no spin */
+        angleSpeed: number;
+        /** @property {Array<Object>} - Live particles
+         *  @type {Array<Object>} */
+        particles: Array<any>;
+        emitTimeBuffer: number;
+        worldPos3D: Vector3;
+        /** Spawn one particle now */
+        emitParticle(): void;
+        /** Draw the particles, as flat squares or as streaks when trailTime is set
+         *  - The whole emitter sorts as one thing, its particles are not sorted against each other */
+        render3D(): any;
+    }
+    /**
+     * Trail3D - A ribbon through where the object has been, thinning and fading with age
+     * - Records its world position each frame it moves, so parent it to something that moves or set pos3D yourself
+     * - The samples are world space, so width is a world width and scale3D does nothing to the ribbon
+     * - Drawn unlit in the transparent stage, dies down on its own once the object stops
+     * @extends EngineObject3D
+     * @memberof Render3D
+     * @example
+     * const trail = new Trail3D(vec3(), 1, .3, undefined, hsl(.08, 1, .5), hsl(0, 1, .5, 0), true);
+     * ball.addChild(trail); // follows the ball
+     */
+    export class Trail3D extends EngineObject3D {
+        /** Create a trail
+         *  @param {Vector3} [pos3D]
+         *  @param {number} [lifeTime] - Seconds the ribbon takes to thin and fade from head to tail,
+         *    Infinity keeps every sample at full width and never drops one, so it grows as long as the object moves
+         *  @param {number} [width] - Width at the head, it thins to nothing at the tail
+         *  @param {TileInfo|TextureInfo} [tileInfo] - Tile or whole texture stretched along the trail, undefined is untextured
+         *  @param {Color} [color] - Color at the head
+         *  @param {Color} [colorEnd] - Color at the tail
+         *  @param {boolean} [additive] - Additive blending */
+        constructor(pos3D?: Vector3, lifeTime?: number, width?: number, tileInfo?: TileInfo | TextureInfo, color?: Color, colorEnd?: Color, additive?: boolean);
+        finishing: boolean;
+        /** @property {number} - Seconds the ribbon takes to thin and fade from head to tail, Infinity never drops a sample */
+        lifeTime: number;
+        /** @property {number} - Width at the head */
+        width: number;
+        /** @property {Color} - Color at the tail */
+        colorEnd: Color;
+        /** @property {Vector3|undefined} - Direction across the ribbon, recorded with each sample, undefined faces the camera
+         *  @type {Vector3|undefined} */
+        side: Vector3 | undefined;
+        /** @property {Array<Object>} - Recorded samples, oldest first
+         *  @type {Array<Object>} */
+        samples: Array<any>;
+        /** Forget the trail so far, for when the object teleports */
+        clear(): void;
+        worldPos3D: Vector3;
+    }
+    /**
+     * Collect the EngineObject3D objects whose boxes overlap a box, sizes are full sizes
+     * - Boxes are axis aligned around the world position, rotation3D is ignored; lights, emitters and trails have no size
+     * @param {Vector3} pos - Center of the box
+     * @param {Vector3|number} size - Full size of the box, a number for a cube
+     * @param {Array<EngineObject>} [objects] - Defaults to every object
+     * @return {Array<EngineObject3D>}
+     * @memberof Render3D
+     */
+    export function engineObjectsCollect3D(pos: Vector3, size: Vector3 | number, objects?: Array<EngineObject>): Array<EngineObject3D>;
+    /**
+     * Call a function for each EngineObject3D whose box overlaps a box
+     * @param {Vector3} pos - Center of the box
+     * @param {Vector3|number} size - Full size of the box, a number for a cube
+     * @param {Function} callback
+     * @param {Array<EngineObject>} [objects] - Defaults to every object
+     * @memberof Render3D
+     */
+    export function engineObjectsCallback3D(pos: Vector3, size: Vector3 | number, callback: Function, objects?: Array<EngineObject>): void;
+    /**
+     * Collect every EngineObject3D a ray passes through, nearest first, the 3D twin of engineObjectsRaycast
+     * - The ray has no end, so everything along it counts however far away it is
+     * - Use render3D.pick for the nearest one on its own, with the distance to it
+     * @param {Ray3D} ray - From render3D.screenToRay, or any ray
+     * @param {Array<EngineObject>} [objects] - Defaults to every object; only those with a mesh or a sprite count
+     * @return {Array<EngineObject3D>}
+     * @memberof Render3D
+     */
+    export function engineObjectsRaycast3D(ray: Ray3D, objects?: Array<EngineObject>): Array<EngineObject3D>;
+    /**
+     * Parse Wavefront OBJ text into a Mesh
+     * - Reads v, vt, vn and f lines with convex polygons of any size, materials and groups are ignored
+     * - Normals come from the file when every corner of a face has one, otherwise from the face
+     * - Use mesh.center() and mesh.fit(size) to bring a model of unknown units to the origin
+     * - Back faces are skipped like any mesh, set doubleSided for a model with open walls or single sided parts
+     * @param {string} text
+     * @param {boolean} [smooth] - Compute smooth normals when the file has none, defaults to render3D.smoothShading
+     * @return {Mesh}
+     * @memberof Render3D
+     * @example
+     * new EngineObject3D(vec3(), parseOBJ(objText).center().fit(4));
+     */
+    export function parseOBJ(text: string, smooth?: boolean): Mesh;
+    /**
+     * Fetch and parse an OBJ file
+     * @param {string} url
+     * @param {boolean} [smooth] - Compute smooth normals when the file has none, defaults to render3D.smoothShading
+     * @return {Promise<Mesh>}
+     * @memberof Render3D
+     * @example
+     * const mesh = await loadOBJ('ship.obj'); // in an async gameInit
+     */
+    export function loadOBJ(url: string, smooth?: boolean): Promise<Mesh>;
+    /** Draw a debug wireframe box
+     *  @param {Vector3} pos - Center
+     *  @param {Vector3|number} [size] - Full size, a number for a cube
+     *  @param {Color} [color]
+     *  @param {number} [time] - How long to show it, 0 is one frame
+     *  @param {Vector3} [rotation] - vec3(pitch, yaw, roll)
+     *  @memberof Render3D */
+    export function debugBox3D(pos: Vector3, size?: Vector3 | number, color?: Color, time?: number, rotation?: Vector3): void;
+    /** Draw a debug wireframe sphere as three rings
+     *  @param {Vector3} pos - Center
+     *  @param {number} [size] - Diameter
+     *  @param {Color} [color]
+     *  @param {number} [time] - How long to show it, 0 is one frame
+     *  @memberof Render3D */
+    export function debugSphere3D(pos: Vector3, size?: number, color?: Color, time?: number): void;
+    /** Draw a debug line
+     *  @param {Vector3} posA
+     *  @param {Vector3} posB
+     *  @param {Color} [color]
+     *  @param {number} [width]
+     *  @param {number} [time] - How long to show it, 0 is one frame
+     *  @memberof Render3D */
+    export function debugLine3D(posA: Vector3, posB: Vector3, color?: Color, width?: number, time?: number): void;
+    /** Draw a debug point as a small cross of three lines
+     *  @param {Vector3} pos
+     *  @param {Color} [color]
+     *  @param {number} [time] - How long to show it, 0 is one frame
+     *  @param {number} [size] - Length of the cross
+     *  @memberof Render3D */
+    export function debugPoint3D(pos: Vector3, color?: Color, time?: number, size?: number): void;
     /**
      * LittleJS Three.js Plugin
      * - Renders a three.js scene on a canvas behind the LittleJS canvases
@@ -5906,10 +7957,10 @@ declare module "littlejsengine" {
         constructor(size?: number);
         /** @property {number} - Width and height of the sheet in pixels */
         size: number;
-        /** @property {OffscreenCanvas} - Canvas holding the packed images */
-        canvas: OffscreenCanvas;
         /** @property {OffscreenCanvasRenderingContext2D} - 2d context for the canvas */
         context: OffscreenCanvasRenderingContext2D;
+        /** @property {OffscreenCanvas} - Canvas holding the packed images */
+        canvas: OffscreenCanvas;
         /** @property {TextureInfo} - The texture info for this sheet */
         textureInfo: TextureInfo;
         /** @property {Vector2} - Where the next image will be packed */