@umicat/three-sdk 0.8.1 → 0.8.3

package/dist/Input3D.d.ts

@@ -84,6 +84,7 @@ export declare class Input3D {
     private wantLook;
     private lookSens;
     private readonly lookDelta;
+    private enabled;
     private readonly touchHeld;
     private readonly pressedAt;
     private readonly unconsumed;
@@ -91,6 +92,21 @@ export declare class Input3D {
     private readonly cleanups;
     constructor(options?: Input3DOptions | Window);
     isDown(...codes: string[]): boolean;
+    /**
+     * Stop accepting input, and take the on-screen controls off the screen.
+     *
+     * For the moment a game puts a modal up — a game-over screen, a shop, a
+     * dialogue box. Two things go wrong otherwise, and the second is worse: the
+     * character keeps walking behind the dialog, and the controls' full-screen
+     * layer sits ABOVE the game's own DOM at z-index 10, so the button in that
+     * modal cannot be tapped at all. "Play Again" that does nothing is this bug.
+     *
+     * Disabling clears what was held, so a thumb that was pushing the stick when
+     * the modal opened does not resume walking when it closes.
+     */
+    setEnabled(on: boolean): void;
+    /** Whether input is currently being accepted. */
+    get isEnabled(): boolean;
     /**
      * Which way to walk. Keyboard and stick are merged, so both work on a device
      * with both.

package/dist/Input3D.js

@@ -71,6 +71,7 @@ export class Input3D {
         this.wantLook = true;
         this.lookSens = 4.6;
         this.lookDelta = { x: 0, y: 0 };
+        this.enabled = true;
         this.touchHeld = new Set();
         this.pressedAt = new Map();
         this.unconsumed = new Set();
@@ -96,7 +97,43 @@ export class Input3D {
             this.mountTouch(opts.container ?? document.body);
         }
     }
-    isDown(...codes) { return codes.some((c) => this.keysDown.has(c)); }
+    isDown(...codes) {
+        return this.enabled && codes.some((c) => this.keysDown.has(c));
+    }
+    /**
+     * Stop accepting input, and take the on-screen controls off the screen.
+     *
+     * For the moment a game puts a modal up — a game-over screen, a shop, a
+     * dialogue box. Two things go wrong otherwise, and the second is worse: the
+     * character keeps walking behind the dialog, and the controls' full-screen
+     * layer sits ABOVE the game's own DOM at z-index 10, so the button in that
+     * modal cannot be tapped at all. "Play Again" that does nothing is this bug.
+     *
+     * Disabling clears what was held, so a thumb that was pushing the stick when
+     * the modal opened does not resume walking when it closes.
+     */
+    setEnabled(on) {
+        this.enabled = on;
+        if (!on) {
+            this.keysDown.clear();
+            this.touchHeld.clear();
+            this.pressedAt.clear();
+            this.unconsumed.clear();
+            this.stick.x = 0;
+            this.stick.z = 0;
+            this.touchJump = false;
+            this.lookDelta.x = 0;
+            this.lookDelta.y = 0;
+        }
+        if (this.root) {
+            this.root.style.display = on ? '' : 'none';
+            // display:none alone would be enough for hit-testing, but a game that
+            // fades its modal in wants the controls gone, not just inert.
+            this.root.style.pointerEvents = 'none';
+        }
+    }
+    /** Whether input is currently being accepted. */
+    get isEnabled() { return this.enabled; }
     /**
      * Which way to walk. Keyboard and stick are merged, so both work on a device
      * with both.
@@ -109,6 +146,8 @@ export class Input3D {
      * behaviour, which is correct for a camera that never moves.
      */
     direction(cameraYaw = 0) {
+        if (!this.enabled)
+            return { x: 0, z: 0 };
         let x = this.stick.x, z = this.stick.z;
         if (this.isDown('KeyW', 'ArrowUp'))
             z -= 1;
@@ -131,9 +170,13 @@ export class Input3D {
     }
     /** Whether the jump control is held right now. Pass it to the controller —
      *  coyote time and buffering live there, not here. */
-    get jump() { return this.held_('jump', this.touchJump || this.isDown('Space')); }
+    get jump() {
+        return this.enabled && this.held_('jump', this.touchJump || this.isDown('Space'));
+    }
     /** Whether an action is held right now — button or bound key, same answer. */
     held(id) {
+        if (!this.enabled)
+            return false;
         const a = this.actions.find((x) => x.id === id);
         return this.held_(id, this.touchHeld.has(id) || (a?.keys ? this.isDown(...a.keys) : false));
     }
@@ -146,6 +189,8 @@ export class Input3D {
      * it twice must not apply it twice. Pass straight to `LoadedScene3D.orbit`.
      */
     look() {
+        if (!this.enabled)
+            return { x: 0, y: 0 };
         const out = { x: this.lookDelta.x, y: this.lookDelta.y };
         this.lookDelta.x = 0;
         this.lookDelta.y = 0;
@@ -157,7 +202,7 @@ export class Input3D {
      *  to last frame's, which means a press that begins and ends between two
      *  frames never happened. This latches at the event, so it cannot be missed
      *  — and it clears on read, so holding the button does not chain. */
-    consume(id) { return this.unconsumed.delete(id); }
+    consume(id) { return this.enabled && this.unconsumed.delete(id); }
     held_(id, physical) {
         if (physical)
             return true;

package/dist/SceneLoader3D.js

@@ -211,6 +211,42 @@ export async function loadScene3D(scene3d, manifest, opts = {}) {
             bodies.set(e.id, body);
         }
     }
+    // Fit every shadow-casting directional light to the scene it is lighting.
+    //
+    // three.js defaults a directional light's shadow camera to an orthographic
+    // box of +-5 units, and nothing warns when a scene is larger: shadows simply
+    // stop at an invisible square edge, which reads as a strange dark patch in
+    // the middle of the ground rather than as a setting. A board 13 units across
+    // hits it immediately.
+    {
+        const bounds = new THREE.Box3();
+        for (const o of entities.values())
+            bounds.expandByObject(o);
+        if (!bounds.isEmpty()) {
+            const size = bounds.getSize(new THREE.Vector3());
+            const centre = bounds.getCenter(new THREE.Vector3());
+            const radius = Math.max(size.x, size.z) * 0.62 + 1;
+            for (const l of scene.children) {
+                const d = l;
+                if (!d.isDirectionalLight || !d.castShadow)
+                    continue;
+                const c = d.shadow.camera;
+                c.left = -radius;
+                c.right = radius;
+                c.top = radius;
+                c.bottom = -radius;
+                c.near = 0.1;
+                c.far = d.position.length() + radius * 2 + size.y;
+                c.updateProjectionMatrix();
+                // The light points at the scene, not at the origin — an offset scene
+                // would otherwise be lit from the side of a box centred somewhere else.
+                d.target.position.copy(centre);
+                scene.add(d.target);
+                d.shadow.mapSize.set(2048, 2048);
+                d.shadow.bias = -0.0012;
+            }
+        }
+    }
     const camera = new THREE.PerspectiveCamera(scene3d.camera?.fov ?? 55, 1, 0.1, 500);
     const camOffset = toVec(scene3d.camera?.offset ?? { x: 0, y: 4, z: 8 });
     camera.position.copy(camOffset);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@umicat/three-sdk",
-  "version": "0.8.1",
+  "version": "0.8.3",
   "description": "Three.js runtime for Umicat games: the scene3d design format, its loader with physics, a kinematic character controller, and the Umicat platform via @umicat/platform-sdk.",
   "type": "module",
   "main": "dist/index.js",