littlejsengine 1.22.0 → 1.23.0

package/dist/littlejs.esm.js

@@ -35,7 +35,7 @@ const engineName = 'LittleJS';
  *  @type {string}
  *  @default
  *  @memberof Engine */
-const engineVersion = '1.22.0';
+const engineVersion = '1.23.0';
 
 /** Frames per second to update
  *  @type {number}
@@ -3772,6 +3772,15 @@ let touchGamepadEnable = false;
  *  @memberof Settings */
 let touchGamepadPassthrough = false;
 
+/** 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 */
+let touchPinchWheel = true;
+
 /** 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
@@ -4167,6 +4176,11 @@ function setTouchInputEnable(enable) { touchInputEnable = enable; }
  *  @memberof Settings */
 function setTouchGamepadEnable(enable) { touchGamepadEnable = enable; }
 
+/** Set if a pinch of two fingers turns the mouse wheel
+ *  @param {boolean} enable
+ *  @memberof Settings */
+function setTouchPinchWheel(enable) { touchPinchWheel = enable; }
+
 /** Set if touches outside the gamepad controls should still drive mouse/touch input
  *  @param {boolean} passthrough
  *  @memberof Settings */
@@ -5473,17 +5487,29 @@ class SpriteAnimator
      *  @return {SpriteAnimation} */
     get clip() { return this.clips[this.name]; }
 
+    /** 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()
+    {
+        // each clip's own isDone calls its onEnd once; a few switches in a row at most
+        for (let i = 4, clip; i-- && clip !== this.clip;)
+            (clip = this.clip).isDone;
+        return this.clip;
+    }
+
     /** The tile of the frame showing now
      *  @return {TileInfo} */
-    get tileInfo() { return this.clip.tileInfo; }
+    get tileInfo() { return this.settledClip.tileInfo; }
 
     /** The frame of the clip showing now
      *  @return {number} */
-    get frame() { return this.clip.frame; }
+    get frame() { return this.settledClip.frame; }
 
     /** True once the clip showing now is a play that has ended
      *  @return {boolean} */
-    get isDone() { return this.clip.isDone; }
+    get isDone() { return this.settledClip.isDone; }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -6922,6 +6948,13 @@ let mouseDeltaScreen = vec2();
  *  @memberof Input */
 let mouseWheel = 0;
 
+/** 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 */
+let touchPinch = 0;
+
 /** True if mouse was inside the document window, set to false when mouse leaves
  *  @type {boolean}
  *  @memberof Input */
@@ -7010,6 +7043,7 @@ function inputClearKey(key, device=0, clearDown=true, clearPressed=true, clearRe
 const inputWASDToArrow = {KeyW:'ArrowUp', KeyS:'ArrowDown', KeyA:'ArrowLeft', KeyD:'ArrowRight'};
 const inputArrowToWASD = {ArrowUp:'KeyW', ArrowDown:'KeyS', ArrowLeft:'KeyA', ArrowRight:'KeyD'};
 const inputKeysHeld = new Set; // the keys physically down, since an arrow's slot is shared with its alias
+let inputPinch; // the two fingers pinching and how far apart they were, undefined with no pinch
 let inputWasTouching = 0, inputTouchIdentifier; // the touch driving the mouse, cleared with the input so only a new touch presses
 let inputLastTouchTime = -1e9; // when a touch event last came, the mouse events a browser makes from a tap follow it
 
@@ -7052,6 +7086,7 @@ function inputClear()
         if (!i || inputData[i]) inputData[i] = [];
     inputKeysHeld.clear();
     inputWasTouching = 0;
+    inputPinch = undefined;
     // release the touch gamepad, a finger still on it has to lift before it can take a control again
     touchGamepadPointerRole.clear();
     touchGamepadButtons.length = 0;
@@ -7579,19 +7614,52 @@ function inputInit()
                     const pressTouch = !inputWasTouching && e.type == 'touchstart' &&
                         [...e.changedTouches].find(t=> !isGamepadTouch(t));
                     const touch = pressTouch || gameTouches[0];
+                    let pos = vec2(touch.clientX, touch.clientY);
+
+                    // two fingers pinch: how far they moved together or apart is the touch screen's wheel, a
+                    // click for every 50 pixels, and the mouse is between them, the place to zoom about; with
+                    // touchPinchWheel off the pinch is only measured, and the first finger is the mouse as ever
+                    const pinching = touching > 1 && touchPinchWheel;
+                    if (touching > 1)
+                    {
+                        const [a, b] = gameTouches, key = a.identifier + ' ' + b.identifier;
+                        const distance = hypot(a.clientX - b.clientX, a.clientY - b.clientY);
+                        if (inputPinch && inputPinch.key === key)
+                        {
+                            const delta = (inputPinch.distance - distance) / 50;
+                            touchPinch += delta;
+                            if (touchPinchWheel)
+                                mouseWheel += delta;
+                        }
+                        inputPinch = {key, distance}; // other fingers start it over, with no jump
+                        if (pinching)
+                            pos = vec2((a.clientX + b.clientX) / 2, (a.clientY + b.clientY) / 2);
+                    }
+                    else
+                        inputPinch = undefined;
 
                     // set event pos and pass it along
-                    const pos = vec2(touch.clientX, touch.clientY);
                     const mousePosScreenLast = mousePosScreen;
                     mousePosScreen = mouseEventToScreen(pos);
-                    if (inputWasTouching && touch.identifier === inputTouchIdentifier)
+                    if (pinching)
+                    {
+                        // a pinch is not a press or a drag, the finger that pressed lets go
+                        if (inputData[0][button] & 1)
+                            inputData[0][button] = inputData[0][button] & 2 | 4;
+                    }
+                    else if (inputWasTouching && touch.identifier === inputTouchIdentifier)
                         mouseDeltaScreen = mouseDeltaScreen.add(mousePosScreen.subtract(mousePosScreenLast));
                     else if (pressTouch)
                         inputData[0][button] = 3;
-                    inputTouchIdentifier = touch.identifier;
+                    // the finger left after a pinch moves the mouse from where it is, with no jump and no press
+                    inputTouchIdentifier = pinching ? undefined : touch.identifier;
+                }
+                else
+                {
+                    inputPinch = undefined;
+                    if (inputWasTouching && (inputData[0][button] & 1))
+                        inputData[0][button] = inputData[0][button] & 2 | 4; // released only if it was pressed
                 }
-                else if (inputWasTouching && (inputData[0][button] & 1))
-                    inputData[0][button] = inputData[0][button] & 2 | 4; // released only if it was pressed
 
                 // set was touching
                 inputWasTouching = touching;
@@ -7850,7 +7918,7 @@ function inputUpdatePost()
     for (const deviceInputData of inputData)
     for (const i in deviceInputData)
         deviceInputData[i] &= 1;
-    mouseWheel = 0;
+    mouseWheel = touchPinch = 0;
     mouseDelta = vec2();
     mouseDeltaScreen = vec2();
 }
@@ -8582,10 +8650,9 @@ class Sound
         ASSERT(isNumber(range), 'range must be a number');
         ASSERT(isNumber(taper), 'taper must be a number');
 
-        /** @property {number} - World space max range of sound */
         this.range = range;
         /** @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 */
+         *  to render3D.soundDefaultRange instead, which is further; setting range makes it false */
         this.rangeIsDefault = rangeIsDefault;
         /** @property {number} - At what percentage of range should it start tapering */
         this.taper = taper;
@@ -8641,6 +8708,15 @@ class Sound
         }
     }
 
+    /** 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() { return this.rangeValue; }
+    set range(range)
+    {
+        this.rangeValue = range;
+        this.rangeIsDefault = false;
+    }
+
     /** Sample data for each channel
      *  Sounds keep their samples in an audio buffer, so reading this rebuilds
      *  the arrays from it and caches them. The copies are safe to hold onto,
@@ -14006,13 +14082,13 @@ class LightSystemPlugin
             // an automatic size follows the canvas, so reallocate the lightmap when
             // the canvas changed size, after the flush so the batch keeps its texture
             const size = lightSystem.textureSize;
-            if (lightSystem.textureSizeAuto &&
-                (size.x !== mainCanvasSize.x || size.y !== mainCanvasSize.y))
+            const wantX = glClampTextureSize(mainCanvasSize.x), wantY = glClampTextureSize(mainCanvasSize.y);
+            if (lightSystem.textureSizeAuto && (size.x !== wantX || size.y !== wantY))
             {
-                lightSystem.textureSize = mainCanvasSize.copy();
+                lightSystem.textureSize = vec2(wantX, wantY);
                 glContext.bindTexture(glContext.TEXTURE_2D, lightSystem.texture);
                 glContext.texImage2D(glContext.TEXTURE_2D, 0, glContext.RGBA,
-                    mainCanvasSize.x, mainCanvasSize.y, 0,
+                    wantX, wantY, 0,
                     glContext.RGBA, glContext.UNSIGNED_BYTE, null);
                 // put back the texture the engine tracks, a draw in renderLight must not sample the lightmap
                 if (glActiveTexture)
@@ -14152,8 +14228,10 @@ class LightSystemPlugin
         this.shadowMapSize = glClampTextureSize(this.shadowMapSize);
         this.shadowTextureSize = glClampTextureSize(this.shadowTextureSize);
         const size = this.textureSize;
-        if (size)
-            this.textureSize = vec2(glClampTextureSize(size.x), glClampTextureSize(size.y));
+        if (!size) return;
+        const x = glClampTextureSize(size.x), y = glClampTextureSize(size.y);
+        if (x !== size.x || y !== size.y)
+            this.textureSize = vec2(x, y); // only when it is too large, this runs every frame
     }
 
     /** Draw a single Light's falloff blob into the currently bound lightmap.
@@ -20991,6 +21069,179 @@ function sceneUpdate() { paused || !timeScale || sceneCurrent?.update?.(); }
 function sceneRender() { sceneCurrent?.render?.(); }
 function sceneRenderPost() { sceneCurrent?.renderPost?.(); }
 
+/**
+ * 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);
+ * });
+ */
+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=vec2(), size=vec2(32, 16), parallax=.5, renderOrder=-1e3, drawFunction=parallaxMountains(),
+        canvasSize=vec2(512, 256))
+    {
+        ASSERT(isNumber(parallax) || isVector2(parallax), 'parallax must be a number or a Vector2');
+        ASSERT(typeof drawFunction == 'function', 'drawFunction must be a function');
+        super(pos, size, 0, renderOrder, canvasSize);
+
+        /** @property {Vector2} - How much of the camera's movement it follows on each axis, 0 stays with the world
+         *  and 1 with the screen */
+        this.parallax = isVector2(parallax) ? /** @type {Vector2} */ (parallax).copy() :
+            vec2(/** @type {number} */ (parallax));
+        /** @property {boolean} - Repeat the image across the view, left and right */
+        this.wrapX = true;
+        /** @property {boolean} - Repeat the image up and down the view */
+        this.wrapY = false;
+        /** @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 */
+        this.zoomFollow = 1;
+        /** @property {number} - The camera scale its size is given for, used when zoomFollow is under 1 */
+        this.zoomScale = cameraScale;
+        /** @property {function(OffscreenCanvasRenderingContext2D, Vector2, ParallaxLayer): void} - Draws the
+         *  image, redraw() after changing it */
+        this.drawFunction = drawFunction;
+        this.redraw();
+    }
+
+    /** Draw the image again with drawFunction, after changing it or what it draws from */
+    redraw()
+    {
+        const context = this.context;
+        if (!context) return; // headless
+        const size = vec2(this.canvas.width, this.canvas.height);
+        context.clearRect(0, 0, size.x, size.y);
+        this.drawFunction(context, size, this);
+        this.updateWebGL();
+    }
+
+    // how much smaller it is drawn than its size, from the camera's zoom and how much of it the layer follows
+    zoomFactor()
+    { return this.zoomFollow < 1 && cameraScale > 0 ? (this.zoomScale / cameraScale) ** (1 - this.zoomFollow) : 1; }
+
+    /** World size one copy of the image is drawn at now, its size unless zoomFollow is under 1
+     *  @return {Vector2} */
+    getDrawSize() { return this.size.scale(this.zoomFactor()); }
+
+    /** 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()
+    {
+        // its place seen from the camera is cut down by the parallax, and by the zoom it does not follow
+        const zoom = this.zoomFactor(), size = this.size.scale(zoom), p = this.parallax;
+        const offset = this.pos.subtract(cameraPos);
+        const center = cameraPos.add(vec2(offset.x * (1 - p.x) * zoom, offset.y * (1 - p.y) * zoom));
+
+        // the copies that reach into the view; a turned camera sees as far as its corner each way
+        const view = mainCanvasSize.scale(.5 / (cameraScale || 1));
+        const reach = cameraAngle ? vec2(view.length()) : view;
+        const range = (wrap, axis)=>
+        {
+            if (!wrap || !(size[axis] > 0)) return [0, 0];
+            const from = cameraPos[axis] - reach[axis] - size[axis] / 2 - center[axis];
+            const to = cameraPos[axis] + reach[axis] + size[axis] / 2 - center[axis];
+            const first = ceil(from / size[axis]);
+            return [first, min(floor(to / size[axis]), first + 99)]; // a tiny image does not draw without end
+        };
+        const [x0, x1] = range(this.wrapX, 'x'), [y0, y1] = range(this.wrapY, 'y'), positions = [];
+        for (let y = y0; y <= y1; ++y)
+        for (let x = x0; x <= x1; ++x)
+            positions.push(vec2(center.x + x * size.x, center.y + y * size.y));
+        return positions;
+    }
+
+    // Render the layer, called automatically by the engine
+    render()
+    {
+        const size = this.getDrawSize();
+        for (const pos of this.getDrawPositions())
+            this.draw(pos, size, this.color, 0, this.mirror, this.additiveColor, false);
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
+// the ridge of a range of mountains: a height for each column of an image and one more, the last the same as the
+// first so the image repeats with no step; it wanders about the middle, turning now and then
+function parallaxRidge(width, height, random)
+{
+    const pointiness = .2, levelness = .005, slopeRange = height / 256; // how often it turns, how hard it is
+    const ridge = new Float32Array(width + 1), middle = height / 2;     // pulled level, how steep it gets
+    let y = middle, slope = random.float(-slopeRange, slopeRange);
+    for (let x = 0; x <= width; ++x)
+    {
+        ridge[x] = y;
+        y += slope -= (y - middle) * levelness;
+        if (random.float() < pointiness)
+            slope = random.float(-slopeRange, slopeRange);
+    }
+    // take out the difference between its ends, a little from each column, and keep it inside the image
+    const drift = ridge[width] - ridge[0];
+    for (let x = 0; x <= width; ++x)
+        ridge[x] = clamp(ridge[x] - drift * x / width, 0, height);
+    return ridge;
+}
+
+/** 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 */
+function parallaxMountains(topColor=hsl(.6, .2, .6), bottomColor=hsl(.6, .3, .25), seed)
+{
+    return (context, size)=>
+    {
+        const w = size.x, h = size.y;
+        const random = new RandomGenerator(seed === undefined ? randInt(1e9) + 1 : seed * 7919 + 1);
+        const ridge = parallaxRidge(w, h, random);
+
+        // a strip one pixel wide with the shading, stretched down each column from its peak
+        const strip = createCanvasContext(1, h);
+        for (let i = h; i--;)
+        {
+            strip.fillStyle = topColor.lerp(bottomColor, i / h).toString();
+            strip.fillRect(0, i, 1, 1);
+        }
+        for (let x = w; x--;)
+            ridge[x] < h && context.drawImage(strip.canvas, 0, 0, 1, h, x, ridge[x], 1, h - ridge[x]);
+    };
+}
+
 /**
  * LittleJS PathFinder Plugin
  * - Grid-based A* pathfinder with two-pass smoothing for natural-looking paths
@@ -23257,12 +23508,17 @@ function render3DShadowCaster()
         light.intensity > 0 && light.color.a > 0 ? light : undefined;
 }
 
+// the widest cone a shadow map can look down, to each side; the light that casts the shadows lights no wider, or
+// what is past the map's edge would be lit with nothing to shade it
+const RENDER3D_SHADOW_CONE_MAX = 1.35;
+
 // a light's cone as the four numbers the shader gets: the way it shines, scaled so that its dot with the way to
 // a point, less the fourth number, is 0 at the edge of the cone and 1 where its fade starts; a light with no cone
 // gets numbers that make it 1 every way
 function render3DLightCone(light)
 {
-    const angle = light.directional ? 0 : min(light.coneAngle, PI);
+    const widest = light === render3DShadowCaster() ? RENDER3D_SHADOW_CONE_MAX : PI;
+    const angle = light.directional ? 0 : min(light.coneAngle, widest);
     if (!(angle > 0)) return [0, 0, 0, -1];
     const outer = cos(angle), inner = cos(angle * (1 - clamp(light.coneSoftness)));
     const k = 1 / max(inner - outer, 1e-4), forward = light.getForward3D();
@@ -24049,8 +24305,9 @@ class Render3DPlugin
             // a spotlight's map looks down its cone with perspective, from just in front of it out to its radius
             const pos = caster.getWorldPos3D(), forward = caster.getForward3D();
             const up = abs(forward.y) > .99 ? vec3(0, 0, 1) : vec3(0, 1, 0);
-            const far = caster.radius, near = max(far / 500, .02);
-            const fov = min(min(caster.coneAngle, PI) * 2 + .1, 2.8);
+            // the near plane stays in front of the far one however small the light
+            const far = caster.radius, near = min(max(far / 500, .02), far / 2);
+            const fov = min(caster.coneAngle, RENDER3D_SHADOW_CONE_MAX) * 2 + .1;
             this.shadowMatrix = Matrix4.perspective(fov, 1, near, far).multiply(
                 Matrix4.lookAt(pos, pos.add(forward), up).invert());
             this.shadowPlanes = render3DFrustumPlanes(this.shadowMatrix);
@@ -27484,7 +27741,7 @@ class InstancedMesh3D extends EngineObject3D
  * - 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
@@ -27533,8 +27790,10 @@ class Light3D extends EngineObject3D
         const r = render3D, c = this.color, pos = render3DObjectMatrix(this).getTranslation();
         const toCamera = r.camera.pos.subtract(pos), distance = toCamera.length();
         const at = distance ? pos.add(toCamera.scale(min(this.glow, distance) / 2 / distance)) : pos;
-        const color = rgb(c.r, c.g, c.b, c.a * min(this.intensity, 1));
-        r.drawBillboard(at, vec2(this.glow), engineGlowTexture(this.glowFalloff), color);
+        const color = rgb(c.r, c.g, c.b, c.a * min(this.intensity, 1)), texture = engineGlowTexture(this.glowFalloff);
+        // a browser that can not make the glow's texture draws no glow, not a plain square
+        if (texture || !glContext)
+            r.drawBillboard(at, vec2(this.glow), texture, color);
     }
 }
 
@@ -27544,7 +27803,7 @@ class Light3D extends EngineObject3D
  * - 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
@@ -28621,6 +28880,9 @@ class ParticleEmitter3D extends EngineObject3D
         /** @property {boolean} - Particles hit the level, the height maps and voxel maps, bouncing by restitution and
          *  sliding along by friction; off by default, it tests each particle's move against the level every frame */
         this.collideLevel = false;
+        /** @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 */
+        this.stick = 0;
         /** @property {Particle3DCallback|undefined} - Called with each particle as it is made
          *  @type {Particle3DCallback|undefined} */
         this.particleCreateCallback = undefined;
@@ -28640,7 +28902,7 @@ class ParticleEmitter3D extends EngineObject3D
         /** @property {Vector3|undefined} - Where the emitter was at its last update, for when its parent is destroyed
          *  @type {Vector3|undefined} */
         this.worldPos3D = undefined;
-        this.emitTimeBuffer = 0;
+        this.emitTimeBuffer = 1; // the first particle comes at once, as the 2D emitter's does
     }
 
     /** Spawn new particles, move the live ones, and go away when done */
@@ -28657,9 +28919,10 @@ class ParticleEmitter3D extends EngineObject3D
         {
             // a rate of zero is an emitter fed by hand, and the global scale only quiets it,
             // neither is a reason to stop counting down the emit time
-            if (this.emitRate && particleEmitRateScale)
+            const rate = this.emitRate * particleEmitRateScale;
+            if (rate > 0 && rate < Infinity)
             {
-                this.emitTimeBuffer += this.emitRate * particleEmitRateScale * timeDelta;
+                this.emitTimeBuffer += rate * timeDelta;
                 for (; this.emitTimeBuffer >= 1; --this.emitTimeBuffer)
                     this.emitParticle();
             }
@@ -28699,7 +28962,9 @@ class ParticleEmitter3D extends EngineObject3D
             const vz = data[k+5] = data[k+5] * damping + gravityZ;
             data[k] += vx, data[k+1] += vy, data[k+2] += vz;
             data[k+18] += data[k+19] *= angleDamping;
-            collideLevel && (this.particleCollide(k, data[k] - vx, data[k+1] - vy, data[k+2] - vz), reread());
+            // true when its collide callback destroyed it, it has had its last callback but the destroy one
+            const gone = collideLevel && this.particleCollide(k, data[k] - vx, data[k+1] - vy, data[k+2] - vz);
+            collideLevel && reread();
             const t = i * trailMax * 3;
             if (trailMax)
             {
@@ -28711,7 +28976,7 @@ class ParticleEmitter3D extends EngineObject3D
                 trail[j] = data[k], trail[j+1] = data[k+1], trail[j+2] = data[k+2];
                 data[k+20] = n + 1;
             }
-            updateCallback && (this.particleCall(updateCallback, k), reread());
+            updateCallback && !gone && (this.particleCall(updateCallback, k), reread());
             if ((data[k+17] += timeDelta) >= data[k+16])
             {
                 // dead: the last particle takes its slot, trail and all, order does not matter
@@ -28813,13 +29078,14 @@ class ParticleEmitter3D extends EngineObject3D
         out[k] = view.pos.x, out[k+1] = view.pos.y, out[k+2] = view.pos.z;
         out[k+3] = view.velocity.x, out[k+4] = view.velocity.y, out[k+5] = view.velocity.z;
         if (view.destroyed)
-            out[k+17] = max(out[k+17], out[k+16] - timeDelta); // aged past its life this update
+            out[k+17] = max(out[k+17], out[k+16]); // its life lived: a step short of it can round to just under
         return result;
     }
 
     // stop the particle at k where its last move went into the level, from where it was: back at the surface, a hair
     // off it, its speed into it turned around by restitution and its speed along it kept by friction, unless the
-    // collide callback lets it through; one that starts inside is let go, as a 2D one is
+    // collide callback lets it through; one that starts inside is let go, as a 2D one is; true when the callback
+    // destroyed it
     particleCollide(k, x, y, z)
     {
         let data = this.particleData;
@@ -28832,18 +29098,21 @@ class ParticleEmitter3D extends EngineObject3D
             if (h && (!hit || h.distance < hit.distance))
                 hit = h, level = l;
         }
-        if (!hit) return;
+        if (!hit) return false;
         const point = from.lerp(to, hit.distance);
         const callback = this.particleCollideCallback;
         if (callback && (!this.particleCall(callback, k, level, point.copy()) || this.particleView.destroyed))
-            return; // let through, or destroyed by the callback
+            return this.particleView.destroyed; // let through, or destroyed by the callback
         data = this.particleData; // as the callback left it, an emit may have grown it
 
         const n = hit.normal, v = vec3(data[k+3], data[k+4], data[k+5]), into = n.scale(v.dot(n));
-        const restitution = max(this.restitution, level.restitution), friction = max(this.friction, level.friction);
+        // the larger friction of the two, as objects take it, then the emitter's own grip, which a level can not undo
+        const restitution = max(this.restitution, level.restitution);
+        const friction = max(this.friction, level.friction) * (1 - clamp(this.stick));
         const out = v.subtract(into).scale(friction).subtract(into.scale(restitution)), p = point.add(n.scale(1e-3));
         data[k] = p.x, data[k+1] = p.y, data[k+2] = p.z;
         data[k+3] = out.x, data[k+4] = out.y, data[k+5] = out.z;
+        return false;
     }
 
     /** Draw the particles, as flat squares or as streaks when trailTime is set
@@ -29107,6 +29376,11 @@ class LensFlare3D extends EngineObject3D
          *  height; shape is glow, disc or ring
          *  @type {Array<{at: number, size: number, color: Color, shape: string}>|undefined} */
         this.elements = undefined;
