littlejsengine 1.21.0 → 1.23.0

package/dist/littlejs.d.ts

@@ -121,6 +121,32 @@ declare module "littlejsengine" {
          */
         renderPost?: () => void;
     };
+    /**
+     * The draw state's values, behind render3D's accessors, and the rgb emissiveMapColor had when it was set
+     */
+    export type Render3DDrawState = {
+        blend: boolean;
+        additive: boolean;
+        depthTest: boolean;
+        depthWrite: boolean;
+        cullBackFaces: boolean;
+        mirrored: boolean;
+        lighting: boolean;
+        emissive: number;
+        receiveShadow: boolean;
+        specular: number;
+        pixelated: boolean;
+        shader: Shader | undefined;
+        normalMap: TextureInfo | undefined;
+        normalScale: number;
+        shininess: number;
+        reflectivity: number;
+        emissiveMap: TextureInfo | undefined;
+        emissiveMapColor: Color;
+        emissiveR: number;
+        emissiveG: number;
+        emissiveB: number;
+    };
     /**
      * A particle as a ParticleEmitter3D's callbacks see it: one object the emitter reuses, set from the particle for each
      * call and written back after it, so copy what you keep
@@ -146,6 +172,11 @@ declare module "littlejsengine" {
          * - Seconds it lives
          */
         lifeTime: number;
+        /**
+         * - How much the emitter grows its effect, from its scale3D and its parents', as the 2D
+         * particle's scale
+         */
+        scale: number;
         /**
          * - Set by destroy
          */
