@umicat/three-sdk 0.8.0 → 0.8.2

package/dist/Input3D.d.ts

@@ -52,7 +52,8 @@ export interface Input3DOptions {
      * taps. Default on wherever touch controls are shown.
      */
     look?: boolean;
-    /** Radians of camera rotation per screen-width dragged. */
+    /** Radians of camera rotation per screen-width dragged. Same number governs
+     *  touch drags and desktop right-drags, so there is one knob to turn. */
     lookSensitivity?: number;
 }
 /**
@@ -141,6 +142,20 @@ export declare class Input3D {
     press(code: string): void;
     release(code: string): void;
     dispose(): void;
+    /**
+     * Desktop: hold the RIGHT mouse button and drag to turn the camera.
+     *
+     * The on-screen look zone only exists where the touch controls do, so
+     * without this a mouse-and-keyboard player has a camera they cannot turn at
+     * all — and now that movement is camera-relative, a camera you cannot turn
+     * is one that has permanently decided which way "forward" is.
+     *
+     * The right button rather than the left: a left-drag is how a game selects,
+     * clicks and aims, and taking that away from every game by default would be
+     * a worse trade than the one it fixes. Right-drag is also what Roblox uses
+     * on desktop, so it is already in players' hands.
+     */
+    private mountMouseLook;
     private mountTouch;
     private wireButton;
 }

package/dist/Input3D.js

@@ -69,7 +69,7 @@ export class Input3D {
         this.actions = [];
         this.stickMode = 'floating';
         this.wantLook = true;
-        this.lookSens = 3.2;
+        this.lookSens = 4.6;
         this.lookDelta = { x: 0, y: 0 };
         this.touchHeld = new Set();
         this.pressedAt = new Map();
@@ -87,7 +87,10 @@ export class Input3D {
         this.actions = opts.actions ?? [];
         this.stickMode = opts.stick ?? 'floating';
         this.wantLook = opts.look ?? true;
-        this.lookSens = opts.lookSensitivity ?? 3.2;
+        this.lookSens = opts.lookSensitivity ?? 4.6;
+        if (this.wantLook && typeof document !== 'undefined') {
+            this.mountMouseLook(opts.container?.ownerDocument ?? document);
+        }
         const wantTouch = opts.touch === undefined || opts.touch === 'auto' ? isTouchDevice() : opts.touch;
         if (wantTouch && typeof document !== 'undefined') {
             this.mountTouch(opts.container ?? document.body);
@@ -194,6 +197,58 @@ export class Input3D {
         this.root = null;
         this.keysDown.clear();
     }
+    /**
+     * Desktop: hold the RIGHT mouse button and drag to turn the camera.
+     *
+     * The on-screen look zone only exists where the touch controls do, so
+     * without this a mouse-and-keyboard player has a camera they cannot turn at
+     * all — and now that movement is camera-relative, a camera you cannot turn
+     * is one that has permanently decided which way "forward" is.
+     *
+     * The right button rather than the left: a left-drag is how a game selects,
+     * clicks and aims, and taking that away from every game by default would be
+     * a worse trade than the one it fixes. Right-drag is also what Roblox uses
+     * on desktop, so it is already in players' hands.
+     */
+    mountMouseLook(doc) {
+        let id = null;
+        let lastX = 0, lastY = 0;
+        const down = (e) => {
+            if (e.button !== 2 || e.pointerType === 'touch' || id !== null)
+                return;
+            id = e.pointerId;
+            lastX = e.clientX;
+            lastY = e.clientY;
+            e.preventDefault();
+        };
+        const move = (e) => {
+            if (e.pointerId !== id)
+                return;
+            // Radians per screen WIDTH, the same unit the touch zone uses, so one
+            // sensitivity number means the same thing on both.
+            const w = Math.max(1, doc.defaultView?.innerWidth ?? 1000);
+            this.lookDelta.x += ((e.clientX - lastX) / w) * this.lookSens;
+            this.lookDelta.y += ((e.clientY - lastY) / w) * this.lookSens;
+            lastX = e.clientX;
+            lastY = e.clientY;
+        };
+        const up = (e) => { if (e.pointerId === id)
+            id = null; };
+        const menu = (e) => { e.preventDefault(); };
+        doc.addEventListener('pointerdown', down);
+        doc.addEventListener('pointermove', move);
+        doc.addEventListener('pointerup', up);
+        doc.addEventListener('pointercancel', up);
+        // Otherwise every right-drag ends with a context menu over the game.
+        doc.addEventListener('contextmenu', menu);
+        this.cleanups.push(() => {
+            doc.removeEventListener('pointerdown', down);
+            doc.removeEventListener('pointermove', move);
+            doc.removeEventListener('pointerup', up);
+            doc.removeEventListener('pointercancel', up);
+            doc.removeEventListener('contextmenu', menu);
+        });
+    }
     // ── on-screen controls ────────────────────────────────────────────────────
     mountTouch(container) {
         const root = document.createElement('div');

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.0",
+  "version": "0.8.2",
   "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",