+        /** @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} */
+        this.light = undefined;
         /** @property {boolean} - Fade out when something is between the camera and the sun */
         this.occlusion = true;
         /** @property {number} - Seconds the flare takes to fade out or in when the sun is hidden or shows again */
@@ -29145,13 +29419,30 @@ class LensFlare3D extends EngineObject3D
         return this.made;
     }
 
-    /** Where the sun is on the screen, in pixels like mousePosScreen, undefined when it is behind the camera
+    // what the flare is of, seen from the camera: the way to it, how far it is, Infinity for the sun, and a point
+    // to find it on the screen by; undefined with no sun direction, or a light that is gone or at the camera
+    flareSource()
+    {
+        const camera = render3D.camera.pos, light = this.light;
+        if (!light)
+        {
+            const sun = render3D.sunDirection;
+            if (!sun.lengthSquared()) return;
+            const direction = sun.normalize();
+            return {direction, distance: Infinity, pos: camera.add(direction.scale(100))};
+        }
+        if (light.destroyed) return;
+        const pos = light.getWorldPos3D(), offset = pos.subtract(camera), distance = offset.length();
+        return distance ? {direction: offset.scale(1 / distance), distance, pos} : undefined;
+    }
+
+    /** 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()
     {
-        const direction = render3D.sunDirection;
-        if (!direction.lengthSquared()) return;
-        return render3D.worldToScreen(render3D.camera.pos.add(direction.normalize(100)));
+        const source = this.flareSource();
+        return source && render3D.worldToScreen(source.pos);
     }
 
     /** The parts of the flare as they are drawn now: each one's place on the screen, its size in pixels and its
@@ -29165,7 +29456,19 @@ class LensFlare3D extends EngineObject3D
         const off = max(abs(sun.x - center.x) / center.x, abs(sun.y - center.y) / center.y);
         const strength = this.visible * clamp((1.3 - off) / .5) * this.intensity;
         if (!(strength > 0)) return [];
-        const tint = this.color.multiply(render3D.sunColor), height = mainCanvasSize.y * this.flareSize;
+        let tint = this.color.multiply(render3D.sunColor), height = mainCanvasSize.y * this.flareSize;
+        const light = this.light, source = light && this.flareSource();
+        if (light)
+        {
+            if (!source) return [];
+            // a light's flare is the light's color, as bright as the light up to 1, and only from inside its cone
+            const cone = render3DLightCone(light), d = source.direction;
+            const inCone = clamp(-(cone[0] * d.x + cone[1] * d.y + cone[2] * d.z) - cone[3]);
+            const c = light.color, bright = c.a * clamp(light.intensity) * inCone;
+            if (!(bright > 0)) return [];
+            tint = this.color.multiply(rgb(c.r, c.g, c.b, bright));
+            height *= min(1, light.radius / source.distance); // smaller from farther than it reaches
+        }
         return this.getElements().map((e)=>
         {
             const c = e.color.multiply(tint);
@@ -29175,15 +29478,32 @@ class LensFlare3D extends EngineObject3D
         });
     }
 
-    /** Is something between the camera and the sun: the level, or an object that is not see through
+    /** 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()
     {
-        const direction = render3D.sunDirection;
-        if (!direction.lengthSquared()) return true;
-        const blockers = engineObjects.filter((o)=> o !== this && o instanceof EngineObject3D && !o.transparent &&
-            !o.additive);
-        return !!render3D.pick(new Ray3D(render3D.camera.pos, direction.normalize()), blockers);
+        const source = this.flareSource();
+        if (!source) return true;
+        const ray = new Ray3D(render3D.camera.pos, source.direction), reach = source.distance;
+        const blockers = engineObjects.filter((o)=> o !== this && o instanceof EngineObject3D && !o.destroyed &&
+            !o.transparent && !o.additive);
+        // a voxel map says block by block what is see through: glass, water and leaves let the sun by, and the
+        // ray goes on to the blocks behind them
+        const maps = /** @type {Array<VoxelMap>} */ (typeof VoxelMap == 'undefined' ? [] :
+            blockers.filter((o)=> o instanceof VoxelMap));
+        for (const map of maps)
+            if (map.raycast(ray, reach, (type)=> !map.blockType(type).seeThrough))
+                return true;
+        // an object is hit by its box, and a box the camera is inside, a room, a wide floor or the player's own
+        // body, says nothing of what is in the way: the ray the other way hits it too, and it is left out; so is
+        // one the light is inside, its lamp
+        const backward = ray.direction.scale(-1), back = new Ray3D(ray.origin, backward);
+        const lamp = this.light && [new Ray3D(source.pos, ray.direction), new Ray3D(source.pos, backward)];
+        const hits = (r, o)=> render3DRaycastObject(r, o) !== undefined;
+        const around = (o)=> !(o instanceof HeightMap) && (hits(back, o) || lamp && hits(lamp[0], o) && hits(lamp[1], o));
+        const hit = render3D.pick(ray, blockers.filter((o)=> !maps.some((map)=> map === o) && !around(o)));
+        return !!hit && hit.distance < reach;
     }
 
     /** Ease visible toward whether the sun shows, called automatically each frame */
@@ -30313,7 +30633,10 @@ function level3DAddMesh(name, mesh, tileInfo, color=WHITE)
  *    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
+ *    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
@@ -30326,6 +30649,7 @@ function level3DLoad(level)
     ASSERT(!!level && typeof level === 'object', 'a level is an object, {} for a new one');
     ASSERT(!(level.littlejs3D > LEVEL3D_VERSION), 'the level was made by a newer LittleJS');
     editor3DLevelLoaded(level); // debug builds: the 3D editor takes the level, its autosaved edits go in first
+    level3DPrefabsAdd(level.prefabs);
     level3DSceneApply(level.scene);
     const made = [], map = level3DVoxelMap = level3DVoxelsMake(level.voxels);
     map && made.push(map);
@@ -30436,14 +30760,49 @@ function level3DTerrainShape(terrain)
         height: isNumber(terrain.height) && terrain.height > 0 ? terrain.height : 1, heights};
 }
 