@@ -185,6 +216,200 @@ declare module "littlejsengine" {
      * - What the game does when the level editor paints a tile
      */
     export type EditorTileCallback = (layer: TileLayer, pos: Vector2, tile: number | undefined) => any;
+    /**
+     * - What the level editor gives the callbacks of a tool of the game's own
+     */
+    export type EditorToolAt = {
+        /**
+         * - Where the mouse is in the level: a Vector2 in the 2D editor; in the 3D one a Vector3 on
+         * the level or the ground, undefined when the mouse is over the panel
+         */
+        pos: any;
+        /**
+         * - 2D: the tile cell under the mouse on the selected tile layer
+         */
+        cell: Vector2 | undefined;
+        /**
+         * - 3D: the mouse's Ray3D
+         */
+        ray: any;
+        /**
+         * - Is Shift held
+         */
+        shift: boolean;
+        /**
+         * - Is Ctrl held
+         */
+        ctrl: boolean;
+    };
+    /**
+     * - A tool of the game's own for the level editor, see LevelEditor.addTool
+     */
+    export type EditorTool = {
+        /**
+         * - The key that picks it, as addKey spells one
+         */
+        key?: string;
+        /**
+         * - The hint line while it is on
+         */
+        hint?: string;
+        /**
+         * - The left button went down in the level; returning false
+         * says the press was not the tool's
+         */
+        onPress?: (arg0: EditorToolAt) => any;
+        /**
+         * - Each frame it is held
+         */
+        onDrag?: (arg0: EditorToolAt) => any;
+        /**
+         * - It was let go
+         */
+        onRelease?: (arg0: EditorToolAt) => any;
+        /**
+         * - Each frame the tool is on, to draw its cursor or preview
+         */
+        onDraw?: (arg0: EditorToolAt) => any;
+    };
+    /**
+     * - The 2D level editor's edit functions, levelEditor.edit2D
+     */
+    export type EditorEdit2D = {
+        /**
+         * - The Tiled map of the selected layer
+         */
+        map: any | undefined;
+        /**
+         * - The selected tile layer, undefined on an object layer
+         */
+        layer: TileLayer | undefined;
+        /**
+         * - A copy of the selected object layer's objects, as Tiled has them
+         */
+        objects: Array<any>;
+        /**
+         * - The cell under the mouse on the selected tile layer
+         */
+        hover: Vector2 | undefined;
+        /**
+         * - The selected objects' ids
+         */
+        selection: Set<number>;
+        /**
+         * - Set a cell of the selected tile layer
+         * to a tile index, -1 erases, with a direction 0 to 3 and a mirror; false off the layer or with none
+         */
+        paint: (arg0: Vector2, arg1: number, ...args: any[]) => boolean;
+        /**
+         * - Edit a copy of the selected object
+         * layer's objects; false when nothing changed
+         */
+        changeObjects: (arg0: (arg0: Array<any>) => void) => boolean;
+        /**
+         * - End the edit: one undo step, and the autosave
+         */
+        strokeEnd: () => void;
+        /**
+         * - Take the edit being made back
+         */
+        strokeCancel: () => void;
+        /**
+         * - Many paints with one redraw a layer
+         */
+        bulk: (arg0: () => void) => void;
+        /**
+         * - Undo, or redo with true
+         */
+        undo: (...args: any[]) => any;
+        /**
+         * - The map as the text Save writes
+         */
+        toJSON: () => string;
+    };
+    /**
+     * - The 3D level editor's edit functions, levelEditor.edit3D; a position, a
+     *   rotation and a scale are Vector3, the rotation in degrees
+     */
+    export type EditorEdit3D = {
+        /**
+         * - The level object being edited
+         */
+        level: any | undefined;
+        /**
+         * - Its objects, the list in the level: read it, edit through change
+         */
+        objects: Array<any>;
+        /**
+         * - The selected objects' ids
+         */
+        selection: Set<number>;
+        /**
+         * - The selected objects
+         */
+        selected: () => Array<any>;
+        /**
+         * - What the game made for an object's id
+         */
+        made: (arg0: number) => any;
+        /**
+         * - Edit a copy of the object list; false
+         * when nothing changed
+         */
+        change: (arg0: (arg0: Array<any>) => void) => boolean;
+        /**
+         * - Edit the level's scene, voxels, terrain
+         * or prefabs block
+         */
+        changePart: (arg0: string, arg1: (arg0: any) => any) => boolean;
+        /**
+         * - End the edit: one undo step, and the autosave
+         */
+        strokeEnd: () => void;
+        /**
+         * - Take the edit being made back
+         */
+        strokeCancel: () => void;
+        /**
+         * - Add an object of a type at a position, selected;
+         * its id, undefined when there is no such type or the level can not be edited
+         */
+        place: (arg0: string, arg1: any) => number | undefined;
+        /**
+         * - Write a place, a rotation and a scale on an
+         * object of the list given to change; one left out is kept
+         */
+        setTransform: (arg0: any, ...args: any[]) => void;
+        /**
+         * - Write a property on an object of the list given
+         * to change, left out of the file when it is the type's default
+         */
+        setProperty: (arg0: any, arg1: string, arg2: any) => void;
+        /**
+         * - An object's position
+         */
+        pos: (arg0: any) => any;
+        /**
+         * - Its rotation, in degrees
+         */
+        rotation: (arg0: any) => any;
+        /**
+         * - Its scale
+         */
+        scale: (arg0: any) => any;
+        /**
+         * - Where the mouse is on the level or the ground, undefined over the panel
+         */
+        mousePoint: () => any;
+        /**
+         * - Undo, or redo with true
+         */
+        undo: (...args: any[]) => boolean;
+        /**
+         * - The level as the text Save writes
+         */
+        toJSON: () => string;
+    };
     /**
      * LittleJS - The Tiny Fast JavaScript Game Engine
      * MIT License - Copyright 2021 Frank Force
@@ -422,7 +647,234 @@ declare module "littlejsengine" {
     /** The level editor, levelEditor.open() to edit the level, levelEditor.close() to play on with the changes
      *  @type {LevelEditor}
      *  @memberof Editor */
-    export const levelEditor: LevelEditor;
+    export let levelEditor: LevelEditor;
+    /**
+     * LittleJS Level Editor
+     * - Paint the game's tile layers while it is paused, then keep playing with the changes
+     * - Press 0 while the debug overlay is open to edit, 0 again to play, or call levelEditor.open() and close()
+     * - Edits the Tiled map the game loaded, saves it back as Tiled JSON, and autosaves every change
+     * - Debug builds only, the release build has stubs for its names in engineRelease.js and none of its code
+     * @namespace Editor
+     */
+    /**
+     *  @callback EditorPlayFromCallback - Puts the player at a world position, for the level editor's Play from mouse
+     *  @param {Vector2} pos - Where to start playing
+     *  @memberof Editor
+     */
+    /**
+     *  @callback EditorRestartCallback - Rebuilds the level from the map the level editor changed
+     *  @memberof Editor
+     */
+    /**
+     *  @callback EditorTileCallback - What the game does when the level editor paints a tile
+     *  @param {TileLayer} layer - The layer painted
+     *  @param {Vector2} pos - The cell's position in the layer
+     *  @param {number|undefined} tile - The tile painted, undefined when erased
+     *  @memberof Editor
+     */
+    /**
+     *  @typedef {Object} EditorToolAt - What the level editor gives the callbacks of a tool of the game's own
+     *  @property {any} pos - Where the mouse is in the level: a Vector2 in the 2D editor; in the 3D one a Vector3 on
+     *    the level or the ground, undefined when the mouse is over the panel
+     *  @property {Vector2|undefined} cell - 2D: the tile cell under the mouse on the selected tile layer
+     *  @property {any} ray - 3D: the mouse's Ray3D
+     *  @property {boolean} shift - Is Shift held
+     *  @property {boolean} ctrl - Is Ctrl held
+     *  @memberof Editor
+     */
+    /**
+     *  @typedef {Object} EditorTool - A tool of the game's own for the level editor, see LevelEditor.addTool
+     *  @property {string} [key] - The key that picks it, as addKey spells one
+     *  @property {string} [hint] - The hint line while it is on
+     *  @property {function(EditorToolAt): any} [onPress] - The left button went down in the level; returning false
+     *    says the press was not the tool's
+     *  @property {function(EditorToolAt): any} [onDrag] - Each frame it is held
+     *  @property {function(EditorToolAt): any} [onRelease] - It was let go
+     *  @property {function(EditorToolAt): any} [onDraw] - Each frame the tool is on, to draw its cursor or preview
+     *  @memberof Editor
+     */
+    /**
+     *  @typedef {Object} EditorEdit2D - The 2D level editor's edit functions, levelEditor.edit2D
+     *  @property {Object|undefined} map - The Tiled map of the selected layer
+     *  @property {TileLayer|undefined} layer - The selected tile layer, undefined on an object layer
+     *  @property {Array<Object>} objects - A copy of the selected object layer's objects, as Tiled has them
+     *  @property {Vector2|undefined} hover - The cell under the mouse on the selected tile layer
+     *  @property {Set<number>} selection - The selected objects' ids
+     *  @property {function(Vector2, number, ...any): boolean} paint - Set a cell of the selected tile layer
+     *    to a tile index, -1 erases, with a direction 0 to 3 and a mirror; false off the layer or with none
+     *  @property {function(function(Array<Object>): void): boolean} changeObjects - Edit a copy of the selected object
+     *    layer's objects; false when nothing changed
+     *  @property {function(): void} strokeEnd - End the edit: one undo step, and the autosave
+     *  @property {function(): void} strokeCancel - Take the edit being made back
+     *  @property {function(function(): void): void} bulk - Many paints with one redraw a layer
+     *  @property {function(...any): any} undo - Undo, or redo with true
+     *  @property {function(): string} toJSON - The map as the text Save writes
+     *  @memberof Editor
+     */
+    /**
+     *  @typedef {Object} EditorEdit3D - The 3D level editor's edit functions, levelEditor.edit3D; a position, a
+     *    rotation and a scale are Vector3, the rotation in degrees
+     *  @property {Object|undefined} level - The level object being edited
+     *  @property {Array<Object>} objects - Its objects, the list in the level: read it, edit through change
+     *  @property {Set<number>} selection - The selected objects' ids
+     *  @property {function(): Array<Object>} selected - The selected objects
+     *  @property {function(number): any} made - What the game made for an object's id
+     *  @property {function(function(Array<Object>): void): boolean} change - Edit a copy of the object list; false
+     *    when nothing changed
+     *  @property {function(string, function(any): any): boolean} changePart - Edit the level's scene, voxels, terrain
+     *    or prefabs block
+     *  @property {function(): void} strokeEnd - End the edit: one undo step, and the autosave
+     *  @property {function(): void} strokeCancel - Take the edit being made back
+     *  @property {function(string, any): number|undefined} place - Add an object of a type at a position, selected;
+     *    its id, undefined when there is no such type or the level can not be edited
+     *  @property {function(Object, ...any): void} setTransform - Write a place, a rotation and a scale on an
+     *    object of the list given to change; one left out is kept
+     *  @property {function(Object, string, any): void} setProperty - Write a property on an object of the list given
+     *    to change, left out of the file when it is the type's default
+     *  @property {function(Object): any} pos - An object's position
+     *  @property {function(Object): any} rotation - Its rotation, in degrees
+     *  @property {function(Object): any} scale - Its scale
+     *  @property {function(): any} mousePoint - Where the mouse is on the level or the ground, undefined over the panel
+     *  @property {function(...any): boolean} undo - Undo, or redo with true
+     *  @property {function(): string} toJSON - The level as the text Save writes
+     *  @memberof Editor
+     */
+    /**
+     * The level editor, open it to pause the game and edit its level, close it to play on with the changes
+     * - One of it, levelEditor, 0 on the debug overlay opens and closes it too
+     * - A game makes it its own: it sets the hooks, adds keys, panel buttons and tools, or extends this class and
+     *   gives its own with setLevelEditor; the same calls work in the 2D editor and the 3D one, see EDITOR.md
+     * - In release builds LevelEditor is a stub that never opens: what a game adds is taken and never called
+     * @memberof Editor
+     * @example
+     * levelEditor.onRestart = ()=> loadLevel(); // adds a Restart button that rebuilds the level
+     * levelEditor.onTile = (layer, pos, tile)=> layer.setCollisionData(pos, tile === ladderTile ? -1 : tile ? 1 : 0);
+     * levelEditor.addKey('k', ()=> clearEnemies(), 'K: clear the enemies');
+     *
+     * // or as a class of the game's own
+     * class MyEditor extends LevelEditor
+     * {
+     *     onRestart() { loadLevel(); }
+     *     onDraw() { drawSpawnZones(); }
+     * }
+     * setLevelEditor(new MyEditor);
+     */
+    export class LevelEditor {
+        /** @property {Array<number>|undefined} - The tiles the palette shows, in its order, for a sheet that also holds
+         *  sprites and art that are not level tiles; undefined shows every tile of the sheet
+         *  @type {Array<number>|undefined} */
+        paletteTiles: Array<number> | undefined;
+        /** @property {boolean|undefined} - Which level editor opens: true the 3D one, false the 2D one, undefined the
+         *  3D one when a level was loaded with level3DLoad and there is a Render3DPlugin
+         *  @type {boolean|undefined} */
+        use3D: boolean | undefined;
+        /** @property {string|undefined} - The tool of the game's own that is on, one added with addTool, undefined
+         *  while a tool of the editor's is
+         *  @type {string|undefined} */
+        tool: string | undefined;
+        /** @type {Object<string, {action: function(boolean): any, help: string|undefined, warned: boolean}>} */
+        keys: {
+            [x: string]: {
+                action: (arg0: boolean) => any;
+                help: string | undefined;
+                warned: boolean;
+            };
+        };
+        /** @type {Array<{label: string, onClick: Function, title: string}>} */
+        buttons: Array<{
+            label: string;
+            onClick: Function;
+            title: string;
+        }>;
+        /** @type {Object<string, EditorTool>} */
+        tools: {
+            [x: string]: EditorTool;
+        };
+        /** What the game does when the 2D editor paints a tile, like setting its collision or its look the way the
+         *  game does when it loads the level; set it or override it, without one the collision layer gets collision 1
+         *  where there is a tile
+         *  @param {TileLayer} layer - The layer painted
+         *  @param {Vector2} pos - The cell's position in the layer
+         *  @param {number|undefined} tile - The tile painted, undefined when erased */
+        onTile(layer: TileLayer, pos: Vector2, tile: number | undefined): void;
+        /** Rebuild the level from what the editor changed; set it or override it and the editor has a Restart button,
+         *  which calls it after switching to play */
+        onRestart(): void;
+        /** Put the player at a position, a Vector2 in the 2D editor and a Vector3 in the 3D one; set it or override it
+         *  and the editor has Play from mouse, which starts play there
+         *  @param {any} pos */
+        onPlayFrom(pos: any): void;
+        /** Called when the editor opens, to set or override */
+        onOpen(): void;
+        /** Called when the editor closes and the game plays on, to set or override */
+        onClose(): void;
+        /** Called each frame while the editor is open, to set or override */
+        onUpdate(): void;
+        /** Called while the editor draws the level, to draw overlays of the game's own in it, to set or override */
+        onDraw(): void;
+        /** Called once when the editor's panel is made, with a box in it for the game's own controls, to set or override
+         *  @param {HTMLElement} element */
+        onPanel(element: HTMLElement): void;
+        /** Called by Save with the text of the file and its name; return true when the game kept it itself, and the
+         *  editor writes no file, to set or override
+         *  @param {string} text
+         *  @param {string} fileName
+         *  @return {boolean|void} */
+        onSave(text: string, fileName: string): boolean | void;
+        /** True while the editor is open, the game is paused under it
+         *  @return {boolean} */
+        get isOpen(): boolean;
+        /** True when the editor in use is the 3D one, as use3D says or since a 3D level was loaded
+         *  @return {boolean} */
+        get is3D(): boolean;
+        /** The 2D editor's edit functions, for a key, a button or a tool of the game's own: map, the Tiled map; layer,
+         *  the selected TileLayer; objects, a copy of the selected object layer's; hover, the cell under the mouse;
+         *  selection, the selected objects' ids; paint(cell, tile, direction, mirror), a tile index, -1 erases;
+         *  changeObjects((list)=> ...); strokeEnd() and strokeCancel(); bulk(()=> ...); undo(redo); toJSON()
+         *  @return {EditorEdit2D} */
+        get edit2D(): EditorEdit2D;
+        /** The 3D editor's edit functions, undefined without the 3D plugins: level; objects; selection, a Set of ids;
+         *  selected(); made(id); change((list)=> ...); changePart(name, (part)=> ...); strokeEnd() and strokeCancel();
+         *  place(type, pos3D); setTransform(object, pos3D, rotationDegrees, scale3D); setProperty(object, name, value);
+         *  pos(object), rotation(object) and scale(object); mousePoint(); undo(redo); toJSON()
+         *  @return {EditorEdit3D|undefined} */
+        get edit3D(): EditorEdit3D;
+        /** Add a key of the game's own to the editor, the 2D and the 3D one
+         *  - Escape and 0 are the editor's own, to play and to exit, and Ctrl is the one modifier: Shift is given to
+         *    the action
+         *  @param {string} key - A letter or digit, 'k', or a key's name in any case, 'Delete', 'F2', 'Enter', 'Space';
+         *    'ctrl+k' with Ctrl or Cmd
+         *  @param {function(boolean): any} action - Called with whether Shift is held; returning false says it did
+         *    nothing, and the key is left to the browser
+         *  @param {string} [helpLine] - A line for the editor's help */
+        addKey(key: string, action: (arg0: boolean) => any, helpLine?: string): void;
+        /** Add a button of the game's own to the editor's panel
+         *  @param {string} label
+         *  @param {Function} onClick
+         *  @param {string} [title] - What it says when the mouse is over it */
+        addButton(label: string, onClick: Function, title?: string): void;
+        /** Add a tool of the game's own: a button in the panel by its name, and while it is on the left button in the
+         *  level is its, not the editor's own tools'
+         *  - Each callback is given {pos, cell, ray, shift, ctrl}: pos is where the mouse is in the level, a Vector2 in
+         *    2D and a Vector3 on the level or the ground in 3D; cell is the tile under it in 2D; ray is the mouse's
+         *    in 3D
+         *  - What the callbacks change through edit2D or edit3D is one undo: the editor ends the stroke at the release,
+         *    and takes it back when the right button or Escape ends the press
+         *  @param {string} name
+         *  @param {EditorTool} tool - {key, hint, onPress, onDrag, onRelease, onDraw}, each optional; onPress returning
+         *    false says the press was not the tool's */
+        addTool(name: string, tool: EditorTool): void;
+        /** Open the editor, pausing the game; until close(), Escape (the debug key) switches between playing and editing */
+        open(): any;
+        /** Close the editor and end its session, the game carries on with the changes and Escape opens the debug
+         *  overlay again */
+        close(): any;
+    }
+    /** Make a level editor of the game's own the one in use: an instance of a class that extends LevelEditor, with
+     *  the game's hooks as its methods; set it before the editor opens
+     *  @param {LevelEditor} editor
+     *  @memberof Editor */
+    export function setLevelEditor(editor: LevelEditor): void;
     /** Asserts if the expression is false, does nothing in release builds
      *  Halts execution if the assert fails and throws an error
      *  @param {*} assert - any value, the assert fails when it is falsy
@@ -775,6 +1227,14 @@ declare module "littlejsengine" {
      *  @default
      *  @memberof Settings */
     export let touchGamepadPassthrough: boolean;
+    /** True if a pinch of two fingers turns the mouse wheel: touchPinch is added to mouseWheel, so what zooms with
+     *  the wheel zooms with a pinch, the mouse is between the two fingers, and a second finger lets go of the button
+     *  the first pressed, since a pinch is not a drag; turn it off for a game with its own use for two fingers, the
+     *  first finger stays the mouse and touchPinch can still be read
+     *  @type {boolean}
+     *  @default
+     *  @memberof Settings */
+    export let touchPinchWheel: boolean;
     /** Size of center button if touch gamepad should have start button in the center
      *  - Prevents activating when pressed near virtual stick or face buttons
      *  - When the game is paused, any touch will press the button
@@ -1065,6 +1525,10 @@ declare module "littlejsengine" {
      *  @param {boolean} passthrough
      *  @memberof Settings */
     export function setTouchGamepadPassthrough(passthrough: boolean): void;
+    /** Set if a pinch of two fingers turns the mouse wheel
+     *  @param {boolean} enable
+     *  @memberof Settings */
+    export function setTouchPinchWheel(enable: boolean): void;
     /** Set if touch gamepad should have start button in the center
      *  - Set size to enable the center button
      *  - When the game is paused, any touch will press the button
@@ -2086,8 +2550,9 @@ declare module "littlejsengine" {
          * @param {boolean} [useWebGL] - Should use WebGL if available?
          * @param {boolean|Array<number>} [wrap] - Should the texture wrap (REPEAT) or clamp (CLAMP_TO_EDGE)? Or the WebGL
          *   modes across and down, like [gl.CLAMP_TO_EDGE, gl.MIRRORED_REPEAT], as a glTF sampler gives them
+         * @param {boolean} [pixelated] - Hard edged or smooth for this texture alone, undefined follows tilesPixelated
          */
-        constructor(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, useWebGL?: boolean, wrap?: boolean | Array<number>);
+        constructor(image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, useWebGL?: boolean, wrap?: boolean | Array<number>, pixelated?: boolean);
         /** @property {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} - image source */
         image: OffscreenCanvas | ImageBitmap | HTMLCanvasElement | HTMLImageElement;
         /** @property {Vector2} - size of the image */
@@ -2101,6 +2566,10 @@ declare module "littlejsengine" {
          *  across and down
          *  @type {boolean|Array<number>} */
         wrap: boolean | Array<number>;
+        /** @property {boolean|undefined} - Hard edged or smooth for this texture alone, a soft glow in a pixel art
+         *  game or pixel art in a smooth one; undefined follows tilesPixelated
+         *  @type {boolean|undefined} */
+        pixelated: boolean | undefined;
         /** Creates the WebGL texture, updates if already created */
         createWebGLTexture(): void;
         /** Destroys the WebGL texture */
@@ -2112,6 +2581,10 @@ declare module "littlejsengine" {
          *  @param {boolean|Array<number>} [wrap] - true for REPEAT, false for CLAMP_TO_EDGE, or the WebGL modes across
          *    and down */
         setWrap(wrap?: boolean | Array<number>): void;
+        /** Make this texture hard edged or smooth on its own, whatever tilesPixelated says for the rest; it is made again
+         *  with the new filtering
+         *  @param {boolean} [pixelated] - undefined follows tilesPixelated again */
+        setPixelated(pixelated?: boolean): void;
     }
     /** Load a texture at a specific index after engineInit, the images passed to engineInit load this way
      *  @param {number} textureIndex - Index to store the texture at, an unused one
@@ -2227,6 +2700,11 @@ declare module "littlejsengine" {
         /** The clip showing now
          *  @return {SpriteAnimation} */
         get clip(): SpriteAnimation;
+        /** The clip showing now, once a clip that has ended has called its onEnd: the callback may switch clips, and a
+         *  read gives the clip it switched to, not the one that ended
+         *  @return {SpriteAnimation}
+         *  @ignore */
+        get settledClip(): SpriteAnimation;
         /** The tile of the frame showing now
          *  @return {TileInfo} */
         get tileInfo(): TileInfo;
@@ -2759,9 +3237,10 @@ declare module "littlejsengine" {
      *  Restores the active texture when done
      *  @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} [image]
      *  @param {boolean|Array<number>} [wrap] - true for REPEAT, false for CLAMP_TO_EDGE, or the WebGL modes across and down
+     *  @param {boolean} [pixelated] - Hard edged or smooth, undefined follows tilesPixelated
      *  @return {WebGLTexture}
      *  @memberof WebGL */
-    export function glCreateTexture(image?: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, wrap?: boolean | Array<number>): WebGLTexture;
+    export function glCreateTexture(image?: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, wrap?: boolean | Array<number>, pixelated?: boolean): WebGLTexture;
     /** Deletes a WebGL texture
      *  @param {WebGLTexture} [texture]
      *  @memberof WebGL */
@@ -2769,8 +3248,9 @@ declare module "littlejsengine" {
     /** Set WebGL texture data from an image, restores the active texture when done
      *  @param {WebGLTexture} texture
      *  @param {HTMLImageElement|HTMLCanvasElement|OffscreenCanvas|ImageBitmap} image
+     *  @param {boolean} [pixelated] - Hard edged or smooth, undefined follows tilesPixelated
      *  @memberof WebGL */
-    export function glSetTextureData(texture: WebGLTexture, image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap): void;
+    export function glSetTextureData(texture: WebGLTexture, image: HTMLImageElement | HTMLCanvasElement | OffscreenCanvas | ImageBitmap, pixelated?: boolean): void;
     /** Draw all sprites and clear out the buffer, called automatically by the system whenever necessary
      *  @memberof WebGL */
     export function glFlush(): void;
@@ -2783,6 +3263,17 @@ declare module "littlejsengine" {
      *  @param {boolean} [antialias]
      *  @memberof WebGL */
     export function glSetAntialias(antialias?: boolean): void;
+    /** The largest texture this device makes, in pixels across, 0 until WebGL starts; at least 2048 with WebGL2
+     *  @type {number}
+     *  @memberof WebGL */
+    export let glMaxTextureSize: number;
+    /** A texture size this device can make: the size asked for, or the largest it supports when that is smaller
+     *  - The engine sizes the textures it makes itself through this, the shadow maps and the like, so a size a device
+     *    does not have falls back instead of failing
+     *  @param {number} size - Pixels across
+     *  @return {number}
+     *  @memberof WebGL */
+    export function glClampTextureSize(size: number): number;
     /** Add a sprite to the gl draw list, used by all gl draw functions
      *  @param {number} x
      *  @param {number} y
@@ -2945,6 +3436,12 @@ declare module "littlejsengine" {
      *  @type {number}
      *  @memberof Input */
     export let mouseWheel: number;
+    /** Touch pinch delta this frame, in the mouse wheel's units: two fingers moving apart are negative, as the wheel
+     *  turned up is, and moving together positive, 1 for every 50 pixels; added to mouseWheel while touchPinchWheel
+     *  is on, so a game that zooms with the wheel zooms with a pinch
+     *  @type {number}
+     *  @memberof Input */
+    export let touchPinch: number;
     /** True if mouse was inside the document window, set to false when mouse leaves
      *  @type {boolean}
      *  @memberof Input */
@@ -3150,8 +3647,13 @@ declare module "littlejsengine" {
          *  @param {SoundLoadCallback} [onloadCallback] - callback function to call when sound is loaded
          */
         constructor(asset?: string | URL | any[], randomness?: number, range?: number, taper?: number, onloadCallback?: SoundLoadCallback);
-        /** @property {number} - World space max range of sound */
-        range: number;
+        set range(arg: number);
+        /** World space max range of sound, 0 for no limit; a range that is set is the sound's own, in 3D too
+         *  @type {number} */
+        get range(): number;
+        /** @property {boolean} - No range was given, so it got soundDefaultRange; played in 3D such a sound is heard
+         *  to render3D.soundDefaultRange instead, which is further; setting range makes it false */
+        rangeIsDefault: boolean;
         /** @property {number} - At what percentage of range should it start tapering */
         taper: number;
         /** @property {number} - How much to randomize frequency each time sound plays
@@ -3185,6 +3687,7 @@ declare module "littlejsengine" {
          *  playing a sound detaches the buffer's own channel arrays.
          *  @return {Array<Array<number>|Float32Array>|undefined} */
         get sampleChannels(): (number[] | Float32Array)[];
+        rangeValue: number;
         /** Move this sound's samples into an audio buffer that every play can share
          *  Does nothing if there is already a buffer or no samples to build one from */
         buildSampleBuffer(): void;
@@ -3435,9 +3938,9 @@ declare module "littlejsengine" {
      *  @param {number}  [decay] - Decay time, how long to reach sustain after attack (seconds)
      *  @param {number}  [tremolo] - Trembling effect, rate controlled by repeat time (percent)
      *  @param {number}  [filter] - Filter cutoff frequency, positive for HPF, negative for LPF (Hz)
-     *  @return {Array} - Array of audio samples
+     *  @return {Float32Array} - The audio samples
      *  @memberof Audio */
-    export function zzfxG(volume?: number, randomness?: number, frequency?: number, attack?: number, sustain?: number, release?: number, shape?: number, shapeCurve?: number, slide?: number, deltaSlide?: number, pitchJump?: number, pitchJumpTime?: number, repeatTime?: number, noise?: number, modulation?: number, bitCrush?: number, delay?: number, sustainVolume?: number, decay?: number, tremolo?: number, filter?: number): any[];
+    export function zzfxG(volume?: number, randomness?: number, frequency?: number, attack?: number, sustain?: number, release?: number, shape?: number, shapeCurve?: number, slide?: number, deltaSlide?: number, pitchJump?: number, pitchJumpTime?: number, repeatTime?: number, noise?: number, modulation?: number, bitCrush?: number, delay?: number, sustainVolume?: number, decay?: number, tremolo?: number, filter?: number): Float32Array;
     /**
      * LittleJS Object System
      * - EngineObject is the base class for all game objects
@@ -4119,6 +4622,13 @@ declare module "littlejsengine" {
         localSpace: boolean;
         /** @property {number} - If non zero the particle is drawn as a trail, stretched in the direction of velocity */
         trailScale: number;
+        /** @property {number} - Grows the whole effect as each particle is born: the spawn area, the particles' sizes,
+         *  speed and fall, so it looks the same only bigger; 1 is as made, and a particle keeps the scale it was born
+         *  with, so a change never moves the ones already out */
+        scale: number;
+        /** @property {number} - The effect's own fall, added to each particle's velocity y every frame, on top of the
+         *  world's gravity times gravityScale; an effect that sets its own looks the same in any game */
+        gravity: number;
         /** @property {ParticleCallback|undefined} - Callback when particle is created
          *  @type {ParticleCallback|undefined} */
         particleCreateCallback: ParticleCallback | undefined;
@@ -4169,6 +4679,8 @@ declare module "littlejsengine" {
         constructor(emitter: ParticleEmitter, pos: Vector2, angle: number, colorStart: Color, colorEnd: Color, lifeTime: number, sizeStart: number, sizeEnd: number, velocity?: Vector2, angleVelocity?: number);
         /** @property {ParticleEmitter} - The emitter this particle came from */
         emitter: ParticleEmitter;
+        /** @property {number} - The emitter's scale when it was made, which grows its fall */
+        scale: number;
         /** @property {Vector2} - Position, world space or local to the emitter when localSpace is set */
         pos: Vector2;
         /** @property {number} - Angle in radians */
@@ -4487,6 +4999,8 @@ declare module "littlejsengine" {
         *  new PostProcessPlugin(shaderCode);
         */
         constructor(shaderCode?: string, includeMainCanvas?: boolean, feedbackTexture?: boolean);
+        /** @property {string} - The shadertoy style mainImage code it shades with, see setShaderCode */
+        shaderCode: string;
         /** @property {WebGLProgram|undefined} - Shader for post processing
          *  @type {WebGLProgram|undefined} */
         shader: WebGLProgram | undefined;
@@ -4499,6 +5013,10 @@ declare module "littlejsengine" {
         /** @property {WebGLVertexArrayObject|undefined} - Vertex array object
          *  @type {WebGLVertexArrayObject|undefined} */
         vao: WebGLVertexArrayObject | undefined;
+        /** Shade with new code from the next frame on, to switch effects while the game runs; the shader is made again
+         *  @param {string} [shaderCode] - Shadertoy style mainImage code, postProcessEffects builds it; none passes the
+         *  frame through */
+        setShaderCode(shaderCode?: string): void;
     }
     /**
      * Set up post processing with a bloom effect, so bright colors and lights glow
@@ -4523,6 +5041,98 @@ declare module "littlejsengine" {
      * @memberof PostProcess
      */
     export function postProcessBloomShader(threshold?: number, strength?: number, size?: number): string;
+    /**
+     * Join effects into one post process shader, in the order given, for PostProcessPlugin or setShaderCode
+     * - Each effect is a piece of shader code on c, the pixel's color, and uv, where it is on the screen from 0 to 1;
+     *   your own code is a piece too, a line of GLSL or many, dropped in where you put it
+     * - Put the ones that bend the picture or sample it first: postProcessCurve, postProcessChromatic, postProcessGlow
+     * @param {...string} effects - The pieces, from the effect functions or your own code
+     * @return {string} - Shadertoy style mainImage code
+     * @example
+     * new PostProcessPlugin(postProcessEffects(
+     *     postProcessScanlines(.5), postProcessVignette(), 'c.rgb *= vec3(1, .9, .8);'));
+     * @memberof PostProcess
+     */
+    export function postProcessEffects(...effects: string[]): string;
+    /**
+     * Bright parts glow, the bloom as an effect to join with others; postProcessBloom sets up bloom on its own
+     * @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 postProcessGlow(threshold?: number, strength?: number, size?: number): string;
+    /**
+     * Scan lines across the screen, like an old TV
+     * @param {number} [strength] - How dark the lines are, and how bright between them
+     * @param {number} [spacing] - Pixels from one line to the next
+     * @return {string}
+     * @memberof PostProcess
+     */
+    export function postProcessScanlines(strength?: number, spacing?: number): string;
+    /**
+     * Static noise over the picture, changing every frame
+     * @param {number} [strength] - How bright the static is
+     * @param {number} [size] - Size of a speck in pixels
+     * @return {string}
+     * @memberof PostProcess
+     */
+    export function postProcessNoise(strength?: number, size?: number): string;
+    /**
+     * Darken toward the edges and corners
+     * @param {number} [strength] - How dark the corners get, 1 is black
+     * @param {number} [falloff] - How far in it reaches, low darkens most of the screen, high only the corners
+     * @return {string}
+     * @memberof PostProcess
+     */
+    export function postProcessVignette(strength?: number, falloff?: number): string;
+    /**
+     * Bend the picture like the bulged glass of an old TV, black past the corners; put it first
+     * @param {number} [strength] - How much it bends
+     * @return {string}
+     * @memberof PostProcess
+     */
+    export function postProcessCurve(strength?: number): string;
+    /**
+     * Split red and blue apart toward the edges, like a cheap lens; put it before what shades the picture
+     * @param {number} [strength] - How far apart at the edge, as a part of the screen
+     * @return {string}
+     * @memberof PostProcess
+     */
+    export function postProcessChromatic(strength?: number): string;
+    /**
+     * Draw lines where the 3D depth jumps, around objects and along their creases; needs render3D.depthTexture on
+     * @param {Color} [color] - The lines' color, its alpha how strong they are
+     * @param {number} [thickness] - How wide the lines are in pixels
+     * @param {number} [threshold] - How big a jump makes a line, as a part of the distance, lower draws more
+     * @return {string}
+     * @memberof PostProcess
+     */
+    export function postProcessOutline(color?: Color, thickness?: number, threshold?: number): string;
+    /**
+     * The look of an old TV, as one effect to use alone or join with others: static noise, scan lines, a soft glow and
+     * a vignette, and a bulged screen when curve is set; any setting at 0 leaves that part out
+     * @param {Object} [settings]
+     * @param {number} [settings.noise] - Static noise strength
+     * @param {number} [settings.scanlines] - Scan line strength
+     * @param {number} [settings.scanlineSpacing] - Pixels from one scan line to the next
+     * @param {number} [settings.glow] - Soft glow strength
+     * @param {number} [settings.vignette] - Vignette strength
+     * @param {number} [settings.curve] - How much the screen bulges, 0 by default for flat
+     * @return {string}
+     * @example
+     * new PostProcessPlugin(postProcessEffects(postProcessTV({scanlines: .4, curve: .1})));
+     * @memberof PostProcess
+     */
+    export function postProcessTV({ noise, scanlines, scanlineSpacing, glow, vignette, curve }?: {
+        noise?: number;
+        scanlines?: number;
+        scanlineSpacing?: number;
+        glow?: number;
+        vignette?: number;
+        curve?: number;
+    }): string;
     /**
      * LittleJS Light System Plugin
      * - Adds 2D dynamic lighting to the scene
@@ -4545,6 +5155,8 @@ declare module "littlejsengine" {
      *   shadow map through renderShadow(), which calls render() by default; obj.castShadow = false keeps it
      *   out (a floor TileLayer, a background), a draw's alpha sets how much light it blocks, and
      *   setShadowTransparent lets its color tint the light
+     * - Set light.glow for a soft hazy glow over a light, like a lamp at night; it is added over the lit scene after the
+     *   lightmap, so it shows in the dark and sits in front of everything there
      * - Must be constructed BEFORE PostProcessPlugin so post-process sees lit pixels
      * @namespace LightSystem
      */
@@ -4642,6 +5254,9 @@ declare module "littlejsengine" {
         shadowMapWorldSize: number;
         shadowMapSizeAllocated: number;
         shadowTextureSizeAllocated: number;
+        /** Bring the sizes of the textures it makes down to what the device can make: shadowMapSize, shadowTextureSize
+         *  and a textureSize given by hand; called before they are made, so a size too big falls back instead of failing */
+        clampTextureSizes(): void;
         /** Draw a single Light's falloff blob into the currently bound lightmap.
          *  Called by Light.renderLight() during the plugin's render pass.
          *  @param {Light} light */
@@ -4689,6 +5304,17 @@ declare module "littlejsengine" {
          *  or torch that holds it, or the player carrying it, does not block it; it has to reach past that object's
          *  corners, about half its diagonal and a little more, or dark rays run out from them */
         shadowCore: number;
+        /** @property {number} - Size across of a soft hazy glow drawn over the light, like a lamp at night, 0 for
+         *  none; it is added over the lit scene, in front of everything there */
+        glow: number;
+        /** @property {number} - How fast the glow fades from its middle: 1 by default, .5 a wide haze, 2 a tight
+         *  bright core */
+        glowFalloff: number;
+        /** @type {TileInfo|undefined} */
+        glowTileInfo: TileInfo | undefined;
+        /** Draw this light's glow, soft and round, its glow size across and in its color, added over the lit scene;
+         *  called by LightSystemPlugin after the lightmap is applied */
+        renderGlow(): void;
     }
     /**
      * LittleJS ZzFXM Plugin
@@ -6967,6 +7593,78 @@ declare module "littlejsengine" {
      *  @return {Scene|undefined}
      *  @memberof SceneSystem */
     export function getScene(): Scene | undefined;
+    /**
+     * LittleJS Parallax Plugin
+     * - A background layer that follows the camera by a part of its movement, so it looks far away
+     * - Repeats across the view, so a level of any width has a background
+     * - Draws mountains by default, or anything a game draws into it
+     * @namespace Parallax
+     */
+    /**
+     * A background layer with parallax: an image that follows the camera by a part of its movement and repeats across
+     * the view, drawn once into a canvas by a function, mountains when none is given
+     * - A far layer has a parallax near 1 and a low renderOrder, a near one a smaller parallax and a higher renderOrder
+     * - The image should meet itself at its left and right edges to repeat without a seam, as the mountains do
+     * @memberof Parallax
+     * @extends CanvasLayer
+     * @example
+     * // three ranges of mountains, the far ones lighter and slower
+     * for (let i = 3; i--;)
+     *     new ParallaxLayer(vec2(0, i*2), vec2(40, 20), .9 - i*.2, -1e3 + i,
+     *         parallaxMountains(hsl(.6, .3, .7 - i*.2), hsl(.6, .5, .2), i));
+     *
+     * // or draw your own image into the layer
+     * new ParallaxLayer(vec2(), vec2(40, 20), .5, -1e3, (context, size)=>
+     * {
+     *     context.fillStyle = '#fff';
+     *     context.fillRect(size.x/2 - 20, size.y/2 - 20, 40, 40);
+     * });
+     */
+    export class ParallaxLayer extends CanvasLayer {
+        /** Create a parallax layer and draw its image
+         *  @param {Vector2} [pos] - Where the middle of the image is in the world when the camera is there too
+         *  @param {Vector2} [size] - World size of one copy of the image
+         *  @param {number|Vector2} [parallax] - How much of the camera's movement it follows, 0 stays with the world
+         *    and 1 with the screen, a Vector2 to follow x and y by different amounts
+         *  @param {number} [renderOrder] - Low to draw behind the game, far layers lowest
+         *  @param {function(OffscreenCanvasRenderingContext2D, Vector2, ParallaxLayer): void} [drawFunction] - Draws
+         *    the image, given the canvas context, its size in pixels and the layer; mountains when not given
+         *  @param {Vector2} [canvasSize] - Size of the image in pixels */
+        constructor(pos?: Vector2, size?: Vector2, parallax?: number | Vector2, renderOrder?: number, drawFunction?: (arg0: OffscreenCanvasRenderingContext2D, arg1: Vector2, arg2: ParallaxLayer) => void, canvasSize?: Vector2);
+        /** @property {Vector2} - How much of the camera's movement it follows on each axis, 0 stays with the world
+         *  and 1 with the screen */
+        parallax: Vector2;
+        /** @property {boolean} - Repeat the image across the view, left and right */
+        wrapX: boolean;
+        /** @property {boolean} - Repeat the image up and down the view */
+        wrapY: boolean;
+        /** @property {number} - How much the camera's zoom changes its size on the screen: 1 like the world, 0 not
+         *  at all, the same on the screen at any zoom as it is at zoomScale */
+        zoomFollow: number;
+        /** @property {number} - The camera scale its size is given for, used when zoomFollow is under 1 */
+        zoomScale: number;
+        /** @property {function(OffscreenCanvasRenderingContext2D, Vector2, ParallaxLayer): void} - Draws the
+         *  image, redraw() after changing it */
+        drawFunction: (arg0: OffscreenCanvasRenderingContext2D, arg1: Vector2, arg2: ParallaxLayer) => void;
+        /** Draw the image again with drawFunction, after changing it or what it draws from */
+        redraw(): void;
+        zoomFactor(): number;
+        /** World size one copy of the image is drawn at now, its size unless zoomFollow is under 1
+         *  @return {Vector2} */
+        getDrawSize(): Vector2;
+        /** Where each copy of the image is drawn now, in the world: one place, or with wrapping every place that
+         *  shows in the view
+         *  @return {Array<Vector2>} */
+        getDrawPositions(): Array<Vector2>;
+    }
+    /** A draw function for a ParallaxLayer: a range of mountains across the image, shaded from the color of their
+     *  peaks down to the color of their feet, that repeats with no seam
+     *  @param {Color} [topColor] - Color at the peaks
+     *  @param {Color} [bottomColor] - Color at the bottom of the image
+     *  @param {number} [seed] - The same seed gives the same mountains, random when not given
+     *  @return {function(OffscreenCanvasRenderingContext2D, Vector2): void}
+     *  @memberof Parallax */
+    export function parallaxMountains(topColor?: Color, bottomColor?: Color, seed?: number): (arg0: OffscreenCanvasRenderingContext2D, arg1: Vector2) => void;
     /** Grid pathfinder using A* with two optional smoothing passes.
      *  @memberof PathFinding
      *  @example
@@ -7686,6 +8384,10 @@ declare module "littlejsengine" {
      * new EngineObject3D(vec3(), buildBox());
      */
     export class Render3DPlugin {
+        /** @type {Render3DDrawState} */
+        drawState: Render3DDrawState;
+        /** @property {number} - Goes up when a draw state field changes, so a batch sees at a glance that none did */
+        stateVersion: number;
         /** @property {Camera3D} - The camera */
         camera: Camera3D;
         /** @property {Vector3} - Direction toward the sun, where its light comes from, like a directional Light3D;
@@ -7724,8 +8426,16 @@ declare module "littlejsengine" {
         depthTexture: boolean;
         /** @property {boolean} - Cast real shadows from the sun, off by default and free when off */
         shadows: boolean;
+        /** @property {number} - How far a sound played with playSound is heard when it was made with no range of
+         *  its own, in world units; further than the 2D soundDefaultRange, a 3D world is bigger */
+        soundDefaultRange: number;
         /** @property {number} - Size of the shadow map in pixels, bigger is sharper and slower */
         shadowMapSize: number;
+        /** @property {Light3D|undefined} - A spotlight, a Light3D with a coneAngle, to cast the shadows in place
+         *  of the sun, a flashlight in the dark: the shadow map looks down its cone, as far as its radius, and the
+         *  sun still lights the scene but casts none; undefined for the sun, as is a light that is off or has no cone
+         *  @type {Light3D|undefined} */
+        shadowLight: Light3D | undefined;
         /** @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 */
@@ -7737,46 +8447,6 @@ declare module "littlejsengine" {
         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; a draw
-         *  with it off goes over what was drawn before it and under what is drawn after, by render order, which
-         *  ends the batch of meshes before it, so one per object costs a draw per object */
-        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 sun and the Light3D objects reflect, 0 is none and
-         *  1 adds a light's full color at its brightest; shininess sets its size */
-        specular: number;
-        /** @property {number} - The highlight's exponent, how small and sharp it is: 4 is broad like rubber, 100 sharp
-         *  like polished metal; set from each object's shininess */
-        shininess: number;
-        /** @property {TextureInfo|undefined} - Normal map for the next draws, set from each object's normalMap
-         *  @type {TextureInfo|undefined} */
-        normalMap: TextureInfo | undefined;
-        /** @property {number} - How strongly the normal map bends the surface, set from each object's normalScale */
-        normalScale: number;
-        /** @property {number} - How much the surface reflects the sky, 0 to 1, set from each object's reflectivity */
-        reflectivity: number;
-        /** @property {TextureInfo|undefined} - Emissive map for the next draws, set from each object's emissiveMap
-         *  @type {TextureInfo|undefined} */
-        emissiveMap: TextureInfo | undefined;
-        /** @property {Color} - Multiplies the emissive map, set from each object's emissiveMapColor */
-        emissiveMapColor: Color;
-        /** @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;
@@ -7798,9 +8468,6 @@ declare module "littlejsengine" {
         /** @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
@@ -7835,7 +8502,6 @@ declare module "littlejsengine" {
         /** @property {Vector3} - Camera forward axis this frame */
         cameraForward: Vector3;
         cameraBack: Vector3;
-        blend: boolean;
         /** @type {Array<Array<number>>} */
         frustumPlanes: Array<Array<number>>;
         /** @type {Array<Array<number>>} */
@@ -7877,6 +8543,9 @@ declare module "littlejsengine" {
         passIsDefault: boolean;
         lightPositions: Float32Array;
         lightColors: Float32Array;
+        lightCones: Float32Array;
+        shadowLightIndex: number;
+        shadowDepthBias: number;
         /** @type {WebGLBuffer|undefined} */
         streamBuffer: WebGLBuffer | undefined;
         /** @type {Array<WebGLBuffer>} */
@@ -7901,6 +8570,89 @@ declare module "littlejsengine" {
             state: any;
             draw: () => void;
         }> | undefined;
+        set lighting(arg: 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
+         *  @return {boolean} */
+        get lighting(): boolean;
+        set emissive(arg: number);
+        /** How much a surface lights itself, set per object by its emissive
+         *  @return {number} */
+        get emissive(): number;
+        set additive(arg: boolean);
+        /** Additive blending instead of alpha, in the transparent stage
+         *  @return {boolean} */
+        get additive(): boolean;
+        set depthTest(arg: boolean);
+        /** Test against the depth buffer, reset to true before each object and callback; a draw
+         *  with it off goes over what was drawn before it and under what is drawn after, by render order, which
+         *  ends the batch of meshes before it, so one per object costs a draw per object
+         *  @return {boolean} */
+        get depthTest(): boolean;
+        set depthWrite(arg: boolean);
+        /** Write to the depth buffer, owned by the stages: on for opaque, off for transparent
+         *  @return {boolean} */
+        get depthWrite(): boolean;
+        set cullBackFaces(arg: boolean);
+        /** Skip back faces, set by drawMesh from each mesh: off for strips so they show from
+         *  both sides
+         *  @return {boolean} */
+        get cullBackFaces(): boolean;
+        set mirrored(arg: boolean);
+        /** The transform mirrors the draw, so the other winding is the front, set by drawMesh
+         *  from each transform
+         *  @return {boolean} */
+        get mirrored(): boolean;
+        set specular(arg: number);
+        /** Strength of the highlight where the sun and the Light3D objects reflect, 0 is none and
+         *  1 adds a light's full color at its brightest; shininess sets its size
+         *  @return {number} */
+        get specular(): number;
+        set shininess(arg: number);
+        /** The highlight's exponent, how small and sharp it is: 4 is broad like rubber, 100 sharp
+         *  like polished metal; set from each object's shininess
+         *  @return {number} */
+        get shininess(): number;
+        set normalMap(arg: TextureInfo);
+        /** Normal map for the next draws, set from each object's normalMap
+         *  @return {TextureInfo|undefined} */
+        get normalMap(): TextureInfo;
+        set normalScale(arg: number);
+        /** How strongly the normal map bends the surface, set from each object's normalScale
+         *  @return {number} */
+        get normalScale(): number;
+        set reflectivity(arg: number);
+        /** How much the surface reflects the sky, 0 to 1, set from each object's reflectivity
+         *  @return {number} */
+        get reflectivity(): number;
+        set emissiveMap(arg: TextureInfo);
+        /** Emissive map for the next draws, set from each object's emissiveMap
+         *  @return {TextureInfo|undefined} */
+        get emissiveMap(): TextureInfo;
+        set emissiveMapColor(arg: Color);
+        /** Multiplies the emissive map, set from each object's emissiveMapColor; compared by its rgb, so a Color
+         *  changed in place is seen when it is set again, and undefined is white
+         *  @return {Color} */
+        get emissiveMapColor(): Color;
+        set shader(arg: Shader);
+        /** Custom Shader for the next draws, set from each object's shader; undefined draws
+         *  with the plugin's own
+         *  @return {Shader|undefined} */
+        get shader(): Shader;
+        set receiveShadow(arg: boolean);
+        /** Darken by the shadow map when shadows are on, turn it off for things that should
+         *  stay lit inside a shadow
+         *  @return {boolean} */
+        get receiveShadow(): boolean;
+        set pixelated(arg: boolean);
+        /** Keep texture pixels hard edged, no mipmaps and no blending between them, set per
+         *  object by pixelated
+         *  @return {boolean} */
+        get pixelated(): boolean;
+        set blend(arg: boolean);
+        /** Blending on, set by the stages
+         *  @return {boolean} */
+        get blend(): boolean;
         /** 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;
@@ -7941,7 +8693,8 @@ declare module "littlejsengine" {
             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
+         *  with a 2D position; a sound made with no range of its own is heard to soundDefaultRange, 100, and one given
+         *  a range keeps it
          *  @param {Sound} sound
          *  @param {Vector3} pos3D
          *  @param {number} [volume]
@@ -8532,20 +9285,24 @@ declare module "littlejsengine" {
      * InstancedMesh3D - Many copies of one mesh drawn as one call, with their transforms kept on the GPU
      * - For big sets that mostly stay put: an instance costs nothing per frame until it changes, so a hundred thousand
      *   trees cost what one tree does; objects and drawMesh batch by themselves too, but rebuild their batch every frame
-     * - setMatrixAt and setColorAt change one instance, and only the changed range uploads before the next draw
+     * - setTransformAt, setMatrixAt and setColorAt change one instance, and only the changed range uploads before the
+     *   next draw; the matrices and the colors are kept apart, so moving instances uploads 64 bytes each
+     * - For many instances moving every frame, setTransforms places a run of them from arrays of positions, rotations
+     *   and scales in one loop, the fastest way; or write matrixData directly and call markDirtyRange
      * - The instances are in world space; the object's own pos3D, rotation3D and scale3D do not move them
-     * - The whole set is culled by one bounding sphere around the origin, and casts and receives shadows like any object
+     * - The whole set is culled by one bounding sphere around the origin, worked out when culling reads it, or set by hand
+     *   with radius; it casts and receives shadows like any object
      * - The object's flags cover the whole set, one emissive, one tileInfo, one shader; only the colors are per instance
      * - A mirrored instance, one with a negative scale, shows its inside unless the mesh is doubleSided
      * - A transparent set draws in one go in the transparent stage, its instances are not sorted against each other;
      *   the set sorts against other transparent draws by the object's position, so put pos3D at its middle
-     * - pick, the raycast and the collect helpers do not see the instances, test them yourself from instanceData
+     * - pick, the raycast and the collect helpers do not see the instances, test them yourself from matrixData
      * @extends EngineObject3D
      * @memberof Render3D
      * @example
      * const forest = new InstancedMesh3D(treeMesh, 1000);
      * for (let i = 0; i < 1000; ++i)
-     *     forest.setMatrixAt(i, buildMatrix(randomGroundPos(), vec3(0, rand(2*PI), 0)));
+     *     forest.setTransformAt(i, randomGroundPos(), vec3(0, rand(2*PI), 0));
      */
     export class InstancedMesh3D extends EngineObject3D {
         /** Create a set of instances of a mesh, each at the origin in the object's color until it is set
@@ -8558,21 +9315,53 @@ declare module "littlejsengine" {
         count: number;
         /** @property {number} - How many instances it was made with */
         maxCount: number;
-        /** @property {Float32Array} - The per instance values the shader reads, 24 floats each: the matrix, the color
-         *  and the uv rect; edit it directly and call markDirty for the instances changed */
-        instanceData: Float32Array;
-        /** @property {number} - Radius of the sphere around the origin that holds every instance set so far, for
-         *  culling; from the farthest instance and the largest scale, and the mesh's size when it draws */
-        radius: number;
-        reach: number;
-        maxScale: number;
-        /** @property {number} - First instance to upload before the next draw */
+        /** @property {Float32Array} - Each instance's matrix, 16 floats, what moving them uploads; edit it directly and
+         *  call markDirty for the instances changed */
+        matrixData: Float32Array;
+        /** @property {Float32Array} - Each instance's color and uv rect, 8 floats, uploaded only when they change; edit
+         *  it directly and call markColorDirty for the instances changed */
+        colorData: Float32Array;
+        /** @property {number} - First instance whose matrix uploads before the next draw */
         dirtyStart: number;
-        /** @property {number} - One past the last instance to upload, so nothing uploads when it is not past dirtyStart */
+        /** @property {number} - One past the last instance whose matrix uploads, nothing when it is not past dirtyStart */
         dirtyEnd: number;
+        /** @property {number} - First instance whose color uploads before the next draw */
+        colorDirtyStart: number;
+        /** @property {number} - One past the last instance whose color uploads */
+        colorDirtyEnd: number;
+        reachSquared: number;
+        scaleSquared: number;
+        boundsStart: number;
+        boundsEnd: number;
+        /** @type {number|undefined} */
+        fixedRadius: number | undefined;
         buffer: WebGLBuffer;
+        /** @type {WebGLBuffer|undefined} */
+        colorBuffer: WebGLBuffer | undefined;
         bufferGeneration: number;
         uvTileInfo: TileInfo | TextureInfo;
+        /** Place an instance by its position, rotation and scale, what buildMatrix takes, written straight in with no
+         *  matrix made; in world space
+         *  @param {number} i
+         *  @param {Vector3} [pos]
+         *  @param {Vector3} [rotation] - Euler angles in radians
+         *  @param {Vector3} [scale] */
+        setTransformAt(i: number, pos?: Vector3, rotation?: Vector3, scale?: Vector3): void;
+        /** Place a run of instances from arrays indexed by instance, plain or typed, as a game keeps them: each is placed
+         *  as setTransformAt places it, all in one loop with nothing made, the fastest way to move many every frame;
+         *  in world space
+         *  @param {number} start - First instance
+         *  @param {number} count - How many
+         *  @param {ArrayLike<number>} x - Positions
+         *  @param {ArrayLike<number>} y
+         *  @param {ArrayLike<number>} z
+         *  @param {ArrayLike<number>} [rx] - Euler angles in radians, all three or none for upright
+         *  @param {ArrayLike<number>} [ry]
+         *  @param {ArrayLike<number>} [rz]
+         *  @param {ArrayLike<number>} [sx] - Scales, all three or none for 1
+         *  @param {ArrayLike<number>} [sy]
+         *  @param {ArrayLike<number>} [sz] */
+        setTransforms(start: number, count: number, x: ArrayLike<number>, y: ArrayLike<number>, z: ArrayLike<number>, rx?: ArrayLike<number>, ry?: ArrayLike<number>, rz?: ArrayLike<number>, sx?: ArrayLike<number>, sy?: ArrayLike<number>, sz?: ArrayLike<number>): void;
         /** Place an instance, in world space
          *  @param {number} i
          *  @param {Matrix4} matrix */
@@ -8585,10 +9374,26 @@ declare module "littlejsengine" {
          *  @param {number} i
          *  @param {Color} color */
         setColorAt(i: number, color: Color): void;
-        /** Note that an instance changed, so it uploads before the next draw and the bounds hold it; setMatrixAt and
-         *  setColorAt call this, and so must an edit made straight to instanceData
+        /** Note that an instance's matrix changed, so it uploads before the next draw and the bounds take it in when
+         *  they are read; setTransformAt and setMatrixAt call this, and so must an edit made straight to matrixData
          *  @param {number} i */
         markDirty(i: number): void;
+        /** Note that a run of instances' matrices changed, for code that writes matrixData directly, the lowest level
+         *  way to move many: they upload before the next draw and the bounds take them in when they are read
+         *  @param {number} start - First instance
+         *  @param {number} end - One past the last */
+        markDirtyRange(start: number, end: number): void;
+        /** Note that an instance's color changed, so it uploads before the next draw; setColorAt calls this, and so must
+         *  an edit made straight to colorData
+         *  @param {number} i */
+        markColorDirty(i: number): void;
+        set radius(arg: number);
+        /** Radius of the sphere around the origin that holds every instance set so far, for culling: the farthest
+         *  instance, and the mesh's size at the largest scale; it only grows, and takes in the instances set since it
+         *  was last read, so with frustum culling off it is never worked out. Set it to fix the sphere, which a big set
+         *  that is culled can use to skip that work, and set it to undefined to go back to the bounds
+         *  @return {number} */
+        get radius(): number;
     }
     /**
      * Spin a flat outline around the Y axis to make a round shape, like a vase or a wheel
@@ -9024,13 +9829,16 @@ declare module "littlejsengine" {
     /**
      * 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; these light and make highlights without one
+     * - A coneAngle makes it a spotlight: it shines along its own forward, turned by rotation3D or by what it is
+     *   attached to, inside the cone, fading over the part of it coneSoftness says
+     * - The sun, render3D.sunDirection, casts the shadows; a spotlight can cast them in its place, see
+     *   render3D.shadowLight; the other lights light and make highlights without one
      * - 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
+     * - Draws nothing but its glow, when it has one; add a small emissive mesh if the lamp itself should be seen
      * @extends EngineObject3D
      * @memberof Render3D
      * @example
@@ -9050,6 +9858,12 @@ declare module "littlejsengine" {
         /** @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;
+        /** @property {number} - Makes it a spotlight: the angle in radians from its forward out to the edge of its
+         *  cone, so the beam is twice this across; 0 for a light that shines every way */
+        coneAngle: number;
+        /** @property {number} - How much of the cone is its fading edge: 0 a hard edge, .2 by default, the outer
+         *  fifth, 1 fading all the way from the middle of the beam */
+        coneSoftness: number;
         /** @property {number} - Size of a soft hazy glow drawn over the light, like a lamp at night, 0 for none; it
          *  is added onto what is behind it, and what is in front of the light hides it */
         glow: number;
@@ -9062,7 +9876,7 @@ declare module "littlejsengine" {
      * - 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, only the sun, render3D.sunDirection, does
+     * - It casts no shadow: the sun, render3D.sunDirection, does, or a spotlight set as render3D.shadowLight
      * @extends Light3D
      * @memberof Render3D
      * @example
@@ -9167,6 +9981,8 @@ declare module "littlejsengine" {
      * @property {Vector3} velocity - How far it moves each frame
      * @property {number} age - Seconds it has lived
      * @property {number} lifeTime - Seconds it lives
+     * @property {number} scale - How much the emitter grows its effect, from its scale3D and its parents', as the 2D
+     *   particle's scale
      * @property {boolean} destroyed - Set by destroy
      * @property {function(): void} destroy - End it this update, the destroy callback gets it
      * @memberof Render3D
@@ -9193,8 +10009,9 @@ declare module "littlejsengine" {
      * - 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
+     * - gravity here is its own number added to velocity y each frame, so an effect keeps its own fall wherever it is
+     *   used, the same as the 2D emitter's gravity; gravityScale adds a share of render3D.gravity on top, as the 2D
+     *   emitter's gravityScale adds the engine's gravity
      * - An emitter with an emitTime destroys itself once its last particle is gone, like the 2D emitter
      * - Callbacks as the 2D emitter's: particleCreateCallback, particleUpdateCallback, particleCollideCallback and
      *   particleDestroyCallback, each given a Particle3D, one object the emitter reuses for every particle and call
@@ -9223,14 +10040,17 @@ declare module "littlejsengine" {
          *  @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} [gravity] - Per frame change to velocity y, negative pulls down; its own number, and
+         *    gravityScale adds a share of render3D.gravity on top
          *  @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 {boolean} - Flatten the spawn area across the way it emits, its own up: a sphere becomes a disc
+         *  and a box a flat rectangle, for rain from a sheet of sky or flames from a patch of ground */
+        emitFlat: boolean;
         /** @property {number} - How long to keep emitting, 0 is forever */
         emitTime: number;
         /** @property {number} - Particles per second, 0 does not emit */
@@ -9274,6 +10094,9 @@ declare module "littlejsengine" {
         trailData: Float32Array | undefined;
         /** @property {number} - Trail points kept per particle, from trailTime */
         trailMax: number;
+        /** @property {number} - How much a particle grips where it lands, 0 to 1: its speed along the surface is
+         *  cut by this much on each hit, on top of the friction, 1 stops it there */
+        stick: number;
         /** @property {Particle3DCallback|undefined} - Called with each particle as it is made
          *  @type {Particle3DCallback|undefined} */
         particleCreateCallback: Particle3DCallback | undefined;
@@ -9297,7 +10120,7 @@ declare module "littlejsengine" {
         /** Spawn one particle now */
         emitParticle(): void;
         particleCall(callback: any, k: any, level: any, pos: any): any;
-        particleCollide(k: any, x: any, y: any, z: any): void;
+        particleCollide(k: any, x: any, y: any, z: any): boolean;
     }
     /**
      * Trail3D - A ribbon through where the object has been, thinning and fading with age
@@ -9342,6 +10165,103 @@ declare module "littlejsengine" {
         clear(): void;
         worldPos3D: Vector3;
     }
+    /**
+     * LensFlare3D - The sun's lens flare, the old kind: a glow at the sun and a row of discs and rings of different
+     * sizes along the line from the sun through the middle of the screen
+     * - Make one and it shows, over the 3D scene and under what the game draws after, a HUD; destroy it to take it away
+     * - It follows render3D.sunDirection, and fades out as the sun leaves the screen or goes behind something
+     * - flareSize, count, intensity and saturation set its look, seed picks another arrangement, and its color tints it,
+     *   with the sun's own color; or give it elements of your own
+     * - visible is how much of the sun shows, 0 to 1, eased over fadeTime, there for a game to read
+     * - What hides the sun is found with a ray from the camera, against the level and every object that is not see
+     *   through, each as the box around its mesh, see render3D.pick; turn it off with occlusion
+     * - It needs WebGL, and it draws nothing in the shadow of renderAfter2D
+     * @extends EngineObject3D
+     * @memberof Render3D
+     * @example
+     * new LensFlare3D;                // the sun flares
+     * new LensFlare3D(1.5, 10, .7, 0); // bigger, 10 ghosts, dimmer, all one color
+     */
+    export class LensFlare3D extends EngineObject3D {
+        /** Create the sun's lens flare
+         *  @param {number} [size] - Scales every part of it, 1 by default
+         *  @param {number} [count] - How many ghosts there are along the line, besides the glow at the sun
+         *  @param {number} [intensity] - How bright it is
+         *  @param {number} [saturation] - How colorful the ghosts are, 0 for all the flare's own color, 1 a rainbow
+         *  @param {Color} [color] - Tints the whole flare, with the sun's color */
+        constructor(size?: number, count?: number, intensity?: number, saturation?: number, color?: Color);
+        /** @property {number} - Scales every part of the flare */
+        flareSize: number;
+        /** @property {number} - How many ghosts there are along the line, besides the glow at the sun */
+        count: number;
+        /** @property {number} - How bright it is */
+        intensity: number;
+        /** @property {number} - How colorful the ghosts are, 0 for all the flare's own color, 1 a rainbow */
+        saturation: number;
+        /** @property {number} - Picks the arrangement of the ghosts, another seed is another flare */
+        seed: number;
+        /** @property {Array<{at: number, size: number, color: Color, shape: string}>|undefined} - The parts of the
+         *  flare, to set your own in place of the ones made from count, seed and saturation: at is where along the
+         *  line, 0 the sun, 1 the middle of the screen, 2 as far past it; size is across, as a part of the screen's
+         *  height; shape is glow, disc or ring
+         *  @type {Array<{at: number, size: number, color: Color, shape: string}>|undefined} */
+        elements: {
+            at: number;
+            size: number;
+            color: Color;
+            shape: string;
+        }[];
+        /** @property {Light3D|undefined} - A light the flare is of in place of the sun, a lamp or a spotlight: the
+         *  flare is at the light and in its color, smaller from farther than the light reaches, hidden by what is
+         *  in front of the light, and a spotlight's shows from inside its beam only
+         *  @type {Light3D|undefined} */
+        light: Light3D | undefined;
+        /** @property {boolean} - Fade out when something is between the camera and the sun */
+        occlusion: boolean;
+        /** @property {number} - Seconds the flare takes to fade out or in when the sun is hidden or shows again */
+        fadeTime: number;
+        /** @property {number} - How much of the sun shows, 0 hidden or behind the camera to 1 in plain view, eased */
+        visible: number;
+        madeKey: string;
+        /** @type {Array<{at: number, size: number, color: Color, shape: string}>} */
+        made: {
+            at: number;
+            size: number;
+            color: Color;
+            shape: string;
+        }[];
+        /** The parts of the flare: the elements set by hand, or the ones made from count, seed and saturation, a glow
+         *  and a core at the sun and the ghosts, made again when one of those changes
+         *  @return {Array<{at: number, size: number, color: Color, shape: string}>} */
+        getElements(): Array<{
+            at: number;
+            size: number;
+            color: Color;
+            shape: string;
+        }>;
+        flareSource(): {
+            direction: Vector3;
+            distance: number;
+            pos: Vector3;
+        };
+        /** Where the sun, or the flare's light, is on the screen, in pixels like mousePosScreen, undefined when it is
+         *  behind the camera
+         *  @return {Vector2|undefined} */
+        getSunScreenPos(): Vector2 | undefined;
+        /** The parts of the flare as they are drawn now: each one's place on the screen, its size in pixels and its
+         *  color, dimmed by how much of the sun shows; empty when there is nothing to draw
+         *  @return {Array<{pos: Vector2, size: number, color: Color, shape: string}>} */
+        getScreenElements(): Array<{
+            pos: Vector2;
+            size: number;
+            color: Color;
+            shape: string;
+        }>;
+        /** Is something between the camera and the sun, or the flare's light: the level, or an object that is not see
+         *  through
+         *  @return {boolean} */
+        isSunHidden(): boolean;
+    }
     /**
      * Collect the EngineObject3D objects whose boxes overlap a sphere or a box, the 3D twin of engineObjectsCollect
      * - Each object is its size3D box at its world position, turned as it is turned; lights, emitters and trails have no
@@ -9671,10 +10591,109 @@ declare module "littlejsengine" {
      *  - What a file written by hand gets wrong uses the default: a value that is not of its default's type
      *  - An object its type can not make is skipped with an error in debug builds, where asserts throw, and the rest
      *    of the level is made
+     *  - A level may hold a map of blocks, in a voxels block: pos, its corner, size, its cells along x, y and z, and
+     *    blocks, runs of a count and a type along x, then y, then z; it is made a VoxelMap, the first of what is
+     *    returned, see level3DVoxelSetup for its sheet
+     *  - A level may hold a terrain, in a terrain block: pos, its center, size, its size in the world along x and z,
+     *    height, how tall a full height is, color, and heights, rows of 0 to 1 from -z to +z, each from -x to +x; it
+     *    is made a HeightMap, returned with what else was made; paint, when it has it, colors its samples: colors, a
+     *    list, and cells, runs of a count and a color along the rows, 0 for the terrain's own and 1 the list's first
+     *  - A level may hold prefabs of its own, in a prefabs block, each by its name as level3DAddPrefab takes it; they
+     *    are added before its objects are made, one the game added itself keeps its place
+     *  - A level may set the scene too, in a scene block beside its objects: sky, three colors for straight up, the
+     *    horizon and straight down, ambient, how much of them lights the scene, .5 when not given, sunDirection and
+     *    sunColor, fog, its start and end, fogColor, the horizon color when not given, and shadows; what the block
+     *    leaves out stays as the game set it, and a level with no block changes nothing
      *  @param {Object} level - The level, the level editor edits this same object
      *  @return {Array<any>} - What each object's type made, a function that made nothing is left out
      *  @memberof Level3D */
     export function level3DLoad(level: any): Array<any>;
+    /** Add a prefab: a small level, its objects placed about its own origin, to place many times under one name
+     *  - It is a type from then on: a level's object of that type, the level editor's Place list and level3DSpawn make
+     *    an instance, a Prefab3D; an instance is made of the prefab as it is then, so the level editor, where a prefab
+     *    changes, makes its instances again
+     *  - The prefab is a level as the level editor saves it, {objects: [...]}, so the editor is the prefab editor too;
+     *    only its objects are used, and they may be of other prefabs
+     *  - With attached true in it the parts are children of the instance and move with it as one body, without
+     *    collision of their own, a prefab inside it too; its handle is at the middle of the box around them and its
+     *    size3D is that box, so setCollision makes the body solid where it is seen; otherwise each part is an object of its own in the world and collides as one placed
+     *    by hand does
+     *  - Adding a name again replaces it
+     *  @param {string} name - The type its instances have in a level
+     *  @param {Object} prefab - {objects, attached}
+     *  @memberof Level3D
+     *  @example
+     *  level3DAddPrefab('Tower', {objects: [{type: 'Box', pos: [0, 1, 0], scale: [2, 2, 2]},
+     *      {type: 'Cylinder', pos: [0, 3, 0]}]});
+     *  level3DLoad({objects: [{type: 'Tower', pos: [5, 0, 5]}, {type: 'Tower', pos: [-5, 0, 5], rotation: [0, 45, 0]}]}); */
+    export function level3DAddPrefab(name: string, prefab: any): void;
+    /** Load a prefab from a file the level editor saved and add it
+     *  @param {string} name - The type its instances have in a level
+     *  @param {string} url
+     *  @return {Promise<void>}
+     *  @memberof Level3D */
+    export function level3DLoadPrefab(name: string, url: string): Promise<void>;
+    /** Make one object of a type added with level3DAddType, level3DAddMesh or level3DAddPrefab, from code, with no
+     *  level: a prefab's instance, or a plain type
+     *  @param {string} type - The type's name
+     *  @param {Vector3} [pos3D]
+     *  @param {Vector3} [rotation3D] - In radians, as an object has it
+     *  @param {Vector3} [scale3D] - Times the scale the type makes it with
+     *  @param {Object} [properties] - Over the type's defaults
+     *  @return {any} - What the type made, a Prefab3D for a prefab, undefined when there is no such type
+     *  @memberof Level3D
+     *  @example
+     *  level3DAddPrefab('House', await fetchJSON('house.json'));
+     *  level3DSpawn('House', vec3(10, 0, 0), vec3(0, PI/2, 0)); */
+    export function level3DSpawn(type: string, pos3D?: Vector3, rotation3D?: Vector3, scale3D?: Vector3, properties?: any): any;
+    /**
+     * An instance of a prefab, what a prefab's type makes: a handle with no shape of its own, and its parts, what the
+     * prefab's objects made
+     * - Parts of a prefab that is not attached are objects of their own in the world: moving, turning or sizing the
+     *   handle puts them where it now says with its next update, or call placeParts; destroying it destroys them
+     * - Parts of an attached prefab are its children and move with it as one body
+     * @extends EngineObject3D
+     * @memberof Level3D
+     */
+    export class Prefab3D extends EngineObject3D {
+        /** Create an instance of a prefab, made by its type: place one with a level or level3DSpawn
+         *  @param {Vector3} [pos3D]
+         *  @param {string} [prefabName] - A prefab added with level3DAddPrefab */
+        constructor(pos3D?: Vector3, prefabName?: string);
+        /** @property {string} - The prefab it is an instance of */
+        prefabName: string;
+        /** @property {boolean} - Are its parts its children, moving with it as one body */
+        attached: boolean;
+        /** @property {Array<any>} - What the prefab's objects made, in the prefab's order */
+        parts: any[];
+        /** @property {Vector3} - From the prefab's origin to the handle, in the prefab's own space: nothing for
+         *  separate parts, and for an attached prefab the middle of the box around its parts, where its handle
+         *  is, as an object's place is the middle of its body */
+        originOffset: Vector3;
+        partObjects: any[];
+        partsPlaced: string;
+        partsMade: boolean;
+        /** Put the instance with its prefab's origin at a place, turned and sized as the handle is: where a level's
+         *  object or level3DSpawn says it goes; the handle of an attached prefab is then at the middle of its body
+         *  @param {Vector3} pos3D */
+        placeAt(pos3D: Vector3): void;
+        /** Put the parts where the handle is now, making them the first time; called by the handle's update when it
+         *  has moved, turned or changed size */
+        placeParts(): void;
+        placeKey(): string;
+        makeParts(): void;
+    }
+    /** How a level's block map is made: the sheet its blocks show tiles of, and a function to set it up
+     *  - A level's voxels block makes a VoxelMap when the level loads, with texture 0 and the default tile size unless
+     *    a sheet is given here; a block's type shows that tile of the sheet on every face
+     *  - setup is called with each map a level makes, to give block types their own faces or make them see-through
+     *  - Call it before level3DLoad; with no arguments the defaults are back
+     *  @param {TileInfo} [tileInfo] - The sheet's first tile, as for a VoxelMap
+     *  @param {function(VoxelMap): void} [setup]
+     *  @example
+     *  level3DVoxelSetup(tile(0, 16, 1), (map)=> map.setBlockType(1, {top: 0, side: 1, bottom: 2})); // grass
+     *  @memberof Level3D */
+    export function level3DVoxelSetup(tileInfo?: TileInfo, setup?: (arg0: VoxelMap) => void): void;
     /**
      * LittleJS Three.js Plugin
      * - Renders a three.js scene on a canvas behind the LittleJS canvases
@@ -9876,68 +10895,166 @@ declare module "littlejsengine" {
      *  @memberof TextureSheets */
     export function spritesReady(): Promise<any>;
     /**
-     * LittleJS Level Editor
-     * - Paint the game's tile layers while it is paused, then keep playing with the changes
-     * - Press 0 while the debug overlay is open to edit, 0 again to play, or call levelEditor.open() and close()
-     * - Edits the Tiled map the game loaded, saves it back as Tiled JSON, and autosaves every change
-     * - Debug builds only, the release build has stubs for its names in engineRelease.js and none of its code
-     * @namespace Editor
-     */
-    /**
-     *  @callback EditorPlayFromCallback - Puts the player at a world position, for the level editor's Play from mouse
-     *  @param {Vector2} pos - Where to start playing
-     *  @memberof Editor
-     */
-    /**
-     *  @callback EditorRestartCallback - Rebuilds the level from the map the level editor changed
-     *  @memberof Editor
-     */
-    /**
-     *  @callback EditorTileCallback - What the game does when the level editor paints a tile
-     *  @param {TileLayer} layer - The layer painted
-     *  @param {Vector2} pos - The cell's position in the layer
-     *  @param {number|undefined} tile - The tile painted, undefined when erased
-     *  @memberof Editor
-     */
-    /**
-     * The level editor, open it to pause the game and edit its level, close it to play on with the changes
-     * - One of it, levelEditor, 0 on the debug overlay opens and closes it too
-     * - In release builds levelEditor is a stub that never opens, and its hooks are never called
-     * @memberof Editor
-     * @example
-     * levelEditor.onRestart = ()=> loadLevel(); // adds a Restart button that rebuilds the level
-     * levelEditor.onTile = (layer, pos, tile)=> layer.setCollisionData(pos, tile === ladderTile ? -1 : tile ? 1 : 0);
-     */
-    class LevelEditor {
-        /** @property {EditorTileCallback|undefined} - What the game does when the editor paints a tile, like
-         *  setting its collision or its look the way the game does when it loads the level; without one, the
-         *  collision layer gets collision 1 where there is a tile
-         *  @type {EditorTileCallback|undefined} */
-        onTile: EditorTileCallback | undefined;
-        /** @property {Function|undefined} - Rebuild the level from the map the editor changed, a Restart button
-         *  calls it after switching to play; without one there is no Restart button
-         *  @type {EditorRestartCallback|undefined} */
-        onRestart: EditorRestartCallback | undefined;
-        /** @property {Function|undefined} - Put the player at a world position; with it, the editor's Advanced
-         *  section has Play from mouse, which starts play there, Escape at the mouse and Play at the view center
-         *  @type {EditorPlayFromCallback|undefined} */
-        onPlayFrom: EditorPlayFromCallback | undefined;
-        /** @property {Array<number>|undefined} - The tiles the palette shows, in its order, for a sheet that also holds
-         *  sprites and art that are not level tiles; undefined shows every tile of the sheet
-         *  @type {Array<number>|undefined} */
-        paletteTiles: Array<number> | undefined;
-        /** @property {boolean|undefined} - Which level editor opens: true the 3D one, false the 2D one, undefined the
-         *  3D one when a level was loaded with level3DLoad and there is a Render3DPlugin
-         *  @type {boolean|undefined} */
-        use3D: boolean | undefined;
-        /** True while the editor is open, the game is paused under it
-         *  @return {boolean} */
-        get isOpen(): boolean;
-        /** Open the editor, pausing the game; until close(), Escape (the debug key) switches between playing and editing */
-        open(): void;
-        /** Close the editor and end its session, the game carries on with the changes and Escape opens the debug
-         *  overlay again */
-        close(): void;
-    }
-    export {};
+     * LittleJS Particle Effects Plugin
+     * - Ready made particle effects in one line, particleEffect('fire', pos), and particleEffect3D for 3D
+     * - Every built-in effect is tuned around a one unit emitter; options.scale grows it to fit, options.hue and
+     *   options.saturation recolor it
+     * - Effects are plain data, {name, settings, behaviors}, the format the particle designer saves: load a library the
+     *   designer saved with particleEffectsLoad and play its effects by name
+     * - The built-in effects draw with a sheet of shapes the plugin draws itself, so they need no image
+     * @namespace ParticleEffects
+     */
+    /** The groups the settings are in, in order
+     *  @type {Array<string>}
+     *  @memberof ParticleEffects */
+    export const particleEffectGroups: Array<string>;
+    /** Every setting an effect has: its name, kind (number, checkbox, color or shape), default, the range the designer's
+     *  slider covers (min, max, step), the hard limits a typed value is clamped to, and whether it is set after the
+     *  emitter is made rather than passed to its constructor (extra)
+     *  @type {Array<{group:string, name:string, kind:string, value:any, min:number, max:number, step:number,
+     *  description:string, hardMin:number, hardMax:number, extra:boolean}>}
+     *  @memberof ParticleEffects */
+    export const particleEffectSettings: Array<{
+        group: string;
+        name: string;
+        kind: string;
+        value: any;
+        min: number;
+        max: number;
+        step: number;
+        description: string;
+        hardMin: number;
+        hardMax: number;
+        extra: boolean;
+    }>;
+    /** The behaviors an effect can use, each a push applied to every particle every update, with a 2D and a 3D version
+     *  @type {Array<{name:string, update:(Function|undefined), update3D:(Function|undefined), min:number, max:number,
+     *  value:number, description:string}>}
+     *  @memberof ParticleEffects */
+    export const particleEffectBehaviors: Array<{
+        name: string;
+        update: (Function | undefined);
+        update3D: (Function | undefined);
+        min: number;
+        max: number;
+        value: number;
+        description: string;
+    }>;
+    /** Names of the shapes the plugin draws, for an effect's shape setting
+     *  @type {Array<string>}
+     *  @memberof ParticleEffects */
+    export const particleEffectShapes: Array<string>;
+    /** Any input into a whole effect: missing fields take their defaults, bad ones are dropped or clamped
+     *  @param {Object} [raw] - {name, settings, behaviors}, from a library file, the designer or code
+     *  @return {{name:string, settings:Object, behaviors:Array<{name:string, strength:number}>}}
+     *  @memberof ParticleEffects */
+    export function particleEffectSanitize(raw?: any): {
+        name: string;
+        settings: any;
+        behaviors: {
+            name: string;
+            strength: number;
+        }[];
+    };
+    /** A copy of an effect with its four colors turned around the color wheel and their saturation scaled; lightness and
+     *  alpha stay, and grey and white have no hue to turn
+     *  @param {Object} effect
+     *  @param {number} [hue] - How far around the wheel, 1 is all the way
+     *  @param {number} [saturation] - Multiplies the saturation, 0 is grey, clamped to 1
+     *  @return {Object}
+     *  @memberof ParticleEffects */
+    export function particleEffectRecolor(effect: any, hue?: number, saturation?: number): any;
+    /** Add effects to play by name, sanitized; one with the name of an effect already there replaces it
+     *  @param {Array<Object>|Object} effects
+     *  @memberof ParticleEffects */
+    export function particleEffectsAdd(effects: Array<any> | any): void;
+    /** The effect with a name, any case, undefined if there is none
+     *  @param {string} name
+     *  @return {Object|undefined}
+     *  @memberof ParticleEffects */
+    export function particleEffectsGet(name: string): any | undefined;
+    /** A library file, or one effect, into sanitized effects; throws on bad input
+     *  @param {string} text
+     *  @return {Array<Object>}
+     *  @memberof ParticleEffects */
+    export function particleEffectsParse(text: string): Array<any>;
+    /** The text of a library file with these effects, what particleEffectsLoad and the designer read
+     *  @param {Array<Object>} effects
+     *  @return {string}
+     *  @memberof ParticleEffects */
+    export function particleEffectsText(effects: Array<any>): string;
+    /** Load a library file the particle designer saved and add its effects
+     *  @param {string} url
+     *  @return {Promise<Array<Object>>} - The effects it had
+     *  @memberof ParticleEffects */
+    export function particleEffectsLoad(url: string): Promise<Array<any>>;
+    /** The tile of a built-in shape, on a sheet the plugin draws once; undefined headless, without a canvas or without
+     *  WebGL, where an effect draws untextured squares
+     *  @param {string} name - One of particleEffectShapes
+     *  @return {TileInfo|undefined}
+     *  @memberof ParticleEffects */
+    export function particleEffectShapeTile(name: string): TileInfo | undefined;
+    /** Play an effect: a 2D emitter set to it, placed, scaled and recolored
+     *  - A continuous effect (fire, a torch) goes until destroyed or given an emitTime, a one-shot ends itself
+     *  - Any setting in the options replaces the effect's own for this play: {emitTime: .5} for a burst of a continuous
+     *    effect, {emitTime: 0, emitRate: 30} to keep a one-shot going, or speed, particleTime and the rest
+     *  - Attach it to an object with addChild to follow it
+     *  @param {string|Object} nameOrEffect - A built-in or added effect's name, or an effect
+     *  @param {Vector2} [pos]
+     *  @param {Object} [options] - What to change for this play, each left out when not wanted:
+     *    scale grows the whole effect, the built-ins fit a one unit object at 1;
+     *    hue turns its colors around the color wheel, 1 is all the way;
+     *    saturation multiplies its saturation, 0 is grey;
+     *    angle is its direction, 0 is up, the effect's own angle when not given;
+     *    tileInfo, a TileInfo or a TextureInfo, is the game's own art to draw with in place of the effect's shape,
+     *    tinted by its colors, a whole texture drawn as one tile;
+     *    and any effect setting by its name, emitTime, emitRate, speed and the rest, replaces the effect's own
+     *  @return {ParticleEmitter|undefined} - undefined when there is no such effect
+     *  @memberof ParticleEffects */
+    export function particleEffect(nameOrEffect: string | any, pos?: Vector2, options?: any): ParticleEmitter | undefined;
+    /** Play an effect in 3D: a ParticleEmitter3D set to it, placed, scaled and recolored
+     *  - The same effect data as particleEffect, so the look carries across: a circle spawn area becomes a sphere and a
+     *    rectangle a box as deep as it is wide, both flat across the way it emits with options.flatten, a disc or a
+     *    sheet; a trail becomes a streak of the same length, and the settings the 3D emitter lacks (particleConeAngle,
+     *    randomColorLinear, velocityInheritance, localSpace) are left out; the stick behavior becomes the emitter's
+     *    stick, its grip where a particle lands
+     *  @param {string|Object} nameOrEffect - A built-in or added effect's name, or an effect
+     *  @param {Vector3} [pos3D]
+     *  @param {Object} [options] - scale, hue, saturation, angle, tileInfo and any setting as particleEffect; angle turns it
+     *    about z, so 0 is up; flatten makes the spawn area flat across the way it emits
+     *  @return {ParticleEmitter3D|undefined} - undefined when there is no such effect
+     *  @memberof ParticleEffects */
+    export function particleEffect3D(nameOrEffect: string | any, pos3D?: Vector3, options?: any): ParticleEmitter3D | undefined;
+    /** The names of the built-in effects, in the order a gallery shows them
+     *  @type {Array<string>}
+     *  @memberof ParticleEffects */
+    export const particleEffectsBuiltIn: Array<string>;
+    /** Set a 2D emitter to an effect, live, so a running one keeps its particles
+     *  @param {ParticleEmitter} emitter
+     *  @param {Object} effect
+     *  @memberof ParticleEffects */
+    export function particleEffectApply(emitter: ParticleEmitter, effect: any): void;
+    /** Set a 3D emitter to an effect, live, so a running one keeps its particles; its place, scale and flatten stay
+     *  @param {ParticleEmitter3D} emitter
+     *  @param {Object} effect
+     *  @memberof ParticleEffects */
+    export function particleEffectApply3D(emitter: ParticleEmitter3D, effect: any): void;
+    /** An effect with a 2D emitter's settings, to save, build again, or build in 3D with particleEffect3D; its tile is
+     *  left out, since a hand made emitter's tile is its own texture and not one an effect can name, and so is its
+     *  scale, which an effect does not keep: pass it again with options.scale
+     *  @param {ParticleEmitter} emitter
+     *  @param {string} [name]
+     *  @return {Object}
+     *  @memberof ParticleEffects */
+    export function particleEffectFromEmitter(emitter: ParticleEmitter, name?: string): any;
+    /** Add a behavior effects can use by name, or replace one
+     *  @param {string} name
+     *  @param {function(Particle, number): void} update - Pushes a 2D particle, given the strength
+     *  @param {function(Particle3D, number): void} [update3D] - The same for a 3D particle, none leaves 3D alone
+     *  @param {number} [min] - Strength range the designer offers
+     *  @param {number} [max]
+     *  @param {number} [value] - Strength when first added
+     *  @param {string} [description]
+     *  @memberof ParticleEffects */
+    export function particleEffectsAddBehavior(name: string, update: (arg0: Particle, arg1: number) => void, update3D?: (arg0: Particle3D, arg1: number) => void, min?: number, max?: number, value?: number, description?: string): void;
 }