+// a hex color of a level as a Color, undefined when it is not one
+function level3DHexColor(hex)
+{ return /^#([0-9a-f]{6}|[0-9a-f]{8})$/i.test(hex) ? new Color().setHex(hex) : undefined; }
+
+// the paint of a level's terrain block, for a terrain of so many samples: its colors as they are written and a
+// color for each sample, row after row, 0 for none and 1 the first of the colors; undefined when it has none or
+// it does not fit the terrain
+function level3DTerrainPaint(terrain, samples)
+{
+    const paint = terrain?.paint, colors = paint?.colors, runs = paint?.cells;
+    if (!isArray(colors) || !isArray(runs) || colors.length > 255 || !colors.every(level3DHexColor)) return;
+    const cells = new Uint8Array(samples);
+    let at = 0;
+    for (let i = 0; i < runs.length; i += 2)
+    {
+        const count = runs[i], color = runs[i + 1];
+        if (!(count > 0 && count % 1 === 0 && color >= 0 && color % 1 === 0) || color > colors.length ||
+            at + count > samples) return;
+        cells.fill(color, at, at += count);
+    }
+    return at === samples ? {colors: colors.slice(), cells} : undefined;
+}
+
+// give a terrain's map the colors of its block: its own color over the whole of it, or with paint a color for
+// each sample, the terrain's own where it is not painted; the caller builds the map again
+function level3DTerrainSetColors(map, terrain, paint=level3DTerrainPaint(terrain, map.rows * map.columns))
+{
+    const base = level3DHexColor(terrain.color) || WHITE;
+    map.color = base, map.colors = undefined;
+    if (!paint || !paint.cells.some((v)=> v)) return;
+    const palette = [base, ...paint.colors.map(level3DHexColor)];
+    map.color = WHITE;
+    map.colors = map.heights.map((row, r)=> row.map((v, c)=> palette[paint.cells[r * map.columns + c]] || base));
+}
+
 // the HeightMap of a level's terrain block, undefined when it has none or it is wrong
 function level3DTerrainMake(terrain)
 {
     const shape = level3DTerrainShape(terrain);
     if (!shape || typeof HeightMap == 'undefined') return;
     const map = new HeightMap(shape.heights, shape.size, shape.height, undefined, shape.pos);
-    if (/^#([0-9a-f]{6}|[0-9a-f]{8})$/i.test(terrain.color))
-        map.color = new Color().setHex(terrain.color);
+    level3DTerrainSetColors(map, terrain);
+    map.colors && map.rebuild();
     return map;
 }
 
@@ -30516,6 +30875,14 @@ function level3DProperties(type, object)
 // make one object of a level from the type added for its name, undefined when there is no such type or it made
 // nothing
 function level3DMake(object)
+{
+    return level3DMakeAt(object, level3DVector(object.pos, vec3()),
+        level3DVector(object.rotation, vec3()).scale(PI / 180), level3DVector(object.scale, vec3(1)));
+}
+
+// make a level object's game object at a place, a rotation in radians and a scale, its own as level3DMake gives
+// them or the ones a prefab's instance puts it at
+function level3DMakeAt(object, pos, rotation, scale)
 {
     const type = level3DTypes.get(object.type);
     if (!type)
@@ -30523,7 +30890,7 @@ function level3DMake(object)
         debug && console.warn(`level3DLoad: no type added for ${object.type}, skipped`);
         return;
     }
-    const pos = level3DVector(object.pos, vec3()), properties = level3DProperties(type, object);
+    const properties = level3DProperties(type, object);
     const {make} = type, count = engineObjects.length;
     let result;
     try { result = make.prototype ? new make(pos, properties) : make(pos, properties); }
@@ -30541,16 +30908,263 @@ function level3DMake(object)
     if (result instanceof EngineObject3D)
     {
         level3DBaseScale.set(result, result.scale3D.copy());
-        result.rotation3D = level3DVector(object.rotation, vec3()).scale(PI / 180);
-        result.scale3D = result.scale3D.multiply(level3DVector(object.scale, vec3(1)));
+        result.rotation3D = rotation.copy();
+        result.scale3D = result.scale3D.multiply(scale);
     }
 
     // the type's own properties are set on it, one the type has no default for could be a field of the engine's
     for (const key in type.defaults)
         result[key] = properties[key];
+    // a prefab's instance makes its parts now that it is where it goes
+    result instanceof Prefab3D && result.placeAt(pos);
     return result;
 }
 
+/** 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)); */
+function level3DSpawn(type, pos3D=vec3(), rotation3D=vec3(), scale3D=vec3(1), properties)
+{
+    ASSERT(isVector3(pos3D) && isVector3(rotation3D) && isVector3(scale3D), 'pos3D, rotation3D and scale3D are vec3');
+    return level3DMakeAt(properties ? {type, properties} : {type}, pos3D.copy(), rotation3D, scale3D);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// prefabs: a prefab is a small level, a list of objects about its own origin, placed many times
+
+// the prefabs by name: how an instance is built, its objects, fromLevel, true for one a level's own prefabs
+// block added, which one the game adds takes the place of, and source, the object it was added from, which the
+// level editor knows a level that is a prefab by
+/** @type {Map<string, {attached: boolean, objects: Array<Object>, fromLevel: boolean, source: Object}>} */
+const level3DPrefabs = new Map;
+
+// how many prefabs deep an instance being made is, a prefab that holds itself is stopped; and how many of those
+// are attached: a prefab inside an attached one is attached too, or its parts would be left behind in the world
+let level3DPrefabDepth = 0, level3DPrefabAttached = 0;
+
+/** 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]}]}); */
+function level3DAddPrefab(name, prefab) { level3DPrefabSet(name, prefab, false); }
+
+// add a prefab, the game's or a level's own
+function level3DPrefabSet(name, prefab, fromLevel)
+{
+    ASSERT(!!prefab && typeof prefab === 'object', 'a prefab is an object, {objects: [...]}');
+    name = String(name);
+    const objects = isArray(prefab?.objects) ? prefab.objects.filter((o)=> o && typeof o === 'object') : [];
+    // a copy, what the game or the editor does to its own afterwards does not change the instances made later
+    level3DPrefabs.set(name, {attached: !!prefab?.attached, objects: JSON.parse(JSON.stringify(objects)), fromLevel,
+        source: prefab});
+    // a class of its own, so the level editor makes its instances again as it does a class's
+    level3DTypes.set(name, {make: class extends Prefab3D { constructor(pos) { super(pos, name); } }, defaults: {},
+        tileInfo: undefined});
+}
+
+// add a level's own prefabs, each unless the game added one of that name or it is a plain type's name
+function level3DPrefabsAdd(prefabs)
+{
+    if (!prefabs || typeof prefabs !== 'object' || isArray(prefabs)) return;
+    for (const name in prefabs)
+    {
+        const known = level3DPrefabs.get(name);
+        if (known ? !known.fromLevel : level3DTypes.has(name)) continue;
+        prefabs[name] && typeof prefabs[name] === 'object' && level3DPrefabSet(name, prefabs[name], true);
+    }
+}
+
+/** 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 */
+async function level3DLoadPrefab(name, url) { level3DAddPrefab(name, await fetchJSON(url)); }
+
+// where an instance puts one of its prefab's objects: the object's own place, turn and size inside the instance's
+function level3DPrefabPartTransform(instance, object)
+{
+    const pos = level3DVector(object.pos, vec3()), scale = level3DVector(object.scale, vec3(1));
+    const rotation = level3DVector(object.rotation, vec3()).scale(PI / 180);
+    // the two turns one after the other; the sizes multiply along each axis, which is exact for an instance sized
+    // evenly or a part that is not turned, and as near as a box can be otherwise
+    const turn = buildMatrix(vec3(), instance.rotation3D).multiply(buildMatrix(vec3(), rotation));
+    return {pos: buildMatrix(instance.pos3D, instance.rotation3D, instance.scale3D).transformPoint(pos),
+        rotation: turn.getRotation(), scale: scale.multiply(instance.scale3D)};
+}
+
+/**
+ * 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
+ */
+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, prefabName='')
+    {
+        super(pos3D);
+        /** @property {string} - The prefab it is an instance of */
+        this.prefabName = prefabName;
+        /** @property {boolean} - Are its parts its children, moving with it as one body */
+        this.attached = !!level3DPrefabs.get(prefabName)?.attached || level3DPrefabAttached > 0;
+        /** @property {Array<any>} - What the prefab's objects made, in the prefab's order */
+        this.parts = [];
+        /** @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 */
+        this.originOffset = vec3();
+        this.partObjects = []; // the prefab's object of each part
+        this.partsPlaced = ''; // where the handle was when its parts were last placed, undefined parts not made
+        this.partsMade = false;
+    }
+
+    /** 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)
+    {
+        this.pos3D = pos3D.copy();
+        this.placeParts();
+        const o = this.originOffset;
+        if (o.x || o.y || o.z)
+            this.pos3D = buildMatrix(pos3D, this.rotation3D, this.scale3D).transformPoint(o);
+    }
+
+    /** 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()
+    {
+        if (this.destroyed) return;
+        this.partsMade ||= (this.makeParts(), true);
+        this.partsPlaced = this.placeKey();
+        if (this.attached) return; // children follow by themselves
+        this.parts.forEach((part, i)=>
+        {
+            if (!(part instanceof EngineObject3D)) return; // what a function made is where it was made
+            const to = level3DPrefabPartTransform(this, this.partObjects[i]);
+            part.rotation3D = to.rotation;
+            part.scale3D = (level3DBaseScale.get(part) ?? vec3(1)).multiply(to.scale);
+            // a prefab inside this one goes by its origin, which is not where an attached one's handle is
+            part instanceof Prefab3D ? part.placeAt(to.pos) : part.pos3D = to.pos;
+        });
+    }
+
+    // the handle's place, turn and size as one text, to tell when it has changed
+    placeKey()
+    {
+        const p = this.pos3D, r = this.rotation3D, s = this.scale3D;
+        return [p.x, p.y, p.z, r.x, r.y, r.z, s.x, s.y, s.z].join();
+    }
+
+    // make the parts, each where the instance puts it, or attached at its own place inside the instance
+    makeParts()
+    {
+        const prefab = level3DPrefabs.get(this.prefabName);
+        if (!prefab) return;
+        if (level3DPrefabDepth >= 8)
+        {
+            debug && console.error(`level3DLoad: the prefab ${this.prefabName} holds itself, left out there`);
+            return;
+        }
+        ++level3DPrefabDepth;
+        this.attached && ++level3DPrefabAttached;
+        try
+        {
+            const low = vec3(Infinity), high = vec3(-Infinity), children = [];
+            for (const object of prefab.objects)
+            {
+                const local = {pos: level3DVector(object.pos, vec3()), scale: level3DVector(object.scale, vec3(1)),
+                    rotation: level3DVector(object.rotation, vec3()).scale(PI / 180)};
+                const at = this.attached ? local : level3DPrefabPartTransform(this, object);
+                const part = level3DMakeAt(object, at.pos, at.rotation, at.scale);
+                if (!part) continue; // level3DMakeAt gives an object or nothing
+                this.parts.push(part);
+                this.partObjects.push(object);
+                if (!this.attached || !(part instanceof EngineObject3D)) continue;
+                // a child rides with its parent and has no collision of its own
+                part.setCollision(false, false, false);
+                children.push(part);
+                // the corners of its box as it is turned; its place is its middle, a prefab inside this one too
+                const box = buildMatrix(part.pos3D, part.rotation3D, part.size3D.multiply(part.scale3D));
+                for (let i = 8; i--;)
+                {
+                    const p = box.transformPoint(vec3(i & 1 ? .5 : -.5, i & 2 ? .5 : -.5, i & 4 ? .5 : -.5));
+                    for (const k of ['x', 'y', 'z'])
+                        low[k] = min(low[k], p[k]), high[k] = max(high[k], p[k]);
+                }
+            }
+            // an attached instance is the box around its parts, its handle at the middle of it as an object's
+            // place is the middle of its body, so a game that makes it solid has it solid where it is seen
+            if (children.length)
+            {
+                this.size3D = high.subtract(low);
+                this.originOffset = low.add(high).scale(.5);
+            }
+            for (const part of children)
+            {
+                part.pos3D = part.pos3D.subtract(this.originOffset);
+                this.addChild(part);
+            }
+        }
+        finally
+        {
+            --level3DPrefabDepth;
+            this.attached && --level3DPrefabAttached;
+        }
+    }
+
+    /** Keep the parts with the handle, called automatically each frame */
+    update()
+    {
+        super.update();
+        if (!this.attached && this.partsPlaced !== this.placeKey())
+            this.placeParts();
+    }
+
+    /** Destroy the instance and its parts
+     *  @param {boolean} [immediate] */
+    destroy(immediate)
+    {
+        if (this.destroyed) return;
+        for (const part of this.parts)
+            part.parent === this || part.destroy?.(immediate); // children go with their parent
+        super.destroy(immediate);
+    }
+
+    /** A prefab's instance has nothing of its own to draw */
+    render3D() {}
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 // the built-in types
 
@@ -30764,7 +31378,9 @@ function particleEffectSanitize(raw)
             settings[setting.name] = value === '' || particleEffectShapes.includes(value) ? value : fallback;
         else if (isNumber(value))
         {
-            const clamped = clamp(value, setting.hardMin, setting.hardMax);
+            // an angle past half a turn comes around, a clamp would point it the other way
+            const wraps = setting.name === 'angle' && isFinite(value) && abs(value) > PI;
+            const clamped = clamp(wraps ? mod(value + PI, 2*PI) - PI : value, setting.hardMin, setting.hardMax);
             settings[setting.name] = setting.step >= 1 ? round(clamped) : clamped;
         }
         else
@@ -30843,9 +31459,11 @@ function particleEffectsGet(name) { return particleEffectsByName.get(String(name
  *  @param {string} text
  *  @return {Array<Object>}
  *  @memberof ParticleEffects */
-function particleEffectsParse(text)
+function particleEffectsParse(text) { return particleEffectsFromData(JSON.parse(text)); }
+
+// a library file's data, or one effect's, into sanitized effects
+function particleEffectsFromData(data)
 {
-    const data = JSON.parse(text);
     const list = isArray(data?.effects) ? data.effects : data?.settings ? [data] : undefined;
     if (!list || !list.length)
         throw new Error('no effects in this file');
@@ -30864,7 +31482,7 @@ function particleEffectsText(effects) { return JSON.stringify({version:1, effect
  *  @memberof ParticleEffects */
 async function particleEffectsLoad(url)
 {
-    const effects = particleEffectsParse(JSON.stringify(await fetchJSON(url)));
+    const effects = particleEffectsFromData(await fetchJSON(url));
     particleEffectsAdd(effects);
     return effects;
 }
@@ -31042,7 +31660,13 @@ function particleEffectTileInfo(s)
  *  @memberof ParticleEffects */
 function particleEffectApply(emitter, effect)
 {
-    effect = particleEffectSanitize(effect); // an effect written by hand or changed since it was added
+    // an effect written by hand or changed since it was added
+    particleEffectSet(emitter, particleEffectSanitize(effect));
+}
+
+// set a 2D emitter to an effect that is sanitized already, as a play's is
+function particleEffectSet(emitter, effect)
+{
     const s = effect.settings, ended = emitter.emitTime < 0; // destroyed, its last particles going
     for (const setting of particleEffectSettings)
         if (!particleEffectIndirect.includes(setting.name))
@@ -31078,15 +31702,14 @@ function particleEffectResolve(nameOrEffect, options)
  *  - 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]
- *  @param {number} [options.scale] - Grows the whole effect, the built-ins fit a one unit object at 1
- *  @param {number} [options.hue] - Turns its colors around the color wheel, 1 is all the way
- *  @param {number} [options.saturation] - Multiplies its saturation, 0 is grey
- *  @param {number} [options.angle] - Direction, 0 is up; the effect's own angle when not given
- *  @param {TileInfo|TextureInfo} [options.tileInfo] - The game's own art to draw with in place of the effect's shape,
- *    tinted by its colors; a whole texture draws as one tile
- *  @param {*} [options.settings] - Any effect setting by its name, emitTime, emitRate, speed and the rest, replacing
- *    the effect's own for this play
+ *  @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 */
 function particleEffect(nameOrEffect, pos=vec2(), options={})
@@ -31094,7 +31717,7 @@ function particleEffect(nameOrEffect, pos=vec2(), options={})
     const effect = particleEffectResolve(nameOrEffect, options);
     if (!effect) return;
     const emitter = new ParticleEmitter(pos.copy());
-    particleEffectApply(emitter, effect);
+    particleEffectSet(emitter, effect);
     emitter.scale = options.scale ?? 1;
     if (options.angle !== undefined)
         emitter.angle = options.angle;
@@ -31158,7 +31781,7 @@ function particleEffectFromEmitter(emitter, name='Effect')
         p.velocity.y += (p.pos.x - c.x) * s * .002;
     };
     b('wind').update3D = (p, s)=> p.velocity.x += s * .004 * p.scale * min(p.age / p.lifeTime, 1);
-    // stick has no 3D push: particleEffect3D makes it the friction a particle lands with
+    // stick has no 3D push: particleEffectApply3D makes it the emitter's stick, its grip on landing
 }
 
 /** Set a 3D emitter to an effect, live, so a running one keeps its particles; its place, scale and flatten stay
@@ -31167,7 +31790,13 @@ function particleEffectFromEmitter(emitter, name='Effect')
  *  @memberof ParticleEffects */
 function particleEffectApply3D(emitter, effect)
 {
-    effect = particleEffectSanitize(effect); // an effect written by hand or changed since it was added
+    // an effect written by hand or changed since it was added
+    particleEffectSet3D(emitter, particleEffectSanitize(effect));
+}
+
+// set a 3D emitter to an effect that is sanitized already, as a play's is
+function particleEffectSet3D(emitter, effect)
+{
     const s = effect.settings, e = emitter;
     // a circle is a sphere and a rectangle a box as deep as it is wide
     e.emitSize = s.emitRect ? vec3(s.emitSize, s.emitHeight, s.emitSize) : s.emitSize;
@@ -31180,8 +31809,8 @@ function particleEffectApply3D(emitter, effect)
         'randomness', 'additive', 'gravityScale', 'angleSpeed', 'angleDamping', 'collideLevel', 'restitution'])
         e[name] = s[name];
     e.trailTime = s.trailScale / 60; // a stretch of speed times trailScale is a streak of that many frames
-    const stick = effect.behaviors.find(b=> b.name == 'stick'); // in 3D, a grip on landing is less sliding
-    e.friction = stick ? min(s.friction, 1 - stick.strength) : s.friction;
+    e.friction = s.friction;
+    e.stick = effect.behaviors.find(b=> b.name == 'stick')?.strength ?? 0; // in 3D the emitter grips on landing
     // a 2D emitter at angle a shoots along (sin a, cos a), a z turn r takes up to (-sin r, cos r), so r is -a
     e.rotation3D = vec3(0, 0, -s.angle);
     e.particleUpdateCallback = particleEffectUpdateCallback(effect.behaviors, true);
@@ -31191,8 +31820,8 @@ function particleEffectApply3D(emitter, effect)
  *  - 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 friction a
- *    particle lands with
+ *    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
@@ -31204,7 +31833,7 @@ function particleEffect3D(nameOrEffect, pos3D=vec3(), options={})
     const effect = particleEffectResolve(nameOrEffect, options);
     if (!effect) return;
     const e = new ParticleEmitter3D(pos3D.copy());
-    particleEffectApply3D(e, effect);
+    particleEffectSet3D(e, effect);
     if (options.angle !== undefined)
         e.rotation3D = vec3(0, 0, -options.angle);
     e.scale3D = vec3(options.scale ?? 1);
@@ -32853,32 +33482,101 @@ function debugPoint3D(pos, color=WHITE, time=0, size=.2)
  *  @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
- * - In release builds levelEditor is a stub that never opens, and its hooks are never called
+ * - 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);
  */
 class LevelEditor
 {
     constructor()
     {
-        /** @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} */
-        this.onTile = 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} */
-        this.onRestart = 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} */
-        this.onPlayFrom = 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} */
@@ -32887,15 +33585,133 @@ class LevelEditor
          *  3D one when a level was loaded with level3DLoad and there is a Render3DPlugin
          *  @type {boolean|undefined} */
         this.use3D = 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} */
+        this.tool = undefined;
+        // what the game added: its keys by how they are spelled, its panel buttons and its tools by name
+        /** @type {Object<string, {action: function(boolean): any, help: string|undefined, warned: boolean}>} */
+        this.keys = {};
+        /** @type {Array<{label: string, onClick: Function, title: string}>} */
+        this.buttons = [];
+        /** @type {Object<string, EditorTool>} */
+        this.tools = {};
+    }
+
+    /** 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, pos, tile) {}
+
+    /** 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() {}
+
+    /** 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) {}
+
+    /** Called when the editor opens, to set or override */
+    onOpen() {}
+
+    /** Called when the editor closes and the game plays on, to set or override */
+    onClose() {}
+
+    /** Called each frame while the editor is open, to set or override */
+    onUpdate() {}
+
+    /** Called while the editor draws the level, to draw overlays of the game's own in it, to set or override */
+    onDraw() {}
+
+    /** 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) {}
+
+    /** 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, fileName) { return false; }
 
     /** True while the editor is open, the game is paused under it
      *  @return {boolean} */
-    get isOpen() { return editorIsOpen; }
+    get isOpen() { return editorIsOpen || !!editorOther?.isOpen(); }
+
+    /** True when the editor in use is the 3D one, as use3D says or since a 3D level was loaded
+     *  @return {boolean} */
+    get is3D() { return !!editorOther?.wanted(); }
+
+    /** 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() { return 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() { return editorOther?.edit; }
+
+    /** 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, action, helpLine)
+    {
+        ASSERT(typeof action == 'function', 'a key needs an action');
+        const spelled = editorKeySpelling(key), name = spelled.replace('ctrl+', '');
+        if (name === 'Escape' || name === '0' || name.length > 1 && name.includes('+'))
+        {
+            console.warn(`levelEditor.addKey: ${key} is not taken, ` + (name.includes('+') ?
+                'Ctrl is the one modifier, Shift is given to the action' : 'Escape and 0 are the editor\'s own'));
+            return;
+        }
+        this.keys[spelled] = {action, help: helpLine, warned: false};
+        this === levelEditor && editorKeyClashes();
+    }
+
+    /** 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, onClick, title='') { this.buttons.push({label, onClick, title}); }
+
+    /** 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, tool)
+    {
+        ASSERT(!!tool && typeof tool == 'object', 'a tool is an object of callbacks');
+        const before = this.tools[name]; // added again, it takes the place of the first, its key too
+        before?.key && delete this.keys[editorKeySpelling(before.key)];
+        this.tools[name] = tool;
+        tool.key && this.addKey(tool.key, ()=> { this.tool = this.tool === name ? undefined : name; });
+    }
 
     /** Open the editor, pausing the game; until close(), Escape (the debug key) switches between playing and editing */
     open()
     {
+        if (editorOther?.wanted())
+            return editorOther.open();
         if (!editorSession)
             editorCameraScale = cameraScale; // a new session starts at the game's zoom, a return keeps the editor's
         editorSession = true;
@@ -32906,6 +33722,8 @@ class LevelEditor
      *  overlay again */
     close()
     {
+        if (editorOther?.active())
+            return editorOther.close();
         editorSession = false;
         editorSetOpen(false);
     }
@@ -32914,7 +33732,118 @@ class LevelEditor
 /** The level editor, levelEditor.open() to edit the level, levelEditor.close() to play on with the changes
  *  @type {LevelEditor}
  *  @memberof Editor */
-const levelEditor = new LevelEditor;
+let levelEditor = new LevelEditor;
+
+/** 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 */
+function setLevelEditor(editor)
+{
+    ASSERT(editor instanceof LevelEditor, 'a level editor extends LevelEditor');
+    levelEditor.isOpen && console.warn('setLevelEditor: the editor is open, close it first');
+    levelEditor = editor;
+}
+
+// the other editor, the 3D one, when its plugin is there: it says if it is the one wanted and open, opens and
+// closes, and has its edit functions; the 2D editor is this file
+/** @type {{wanted: function(): boolean, isOpen: function(): boolean, active: function(): boolean, open: Function,
+ *      close: Function, hasKey: function(string, boolean): boolean, edit: EditorEdit3D}|undefined} */
+let editorOther;
+
+// if the game gave a hook: set on the editor, or a method of its own class, not the empty one of LevelEditor
+function editorHas(name)
+{
+    const hook = levelEditor[name];
+    return typeof hook == 'function' && hook !== LevelEditor.prototype[name];
+}
+
+// a hook or a moment of the game's, called when it is one: a game may set one to undefined to take it away
+function editorCall(name, ...args)
+{
+    const hook = levelEditor[name];
+    return typeof hook == 'function' ? hook.apply(levelEditor, args) : undefined;
+}
+
+// the names keys have, by their lower case, so a game may spell one in any case
+const editorKeyNames = {};
+for (const name of ['Delete', 'Backspace', 'Enter', 'Tab', 'Escape', 'Space', 'Home', 'End', 'PageUp', 'PageDown',
+    'Insert', 'ArrowUp', 'ArrowDown', 'ArrowLeft', 'ArrowRight', ...[...Array(12)].map((v, i)=> 'F' + (i + 1))])
+    editorKeyNames[name.toLowerCase()] = name;
+
+// a key as addKey keeps it: a letter in lower case, a name as keys are named, 'ctrl+' in front with Ctrl
+function editorKeySpelling(key)
+{
+    const text = String(key), ctrl = text.trim().toLowerCase().startsWith('ctrl+');
+    let name = ctrl ? text.trim().slice(5) : text;
+    name = name === ' ' ? 'Space' : name.trim();
+    name = name.length === 1 ? name.toLowerCase() : editorKeyNames[name.toLowerCase()] ?? name;
+    return (ctrl ? 'ctrl+' : '') + name;
+}
+
+// say once, for each key of the game's own that is one of the open editor's too, that the game's takes its place:
+// when the editor opens, or when the key is added while it is open, since the 2D and 3D editors' keys differ
+function editorKeyClashes()
+{
+    if (!levelEditor.isOpen) return;
+    for (const [spelled, key] of Object.entries(levelEditor.keys))
+    {
+        const ctrl = spelled.startsWith('ctrl+'), name = spelled.slice(ctrl ? 5 : 0);
+        // in 2D the digits 1 to 9 pick a layer
+        const clash = levelEditor.is3D ? editorOther.hasKey(name, ctrl) :
+            !!(ctrl ? editorCtrlKeys : editorKeys)[name] || !ctrl && name.length === 1 && name >= '1' && name <= '9';
+        if (key.warned || !clash) continue;
+        key.warned = true;
+        console.warn(`levelEditor.addKey: ${spelled} is a key of the editor's, the game's takes its place`);
+    }
+}
+
+// the help lines of the game's own keys
+function editorGameHelpLines()
+{ return Object.values(levelEditor.keys).map((key)=> key.help).filter((line)=> !!line); }
+
+// the tool of the game's own that is on, undefined when there is none
+function editorGameTool() { return levelEditor.tool !== undefined ? levelEditor.tools[levelEditor.tool] : undefined; }
+
+// the game's box of an editor's panel: a row of its tools and its buttons, made again when one was added, the
+// tool that is on lit; and, the first time for a level editor, onPanel is given the box for controls of its own
+const editorGamePanels = new WeakMap;
+function editorGamePanel(box)
+{
+    let state = editorGamePanels.get(box);
+    if (state?.owner !== levelEditor)
+    {
+        box.replaceChildren();
+        state = {owner: levelEditor, row: editorElement('div', box, 'display:flex;gap:4px;margin:4px 0;flex-wrap:wrap'),
+            key: '', buttons: {}};
+        editorGamePanels.set(box, state);
+        editorCall('onPanel', box);
+    }
+    const tools = Object.keys(levelEditor.tools);
+    const key = tools.map((name)=> name + '\t' + (levelEditor.tools[name].hint || '')).join('\n') + '\n\n' +
+        levelEditor.buttons.length;
+    if (state.key !== key)
+    {
+        state.key = key;
+        state.buttons = {};
+        const press = 'padding:3px 6px;cursor:pointer';
+        state.row.replaceChildren(...tools.map((name)=>
+        {
+            const b = state.buttons[name] = editorElement('button', undefined, press, name);
+            b.title = levelEditor.tools[name].hint || '';
+            b.onclick = ()=> { levelEditor.tool = levelEditor.tool === name ? undefined : name; b.blur?.(); };
+            return b;
+        }), ...levelEditor.buttons.map((button)=>
+        {
+            const b = editorElement('button', undefined, press, button.label);
+            b.title = button.title;
+            b.onclick = ()=> { button.onClick.call(levelEditor); b.blur?.(); };
+            return b;
+        }));
+    }
+    for (const name of tools)
+        state.buttons[name].style.outline = name === levelEditor.tool ? '2px solid #4af' : '';
+}
 
 // if the editor is open, and if it was opened and not exited, while Escape switches between playing and editing
 let editorIsOpen = false, editorSession = false;
@@ -32926,7 +33855,7 @@ let editorPlayFromMouse = false, editorAdvanced = false;
 function editorPlay(pos)
 {
     editorSetOpen(false);
-    editorPlayFromMouse && pos && levelEditor.onPlayFrom?.(pos.copy());
+    editorPlayFromMouse && pos && editorHas('onPlayFrom') && levelEditor.onPlayFrom(pos.copy());
 }
 
 // the game's pause and camera from before the editor opened, handed back when it closes
@@ -32978,10 +33907,13 @@ function editorSetOpen(open)
             layers.filter((layer)=> !layer.isObjects).at(-1));
         layers.includes(editorObjectLayer) || (editorObjectLayer = editorLayer ? undefined :
             layers.find((layer)=> layer.isObjects)); // a level of objects alone
+        editorCall('onOpen');
+        editorKeyClashes();
     }
     else
     {
         editorStrokeEnd();
+        editorToolHeld = false;
         editorSelection = editorSelectionDrag = editorRightPress = editorObjectDrag = editorObjectBox = undefined;
         editorObjectSelection.clear();
         editorMouseOnPanel = false; // the panel hides, with no mouseleave
@@ -32990,6 +33922,7 @@ function editorSetOpen(open)
         setCameraPos(state.cameraPos);
         setCameraScale(state.cameraScale);
         setCameraAngle(state.cameraAngle);
+        editorCall('onClose');
     }
 }
 
@@ -33260,7 +34193,14 @@ async function editorSave(record, pickAgain=false)
     if (!record) return;
     editorStrokeEnd();
     const text = editorMapJSON(record); // the map as it is now, later edits wait for a later save
-    const saved = (async ()=> { await record.saving; return editorSaveText(record, text, pickAgain); })();
+    // its place in line is taken now, and the game's hook is asked when its turn comes, so saves are written in
+    // the order they were asked for however long a hook takes
+    const saved = (async ()=>
+    {
+        await record.saving;
+        if (await editorCall('onSave', text, record.fileName) === true) return 'kept'; // the game kept it itself
+        return editorSaveText(record, text, pickAgain);
+    })();
     record.saving = saved.catch(()=> {});
     return saved;
 }
@@ -33384,7 +34324,7 @@ function editorPaintData(record, data, objects, width=record.map.width, height=r
     editorStrokeEnd();
     if (width !== record.map.width || height !== record.map.height)
     {
-        if (!levelEditor.onRestart) return;
+        if (!editorHas('onRestart')) return;
         const before = editorMapSnapshot(record);
         editorSetMapSnapshot(record, {width, height, layers: data, objects});
         editorMapChanged(record, before);
@@ -33429,7 +34369,7 @@ function editorPendingFits(record, saved)
 {
     const map = record.map, data = editorTileLayerData(map.layers), groups = editorObjectGroups(map.layers).length;
     const width = saved.width ?? map.width, height = saved.height ?? map.height;
-    return (width === map.width && height === map.height || !!levelEditor.onRestart) &&
+    return (width === map.width && height === map.height || editorHas('onRestart')) &&
         saved.layers?.length === data.length && saved.layers.every((layer)=> layer.length === width * height) &&
         (saved.objects ?? []).every((objects, i)=> i < groups || !objects.length);
 }
@@ -33533,7 +34473,7 @@ function editorMapChanged(record, before)
 function editorResize(record, width, height)
 {
     const map = record?.map;
-    if (!map || record.synthetic || record.pending || !levelEditor.onRestart) return false;
+    if (!map || record.synthetic || record.pending || !editorHas('onRestart')) return false;
     if (width === map.width && height === map.height) return false;
     editorStrokeEnd();
     const before = editorMapSnapshot(record);
@@ -33587,7 +34527,7 @@ function editorSetCell(layer, pos, gid)
     }
     const t = editorGidToTile(gid);
     live.setData(pos, t ? new TileLayerData(t.tile, t.direction, t.mirror, color) : new TileLayerData, true);
-    if (levelEditor.onTile)
+    if (editorHas('onTile'))
         levelEditor.onTile(live, pos.copy(), t?.tile);
     else if (live instanceof TileCollisionLayer && live.isSolid)
         live.setCollisionData(pos, gid ? 1 : 0); // as tileLayersLoad gives it
@@ -33656,7 +34596,7 @@ function editorChanged(stroke)
     editorRedraw(stroke);
     for (const record of new Set(stroke.map(editorEntryRecord)))
         editorAutosave(record);
-    stroke.some((entry)=> entry.resize) && levelEditor.onRestart?.();
+    stroke.some((entry)=> entry.resize) && editorHas('onRestart') && levelEditor.onRestart();
 }
 
 // the tile layers a stroke touched draw again whole
@@ -33849,6 +34789,7 @@ let editorObjectDrag, editorObjectBox;
 function editorSelectLayer(layer)
 {
     editorStrokeEnd();
+    levelEditor.tool = undefined; // a tool of the game's own is put down
     editorLastCell = editorObjectDrag = editorRightPress = editorObjectBox = undefined; // presses stay on their layer
     editorSelectionDrag = undefined; // a move so far is kept, the stroke ended
     editorObjectSelection.clear();
@@ -34476,6 +35417,7 @@ const editorHelpLines =
 function editorHint()
 {
     if (keyIsDown('Space')) return 'Drag to pan';
+    if (editorGameTool()) return editorGameTool().hint || levelEditor.tool;
     if (editorObjectLayer)
         return editorObjectSelection.size ? 'Selection: drag moves · Delete removes · Ctrl+C copy · Ctrl+X cut · click to clear' :
             'Left place / select · drag moves · Right pick / drag select · Delete removes';
@@ -34544,6 +35486,8 @@ function editorPanelInit()
     button(undo, 'Undo', ()=> editorUndo(), 'Ctrl+Z');
     button(undo, 'Redo', ()=> editorUndo(true), 'Ctrl+Y');
     button(undo, 'Keys', ()=> editorHelp = !editorHelp, 'Every control, ?');
+    // the game's own tools, buttons and controls, near the top where the tools are
+    const game = editorElement('div', editorPanel);
 
     // a file that changed under its autosave
     const pending = editorElement('div', editorPanel, 'padding:4px;margin:4px 0;background:#630;border-radius:3px');
@@ -34630,9 +35574,10 @@ function editorPanelInit()
     const help = editorElement('div', editorPanel, 'color:#aaa;margin-top:4px;border-top:1px solid #444;padding-top:4px');
     for (const line of editorHelpLines)
         editorElement('div', help, 'margin:2px 0', line);
+    const gameHelp = editorElement('div', help);
     button(help, 'Close', ()=> editorHelp = false, '?');
 
-    editorPanelParts = {pendingUnfit, reset, advancedToggle, advanced, playFromLabel, playFrom, sizeRow, sizeX, sizeY, resize, restart, pending, layerRow, allLayers, turns, palette, brush, properties, status, storage, hint, help, layers: undefined};
+    editorPanelParts = {game, gameHelp, pendingUnfit, reset, advancedToggle, advanced, playFromLabel, playFrom, sizeRow, sizeX, sizeY, resize, restart, pending, layerRow, allLayers, turns, palette, brush, properties, status, storage, hint, help, layers: undefined};
 }
 
 // the palette's cell size in pixels and how many to a row
@@ -34791,15 +35736,15 @@ function editorPanelUpdate()
     p.hint.textContent = editorHint();
     p.help.style.display = editorHelp ? '' : 'none';
     p.storage.style.display = editorSaveFailed ? '' : 'none';
-    p.restart.style.display = levelEditor.onRestart ? '' : 'none';
+    p.restart.style.display = editorHas('onRestart') ? '' : 'none';
     p.advancedToggle.textContent = editorAdvanced ? 'Advanced ▾' : 'Advanced ▸';
     p.advanced.style.display = editorAdvanced ? '' : 'none';
-    p.playFromLabel.style.display = levelEditor.onPlayFrom ? 'flex' : 'none';
+    p.playFromLabel.style.display = editorHas('onPlayFrom') ? 'flex' : 'none';
     p.playFrom.checked = editorPlayFromMouse;
 
     // the level's size, shown until a field is being typed in; without the Restart hook it can not change
     const record = editorRecord(), map = record?.map;
-    const canResize = !!levelEditor.onRestart && !record?.synthetic && !record?.pending;
+    const canResize = editorHas('onRestart') && !record?.synthetic && !record?.pending;
     p.sizeRow.style.display = map ? 'flex' : 'none';
     if (map && !p.sizeRow.contains(document.activeElement))
     {
@@ -34869,6 +35814,7 @@ function editorIsTextField(target)
 function editorOnKeyDown(e)
 {
     if (!editorIsOpen || e.repeat || e.altKey || editorIsTextField(e.target)) return;
+    if (editorToolHeld) return; // the keys wait for a tool of the game's own to let go
     if (editorSelectionDrag && !(debugKey && e.code === debugKey))
     {
         // a key ends a selection drag where it is, an undo of its own, so Delete or undo acts on what is there;
@@ -34876,10 +35822,12 @@ function editorOnKeyDown(e)
         editorStrokeEnd();
         editorSelectionDrag = undefined;
     }
-    let key = e.key.length === 1 ? e.key.toLowerCase() : e.key;
-    if (key.length === 1 && !/[a-z?]/.test(key))
+    let key = e.key === ' ' ? 'Space' : e.key.length === 1 ? e.key.toLowerCase() : e.key;
+    if (key.length === 1 && !/[a-z?]/.test(key) && !levelEditor.keys[key])
         key = e.code?.match(/^Key([A-Z])$/)?.[1].toLowerCase() ?? key;
-    const action = (e.ctrlKey || e.metaKey ? editorCtrlKeys : editorKeys)[key];
+    // a key of the game's own first, it takes the place of one of the editor's
+    const ctrl = e.ctrlKey || e.metaKey, own = levelEditor.keys[(ctrl ? 'ctrl+' : '') + key];
+    const action = own ? (shift)=> own.action.call(levelEditor, shift) : (ctrl ? editorCtrlKeys : editorKeys)[key];
     if (action && action(e.shiftKey) !== false)
         e.preventDefault();
 }
@@ -35073,6 +36021,15 @@ function editorUpdate()
         return;
     }
 
+    // Escape while a tool of the game's own is held takes its press back, and stays in the editor
+    if (editorToolHeld && debugKey && keyWasPressed(debugKey))
+    {
+        inputClearKey(debugKey);
+        editorStrokeCancel();
+        editorToolHeld = false;
+        return;
+    }
+
     // in an editing session Escape, the debug key, switches between playing and editing; taken, so the debug
     // overlay waits till the session ends
     if (editorSession && debugKey && keyWasPressed(debugKey))
@@ -35103,7 +36060,7 @@ function editorUpdate()
     // keeps them while it is open
     for (let i = 1; !debugOverlay && i <= 9; ++i)
     {
-        if (!keyWasPressed('Digit' + i)) continue;
+        if (!keyWasPressed('Digit' + i) || levelEditor.keys[i]) continue; // a digit of the game's own is its
         inputClearKey('Digit' + i);
         const layer = editorLayers()[i - 1];
         layer && layer !== (editorObjectLayer ?? editorLayer) && editorSelectLayer(layer); // a drag does not carry across
@@ -35116,6 +36073,8 @@ function editorUpdate()
     editorApplyCamera();
 
     editorMouseOnPanel || (editorMouseScreen = mousePosScreen.copy());
+    editorCall('onUpdate');
+    if (editorToolUpdate(space)) return; // a tool of the game's own has the mouse
     if (editorObjectLayer)
         return editorUpdateObjects(space);
     const layer = editorLayer?.live.destroyed ? undefined : editorLayer, mouse = screenToWorld(editorMouseScreen);
@@ -35185,10 +36144,87 @@ function editorUpdate()
     }
 }
 
+// a tool of the game's own: if its press is held, and what was picked in the editor when it was turned on, since
+// picking a layer, a tile or an object type puts the game's tool down
+let editorToolHeld = false, editorToolName, editorToolPicked = [];
+
+// what a tool's callbacks are given: where the mouse is in the level, the cell under it on the selected tile
+// layer, and the keys held
+function editorToolAt()
+{
+    const layer = editorObjectLayer || editorLayer?.live.destroyed ? undefined : editorLayer;
+    const pos = screenToWorld(editorMouseScreen);
+    return {pos, cell: layer && !editorMouseOnPanel ? editorCellAt(layer.live, pos) || undefined : undefined,
+        ray: undefined, shift: keyIsDown('ShiftLeft') || keyIsDown('ShiftRight'),
+        ctrl: keyIsDown('ControlLeft') || keyIsDown('ControlRight')};
+}
+
+// the game's tool, when one is on: the left button is its, a press, a drag and a release one undo, the right
+// button takes a held press back; true when it has the mouse
+function editorToolUpdate(space)
+{
+    const picked = [editorLayer, editorObjectLayer, editorBrush, editorObjectBrush];
+    if (levelEditor.tool !== editorToolName)
+        editorToolName = levelEditor.tool, editorToolPicked = picked; // turned on, or off, by its key or button
+    else if (picked.some((value, i)=> value !== editorToolPicked[i]))
+        levelEditor.tool = editorToolName = undefined; // something of the editor's was picked
+    const tool = editorGameTool();
+    if (!tool)
+    {
+        editorToolHeld = false;
+        return false;
+    }
+    const at = editorToolAt();
+    editorHover = at.cell;
+    editorRightPress = undefined; // a right press from before the tool was on is not the editor's to finish
+    if (editorToolHeld && mouseWasPressed(2))
+    {
+        inputClearKey(2);
+        editorStrokeCancel();
+        editorToolHeld = false;
+    }
+    else if (mouseWasPressed(0) && !space && !editorMouseOnPanel)
+        editorToolHeld = tool.onPress?.(at) !== false;
+    else if (editorToolHeld && mouseIsDown(0))
+        tool.onDrag?.(at);
+    if (editorToolHeld && !mouseIsDown(0))
+    {
+        tool.onRelease?.(at);
+        editorStrokeEnd();
+        editorToolHeld = false;
+    }
+    return true;
+}
+
+// the 2D editor's edit functions, what levelEditor.edit2D gives a game's own keys, buttons and tools
+const editorEdit2D =
+{
+    get map() { return editorRecord()?.map; },
+    get layer() { return editorObjectLayer ? undefined : editorLayer?.live; },
+    get objects() { return editorObjectLayer ? editorObjectsCopy(editorObjectList(editorObjectLayer)) : []; },
+    get hover() { return editorHover && !editorObjectLayer ? editorHover.copy() : undefined; },
+    get selection() { return editorObjectSelection; },
+    paint(cell, tile, direction=0, mirror=false)
+    {
+        const layer = editorObjectLayer ? undefined : editorLayer, size = layer?.live.size;
+        if (!layer || layer.live.destroyed || layer.record.pending || !isVector2(cell)) return false;
+        const x = floor(cell.x), y = floor(cell.y);
+        if (x < 0 || y < 0 || x >= size.x || y >= size.y) return false;
+        editorPaint(layer, vec2(x, y), tile < 0 ? 0 : editorTileToGid(tile, direction & 3, mirror));
+        return true;
+    },
+    changeObjects(change) { return editorChangeObjects(editorObjectLayer, change); },
+    strokeEnd() { editorStrokeEnd(); },
+    strokeCancel() { editorStrokeCancel(); },
+    bulk(edit) { editorBulkEdit(edit); },
+    undo(redo=false) { return editorUndo(redo); },
+    toJSON() { const record = editorRecord(); return record ? editorMapJSON(record) : ''; },
+};
+
 // switch to play and have the game rebuild its level from the changed map, when it has a hook for that
 function editorRestart()
 {
-    if (!levelEditor.onRestart) return;
+    if (!editorHas('onRestart')) return;
     editorSetOpen(false); // ends a held stroke, and hands back the game's pause and camera, Escape comes back
     levelEditor.onRestart();
 }
@@ -35202,6 +36238,11 @@ function editorPreRender() { editorIsOpen && editorApplyCamera(); }
 function editorRender()
 {
     headlessMode || editorPanelUpdate();
+    if (!headlessMode && editorIsOpen && editorPanelParts)
+    {
+        editorGamePanel(editorPanelParts.game);
+        editorGameHelp(editorPanelParts.gameHelp);
+    }
     if (!editorIsOpen || headlessMode) return;
     const layer = editorLayer?.live.destroyed ? undefined : editorLayer;
     if (!layer && !editorObjectLayer) return;
@@ -35250,12 +36291,12 @@ function editorRender()
     if (editorSelection && !editorObjectLayer)
         outline(editorSelection.min, editorSelection.max.add(vec2(1)), hsl(.15, 1, .6), thin * 3);
     const last = editorLastPlaced, shift = keyIsDown('ShiftLeft') || keyIsDown('ShiftRight');
-    if (shift && editorHover && last?.layer === layer && !mouseIsDown(0))
+    if (shift && editorHover && last?.layer === layer && !mouseIsDown(0) && !editorGameTool())
         drawLine(live.pos.add(last.pos).add(vec2(.5)), live.pos.add(editorHover).add(vec2(.5)), thin * 2,
             hsl(.55, 1, .6, .6), undefined, 0, glEnable, false);
 
-    // the brush where it would paint, the Erase brush's cells in red
-    if (editorHover)
+    // the brush where it would paint, the Erase brush's cells in red; a tool of the game's own draws its own
+    if (editorHover && !editorGameTool())
     {
         const grid = editorStampGrid(layer, editorBrush), {width: w, height: h} = editorBrush;
         for (let y = h; y--;)
@@ -35273,7 +36314,24 @@ function editorRender()
     editorObjectLayer && editorRenderObjects(thin);
 }
 
-debug && engineAddPlugin(editorUpdate, editorRender);
+// the game's own drawing in the level, over the editor's: the editor's onDraw, and its tool's while one is on
+function editorRenderGame()
+{
+    if (!editorIsOpen) return;
+    editorCall('onDraw');
+    editorGameTool()?.onDraw?.(editorToolAt());
+}
+
+// the lines of the game's own keys in a panel's help, made again when they change
+function editorGameHelp(element)
+{
+    const lines = editorGameHelpLines(), key = lines.join('\n');
+    if (element.dataset.key === key) return;
+    element.dataset.key = key;
+    element.replaceChildren(...lines.map((line)=> editorElement('div', undefined, 'margin:2px 0', line)));
+}
+
+debug && engineAddPlugin(editorUpdate, ()=> { editorRender(); editorRenderGame(); });
 
 // the editor's own listeners for letter shortcuts and the wheel, the engine's input reads keys by position
 if (debug && globalThis.document?.addEventListener)
@@ -35570,9 +36628,11 @@ const editor3DSelection = new Set; // the ids of the selected objects
 // the type a click places
 /** @type {string|undefined} */
 let editor3DBrush;
-// the copied objects
+// the copied objects, and the size and box offset each had when it was copied
 /** @type {Array<Object>|undefined} */
 let editor3DClipboard;
+/** @type {Map<Object, {size: Vector3, offset: Vector3}>} */
+let editor3DClipboardBoxes = new Map;
 // the level's, each entry its object list and its parts, the scene and the blocks, before and after an edit
 let editor3DUndoList = [], editor3DRedoList = [];
 // the edit being made, a drag is one: the objects and the parts as they were before it, and painted when blocks
@@ -35591,7 +36651,7 @@ const editor3DSelected = ()=> editor3DObjects().filter((o)=> editor3DSelection.h
 
 // the parts of a level beside its objects that the editor edits: its scene block and its map of blocks; each is
 // undone, autosaved, reset and saved as the objects are
-const editor3DLevelPartNames = ['scene', 'voxels', 'terrain'];
+const editor3DLevelPartNames = ['scene', 'voxels', 'terrain', 'prefabs'];
 
 // the last copy made of each part, as its text and the copy: a part that has not changed since is not copied
 // again, so undo steps share one copy of a terrain until it is sculpted; a copy is never changed
@@ -35695,12 +36755,46 @@ const editor3DTurned = (object)=> editor3DRotation(object).lengthSquared() > 0;
 // the size of an object's box: what the game made for it says, a marker is 1 unit
 function editor3DSize(object)
 {
-    const made = editor3DInstances.get(object.id);
+    const made = editor3DInstances.get(object.id), box = editor3DPrefabBox(made);
+    if (box) return box.size;
     if (!(made instanceof EngineObject3D) || !(made.mesh || made.tileInfo)) return vec3(1);
     const s = made.size3D, k = made.scale3D;
     return vec3(s.x * abs(k.x), s.y * abs(k.y), s.z * abs(k.z));
 }
 
+// the box around a prefab's instance in the world, the boxes of its parts together, as its middle and its size;
+// undefined for anything else, or an instance with nothing to see
+function editor3DPrefabBox(made)
+{
+    if (!(made instanceof Prefab3D) || made.destroyed) return;
+    const low = vec3(Infinity), high = vec3(-Infinity);
+    for (const part of editor3DParts(made))
+    {
+        if (!(part instanceof EngineObject3D) || !(part.mesh || part.tileInfo)) continue;
+        const bounds = part.mesh && (part.mesh.bounds || part.mesh.getBounds());
+        const matrix = render3DObjectMatrix(part).copy().multiply(bounds ?
+            buildMatrix(bounds.min.add(bounds.max).scale(.5), undefined, bounds.max.subtract(bounds.min)) :
+            buildMatrix(vec3(), undefined, part.size3D));
+        for (let i = 8; i--;)
+        {
+            const p = matrix.transformPoint(vec3(i & 1 ? .5 : -.5, i & 2 ? .5 : -.5, i & 4 ? .5 : -.5));
+            for (const k of ['x', 'y', 'z'])
+                low[k] = min(low[k], p[k]), high[k] = max(high[k], p[k]);
+        }
+    }
+    // to the nearest part of the file's numbers, so a box worked out through a matrix reads as it was written
+    const tidy = (v)=> vec3(editor3DRound(v.x), editor3DRound(v.y), editor3DRound(v.z));
+    return low.x <= high.x ? {pos: tidy(low.add(high).scale(.5)), size: tidy(high.subtract(low))} : undefined;
+}
+
+// from an object's place to the middle of its box: nothing for a plain object, whose place is its middle, and for
+// a prefab's instance how far its origin is from the middle of its parts, as it is turned and sized now
+function editor3DBoxOffset(object)
+{
+    const box = editor3DPrefabBox(editor3DInstances.get(object.id));
+    return box ? box.pos.subtract(editor3DPos(object)) : vec3();
+}
+
 // every object gets an id of its own, a whole number: one without, or with one already used, gets a new one
 function editor3DFixIds(objects)
 {
@@ -35736,6 +36830,12 @@ function editor3DLevelLoaded(level)
         editor3DSelection.clear();
         editor3DStroke = undefined;
     }
+    if (!editor3DPrefabLevels.has(level) && editor3DPrefabStack.length)
+    {
+        // the game loaded a level while a prefab was open: what was open is gone with what it was opened from
+        editor3DPrefabStack.length = 0;
+        editor3DPrefabEdits = {};
+    }
     editor3DLevel = level;
     editor3DInstances.clear();
     if (isArray(level.objects))
@@ -35775,7 +36875,8 @@ function editor3DLevelLoaded(level)
     editor3DUndoList = record.undo;
     editor3DRedoList = record.redo;
     // an autosave the file already has, from a Save, goes; one of this file, or of the file a Save wrote, comes back
-    const saved = editor3DSaves()[record.key];
+    // a prefab being edited has no autosave, and one of a level with the same objects is not its
+    const saved = editor3DPrefabLevels.has(level) ? undefined : editor3DSaves()[record.key];
     if (saved && isArray(saved.objects) && editor3DSame(saved.objects, original) &&
         editor3DSame(editor3DLevelParts(saved), originalParts))
         editor3DAutosave(level);
@@ -35805,6 +36906,7 @@ function editor3DPlaceInstance(made, object)
     made.scale3D = (level3DBaseScale.get(made) ?? vec3(1)).multiply(editor3DScale(object));
     made.velocity3D = vec3();
     made.angleVelocity3D = vec3();
+    made instanceof Prefab3D && made.placeAt(editor3DPos(object)); // by its origin, and its parts go with it
 }
 
 // make an object's game object, again when it has one
@@ -35839,6 +36941,24 @@ function editor3DSetObjects(list)
             made instanceof EngineObject3D && !made.destroyed;
         onlyMoved ? editor3DPlaceInstance(made, object) : editor3DMakeInstance(object);
     }
+    editor3DShadowLight();
+}
+
+// the light that casts the shadows is the level's last Light that asks to, as it is after a load, whatever order
+// the edits made them in; a light of the game's own is left alone while no Light of the level asks
+function editor3DShadowLight()
+{
+    if (!render3D) return;
+    let light;
+    for (const object of editor3DObjects())
+    {
+        const made = editor3DInstances.get(object.id);
+        if (object.type === 'Light' && object.properties?.shadows === true && made instanceof Light3D && !made.destroyed)
+            light = made;
+    }
+    const now = render3D.shadowLight;
+    if (light || !now || now.destroyed || [...editor3DInstances.values()].some((made)=> made === now))
+        render3D.shadowLight = light;
 }
 
 // change the level's objects as part of the edit being made: change edits a copy of the list; the changes until
@@ -35867,8 +36987,30 @@ function editor3DSetPart(name, part)
     }
     else if (name === 'voxels')
         editor3DVoxelShow();
-    else
+    else if (name === 'terrain')
         editor3DTerrainShow();
+    else
+        editor3DPrefabsShow();
+}
+
+// bring the prefab types in line with the level's own prefabs, and make every instance again: a prefab the level
+// no longer has is no longer a type, one it has is added as level3DLoad adds it, and what a prefab makes is made
+// when its instance is, so each instance is made again
+function editor3DPrefabsShow()
+{
+    if (editor3DPrefabLevels.has(editor3DLevel)) return; // inside a prefab, the prefabs are the level's
+    const prefabs = editor3DLevelPart('prefabs') ?? {};
+    for (const [name, prefab] of level3DPrefabs)
+    {
+        if (!prefab.fromLevel || prefabs[name]) continue;
+        level3DPrefabs.delete(name);
+        level3DTypes.delete(name);
+    }
+    level3DPrefabsAdd(prefabs);
+    // every object of a prefab's type, one whose type was not there when the objects were set too
+    for (const object of editor3DObjects())
+        level3DPrefabs.has(object.type) && editor3DMakeInstance(object);
+    editor3DShadowLight();
 }
 
 // make the level's parts these, the ones that differ
@@ -35878,6 +37020,11 @@ function editor3DSetParts(parts)
         editor3DSame(parts[name], editor3DLevelPart(name)) || editor3DSetPart(name, parts[name]);
 }
 
+// the stroke being made, started here with the level as it is when there is none: called before the level changes
+/** @return {{before: Array<Object>, parts: Object, painted?: boolean, sculpted?: boolean}} */
+function editor3DStrokeBegin()
+{ return editor3DStroke ||= {before: editor3DCopy(editor3DObjects()), parts: editor3DLevelParts()}; }
+
 // change a part of the level as part of the edit being made, as editor3DChange does its objects: change is given
 // a copy of the part, undefined when the level has none, and returns the new one, or undefined for none; false
 // when nothing changed
@@ -35886,7 +37033,7 @@ function editor3DChangePart(name, change)
     if (!editor3DLevel || editor3DRecords.get(editor3DLevel)?.pending) return false; // its autosave waits first
     const parts = editor3DLevelParts(), after = change(parts[name] && editor3DCopy(parts[name]));
     if (editor3DSame(parts[name], after)) return false;
-    editor3DStroke ||= {before: editor3DCopy(editor3DObjects()), parts};
+    editor3DStrokeBegin();
     editor3DSetPart(name, after);
     return true;
 }
@@ -35963,8 +37110,7 @@ function editor3DVoxelSet(cell, type)
     const map = editor3DVoxelMap();
     if (!map || editor3DRecords.get(editor3DLevel)?.pending) return false; // its autosave waits first
     if (!editor3DVoxelInside(map, cell) || map.getVoxel(cell) === type) return false;
-    editor3DStroke ||= {before: editor3DCopy(editor3DObjects()), parts: editor3DLevelParts()};
-    editor3DStroke.painted = true;
+    editor3DStrokeBegin().painted = true;
     map.setVoxel(cell, type);
     return true;
 }
@@ -35986,8 +37132,85 @@ function editor3DVoxelDragCell(drag, ray)
 // the level's terrain: the level's terrain block is the source of truth, the game's HeightMap follows it;
 // sculpting changes the game's map as it goes, and the stroke's end writes its heights into the level
 
-// the brush: its size across in world units, and how strong it is, 0 to 1
-const editor3DTerrainBrush = {size: 8, strength: .5};
+// the brush: its size across in world units, how strong it is, 0 to 1, which brush it is, sculpt, flatten or
+// paint, and the color it paints
+const editor3DTerrainBrush = {size: 8, strength: .5, mode: 'sculpt', color: '#8a6a4a'};
+const editor3DTerrainBrushes = ['sculpt', 'flatten', 'paint'];
+
+// the paint of the game's terrain map as it is being edited, {colors, cells} as level3DTerrainPaint gives it:
+// from the level, and ahead of it while a stroke paints
+const editor3DTerrainPaints = new WeakMap;
+function editor3DTerrainPaint(map)
+{
+    let paint = editor3DTerrainPaints.get(map);
+    if (!paint)
+    {
+        const samples = map.rows * map.columns;
+        paint = level3DTerrainPaint(editor3DLevelPart('terrain'), samples) || {colors: [], cells: new Uint8Array(samples)};
+        editor3DTerrainPaints.set(map, paint);
+    }
+    return paint;
+}
+
+// the next brush of the Terrain tool
+function editor3DTerrainNextBrush()
+{
+    const brushes = editor3DTerrainBrushes;
+    editor3DTerrainBrush.mode = brushes[(brushes.indexOf(editor3DTerrainBrush.mode) + 1) % brushes.length];
+}
+
+// the drag a press on the ground starts, by the brush and the keys held: sculpt raises, Shift lowers; flatten
+// brings the ground to the height pressed; paint colors it, Shift takes the paint off; Ctrl smooths with the two
+// that shape the ground
+function editor3DTerrainPress(point, shift, ctrl)
+{
+    const map = editor3DTerrainMap(), brush = editor3DTerrainBrush.mode;
+    if (!map) return;
+    if (brush === 'paint')
+        return {kind: 'terrain', mode: shift ? 'erase' : 'paint'};
+    if (ctrl)
+        return {kind: 'terrain', mode: 'smooth'};
+    if (brush === 'flatten')
+        return {kind: 'terrain', mode: 'flatten', level: clamp((point.y - map.pos3D.y) / map.height)};
+    return {kind: 'terrain', mode: shift ? 'lower' : 'raise'};
+}
+
+// the mouse held on the ground with a terrain drag
+function editor3DTerrainDragTo(drag, point)
+{
+    return drag.mode === 'paint' || drag.mode === 'erase' ? editor3DTerrainPaintAt(point, drag.mode === 'erase') :
+        editor3DTerrainSculpt(point, drag.mode, editor3DSeconds, drag.level);
+}
+
+// paint the ground around a point with the brush's color, or take its paint off, as part of the edit being made:
+// every sample under the brush, in the game's map now and in the level when the stroke ends; false when nothing
+// changed, or when the terrain has all the colors it can keep, 255
+function editor3DTerrainPaintAt(point, erase=false)
+{
+    const map = editor3DTerrainMap();
+    if (!map || editor3DRecords.get(editor3DLevel)?.pending) return false; // its autosave waits first
+    const paint = editor3DTerrainPaint(map), hex = editor3DInputColor(editor3DTerrainBrush.color);
+    let color = erase ? 0 : paint.colors.indexOf(hex) + 1;
+    if (!erase && !color && paint.colors.length >= 255) return false;
+    const radius = editor3DTerrainBrush.size / 2, rows = map.rows, columns = map.columns;
+    const stepX = map.mapSize.x / (columns - 1), stepZ = map.mapSize.y / (rows - 1);
+    const x0 = map.pos3D.x - map.mapSize.x / 2, z0 = map.pos3D.z - map.mapSize.y / 2;
+    let changed = false;
+    for (let r = 0; r < rows; ++r)
+    for (let c = 0; c < columns; ++c)
+    {
+        if (hypot(x0 + c * stepX - point.x, z0 + r * stepZ - point.z) >= radius) continue;
+        color ||= erase ? 0 : paint.colors.push(hex); // a new color joins the list with the first sample it paints
+        if (paint.cells[r * columns + c] === color) continue;
+        paint.cells[r * columns + c] = color;
+        changed = true;
+    }
+    if (!changed) return false;
+    editor3DStrokeBegin().sculpted = true;
+    level3DTerrainSetColors(map, editor3DLevelPart('terrain'), paint);
+    map.rebuild();
+    return true;
+}
 
 // the game's map of the level's terrain, undefined when the level has none
 function editor3DTerrainMap()
@@ -36016,15 +37239,30 @@ function editor3DTerrainShow()
         return;
     }
     map.heights = shape.heights;
-    map.color = /^#([0-9a-f]{6}|[0-9a-f]{8})$/i.test(terrain.color) ? new Color().setHex(terrain.color) : WHITE;
+    editor3DTerrainPaints.delete(map); // as the level has it
+    level3DTerrainSetColors(map, terrain);
     map.rebuild();
 }
 
-// write the game's map into the level, as a stroke of sculpting ends, its heights to a thousandth
+// write the game's map into the level, as a stroke of sculpting ends, its heights to a thousandth, and its paint:
+// the colors still in use and runs of a count and a color along the rows, or no paint when none is left
 function editor3DTerrainStore()
 {
     const map = editor3DTerrainMap(), terrain = editor3DLevelPart('terrain');
-    map && terrain && (terrain.heights = map.heights.map((row)=> row.map((v)=> round(v * 1e3) / 1e3)));
+    if (!map || !terrain) return;
+    terrain.heights = map.heights.map((row)=> row.map((v)=> round(v * 1e3) / 1e3));
+    const paint = editor3DTerrainPaints.get(map);
+    if (!paint) return; // nothing painted since the level's was read
+    const used = paint.colors.map((hex, i)=> paint.cells.includes(i + 1));
+    const colors = paint.colors.filter((hex, i)=> used[i]), cells = [];
+    const index = paint.colors.map((hex, i)=> used[i] ? colors.indexOf(hex) + 1 : 0);
+    for (const v of paint.cells)
+    {
+        const color = v && index[v - 1];
+        cells[cells.length - 1] === color ? ++cells[cells.length - 2] : cells.push(1, color);
+    }
+    colors.length ? terrain.paint = {colors, cells} : delete terrain.paint;
+    editor3DTerrainPaints.delete(map); // read from the level again, with its colors as they are numbered now
 }
 
 // give the level a flat terrain, as one undo: its size in the world, how many cells a side, and how tall a full
@@ -36048,9 +37286,9 @@ function editor3DTerrainRemove()
 }
 
 // sculpt the ground around a point for some seconds, as part of the edit being made: raise, lower or smooth it
-// under the brush, a soft circle, most in its middle and nothing at its edge; in the game's map now, in the level
-// when the stroke ends; false when nothing changed
-function editor3DTerrainSculpt(point, mode, seconds)
+// under the brush, a soft circle, most in its middle and nothing at its edge, or flatten it toward a height, level,
+// 0 to 1; in the game's map now, in the level when the stroke ends; false when nothing changed
+function editor3DTerrainSculpt(point, mode, seconds, level=0)
 {
     const map = editor3DTerrainMap();
     if (!map || editor3DRecords.get(editor3DLevel)?.pending) return false; // its autosave waits first
@@ -36061,7 +37299,7 @@ function editor3DTerrainSculpt(point, mode, seconds)
     const c0 = max(0, ceil((point.x - radius - x0) / stepX)), c1 = min(columns - 1, floor((point.x + radius - x0) / stepX));
     const r0 = max(0, ceil((point.z - radius - z0) / stepZ)), r1 = min(rows - 1, floor((point.z + radius - z0) / stepZ));
     // smoothing reads the ground as it was, so the order the samples are done in does not show
-    const old = mode === 'smooth' ? heights.map((row)=> row.slice()) : heights;
+    const old = mode === 'smooth' ? heights.map((row, r)=> r >= r0 - 1 && r <= r1 + 1 ? row.slice() : row) : heights;
     const rate = strength * 10 * seconds; // world units of height at full strength, 10 a second
     let changed = false;
     for (let r = r0; r <= r1; ++r)
@@ -36079,6 +37317,8 @@ function editor3DTerrainSculpt(point, mode, seconds)
                 old[r + dr]?.[c + dc] !== undefined && (sum += old[r + dr][c + dc], ++count);
             v = h + (sum / count - h) * min(1, rate * falloff);
         }
+        else if (mode === 'flatten')
+            v = h + (level - h) * min(1, rate * falloff);
         else
             v = clamp(h + (mode === 'lower' ? -1 : 1) * rate * falloff / map.height);
         if (v === h) continue;
@@ -36086,8 +37326,7 @@ function editor3DTerrainSculpt(point, mode, seconds)
         changed = true;
     }
     if (!changed) return false;
-    editor3DStroke ||= {before: editor3DCopy(editor3DObjects()), parts: editor3DLevelParts()};
-    editor3DStroke.sculpted = true;
+    editor3DStrokeBegin().sculpted = true;
     map.rebuild();
     return true;
 }
@@ -36108,16 +37347,81 @@ function editor3DVoxelPress(ray, mode)
 {
     const target = editor3DVoxelTarget(ray, mode);
     if (!target) return;
-    const {cell, axis, plane} = target;
+    const {cell, axis, plane, side} = target;
+    if (editor3DBlockBox)
+    {
+        // a box grows out from the face when placing, and into the blocks when removing or repainting
+        const drag = {kind: 'blocks', mode, axis, plane, layer: cell[axis], last: cell, start: cell,
+            grow: mode === 'place' ? side : -side, height: max(1, floor(editor3DBlockBoxHeight)),
+            changed: new Map, region: undefined};
+        editor3DVoxelBoxTo(drag, cell);
+        return drag;
+    }
     editor3DVoxelApply(cell, mode);
     return {kind: 'blocks', mode, axis, plane, layer: cell[axis], last: cell};
 }
 
+// a box drag goes on: what it changed so far is put back, then every cell of the box from where it started to a
+// cell of the same layer is changed, as many layers as its height, the part of it inside the map
+function editor3DVoxelBoxTo(drag, cell)
+{
+    const map = editor3DVoxelMap();
+    if (!map) return;
+    for (const [at, type] of drag.changed.values())
+        map.setVoxel(at, type);
+    drag.changed.clear();
+    const lo = vec3(min(drag.start.x, cell.x), min(drag.start.y, cell.y), min(drag.start.z, cell.z));
+    const hi = vec3(max(drag.start.x, cell.x), max(drag.start.y, cell.y), max(drag.start.z, cell.z));
+    const far = drag.layer + drag.grow * (drag.height - 1), axis = drag.axis, s = map.mapSize;
+    lo[axis] = clamp(min(drag.layer, far), 0, s[axis] - 1);
+    hi[axis] = clamp(max(drag.layer, far), 0, s[axis] - 1);
+    for (let z = lo.z; z <= hi.z; ++z)
+    for (let y = lo.y; y <= hi.y; ++y)
+    for (let x = lo.x; x <= hi.x; ++x)
+    {
+        const at = vec3(x, y, z), type = map.getVoxel(at);
+        editor3DVoxelApply(at, drag.mode) && drag.changed.set(x + s.x * (y + s.y * z), [at, type]);
+    }
+    drag.region = {lo, hi};
+    drag.last = cell;
+}
+
+// change the size of the level's map in cells, as one undo: it grows and shrinks about its middle across, and at
+// its top, and its blocks stay where they are in the world, the ones outside the new size gone
+function editor3DVoxelResize(size)
+{
+    const changed = editor3DChangePart('voxels', (voxels)=>
+    {
+        const shape = level3DVoxelsShape(voxels);
+        const to = vec3(floor(size.x), floor(size.y), floor(size.z));
+        if (!shape || to.x < 1 || to.y < 1 || to.z < 1 || to.x * to.y * to.z > LEVEL3D_VOXEL_CELLS) return voxels;
+        const from = shape.size, old = new Uint8Array(from.x * from.y * from.z);
+        level3DVoxelsDecode(voxels.blocks, old);
+        // how far each block moves in cells, so the corner moves the other way and the blocks stay put
+        const dx = floor((to.x - from.x) / 2), dz = floor((to.z - from.z) / 2);
+        const data = new Uint8Array(to.x * to.y * to.z);
+        for (let z = 0; z < from.z; ++z)
+        for (let y = 0; y < min(from.y, to.y); ++y)
+        for (let x = 0; x < from.x; ++x)
+        {
+            const nx = x + dx, nz = z + dz;
+            if (nx >= 0 && nz >= 0 && nx < to.x && nz < to.z)
+                data[nx + to.x * (y + to.y * nz)] = old[x + from.x * (y + from.y * z)];
+        }
+        return {...voxels, pos: [shape.pos.x - dx, shape.pos.y, shape.pos.z - dz], size: [to.x, to.y, to.z],
+            blocks: level3DVoxelsEncode(data)};
+    });
+    editor3DStrokeEnd();
+    return changed;
+}
+
 // a drag of the Blocks tool goes on: every cell of the layer from the last one to the one under the ray
 function editor3DVoxelDragTo(drag, ray)
 {
     const cell = editor3DVoxelDragCell(drag, ray), last = drag.last;
     if (!cell) return;
+    if (drag.changed)
+        return editor3DVoxelBoxTo(drag, cell);
     const d = cell.subtract(last), steps = max(abs(d.x), abs(d.y), abs(d.z));
     for (let i = 1; i <= steps; ++i)
         editor3DVoxelApply(vec3(round(last.x + d.x * i / steps), round(last.y + d.y * i / steps),
@@ -36144,12 +37448,12 @@ function editor3DVoxelTarget(ray, mode)
     if (!hit)
     {
         const cell = place ? editor3DVoxelDragCell({axis: 'y', plane: 0, layer: 0}, ray) : undefined;
-        return cell && {cell, axis: 'y', plane: 0};
+        return cell && {cell, axis: 'y', plane: 0, side: 1};
     }
     const n = hit.normal, axis = n.x ? 'x' : n.y ? 'y' : 'z', cell = place ? hit.cell.add(n) : hit.cell;
     if (!editor3DVoxelInside(map, cell)) return;
-    // the face between the block hit and the cell in front of it
-    return {cell, axis, plane: cell[axis] + ((n[axis] > 0) === place ? 0 : 1)};
+    // the face between the block hit and the cell in front of it, and side, the way that face looks along the axis
+    return {cell, axis, plane: cell[axis] + ((n[axis] > 0) === place ? 0 : 1), side: n[axis]};
 }
 
 // end the edit being made: one undo, and the autosave
@@ -36223,6 +37527,7 @@ function editor3DSetProperty(object, name, value, defaultValue)
 // add an object of a type at a position, selected; its id, or undefined when the level can not be edited
 function editor3DPlace(type, pos)
 {
+    if (editor3DPrefabSelf(type)) return; // it would hold itself
     let id;
     const placed = editor3DChange((list)=>
     {
@@ -36236,6 +37541,302 @@ function editor3DPlace(type, pos)
     return id;
 }
 
+///////////////////////////////////////////////////////////////////////////////
+// prefabs: a selection made one, an instance made objects again, and a prefab's own settings
+
+// what the panel says about the last prefab action that was refused
+let editor3DPrefabMessage = '';
+
+// the box around an object in the world, turned and sized as it is, as its low and high corners
+function editor3DWorldBox(object, low=vec3(Infinity), high=vec3(-Infinity))
+{
+    const matrix = editor3DBoxMatrix(object);
+    for (let i = 8; i--;)
+    {
+        const p = matrix.transformPoint(vec3(i & 1 ? .5 : -.5, i & 2 ? .5 : -.5, i & 4 ? .5 : -.5));
+        for (const k of ['x', 'y', 'z'])
+            low[k] = min(low[k], p[k]), high[k] = max(high[k], p[k]);
+    }
+    return {low, high};
+}
+
+// is a type the prefab being edited, or one that holds it: a prefab that is open, or one the game made of the
+// level being edited itself, as a prefab maker does; placed there it would hold itself
+function editor3DPrefabSelf(type)
+{
+    const names = editor3DPrefabStack.map((frame)=> frame.name);
+    for (const [name, prefab] of level3DPrefabs)
+        prefab.source === editor3DLevel && names.push(name);
+    return names.some((name)=> editor3DPrefabHolds(type, name));
+}
+
+// the types the Place list has, the plain ones and then the prefabs
+function editor3DPlaceNames()
+{
+    const all = [...level3DTypes.keys()].filter((name)=> !editor3DPrefabSelf(name));
+    return [...all.filter((name)=> !level3DPrefabs.has(name)), ...all.filter((name)=> level3DPrefabs.has(name))];
+}
+
+// does a type hold a prefab, itself or through the prefabs it holds
+function editor3DPrefabHolds(type, name, depth=0)
+{
+    return type === name || depth < 8 &&
+        !!level3DPrefabs.get(type)?.objects.some((o)=> editor3DPrefabHolds(o.type, name, depth + 1));
+}
+
+// make the selected objects a prefab of the level's own, about the bottom centre of their box, and put one
+// instance of it where they were, as one undo; a name the level's prefabs have replaces that prefab, and every
+// instance of it changes; true, or why not, which the panel shows
+function editor3DMakePrefab(name='')
+{
+    const refuse = (why)=> editor3DPrefabMessage = why;
+    const selected = editor3DSelected();
+    if (editor3DPrefabStack.length) return refuse('Go back to the level to make a prefab');
+    if (!selected.length) return refuse('Select the objects to make a prefab of');
+    if (!editor3DLevel || editor3DRecords.get(editor3DLevel)?.pending) return refuse('The level can not be edited now');
+    name = String(name).trim();
+    for (let i = 1; !name; ++i)
+        level3DTypes.has('Prefab ' + i) || (name = 'Prefab ' + i);
+    const known = level3DPrefabs.get(name);
+    if (known ? !known.fromLevel : level3DTypes.has(name))
+        return refuse(name + ' is a type the game added, pick another name');
+    if (selected.some((o)=> editor3DPrefabHolds(o.type, name)))
+        return refuse(name + ' can not hold itself');
+
+    // its origin is the bottom centre of the selection, so an instance stands on the ground
+    const low = vec3(Infinity), high = vec3(-Infinity);
+    for (const object of selected)
+        editor3DWorldBox(object, low, high);
+    const origin = vec3(editor3DRound((low.x + high.x) / 2), editor3DRound(low.y), editor3DRound((low.z + high.z) / 2));
+    const objects = selected.map((object, i)=>
+    {
+        const part = {...editor3DCopy(object), id: i + 1};
+        editor3DSetTransform(part, editor3DPos(object).subtract(origin));
+        return part;
+    });
+    editor3DStrokeEnd();
+    const id = editor3DObjects().reduce((next, o)=> max(next, o.id + 1), 1);
+    const ids = new Set(selected.map((o)=> o.id));
+    // the prefab first, so its type is there when the instance is made
+    editor3DChangePart('prefabs', (prefabs={})=>
+        ({...prefabs, [name]: prefabs[name]?.attached ? {attached: true, objects} : {objects}}));
+    editor3DChange((list)=>
+    {
+        for (let i = list.length; i--;)
+            ids.has(list[i].id) && list.splice(i, 1);
+        const instance = {id, type: name};
+        editor3DSetTransform(instance, origin);
+        list.push(instance);
+    });
+    editor3DStrokeEnd();
+    editor3DSelection.clear();
+    editor3DSelection.add(id);
+    editor3DPrefabMessage = '';
+    return true;
+}
+
+// add a prefab from the text of a file the editor saved, a level file, to the level's own prefabs under a name,
+// as one undo, and pick it to place; a name the level's prefabs have is replaced, as Make prefab does; true, or
+// why not, which the panel shows
+function editor3DPrefabLoad(name, text)
+{
+    const refuse = (why)=> editor3DPrefabMessage = why;
+    if (editor3DPrefabStack.length) return refuse('Go back to the level to load a prefab');
+    if (!editor3DLevel || editor3DRecords.get(editor3DLevel)?.pending) return refuse('The level can not be edited now');
+    name = String(name).trim();
+    if (!name) return refuse('The prefab needs a name');
+    let file;
+    try { file = JSON.parse(text); }
+    catch { return refuse(name + ' is not a JSON file'); }
+    if (!file || typeof file !== 'object' || !isArray(file.objects))
+        return refuse(name + ' is not a prefab, it has no objects');
+    const known = level3DPrefabs.get(name);
+    if (known ? !known.fromLevel : level3DTypes.has(name))
+        return refuse(name + ' is a type the game added, rename the file');
+    const objects = file.objects.filter((o)=> o && typeof o === 'object');
+    if (objects.some((o)=> editor3DPrefabHolds(o.type, name)))
+        return refuse(name + ' can not hold itself');
+    editor3DStrokeEnd();
+    editor3DChangePart('prefabs', (prefabs={})=> ({...prefabs, [name]: file.attached ? {attached: true, objects} : {objects}}));
+    editor3DStrokeEnd();
+    editor3DPickTool(editor3DTool); // a tool of the game's own is put down
+    editor3DBrush = name;
+    editor3DPrefabMessage = '';
+    return true;
+}
+
+// pick a prefab's file and load it, by its file name
+function editor3DPrefabPickFile()
+{
+    const input = document.createElement('input');
+    input.type = 'file';
+    input.accept = '.json,application/json';
+    input.onchange = async ()=>
+    {
+        const file = input.files?.[0];
+        file && editor3DPrefabLoad(file.name.replace(/\.json$/i, ''), await file.text());
+    };
+    input.click();
+}
+
+// turn the selected instances of prefabs into the objects they are made of, where they are, as one undo; false
+// with none selected
+function editor3DUnpack()
+{
+    const instances = editor3DSelected().filter((o)=> editor3DInstances.get(o.id) instanceof Prefab3D);
+    if (!instances.length) return false;
+    editor3DStrokeEnd();
+    const added = [];
+    const changed = editor3DChange((list)=>
+    {
+        let id = list.reduce((next, o)=> max(next, o.id + 1), 1);
+        for (const instance of instances)
+        {
+            const made = editor3DInstances.get(instance.id);
+            // by the level's own place of it, its origin, which is not where an attached one's handle is
+            const origin = {pos3D: editor3DPos(instance), rotation3D: editor3DRotation(instance).scale(PI / 180),
+                scale3D: editor3DScale(instance)};
+            for (const part of level3DPrefabs.get(made.prefabName)?.objects ?? [])
+            {
+                const at = level3DPrefabPartTransform(origin, part), object = {...editor3DCopy(part), id: id++};
+                editor3DSetTransform(object, at.pos, at.rotation.scale(180 / PI), at.scale);
+                list.push(object);
+                added.push(object.id);
+            }
+            list.splice(list.findIndex((o)=> o.id === instance.id), 1);
+        }
+    });
+    editor3DStrokeEnd();
+    if (!changed) return false;
+    editor3DSelection.clear();
+    for (const id of added)
+        editor3DSelection.add(id);
+    return true;
+}
+
+// make a prefab of the level's own attached, its parts the children of each instance, or not, as one undo
+function editor3DPrefabSetAttached(name, attached)
+{
+    if (editor3DPrefabStack.length) return false; // a prefab is the level's, set from the level
+    editor3DStrokeEnd();
+    const changed = editor3DChangePart('prefabs', (prefabs)=>
+    {
+        if (!prefabs?.[name]) return prefabs;
+        const {attached: was, ...rest} = prefabs[name];
+        return {...prefabs, [name]: attached ? {attached: true, ...rest} : rest};
+    });
+    editor3DStrokeEnd();
+    return changed;
+}
+
+// a prefab as its own file has it, a level file of its objects, to load with level3DLoadPrefab
+function editor3DPrefabJSON(name)
+{
+    const prefab = level3DPrefabs.get(name);
+    if (!prefab) return '';
+    return editor3DLevelJSON({...(prefab.attached ? {attached: true} : {}), objects: prefab.objects});
+}
+
+///////////////////////////////////////////////////////////////////////////////
+// Edit prefab: the editor on a prefab alone, the level it came from put away until Back
+
+// the prefabs opened one inside the other, each with the level it was opened from, its name, the selection there
+// and the ids of that level's objects that had something made for them
+/** @type {Array<{level: Object, name: string, selection: Array<number>, made: Set<number>, entered?: string, saved?: string}>} */
+const editor3DPrefabStack = [];
+// the levels that are a prefab being edited, they have no autosave of their own
+const editor3DPrefabLevels = new WeakSet;
+// what was edited in prefabs of the level's own since the level was left, written into it on the way back
+/** @type {Object<string, Object>} */
+let editor3DPrefabEdits = {};
+// the prefabs of the game's own that were edited and are not in a file yet
+const editor3DPrefabDirty = new Set;
+
+// destroy what the level being edited has in the world, its objects' and its maps'
+function editor3DPrefabClear()
+{
+    for (const made of editor3DInstances.values())
+        made?.destroy?.();
+    editor3DInstances.clear();
+    for (const map of [level3DVoxelMap, level3DTerrainMap])
+        map && !map.destroyed && map.destroy();
+}
+
+// open the prefab of an instance, the selected one when none is given, to edit alone: its objects about its own
+// origin, with an undo of its own, and the level it is in put away; false when it is not a prefab's instance
+function editor3DPrefabEnter(id)
+{
+    const selected = editor3DSelected();
+    id ??= selected.length === 1 ? selected[0].id : undefined;
+    const made = editor3DInstances.get(id), from = editor3DLevel;
+    const prefab = made instanceof Prefab3D && level3DPrefabs.get(made.prefabName);
+    if (!prefab || editor3DRecords.get(from)?.pending) return false;
+    editor3DStrokeEnd();
+    editor3DDrag = editor3DHover = undefined;
+    const frame = {level: from, name: made.prefabName, selection: [...editor3DSelection],
+        made: new Set(editor3DInstances.keys()), entered: undefined};
+    editor3DPrefabStack.push(frame);
+    editor3DPrefabClear();
+    const level = {littlejs3D: LEVEL3D_VERSION, ...(prefab.attached ? {attached: true} : {}),
+        objects: editor3DCopy(prefab.objects)};
+    editor3DPrefabLevels.add(level);
+    level3DLoad(level); // the editor takes it as it does any level
+    frame.entered = JSON.stringify(editor3DObjects()); // as the editor has it, an edit is what differs from this
+    return true;
+}
+
+// leave the prefab being edited for the level it was opened from: the prefab is what was edited, every instance
+// of it is made again, and back in the level itself what was edited in its own prefabs is one undo; false when
+// no prefab is open
+function editor3DPrefabBack()
+{
+    const frame = editor3DPrefabStack.pop(), edited = editor3DLevel;
+    if (!frame) return false;
+    editor3DStrokeEnd();
+    editor3DDrag = editor3DHover = undefined;
+    const known = level3DPrefabs.get(frame.name);
+    const objects = editor3DCopy(editor3DObjects()), changed = JSON.stringify(objects) !== frame.entered;
+    editor3DPrefabClear();
+    if (changed)
+    {
+        // the prefab as it is now, for whatever is made next; one of the game's own waits to be saved to its file
+        const prefab = known?.attached ? {attached: true, objects} : {objects}, fromLevel = !!known?.fromLevel;
+        level3DPrefabSet(frame.name, prefab, fromLevel);
+        if (fromLevel)
+            editor3DPrefabEdits[frame.name] = prefab;
+        else if (JSON.stringify(objects) !== frame.saved)
+            editor3DPrefabDirty.add(frame.name); // not what Save wrote while it was open
+    }
+
+    // the level it was opened from is the editor's again, with its own undo
+    const level = editor3DLevel = frame.level, record = editor3DRecords.get(level);
+    editor3DUndoList = record.undo, editor3DRedoList = record.redo;
+    editor3DStroke = undefined;
+    if (!editor3DPrefabStack.length)
+    {
+        // back in the level: its own prefabs that were edited go into it, as one undo
+        const edits = editor3DPrefabEdits;
+        editor3DPrefabEdits = {};
+        Object.keys(edits).length && editor3DChangePart('prefabs', (prefabs={})=> ({...prefabs, ...edits}));
+        editor3DStrokeEnd();
+    }
+    // what the level had in the world is made again: what a class makes, and what else had something made
+    for (const object of editor3DObjects())
+    {
+        const type = level3DTypes.get(object.type);
+        type && (type.make.prototype || frame.made.has(object.id)) && editor3DMakeInstance(object);
+    }
+    editor3DSceneRestore(record.sceneBase);
+    level3DSceneApply(level.scene);
+    editor3DVoxelShow();
+    editor3DTerrainShow();
+    editor3DShadowLight();
+    editor3DSelection.clear();
+    for (const id of frame.selection)
+        editor3DObject(id) && editor3DSelection.add(id);
+    return true;
+}
+
 // remove the selected objects, as one undo
 function editor3DDelete()
 {
@@ -36255,6 +37856,9 @@ function editor3DCopySelection()
     const selected = editor3DSelected();
     if (!selected.length) return false;
     editor3DClipboard = editor3DCopy(selected);
+    // how big each was and where its box was about its place: what is cut has nothing left to measure
+    editor3DClipboardBoxes = new Map(editor3DClipboard.map((copy, i)=>
+        [copy, {size: editor3DSize(selected[i]), offset: editor3DBoxOffset(selected[i])}]));
 }
 
 // copy the selected objects and remove them
@@ -36306,11 +37910,17 @@ function editor3DRestore()
     {
         const type = level3DTypes.get(object.type), made = editor3DInstances.get(object.id);
         if (!type) continue;
-        if (made instanceof EngineObject3D && !made.destroyed)
+        // a prefab's instance that play took a part of is made again, whole
+        const broken = (p)=> p instanceof Prefab3D && p.parts.some((part)=> part?.destroyed || broken(part));
+        if (made instanceof EngineObject3D && !made.destroyed && !broken(made))
             editor3DPlaceInstance(made, object);
-        else if (type.make.prototype && (!made || made.destroyed))
+        else if (type.make.prototype && (!made || made.destroyed || broken(made)))
             editor3DMakeInstance(object);
     }
+    // the blocks and the terrain as the level has them: what play dug, raised or destroyed is not the level's,
+    // and must not be written into it by the next stroke
+    editor3DVoxelShow();
+    editor3DTerrainShow();
 }
 
 // open or close the editor, the session goes on: the game is paused under it and reads no input
@@ -36328,14 +37938,19 @@ function editor3DSetOpen(open)
         setDebugOverlay(false); // out of the way of the level
         editor3DIsOpen = true;
         editor3DRestore();
+        editorCall('onOpen');
+        editorKeyClashes();
     }
     else
     {
         editor3DDrag = editor3DHover = undefined;
         editor3DMouseOnPanel = false; // the panel hides, with no mouseleave
         editor3DStrokeEnd();
+        while (editor3DPrefabBack()); // the game plays the level, not a prefab that was open
+        editor3DToolHeld = false;
         editor3DIsOpen = false;
         setPaused(editor3DGamePaused);
+        editorCall('onClose');
     }
     inputCapture(editor3DViewOn());
 }
@@ -36359,24 +37974,116 @@ function editor3DClose()
 function editor3DPlay(pos)
 {
     editor3DSetOpen(false);
-    editor3DPlayFromMouse && pos && levelEditor.onPlayFrom?.(pos.copy());
+    editor3DPlayFromMouse && pos && editorHas('onPlayFrom') && levelEditor.onPlayFrom(pos.copy());
 }
 
 // rebuild the level through the game's hook and play it
 function editor3DRestart()
 {
-    if (!levelEditor.onRestart) return;
+    if (!editorHas('onRestart')) return;
     editor3DSetOpen(false);
     levelEditor.onRestart();
 }
 
-// the level editor's open, close and isOpen go to the 3D editor when the game has a 3D level
+// a key as addKey spells it, as the 3D editor's tables have it, by its position: a letter, a digit, a mark by the
+// key it is on, or its name
+const editor3DKeyMarks = {'?': 'Slash', '/': 'Slash', ',': 'Comma', '.': 'Period', ';': 'Semicolon', "'": 'Quote',
+    '[': 'BracketLeft', ']': 'BracketRight', '-': 'Minus', '=': 'Equal', '\\': 'Backslash', '`': 'Backquote'};
+function editor3DKeyCode(name)
+{
+    return name.length !== 1 ? name : editor3DKeyMarks[name] ??
+        (name >= '0' && name <= '9' ? 'Digit' + name : 'Key' + name.toUpperCase());
+}
+
+// the 3D editor's edit functions, what levelEditor.edit3D gives a game's own keys, buttons and tools
+const editor3DEdit =
+{
+    get level() { return editor3DLevel; },
+    get objects() { return editor3DObjects(); },
+    get selection() { return editor3DSelection; },
+    selected() { return editor3DSelected(); },
+    made(id) { return editor3DInstances.get(id); },
+    change(change) { return editor3DChange(change); },
+    changePart(name, change) { return editor3DLevelPartNames.includes(name) && editor3DChangePart(name, change); },
+    strokeEnd() { editor3DStrokeEnd(); },
+    strokeCancel() { editor3DStrokeCancel(); },
+    place(type, pos3D) { return level3DTypes.has(type) ? editor3DPlace(type, pos3D) : undefined; },
+    setTransform(object, pos3D, rotation, scale3D) { editor3DSetTransform(object, pos3D, rotation, scale3D); },
+    setProperty(object, name, value)
+    { editor3DSetProperty(object, name, value, level3DTypes.get(object.type)?.defaults[name]); },
+    pos(object) { return editor3DPos(object); },
+    rotation(object) { return editor3DRotation(object); },
+    scale(object) { return editor3DScale(object); },
+    mousePoint() { return editor3DIsOpen && !editor3DMouseOnPanel ? editor3DWithView(editor3DMousePoint) : undefined; },
+    undo(redo=false) { return editor3DUndo(redo); },
+    toJSON() { return editor3DLevel ? editor3DLevelJSON() : ''; },
+};
+
+// the level editor's open, close and isOpen go to the 3D editor when the game has a 3D level, and it has the 3D
+// editor's keys and edit functions through this
 if (debug)
+    editorOther = {wanted: editor3DWanted, isOpen: ()=> editor3DIsOpen, active: ()=> editor3DIsOpen || editor3DSession,
+        open: editor3DOpen, close: editor3DClose, edit: editor3DEdit,
+        hasKey: (name, ctrl)=> !!(ctrl ? editor3DCtrlKeys : editor3DKeys)[editor3DKeyCode(name)]};
+
+// pick a tool of the editor's own, which puts a tool of the game's down
+function editor3DPickTool(tool)
+{
+    editor3DTool = tool;
+    levelEditor.tool = undefined;
+}
+
+// a tool of the game's own: if its press is held, and the editor's tool and type to place when it was turned on,
+// since picking one of those puts the game's tool down
+let editor3DToolHeld = false, editor3DToolName, editor3DToolPicked = [];
+
+// what a tool's callbacks are given: where the mouse is on the level or the ground, its ray, and the keys held
+function editor3DToolAt(ray=render3D.screenToRay(mousePosScreen), shift=false, ctrl=false)
+{ return {pos: editor3DMouseOnPanel ? undefined : editor3DSurface(ray), cell: undefined, ray, shift, ctrl}; }
+
+// the game's tool, when one is on: the left button is its, a press, a drag and a release one undo, the right
+// button takes a held press back; true when it has the mouse
+function editor3DToolUpdate(ray, idle, shift, ctrl)
+{
+    const picked = [editor3DTool, editor3DBrush];
+    if (levelEditor.tool !== editor3DToolName)
+        editor3DToolName = levelEditor.tool, editor3DToolPicked = picked; // turned on, or off, by its key or button
+    else if (picked.some((value, i)=> value !== editor3DToolPicked[i]))
+        levelEditor.tool = editor3DToolName = undefined; // a tool or a type of the editor's was picked
+    const tool = editorGameTool();
+    if (!tool)
+    {
+        editor3DToolHeld = false;
+        return false;
+    }
+    const at = editor3DToolAt(ray, shift, ctrl);
+    editor3DHover = editor3DBlockHover = editor3DTerrainHover = undefined; // the editor's own cursors are put away
+    if (editor3DToolHeld && mouseWasPressed(2))
+    {
+        editor3DStrokeCancel();
+        editor3DToolHeld = false;
+    }
+    else if (idle && mouseWasPressed(0))
+        editor3DToolHeld = tool.onPress?.(at) !== false;
+    else if (editor3DToolHeld && mouseIsDown(0))
+        tool.onDrag?.(at);
+    if (editor3DToolHeld && !mouseIsDown(0))
+    {
+        tool.onRelease?.(at);
+        editor3DStrokeEnd();
+        editor3DToolHeld = false;
+    }
+    return true;
+}
+
+// the game's own drawing in the level, in the editor's 3D pass: the editor's onDraw, and its tool's while one is on
+function editor3DDrawGame()
 {
-    const open2D = levelEditor.open.bind(levelEditor), close2D = levelEditor.close.bind(levelEditor);
-    levelEditor.open = ()=> editor3DWanted() ? editor3DOpen() : open2D();
-    levelEditor.close = ()=> editor3DIsOpen || editor3DSession ? editor3DClose() : close2D();
-    Object.defineProperty(levelEditor, 'isOpen', {get: ()=> editor3DIsOpen || editorIsOpen});
+    if (!editor3DIsOpen) return;
+    editorCall('onDraw');
+    const held = (...codes)=> inputCaptureRead(()=> codes.some((code)=> keyIsDown(code)));
+    editorGameTool()?.onDraw?.(editor3DToolAt(undefined, held('ShiftLeft', 'ShiftRight'),
+        held('ControlLeft', 'ControlRight', 'MetaLeft', 'MetaRight')));
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -36413,9 +38120,25 @@ const editor3DSaves = ()=> readSaveData(editor3DSaveName(), {});
 let editor3DSaveFailed = false;
 
 // remember the level's objects and parts, or forget them when they are back to the file
-function editor3DAutosave(level=editor3DLevel)
+function editor3DAutosave(level=editor3DLevel, known)
 {
-    const record = editor3DRecords.get(level);
+    // a prefab being edited is kept with the level it is in, as that level would be on going back: its own
+    // prefabs with what is open, and what was edited on the way, in them
+    if (editor3DPrefabLevels.has(level))
+    {
+        const root = editor3DPrefabStack[0]?.level, edits = {...editor3DPrefabEdits};
+        editor3DPrefabStack.forEach((frame, i)=>
+        {
+            const open = editor3DPrefabStack[i + 1]?.level ?? editor3DLevel, known = level3DPrefabs.get(frame.name);
+            const objects = isArray(open.objects) ? editor3DCopy(open.objects) : [];
+            if (known?.fromLevel && JSON.stringify(objects) !== frame.entered)
+                edits[frame.name] = known.attached ? {attached: true, objects} : {objects};
+        });
+        if (root && Object.keys(edits).length)
+            editor3DAutosave({...root, prefabs: {...editor3DLevelPart('prefabs', root), ...edits}}, editor3DRecords.get(root));
+        return;
+    }
+    const record = known ?? editor3DRecords.get(level);
     if (!record || record.pending) return; // edits waiting to be applied keep their autosave
     const saves = editor3DSaves(), objects = isArray(level.objects) ? level.objects : [];
     const parts = editor3DLevelParts(level);
@@ -36482,11 +38205,36 @@ async function editor3DSave(pickAgain=false)
     const level = editor3DLevel, record = editor3DRecords.get(level);
     if (!record) return;
     editor3DStrokeEnd();
+    const open = editor3DPrefabStack[editor3DPrefabStack.length - 1];
+    if (open)
+    {
+        // inside a prefab, Save writes the prefab as a file of its own, or the game keeps it itself
+        const text = editor3DLevelJSON(level), name = open.name + '.json';
+        const written = JSON.stringify(editor3DObjects()); // as the file has it
+        const saved = (async ()=>
+        {
+            await record.saving; // in the order asked for, as a level's saves are
+            const kept = await editorCall('onSave', text, name) === true;
+            kept || saveText(text, name, 'application/json');
+            editor3DPrefabDirty.delete(open.name);
+            open.saved = written;
+            return kept ? 'kept' : 'downloaded';
+        })();
+        record.saving = saved.catch(()=> {});
+        return saved;
+    }
     // what is written, kept as it is now: the level can change while the file is picked and written, and those
     // edits are not in the file, so they stay in the autosave; the level and record are this one's, whichever is
     // open by then
     const text = editor3DLevelJSON(level);
-    const saved = (async ()=> { await record.saving; return editor3DSaveText(level, record, text, pickAgain); })();
+    // its place in line is taken now, and the game's hook is asked when its turn comes, so saves are written in
+    // the order they were asked for however long a hook takes
+    const saved = (async ()=>
+    {
+        await record.saving;
+        if (await editorCall('onSave', text, record.fileName) === true) return 'kept'; // the game kept it itself
+        return editor3DSaveText(level, record, text, pickAgain);
+    })();
     record.saving = saved.catch(()=> {});
     return saved;
 }
@@ -36546,6 +38294,8 @@ const EDITOR3D_AXES = {x: vec3(1, 0, 0), y: vec3(0, 1, 0), z: vec3(0, 0, 1)};
 
 let editor3DTool = 'move';     // 'select', 'move', 'rotate', 'scale', 'blocks' or 'terrain'
 let editor3DBlockType = 1;     // the block type the Blocks tool places
+let editor3DBlockBox = false;  // the Blocks tool fills a box: the rectangle dragged, editor3DBlockBoxHeight tall
+let editor3DBlockBoxHeight = 1;
 let editor3DSeconds = 0;       // how long the last step was, for a brush held down
 // where the mouse is on the terrain, for the Terrain tool's brush
 /** @type {Vector3|undefined} */
@@ -36555,6 +38305,7 @@ let editor3DTerrainHover;
 let editor3DBlockHover;
 let editor3DGrid = true;       // moves, turns and sizes go in steps, Ctrl flips it for a drag
 let editor3DGroundSnap = true; // a body drag slides along what is under the mouse
+let editor3DLocalAxes = false; // the Move handles follow the object's own axes, not the world's
 let editor3DMoveStep = 1, editor3DRotateStep = 15, editor3DScaleStep = .25; // the rotate step in degrees
 let editor3DHelp = false;      // the keys are shown
 let editor3DMouseOnPanel = false;
@@ -36582,7 +38333,7 @@ function editor3DSelectionCenter()
 function editor3DHandles()
 {
     const center = editor3DSelectionCenter(), tool = editor3DTool, handles = [];
-    if (!center || tool === 'select' || tool === 'blocks' || tool === 'terrain') return handles;
+    if (!center || tool === 'select' || tool === 'blocks' || tool === 'terrain' || editorGameTool()) return handles;
     const length = editor3DScreenScale(center) * EDITOR3D_HANDLE_SIZE;
     const rotation = editor3DRotation(editor3DSelected()[0]).scale(PI / 180), frame = buildMatrix(vec3(), rotation);
     for (const axis of 'xyz')
@@ -36599,16 +38350,19 @@ function editor3DHandles()
             continue;
         }
 
-        // an arrow or scale handle starts a little out from the middle, which is left for the object's body
-        const direction = tool === 'move' ? EDITOR3D_AXES[axis] : frame.transformDirection(EDITOR3D_AXES[axis]);
-        handles.push({kind: tool === 'move' ? 'arrow' : 'scale', axis, center, length, direction,
+        // an arrow or scale handle starts a little out from the middle, which is left for the object's body; Move
+        // goes along the world's axes, or with own axes on along the object's, as Scale always does
+        const local = tool !== 'move' || editor3DLocalAxes;
+        const way = (k)=> local ? frame.transformDirection(EDITOR3D_AXES[k]) : EDITOR3D_AXES[k];
+        const direction = way(axis), turn = tool === 'move' && local ? rotation : undefined;
+        handles.push({kind: tool === 'move' ? 'arrow' : 'scale', axis, center, length, direction, turn,
             points: [center.add(direction.scale(length * .2)), center.add(direction.scale(length))]});
         if (tool === 'move')
         {
-            // the square between the other two axes moves along both
+            // the square between the other two axes moves along both; across is the axis it does not move along
             const [a, b] = 'xyz'.replace(axis, '');
-            handles.push({kind: 'plane', axis: a + b, center, length, direction,
-                points: [center.add(EDITOR3D_AXES[a].add(EDITOR3D_AXES[b]).scale(length * .35))]});
+            handles.push({kind: 'plane', axis: a + b, center, length, direction, turn, across: axis,
+                ways: [way(a), way(b)], points: [center.add(way(a).add(way(b)).scale(length * .35))]});
         }
     }
     tool === 'scale' && handles.push({kind: 'scaleAll', axis: 'xyz', center, length, points: [center]});
@@ -36675,6 +38429,10 @@ function editor3DParts(made, parts=[])
         parts.push(made);
         for (const child of made.children)
             editor3DParts(child, parts);
+        // a prefab's instance and its parts are one thing, the ones that are not its children too
+        if (made instanceof Prefab3D)
+            for (const part of made.parts)
+                part?.parent === made || editor3DParts(part, parts);
     }
     return parts;
 }
@@ -36748,10 +38506,13 @@ function editor3DPlaceAt(type, ray)
     editor3DStrokeEnd();
     const id = editor3DPlace(type, point);
     if (id === undefined) return;
-    const size = editor3DSize(editor3DObject(id)), ignore = new Set(editor3DParts(editor3DInstances.get(id)));
+    const object = editor3DObject(id), size = editor3DSize(object), offset = editor3DBoxOffset(object);
+    const ignore = new Set(editor3DParts(editor3DInstances.get(id)));
     const snapped = editor3DSnapPos(editor3DRest(point, size), size, editor3DGrid ? editor3DMoveStep : 0);
     const y = editor3DLand(snapped.x, snapped.z, point.y, size, ignore);
-    editor3DChange((list)=> editor3DSetTransform(list.find((o)=> o.id === id), vec3(snapped.x, y, snapped.z)));
+    // the box stands there, and the object's place is where that puts it
+    const to = vec3(snapped.x, y, snapped.z).subtract(offset);
+    editor3DChange((list)=> editor3DSetTransform(list.find((o)=> o.id === id), to));
     editor3DStrokeEnd();
 }
 
@@ -36761,7 +38522,7 @@ function editor3DDragTo(drag, mouse, ray, snap)
     if (drag.kind === 'blocks')
         return editor3DVoxelDragTo(drag, ray);
     if (drag.kind === 'terrain')
-        return editor3DTerrainHover && editor3DTerrainSculpt(editor3DTerrainHover, drag.mode, editor3DSeconds);
+        return editor3DTerrainHover && editor3DTerrainDragTo(drag, editor3DTerrainHover);
     if (drag.kind === 'box')
     {
         drag.to = mouse.copy();
@@ -36772,18 +38533,23 @@ function editor3DDragTo(drag, mouse, ray, snap)
     const was = first && start.get(first.id);
     if (!was) return;
     const size = editor3DSize(first), turned = editor3DTurned(first), step = snap ? editor3DMoveStep : 0;
-    const snapTo = (to)=> editor3DSnapPos(to, size, step, turned).subtract(was.pos);
+    const offset = editor3DBoxOffset(first); // snapping and landing go by its box
+    const snapTo = (to)=> editor3DSnapPos(to.add(offset), size, step, turned).subtract(offset).subtract(was.pos);
     let move, turn, factor;
     if (kind === 'arrow')
     {
         const d = editor3DAxisDistance(ray, handle.center, handle.direction) - grab;
-        move = handle.direction.multiply(snapTo(was.pos.add(handle.direction.scale(d)))); // along its axis alone
+        // an axis of its own does not follow the grid, so the move goes in steps from where it started
+        move = handle.turn ? handle.direction.scale(step ? round(d / step) * step : d) :
+            handle.direction.multiply(snapTo(was.pos.add(handle.direction.scale(d)))); // along its axis alone
     }
     else if (kind === 'plane')
     {
         const point = editor3DPlanePoint(ray, handle.center, handle.direction);
         if (!point || !grab) return;
-        move = vec3(1).subtract(handle.direction).multiply(snapTo(was.pos.add(point.subtract(grab))));
+        const delta = point.subtract(grab), along = (w)=> step ? round(delta.dot(w) / step) * step : delta.dot(w);
+        move = handle.turn ? handle.ways[0].scale(along(handle.ways[0])).add(handle.ways[1].scale(along(handle.ways[1]))) :
+            vec3(1).subtract(handle.direction).multiply(snapTo(was.pos.add(delta)));
     }
     else if (kind === 'body')
     {
@@ -36791,8 +38557,8 @@ function editor3DDragTo(drag, mouse, ray, snap)
         const point = editor3DPlanePoint(ray, drag.level, drag.normal);
         if (!point) return;
         const across = snapTo(was.pos.add(point.subtract(drag.level)));
-        const y = editor3DGroundSnap ? editor3DLand(was.pos.x + across.x, was.pos.z + across.z,
-            was.pos.y - size.y / 2, size, drag.ignore) : was.pos.y;
+        const y = editor3DGroundSnap ? editor3DLand(was.pos.x + offset.x + across.x, was.pos.z + offset.z + across.z,
+            was.pos.y + offset.y - size.y / 2, size, drag.ignore) - offset.y : was.pos.y;
         move = vec3(across.x, y - was.pos.y, across.z);
     }
     else if (kind === 'ring')
@@ -36893,9 +38659,9 @@ function editor3DDropSelection()
     {
         for (const object of list)
         {
-            const to = editor3DSelection.has(object.id) &&
-                editor3DDrop(editor3DPos(object), editor3DSize(object), ignore);
-            to && editor3DSetTransform(object, to);
+            const offset = editor3DBoxOffset(object), to = editor3DSelection.has(object.id) &&
+                editor3DDrop(editor3DPos(object).add(offset), editor3DSize(object), ignore);
+            to && editor3DSetTransform(object, to.subtract(offset));
         }
     });
     editor3DStrokeEnd();
@@ -36909,11 +38675,12 @@ function editor3DPasteAtMouse()
     if (!copied?.length) return false;
     if (!point) return editor3DPaste();
     const center = copied.reduce((sum, o)=> sum.add(editor3DPos(o)), vec3()).scale(1 / copied.length);
-    const bottom = copied.reduce((low, o)=> min(low, editor3DPos(o).y - editor3DSize(o).y / 2), Infinity);
-    const first = copied[0], was = editor3DPos(first);
-    const snapped = editor3DSnapPos(was.add(vec3(point.x - center.x, 0, point.z - center.z)), editor3DSize(first),
+    const box = (o)=> editor3DClipboardBoxes.get(o) ?? {size: editor3DSize(o), offset: editor3DBoxOffset(o)};
+    const bottom = copied.reduce((low, o)=> min(low, editor3DPos(o).y + box(o).offset.y - box(o).size.y / 2), Infinity);
+    const first = copied[0], size = box(first).size, was = editor3DPos(first).add(box(first).offset); // its box's middle
+    const snapped = editor3DSnapPos(was.add(vec3(point.x - center.x, 0, point.z - center.z)), size,
         editor3DGrid ? editor3DMoveStep : 0, editor3DTurned(first));
-    const land = editor3DLand(snapped.x, snapped.z, point.y, editor3DSize(first)) - editor3DSize(first).y / 2;
+    const land = editor3DLand(snapped.x, snapped.z, point.y, size) - size.y / 2;
     return editor3DPaste(vec3(snapped.x - was.x, land - bottom, snapped.z - was.z));
 }
 
@@ -36922,18 +38689,22 @@ function editor3DPasteAtMouse()
 /** @type {Object<string, function(boolean=): any>} */
 const editor3DKeys =
 {
-    KeyQ: ()=> { editor3DTool = 'select'; editor3DBrush = undefined; },
-    KeyW: ()=> { editor3DTool = 'move'; },
-    KeyE: ()=> { editor3DTool = 'rotate'; },
-    KeyR: ()=> { editor3DTool = 'scale'; },
-    KeyB: ()=> { editor3DTool = 'blocks'; editor3DBrush = undefined; },
-    KeyT: ()=> { editor3DTool = 'terrain'; editor3DBrush = undefined; },
+    KeyQ: ()=> { editor3DPickTool('select'); editor3DBrush = undefined; },
+    KeyW: ()=> { editor3DPickTool('move'); },
+    KeyE: ()=> { editor3DPickTool('rotate'); },
+    KeyR: ()=> { editor3DPickTool('scale'); },
+    KeyB: ()=> { editor3DPickTool('blocks'); editor3DBrush = undefined; },
+    KeyT: ()=> { editor3DPickTool('terrain'); editor3DBrush = undefined; },
     KeyP: ()=> editor3DTool === 'blocks' && editor3DVoxelPick(render3D.screenToRay(mousePosScreen)),
+    KeyX: ()=> editor3DTool === 'terrain' ? editor3DTerrainNextBrush() :
+        editor3DTool === 'blocks' && (editor3DBlockBox = !editor3DBlockBox),
     KeyG: ()=> { editor3DGrid = !editor3DGrid; },
+    KeyL: ()=> { editor3DLocalAxes = !editor3DLocalAxes; },
     KeyF: ()=> editor3DFrame(),
     End: ()=> editor3DDropSelection(),
     Delete: ()=> editor3DDelete(),
-    Backspace: ()=> editor3DDelete(),
+    Backspace: ()=> editor3DSelection.size ? editor3DDelete() : editor3DPrefabBack(),
+    Enter: ()=> editor3DPrefabEnter(),
     Slash: ()=> { editor3DHelp = !editor3DHelp; },
 };
 /** @type {Object<string, function(boolean=): any>} */
@@ -36945,6 +38716,7 @@ const editor3DCtrlKeys =
     KeyX: ()=> editor3DCut(),
     KeyV: ()=> editor3DPasteAtMouse(),
     KeyD: ()=> editor3DDuplicate(),
+    KeyG: (shift)=> shift ? editor3DUnpack() : editor3DMakePrefab() === true,
 };
 
 // the camera: the right button looks and the keys fly while it is held, the middle button or Space and the left
@@ -36997,7 +38769,13 @@ function editor3DEditorUpdate(seconds)
     if (debugKey && keyWasPressed(debugKey))
     {
         inputClearKey(debugKey);
-        editor3DDrag ? editor3DDragCancel() : editor3DPlay(editor3DMousePoint());
+        if (editor3DToolHeld)
+        {
+            editor3DStrokeCancel(); // a held press of the game's tool is taken back
+            editor3DToolHeld = false;
+        }
+        else
+            editor3DDrag ? editor3DDragCancel() : editor3DPlay(editor3DMousePoint());
         return;
     }
 
@@ -37013,9 +38791,20 @@ function editor3DEditorUpdate(seconds)
     const looking = mouseIsDown(2), cameraDrag = looking || mouseIsDown(1) || keyIsDown('Space') || alt;
 
     // the keys, which wait for a drag to end, and fly while the right button is held
-    if (!editor3DDrag && !looking)
+    if (!editor3DDrag && !looking && !editor3DToolHeld)
+    {
+        // the game's own keys first, each takes the place of the editor's key of the same spelling
+        const taken = new Set;
+        for (const [spelled, key] of Object.entries(levelEditor.keys))
+        {
+            const withCtrl = spelled.startsWith('ctrl+'), code = editor3DKeyCode(spelled.slice(withCtrl ? 5 : 0));
+            if (withCtrl !== ctrl) continue;
+            taken.add(code);
+            keyWasPressed(code) && key.action.call(levelEditor, shift);
+        }
         for (const [code, action] of Object.entries(ctrl ? editor3DCtrlKeys : editor3DKeys))
-            keyWasPressed(code) && action(shift);
+            taken.has(code) || keyWasPressed(code) && action(shift);
+    }
 
     // a right press during a drag puts it back
     if (editor3DDrag && mouseWasPressed(2))
@@ -37023,22 +38812,24 @@ function editor3DEditorUpdate(seconds)
 
     const ray = render3D.screenToRay(mouse), idle = !cameraDrag && !editor3DMouseOnPanel && !editor3DDrag;
     editor3DHover = idle ? editor3DHandleAt(mouse) : undefined;
+    editorCall('onUpdate');
+    if (editor3DToolUpdate(ray, idle, shift, ctrl)) return; // a tool of the game's own has the mouse
 
     // the Blocks tool takes the mouse while the level has a map: Shift removes, Ctrl repaints
-    const painting = editor3DTool === 'blocks' && !!editor3DVoxelMap();
+    // a type picked to place is placed, whichever tool is on
+    const painting = editor3DTool === 'blocks' && !editor3DBrush && !!editor3DVoxelMap();
     const mode = shift ? 'remove' : ctrl ? 'paint' : 'place';
     const target = painting && idle ? editor3DVoxelTarget(ray, mode) : undefined;
     editor3DBlockHover = target && {cell: target.cell, mode};
-    // the Terrain tool takes it while the level has a terrain: held down it raises the ground, Shift lowers,
-    // Ctrl smooths
-    const terrain = editor3DTool === 'terrain' ? editor3DTerrainMap() : undefined;
+    // the Terrain tool takes it while the level has a terrain: held down its brush works on the ground
+    const terrain = editor3DTool === 'terrain' && !editor3DBrush ? editor3DTerrainMap() : undefined;
     const reach = terrain && !cameraDrag && !editor3DMouseOnPanel ? terrain.raycast(ray) : undefined;
     editor3DTerrainHover = reach === undefined ? undefined : ray.getPosition(reach);
     if (painting)
         idle && mouseWasPressed(0) && (editor3DDrag = editor3DVoxelPress(ray, mode));
     else if (terrain)
         idle && mouseWasPressed(0) && editor3DTerrainHover &&
-            (editor3DDrag = {kind: 'terrain', mode: shift ? 'lower' : ctrl ? 'smooth' : 'raise'});
+            (editor3DDrag = editor3DTerrainPress(editor3DTerrainHover, shift, ctrl));
     else if (idle && mouseWasPressed(0))
         editor3DPress(mouse, ray, shift);
 
@@ -37052,7 +38843,7 @@ function editor3DEditorUpdate(seconds)
 if (debug && globalThis.document?.addEventListener)
     document.addEventListener('keydown', (e)=>
     {
-        if (editor3DIsOpen && (e.ctrlKey || e.metaKey) && /^Key[ZYCXVD]$/.test(e.code) && !editorIsTextField(e.target))
+        if (editor3DIsOpen && (e.ctrlKey || e.metaKey) && /^Key[ZYCXVDG]$/.test(e.code) && !editorIsTextField(e.target))
             e.preventDefault();
     });
 
@@ -37064,13 +38855,16 @@ const editor3DHelpLines =
 [
     'Left: select · Shift+Left: add or take away · Left drag from empty space: box select',
     'Q select · W move · E rotate · R scale: drag a handle, or the object itself',
-    'G: grid snap, Ctrl flips it for a drag · End: drop to the ground',
+    'G: grid snap, Ctrl flips it for a drag · L: move along its own axes · End: drop to the ground',
     'Right button: look, and WASD and QE fly while it is held, Shift faster',
     'Wheel: zoom · Middle drag or Space+drag: pan · Alt+drag: orbit · F: frame the selection',
     'Pick a type, then click to place it, Shift+click keeps placing',
     'B blocks: click or drag places · Shift removes · Ctrl repaints · P picks the type under the mouse',
-    'T terrain: hold to raise the ground · Shift lowers · Ctrl smooths · the brush is in the panel',
+    'X box fill: a drag fills the rectangle dragged, as tall as the height in the panel',
+    'T terrain: hold to raise the ground · Shift lowers · Ctrl smooths · X the next brush, flatten and paint',
     'Delete · Ctrl+C / X / V: copy, cut, paste · Ctrl+D: duplicate · Ctrl+Z / Y: undo, redo',
+    'Ctrl+G: make the selection a prefab, one thing to place many times · Ctrl+Shift+G: unpack it into its objects',
+    'Enter: open the selected prefab to edit it alone, every instance follows · Backspace with nothing selected: back',
     'Reset to file: the level as its file has it, Restart keeps your edits, Undo brings them back',
     'Esc: play and edit · 0: exit the editor · ?: keys',
 ];
@@ -37080,6 +38874,7 @@ function editor3DHint()
 {
     if (editor3DRecords.get(editor3DLevel)?.pending)
         return 'The level file changed: apply your edits or drop them';
+    if (editorGameTool()) return editorGameTool().hint || levelEditor.tool;
     if (editor3DDrag)
         return editor3DDrag.kind === 'box' ? 'Let go to select what is inside' :
             'Esc or right click puts it back · Ctrl flips the snap';
@@ -37088,10 +38883,14 @@ function editor3DHint()
     if (editor3DBrush)
         return `Click to place a ${editor3DBrush} · Shift keeps placing · Q puts it down`;
     if (editor3DTool === 'terrain')
-        return editor3DTerrainMap() ? 'Hold to raise the ground · Shift lowers · Ctrl smooths' :
-            'Add a terrain in the panel to sculpt it';
+        return !editor3DTerrainMap() ? 'Add a terrain in the panel to sculpt it' :
+            {sculpt: 'Hold to raise the ground · Shift lowers · Ctrl smooths',
+            flatten: 'Hold to flatten the ground to the height pressed · Ctrl smooths',
+            paint: 'Hold to paint the ground · Shift takes the paint off'}[editor3DTerrainBrush.mode] +
+            ' · X the next brush';
     if (editor3DTool === 'blocks')
-        return editor3DVoxelMap() ? 'Click or drag places · Shift removes · Ctrl repaints · P picks a type' :
+        return editor3DVoxelMap() ? (editor3DBlockBox ? 'Drag a box to fill it' : 'Click or drag places') +
+            ' · Shift removes · Ctrl repaints · P picks a type · X box' :
             'Add a block map in the panel to paint blocks';
     if (editor3DSelection.size)
         return 'Drag a handle or the object · W move · E rotate · R scale · End drops it';
@@ -37165,7 +38964,8 @@ function editor3DDrawRing(center, across, along, radius, color, pixels=2)
 function editor3DVisible(object)
 {
     const made = editor3DInstances.get(object.id);
-    return made instanceof EngineObject3D && !made.destroyed && (made.mesh || made.tileInfo) ? made : undefined;
+    return made instanceof EngineObject3D && !made.destroyed && (made.mesh || made.tileInfo || editor3DPrefabBox(made)) ?
+        made : undefined;
 }
 
 // the box around an object as a matrix: around its mesh where it is, turned and sized as it is, a unit box for a
@@ -37175,6 +38975,9 @@ function editor3DBoxMatrix(object)
     const made = editor3DVisible(object), bounds = made?.mesh && (made.mesh.bounds || made.mesh.getBounds());
     if (!made)
         return buildMatrix(editor3DPos(object));
+    const box = editor3DPrefabBox(made);
+    if (box)
+        return buildMatrix(box.pos, undefined, box.size);
     const matrix = render3DObjectMatrix(made).copy();
     return bounds ? matrix.multiply(buildMatrix(bounds.min.add(bounds.max).scale(.5), undefined,
         bounds.max.subtract(bounds.min))) : matrix.multiply(buildMatrix(vec3(), undefined, made.size3D));
@@ -37238,6 +39041,15 @@ function editor3DDraw()
         editor3DDrawRing(editor3DTerrainHover.add(vec3(0, .05, 0)), EDITOR3D_AXES.x, EDITOR3D_AXES.z,
             editor3DTerrainBrush.size / 2, hsl(0, 0, 1, .9), 2.5);
 
+    // the box a box drag fills
+    const region = map && editor3DDrag?.region;
+    if (region)
+    {
+        const size = region.hi.subtract(region.lo).add(vec3(1));
+        editor3DDrawWire(buildMatrix(map.pos3D.add(region.lo).add(size.scale(.5)), undefined, size.add(vec3(.02))),
+            editor3DDrag.mode === 'place' ? hsl(0, 0, 1, .9) : editor3DDrag.mode === 'remove' ? hsl(0, 1, .6) :
+            hsl(.15, 1, .6), 2.5);
+    }
     // the map's edges, to see where it ends
     if (map)
         editor3DDrawWire(buildMatrix(map.pos3D.add(map.mapSize.scale(.5)), undefined, map.mapSize),
@@ -37264,9 +39076,8 @@ function editor3DDraw()
         else if (kind === 'plane')
         {
             // a flat square across its two axes, in the color of the axis it does not move along
-            const size = vec3(tip * 1.6).subtract(handle.direction.scale(tip * 1.5));
-            r.drawBox(points[0], size, lit ? color : EDITOR3D_AXIS_COLORS['xyz'.replace(axis[0], '')
-                .replace(axis[1], '')].scale(1, .7));
+            const size = vec3(tip * 1.6).subtract(EDITOR3D_AXES[handle.across].scale(tip * 1.5));
+            r.drawBox(points[0], size, lit ? color : EDITOR3D_AXIS_COLORS[handle.across].scale(1, .7), handle.turn);
         }
         else if (kind === 'scaleAll')
             r.drawBox(center, tip * 1.4, lit ? color : WHITE);
@@ -37276,7 +39087,8 @@ function editor3DDraw()
             r.drawLine(points[0], points[1], width, color);
             const turn = axis === 'x' ? vec3(0, 0, -PI / 2) : axis === 'z' ? vec3(PI / 2, 0, 0) : undefined;
             const at = points[1].add(handle.direction.scale(tip));
-            r.drawMesh(editor3DConeMesh(), buildMatrix(at, turn, vec3(tip * 1.4, tip * 2, tip * 1.4)), undefined, color);
+            const cone = buildMatrix(vec3(), turn, vec3(tip * 1.4, tip * 2, tip * 1.4));
+            r.drawMesh(editor3DConeMesh(), buildMatrix(at, handle.turn).multiply(cone), undefined, color);
         }
         else
         {
@@ -37284,6 +39096,7 @@ function editor3DDraw()
             r.drawBox(points[1], tip, color, editor3DRotation(editor3DSelected()[0]).scale(PI / 180));
         }
     }
+    editor3DDrawGame();
 }
 
 // the editor's drawing on the 2D layer: the name of each marker, and the box being dragged out to select with
@@ -37374,9 +39187,11 @@ function editor3DPanelInit()
         ['scale', 'Scale', 'R'], ['blocks', 'Blocks', 'B'], ['terrain', 'Terrain', 'T']])
         toolButtons[tool] = button(tools, text, ()=>
         {
-            editor3DTool = tool;
+            editor3DPickTool(tool);
             (tool === 'select' || tool === 'blocks' || tool === 'terrain') && (editor3DBrush = undefined);
         }, key);
+    // the game's own tools, buttons and controls, under the editor's tools
+    const game = editorElement('div', panel);
     const snap = editorElement('div', panel, box);
     const grid = check(snap, 'Grid snap', (on)=> editor3DGrid = on, 'G, and Ctrl flips it for a drag');
     const steps = row(snap);
@@ -37385,12 +39200,26 @@ function editor3DPanelInit()
     const scaleStep = choice(steps, 'Size', [1, .5, .25], (v)=> editor3DScaleStep = v);
     const ground = check(snap, 'Ground snap', (on)=> editor3DGroundSnap = on,
         'A drag of an object slides it along what is under the mouse');
+    const ownAxes = check(snap, 'Own axes', (on)=> editor3DLocalAxes = on,
+        'L: the Move handles go along the object\'s own axes, as it is turned, not the world\'s');
 
     // the types, a click picks one up to place, made again when types are added
     editorElement('div', panel, 'color:#aaa;margin-top:4px', 'Place');
     const types = row();
+    const prefabNote = editorElement('div', panel, 'color:#f86'); // why a prefab was not loaded
     const properties = editorElement('div', panel, box);
 
+    // prefabs: the selection made one, or the selected instance's own
+    const prefabBox = editorElement('div', panel, box);
+
+    // the prefab that is open, and the way back
+    const prefabOpen = editorElement('div', panel, 'padding:4px;margin:4px 0;background:#235;border-radius:3px;' +
+        'display:flex;gap:6px;align-items:center');
+    panel.insertBefore(prefabOpen, panel.firstChild);
+    const prefabName = editorElement('span', prefabOpen, 'flex:1');
+    button(prefabOpen, 'Back', ()=> editor3DPrefabBack(),
+        'Backspace with nothing selected: back to where the prefab was opened from, every instance of it follows');
+
     // the Blocks tool's box: a map to add, or the types to paint with
     const blocks = editorElement('div', panel, box);
 
@@ -37421,13 +39250,15 @@ function editor3DPanelInit()
 
     const storage = editorElement('div', panel, 'color:#f86;margin-top:4px',
         'Autosave failed, storage is full: Save to a file');
+    const prefabUnsaved = editorElement('div', panel, 'color:#fc6;margin-top:4px');
     const hint = editorElement('div', panel, 'color:#8ab;margin-top:4px');
     const help = editorElement('div', panel, 'color:#aaa;margin-top:4px;border-top:1px solid #444;padding-top:4px');
     for (const line of editor3DHelpLines)
         editorElement('div', help, 'margin:2px 0', line);
+    const gameHelp = editorElement('div', help);
     button(help, 'Close', ()=> editor3DHelp = false, '?');
 
-    editor3DPanelParts = {restart, pending, toolButtons, grid, moveStep, rotateStep, scaleStep, ground, types,
+    editor3DPanelParts = {game, gameHelp, restart, pending, toolButtons, grid, moveStep, rotateStep, scaleStep, ground, ownAxes, types, prefabBox, prefabOpen, prefabName, prefabUnsaved, prefabNote,
         properties, blocks, terrainBox, sceneOn, sceneRows, playFrom, storage, hint, help, typeNames: ''};
 }
 
@@ -37442,49 +39273,126 @@ function editor3DPanelUpdate()
     editor3DPanel || editor3DPanelInit();
     editor3DPanel.style.display = '';
     const p = editor3DPanelParts, lit = '2px solid #4af';
-    p.restart.style.display = levelEditor.onRestart ? '' : 'none';
+    editorGamePanel(p.game);
+    editorGameHelp(p.gameHelp);
+    p.restart.style.display = editorHas('onRestart') ? '' : 'none';
     p.pending.style.display = editor3DRecords.get(editor3DLevel)?.pending ? '' : 'none';
     for (const tool in p.toolButtons)
         p.toolButtons[tool].style.outline = tool === editor3DTool ? lit : '';
     p.grid.checked = editor3DGrid;
     p.ground.checked = editor3DGroundSnap;
+    p.ownAxes.checked = editor3DLocalAxes;
     p.moveStep.value = editor3DMoveStep + '';
     p.rotateStep.value = editor3DRotateStep + '';
     p.scaleStep.value = editor3DScaleStep + '';
     p.playFrom.checked = editor3DPlayFromMouse;
-    p.playFrom.parentElement.style.display = levelEditor.onPlayFrom ? 'flex' : 'none';
+    p.playFrom.parentElement.style.display = editorHas('onPlayFrom') ? 'flex' : 'none';
     p.storage.style.display = editor3DSaveFailed ? '' : 'none';
     p.hint.textContent = editor3DHint();
     p.help.style.display = editor3DHelp ? '' : 'none';
 
     // a button for each type, made again when the types changed
-    const names = [...level3DTypes.keys()], typeNames = names.join('\n');
+    const names = editor3DPlaceNames(), plain = names.filter((name)=> !level3DPrefabs.has(name));
+    const prefabs = names.slice(plain.length);
+    const typeNames = plain.join('\n') + '\n\n' + prefabs.join('\n');
     if (p.typeNames !== typeNames)
     {
         p.typeNames = typeNames;
-        p.types.replaceChildren(...names.map((name)=>
+        p.typeButtons = names.map((name)=>
         {
             const b = editorElement('button', undefined, 'padding:3px 6px;cursor:pointer', name);
             b.onclick = ()=> { editor3DBrush = editor3DBrush === name ? undefined : name; b.blur(); };
             return b;
-        }));
-    }
-    names.forEach((name, i)=> p.types.children[i].style.outline = name === editor3DBrush ? lit : '');
+        });
+        const label = editorElement('span', undefined, 'color:#aaa;width:100%', 'Prefabs');
+        const load = editorElement('button', undefined, 'padding:3px 6px;cursor:pointer', 'Load prefab…');
+        load.title = 'Add a prefab from a file the editor saved, by its file name, to place in this level';
+        load.onclick = ()=> { editor3DPrefabPickFile(); load.blur(); };
+        p.types.replaceChildren(...p.typeButtons.slice(0, plain.length), label, ...p.typeButtons.slice(plain.length), load);
+    }
+    p.prefabNote.style.display = editor3DPrefabMessage && !editor3DSelection.size ? '' : 'none';
+    p.prefabNote.textContent = editor3DPrefabMessage;
+    names.forEach((name, i)=> p.typeButtons[i].style.outline = name === editor3DBrush ? lit : '');
     editor3DPropertiesUpdate(p.properties);
+    editor3DPrefabBoxUpdate(p.prefabBox);
+    p.prefabOpen.style.display = editor3DPrefabStack.length ? 'flex' : 'none';
+    p.prefabName.textContent = 'Editing prefab ' + editor3DPrefabStack.map((frame)=> frame.name).join(' > ');
+    p.prefabUnsaved.style.display = editor3DPrefabDirty.size ? '' : 'none';
+    p.prefabUnsaved.textContent = 'Edited and not in its file: ' + [...editor3DPrefabDirty].join(', ') +
+        '. Open it with Enter and Save';
     editor3DBlocksUpdate(p.blocks);
     editor3DTerrainBoxUpdate(p.terrainBox);
     p.sceneOn.checked = !!editor3DScene();
     editor3DSceneUpdate(p.sceneRows);
 }
 
+// the prefab box, shown with a selection: a name and a button to make it a prefab, and for one selected instance
+// its prefab's name, Unpack, Export, and for a prefab of the level's own whether it is attached
+function editor3DPrefabBoxUpdate(box)
+{
+    const selected = editor3DSelected(), made = selected.length === 1 && editor3DInstances.get(selected[0].id);
+    const instance = made instanceof Prefab3D ? made : undefined, prefab = instance && level3DPrefabs.get(instance.prefabName);
+    const key = !selected.length ? '' : [selected.length, instance?.prefabName, prefab?.attached, prefab?.fromLevel,
+        editor3DPrefabMessage, editor3DPrefabStack.length] + '';
+    box.style.display = key ? '' : 'none';
+    if (box.dataset.key === key || box.contains(document.activeElement)) return;
+    box.dataset.key = key;
+    box.replaceChildren();
+    if (!key) return;
+    const field = 'background:#222;color:#eee', press = 'padding:2px 6px;cursor:pointer';
+    const row = ()=> editorElement('div', box, 'display:flex;gap:4px;align-items:center;margin:2px 0;flex-wrap:wrap');
+    if (prefab)
+    {
+        const line = row();
+        editorElement('span', line, 'flex:1;color:#aaa', 'Prefab ' + instance.prefabName);
+        const open = editorElement('button', line, press, 'Edit');
+        open.title = 'Enter: open the prefab alone to edit it, every instance of it follows';
+        open.onclick = ()=> { editor3DPrefabEnter(); open.blur(); };
+        const unpack = editorElement('button', line, press, 'Unpack');
+        unpack.title = 'Ctrl+Shift+G: turn this instance into the objects it is made of';
+        unpack.onclick = ()=> { editor3DUnpack(); unpack.blur(); };
+        const save = editorElement('button', line, press, 'Export');
+        save.title = 'Save the prefab as a file of its own, to load with level3DLoadPrefab';
+        save.onclick = ()=>
+        {
+            saveText(editor3DPrefabJSON(instance.prefabName), instance.prefabName + '.json', 'application/json');
+            save.blur();
+        };
+        if (prefab.fromLevel && !editor3DPrefabStack.length)
+        {
+            const label = editorElement('label', box, 'display:flex;gap:6px;align-items:center;margin:2px 0');
+            label.title = 'Its parts are attached to each instance and move with it as one body, with no ' +
+                'collision of their own; off, each part is an object of its own and solid';
+            const attached = editorElement('input', label);
+            attached.type = 'checkbox';
+            attached.checked = prefab.attached;
+            attached.onchange = ()=> { editor3DPrefabSetAttached(instance.prefabName, attached.checked); attached.blur(); };
+            editorElement('span', label, '', 'Attached, one body');
+        }
+    }
+    const line = row();
+    const name = editorElement('input', line, field + ';flex:1;min-width:60px');
+    name.placeholder = 'prefab name';
+    const make = editorElement('button', line, press, 'Make prefab');
+    make.title = 'Ctrl+G: the selection becomes one thing to place many times, kept in the level';
+    make.onclick = ()=> { editor3DMakePrefab(name.value); make.blur(); };
+    name.onkeydown = (e)=> { e.key === 'Enter' && (editor3DMakePrefab(name.value), name.blur()); };
+    editor3DPrefabMessage && editorElement('div', box, 'color:#f86', editor3DPrefabMessage);
+}
+
+// a level's color as a color input takes it, six digits and no alpha, white for one it can not show
+function editor3DInputColor(hex) { return /^#[0-9a-f]{6}/i.test(hex) ? hex.slice(0, 7) : '#ffffff'; }
+
 // the terrain box, shown with the Terrain tool: without a terrain, its size, cells and height and a button to add
-// it; with one, the brush's size and strength, the terrain's color, and a button to take it away
+// it; with one, the brush, its size and strength or the color it paints, the terrain's color, and a button to
+// take it away
 function editor3DTerrainBoxUpdate(box)
 {
     const map = editor3DTerrainMap(), shown = editor3DTool === 'terrain';
     box.style.display = shown ? '' : 'none';
     if (!shown) return;
-    const terrain = editor3DLevelPart('terrain'), key = map ? 'terrain ' + terrain.color : 'none';
+    const terrain = editor3DLevelPart('terrain'), brush = editor3DTerrainBrush;
+    const key = map ? ['terrain', terrain.color, brush.mode] + '' : 'none';
     if (box.dataset.key === key || box.contains(document.activeElement)) return;
     box.dataset.key = key;
     box.replaceChildren();
@@ -37532,13 +39440,27 @@ function editor3DTerrainBoxUpdate(box)
         input.oninput = ()=> set(parseFloat(input.value));
         input.onchange = ()=> input.blur();
     };
-    slider('Brush size', 'How far across the brush is', 1, 32, .5, editor3DTerrainBrush.size,
-        (v)=> editor3DTerrainBrush.size = v);
-    slider('Strength', 'How fast the brush works', .05, 1, .05, editor3DTerrainBrush.strength,
-        (v)=> editor3DTerrainBrush.strength = v);
-    const color = editorElement('input', line('Color'), field + ';width:60px');
+    const brushes = editorElement('select', line('Brush', 'X: sculpt raises and lowers the ground, flatten brings ' +
+        'it to the height pressed, paint colors it'), field + ';width:120px');
+    for (const name of editor3DTerrainBrushes)
+        editorElement('option', brushes, '', name[0].toUpperCase() + name.slice(1)).value = name;
+    brushes.value = brush.mode;
+    brushes.onchange = ()=> { brush.mode = brushes.value; brushes.blur(); };
+    slider('Brush size', 'How far across the brush is', 1, 32, .5, brush.size, (v)=> brush.size = v);
+    if (brush.mode === 'paint')
+    {
+        const paint = editorElement('input', line('Paint', 'The color the brush paints'), field + ';width:60px');
+        paint.type = 'color';
+        paint.value = editor3DInputColor(brush.color);
+        paint.oninput = ()=> brush.color = paint.value;
+        paint.onchange = ()=> { brush.color = paint.value; paint.blur(); };
+    }
+    else
+        slider('Strength', 'How fast the brush works', .05, 1, .05, brush.strength, (v)=> brush.strength = v);
+    const color = editorElement('input', line('Color', 'The color of the ground that is not painted'),
+        field + ';width:60px');
     color.type = 'color';
-    color.value = /^#[0-9a-f]{6}/i.test(terrain.color) ? terrain.color.slice(0, 7) : '#ffffff';
+    color.value = editor3DInputColor(terrain.color);
     color.oninput = ()=> editor3DChangePart('terrain', (t)=> ({...t, color: color.value}));
     color.onchange = ()=> { color.oninput(); editor3DStrokeEnd(); color.blur(); };
     const remove = editorElement('button', box, 'margin-top:4px;padding:2px 6px;cursor:pointer', 'Remove terrain');
@@ -37554,7 +39476,8 @@ function editor3DBlocksUpdate(box)
     box.style.display = shown ? '' : 'none';
     if (!shown) return;
     const first = map?.tileInfo, texture = first?.textureInfo;
-    const key = map ? ['map', editor3DBlockType, texture?.size.x, map.blockTypes.length].join() : 'none';
+    const key = map ? ['map', editor3DBlockType, texture?.size.x, map.blockTypes.length, editor3DBlockBox,
+        map.mapSize].join() : 'none';
     if (box.dataset.key === key || box.contains(document.activeElement)) return;
     box.dataset.key = key;
     box.replaceChildren();
@@ -37575,7 +39498,7 @@ function editor3DBlocksUpdate(box)
         add.title = 'An empty map of blocks, centered, its bottom on the ground';
         add.onclick = ()=>
         {
-            const [x, y, z] = inputs.map((i)=> clamp(floor(parseFloat(i.value)) || 1, 1, 256));
+            const [x, y, z] = inputs.map((i, k)=> clamp(floor(parseFloat(i.value)) || [32, 16, 32][k], 1, 256));
             editor3DVoxelAdd(vec3(x, y, z));
             add.blur();
         };
@@ -37615,6 +39538,46 @@ function editor3DBlocksUpdate(box)
         }
         catch {} // an image that can not be drawn or read, the title still says the type
     }
+    // box fill: a drag fills the rectangle dragged, this many layers tall
+    const boxRow = editorElement('label', box, 'display:flex;gap:6px;align-items:center;margin:4px 0 2px');
+    boxRow.title = 'X: a drag fills the whole rectangle from the press to the mouse, Shift clears it, Ctrl repaints';
+    const boxOn = editorElement('input', boxRow);
+    boxOn.type = 'checkbox';
+    boxOn.checked = editor3DBlockBox;
+    boxOn.onchange = ()=> { editor3DBlockBox = boxOn.checked; boxOn.blur(); };
+    editorElement('span', boxRow, 'flex:1', 'Box fill, height');
+    const boxHeight = editorElement('input', boxRow, field);
+    boxHeight.type = 'number';
+    boxHeight.min = '1', boxHeight.max = '256', boxHeight.step = '1';
+    boxHeight.value = editor3DBlockBoxHeight + '';
+    boxHeight.onchange = ()=>
+    {
+        editor3DBlockBoxHeight = clamp(floor(parseFloat(boxHeight.value)) || 1, 1, 256);
+        boxHeight.value = editor3DBlockBoxHeight + '';
+        boxHeight.blur();
+    };
+
+    // the map's size, to change
+    const sizeRow = editorElement('label', box, 'display:flex;gap:4px;align-items:center;margin:2px 0');
+    editorElement('span', sizeRow, 'flex:1', 'Map size');
+    const axes = ['x', 'y', 'z'], sizes = axes.map((axis)=>
+    {
+        const input = editorElement('input', sizeRow, field);
+        input.type = 'number';
+        input.min = '1', input.max = '256', input.step = '1';
+        input.value = map.mapSize[axis] + '';
+        return input;
+    });
+    const resize = editorElement('button', box, 'padding:2px 6px;cursor:pointer;margin-right:4px', 'Resize');
+    resize.title = 'Change the map\'s size, its blocks stay where they are; Undo brings back what was cut off';
+    resize.onclick = ()=>
+    {
+        // a field left empty keeps the size it has
+        const [x, y, z] = sizes.map((i, k)=> clamp(floor(parseFloat(i.value)) || map.mapSize[axes[k]], 1, 256));
+        editor3DVoxelResize(vec3(x, y, z));
+        resize.blur();
+    };
+
     const remove = editorElement('button', box, 'margin-top:4px;padding:2px 6px;cursor:pointer', 'Remove map');
     remove.title = 'Take the block map out of the level, Undo brings it back';
     remove.onclick = ()=> { editor3DVoxelRemove(); remove.blur(); };
@@ -37633,7 +39596,11 @@ function editor3DSceneUpdate(box)
 
     // a setting the block leaves out shows as it is on screen
     const view = editor3DSceneFromView(), value = (name)=> scene[name] ?? view[name];
-    const change = (name, v)=> editor3DChangeScene((s={})=> ({...s, [name]: v}));
+    // an input changes the scene as it is when it is used, not as it was when the box was made: the box is not
+    // made again while it has the focus, so a field edited right after another must not put the other one back;
+    // set is given the setting's value now, or what shows for one the block leaves out
+    const change = (name, set)=> editor3DChangeScene((s={})=>
+        ({...s, [name]: typeof set === 'function' ? set(s[name] ?? view[name]) : set}));
     const field = 'background:#222;color:#eee';
     const line = (name, title='')=>
     {
@@ -37661,7 +39628,7 @@ function editor3DSceneUpdate(box)
     {
         const input = editorElement('input', line(name, title), field + ';width:60px');
         input.type = 'color';
-        input.value = /^#[0-9a-f]{6}/i.test(hex) ? hex.slice(0, 7) : '#ffffff';
+        input.value = editor3DInputColor(hex);
         return live(input, ()=> set(input.value));
     };
     const number = (row, v, set)=>
@@ -37674,7 +39641,7 @@ function editor3DSceneUpdate(box)
         input.onchange = ()=>
         {
             const n = parseFloat(input.value);
-            isNumber(n) && n >= 0 && set(n);
+            isNumber(n) && n >= 0 ? set(v = n) : input.value = v + ''; // one not taken shows what it has again
             editor3DStrokeEnd();
             input.blur();
         };
@@ -37699,7 +39666,7 @@ function editor3DSceneUpdate(box)
     if (sky)
     {
         ['Sky top', 'Sky horizon', 'Sky bottom'].forEach((name, i)=> color(name, '', sky[i], (hex)=>
-            change('sky', sky.map((c, k)=> k === i ? hex : c))));
+            change('sky', (now)=> (isArray(now) && now.length === 3 ? now : sky).map((c, k)=> k === i ? hex : c))));
         slider('Ambient', 'How much of the sky colors lights the scene', 0, 1, .05,
             isNumber(scene.ambient) ? scene.ambient : .5, (v)=> change('ambient', v));
     }
@@ -37707,16 +39674,17 @@ function editor3DSceneUpdate(box)
     // the sun, as two angles
     const [around, height] = editor3DSunAngles(value('sunDirection'));
     slider('Sun around', 'Where the sun is around the scene, in degrees', 0, 359, 1, around, (v)=>
-        change('sunDirection', editor3DSunDirection(v, editor3DSunAngles(value('sunDirection'))[1])));
-    slider('Sun height', 'How high the sun is over the horizon, in degrees', 5, 90, 1, height, (v)=>
-        change('sunDirection', editor3DSunDirection(editor3DSunAngles(value('sunDirection'))[0], v)));
+        change('sunDirection', (now)=> editor3DSunDirection(v, editor3DSunAngles(now)[1])));
+    slider('Sun height', 'How high the sun is over the horizon, in degrees', 5, 89, 1, height, (v)=>
+        change('sunDirection', (now)=> editor3DSunDirection(editor3DSunAngles(now)[0], v)));
     color('Sun color', '', value('sunColor'), (hex)=> change('sunColor', hex));
 
     // the fog, by its distances, an end of 0 for none
     const fog = isArray(value('fog')) ? value('fog') : [0, 0], fogRow = line('Fog start, end',
         'Where the fog starts and where it is total, an end of 0 for no fog');
-    number(fogRow, fog[0], (v)=> change('fog', [v, fog[1]]));
-    number(fogRow, fog[1], (v)=> change('fog', [fog[0], v]));
+    const fogNow = (now)=> isArray(now) && now.length === 2 ? now : fog;
+    number(fogRow, fog[0], (v)=> change('fog', (now)=> [v, fogNow(now)[1]]));
+    number(fogRow, fog[1], (v)=> change('fog', (now)=> [fogNow(now)[0], v]));
     color('Fog color', 'The sky\'s horizon color when the level has a sky and no fog color',
         scene.fogColor ?? (sky ? sky[1] : view.fogColor), (hex)=> change('fogColor', hex));
     toggle('Shadows', 'The sun casts shadows', !!value('shadows'), (on)=> change('shadows', on));
@@ -37896,6 +39864,8 @@ export
     debugKeysAlways,
     debugTweakables,
     levelEditor,
+    LevelEditor,
+    setLevelEditor,
 
     // Debug
     ASSERT,
@@ -37957,6 +39927,7 @@ export
     touchInputEnable,
     touchGamepadEnable,
     touchGamepadPassthrough,
+    touchPinchWheel,
     touchGamepadCenterButtonSize,
     touchGamepadButtonCount,
     touchGamepadLeftStick,
@@ -38018,6 +39989,7 @@ export
     setInputWASDEmulateDirection,
     setTouchGamepadEnable,
     setTouchGamepadPassthrough,
+    setTouchPinchWheel,
     setTouchGamepadCenterButtonSize,
     setTouchGamepadButtonCount,
     setTouchGamepadLeftStick,
@@ -38221,6 +40193,7 @@ export
     mouseDelta,
     mouseDeltaScreen,
     mouseWheel,
+    touchPinch,
     mouseInWindow,
     isUsingGamepad,
     lastInputDevice,
@@ -38404,6 +40377,10 @@ export
     setScene,
     getScene,
 
+    // Parallax
+    ParallaxLayer,
+    parallaxMountains,
+
     // Path Finding
     PathFinder,
     PathFinderNode,
@@ -38484,6 +40461,10 @@ export
     level3DAddType,
     level3DAddMesh,
     level3DLoad,
+    level3DAddPrefab,
+    level3DLoadPrefab,
+    level3DSpawn,
+    Prefab3D,
     level3DVoxelSetup,
 
     // Three.js