@heliguy-xyz/splat-viewer 1.0.0-rc.4 → 1.0.0-rc.6

package/dist/web-component/splat-viewer.js

@@ -104343,10 +104343,13 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        if (nextMode === this.mode)
 	            return;
 	        const prev = this.mode;
-	        // Preserve camera transform
+	        // Preserve camera transform (position + rotation)
 	        const pos = this.camera.getPosition
 	            ? this.camera.getPosition().clone()
 	            : { x: 0, y: 0, z: 10 };
+	        const rot = this.camera.getRotation
+	            ? this.camera.getRotation().clone()
+	            : null;
 	        // Switch
 	        if (nextMode === 'fly') {
 	            this.deactivateOrbitMode();
@@ -104357,6 +104360,9 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	            this.activateOrbitMode();
 	        }
 	        this.camera.setPosition(pos);
+	        if (rot && this.camera.setRotation) {
+	            this.camera.setRotation(rot);
+	        }
 	        this.mode = nextMode;
 	        // Emit camera-mode-changed
 	        this.emit('camera-mode-changed', { mode: nextMode, previousMode: prev });
@@ -104461,6 +104467,22 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	            return;
 	        if (typeof this.fly.activate === 'function')
 	            this.fly.activate();
+	        // Align fly camera internal orientation with the current camera rotation so that
+	        // switching from orbit -> fly does not snap the view back to the initial direction.
+	        try {
+	            const euler = this.camera.getEulerAngles
+	                ? this.camera.getEulerAngles()
+	                : null;
+	            if (euler) {
+	                // These properties are part of the FlyCamera runtime state
+	                ;
+	                this.fly._pitch = euler.x || 0;
+	                this.fly._yaw = euler.y || 0;
+	            }
+	        }
+	        catch {
+	            // Best-effort sync; ignore if camera or script API differs
+	        }
 	    }
 	    deactivateFlyMode() {
 	        if (!this.fly)
@@ -104580,7 +104602,11 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	                : { x: 0, y: 0, z: 0 };
 	            this.emitFlyEvent?.('fly-camera-move', {
 	                position: { x: pos.x, y: pos.y, z: pos.z },
-	                velocity: { x: this._velocity.x, y: this._velocity.y, z: this._velocity.z },
+	                velocity: {
+	                    x: this._velocity.x,
+	                    y: this._velocity.y,
+	                    z: this._velocity.z,
+	                },
 	            });
 	            this._lastMoveEmitTime = now;
 	        }
@@ -104611,7 +104637,8 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        document.addEventListener('mousemove', this._onMouseMove);
 	        document.addEventListener('pointerlockchange', this._onPointerLockChange);
 	        const canvas = this.app.graphicsDevice.canvas;
-	        this._onClickToLock = this._onClickToLock || (() => this._requestPointerLock());
+	        this._onClickToLock =
+	            this._onClickToLock || (() => this._requestPointerLock());
 	        canvas.addEventListener('mousedown', this._onClickToLock);
 	    };
 	    FlyCamera.prototype.deactivate = function () {
@@ -104661,7 +104688,11 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        return {
 	            position: { x: pos.x, y: pos.y, z: pos.z },
 	            rotation: { pitch: this._pitch, yaw: this._yaw },
-	            velocity: { x: this._velocity.x, y: this._velocity.y, z: this._velocity.z },
+	            velocity: {
+	                x: this._velocity.x,
+	                y: this._velocity.y,
+	                z: this._velocity.z,
+	            },
 	            isMoving: Math.abs(this._velocity.x) +
 	                Math.abs(this._velocity.y) +
 	                Math.abs(this._velocity.z) >
@@ -104669,17 +104700,47 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        };
 	    };
 	    FlyCamera.prototype._handleKeyDown = function (e) {
-	        this._pressed.add(e.code);
+	        const keys = [];
+	        if (e.code) {
+	            keys.push(e.code);
+	        }
+	        if (e.key) {
+	            keys.push(e.key);
+	            if (e.key.length === 1) {
+	                // Allow matching against both `KeyW` style codes and plain characters
+	                keys.push(`Key${e.key.toUpperCase()}`);
+	                keys.push(e.key.toUpperCase());
+	                keys.push(e.key.toLowerCase());
+	            }
+	        }
+	        for (const k of keys) {
+	            this._pressed.add(k);
+	        }
 	    };
 	    FlyCamera.prototype._handleKeyUp = function (e) {
-	        this._pressed.delete(e.code);
+	        const keys = [];
+	        if (e.code) {
+	            keys.push(e.code);
+	        }
+	        if (e.key) {
+	            keys.push(e.key);
+	            if (e.key.length === 1) {
+	                keys.push(`Key${e.key.toUpperCase()}`);
+	                keys.push(e.key.toUpperCase());
+	                keys.push(e.key.toLowerCase());
+	            }
+	        }
+	        for (const k of keys) {
+	            this._pressed.delete(k);
+	        }
 	    };
 	    FlyCamera.prototype._handleMouseMove = function (e) {
 	        if (!this._isPointerLocked || !this._isActive)
 	            return;
+	        // Invert horizontal (yaw) rotation: moving mouse right rotates view left, and vice versa
 	        const dx = e.movementX * this.lookSensitivity;
 	        const dy = e.movementY * this.lookSensitivity * (this.invertY ? 1 : -1);
-	        this._yaw = (this._yaw + dx) % 360;
+	        this._yaw = (this._yaw - dx) % 360;
 	        this._pitch = Math.max(-89, Math.min(89, this._pitch + dy));
 	    };
 	    FlyCamera.prototype._handlePointerLockChange = function () {
@@ -104702,15 +104763,19 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	            }
 	        }
 	    };
-	    FlyCamera.prototype._updateVelocity = function (dt) {
+	    FlyCamera.prototype._updateVelocity = function (_dt) {
 	        // Input direction (local space)
 	        const kb = this.keyBindings;
-	        const forward = this._pressed.has(kb.forward) ? 1 : 0;
-	        const backward = this._pressed.has(kb.backward) ? 1 : 0;
-	        const left = this._pressed.has(kb.left) ? 1 : 0;
-	        const right = this._pressed.has(kb.right) ? 1 : 0;
-	        const up = this._pressed.has(kb.up) ? 1 : 0;
-	        const down = this._pressed.has(kb.down) ? 1 : 0;
+	        const isPressed = (binding, fallbacks) => {
+	            const all = [binding, ...fallbacks].filter(Boolean);
+	            return all.some(k => this._pressed.has(k));
+	        };
+	        const forward = isPressed(kb.forward, ['KeyW', 'w', 'W']) ? 1 : 0;
+	        const backward = isPressed(kb.backward, ['KeyS', 's', 'S']) ? 1 : 0;
+	        const left = isPressed(kb.left, ['KeyA', 'a', 'A']) ? 1 : 0;
+	        const right = isPressed(kb.right, ['KeyD', 'd', 'D']) ? 1 : 0;
+	        const up = isPressed(kb.up, ['KeyE', 'e', 'E']) ? 1 : 0;
+	        const down = isPressed(kb.down, ['KeyQ', 'q', 'Q']) ? 1 : 0;
 	        const inputZ = forward - backward;
 	        const inputX = right - left;
 	        const inputY = up - down;
@@ -104718,17 +104783,25 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        const planarLen = Math.hypot(inputX, inputZ);
 	        const nx = planarLen > 0 ? inputX / planarLen : 0;
 	        const nz = planarLen > 0 ? inputZ / planarLen : 0;
-	        // Effective speed with modifiers
-	        const speed = this._getEffectiveSpeed();
-	        // Compute direction vectors from current yaw/pitch
-	        const yawRad = (this._yaw * Math.PI) / 180;
-	        const pitchRad = (this._pitch * Math.PI) / 180;
-	        // Forward vector (normalized)
-	        const fwd = new Vec3(Math.cos(pitchRad) * Math.sin(yawRad), Math.sin(pitchRad), Math.cos(pitchRad) * Math.cos(yawRad));
-	        // Right vector (perpendicular to yaw on horizontal plane)
-	        const rightVec = new Vec3(Math.sin(yawRad - Math.PI / 2), 0, Math.cos(yawRad - Math.PI / 2));
-	        // Up vector (world up)
-	        const upVec = Vec3.UP.clone();
+	        // Effective speed with modifiers (scaled x2 as requested)
+	        const speed = this._getEffectiveSpeed() * 2;
+	        // Compute direction vectors from the camera entity so movement matches look direction
+	        const entity = this.entity;
+	        const fwd = entity?.forward && entity.forward.clone
+	            ? entity.forward.clone()
+	            : entity?.forward
+	                ? new Vec3(entity.forward.x, entity.forward.y, entity.forward.z)
+	                : new Vec3(0, 0, -1);
+	        const rightVec = entity?.right && entity.right.clone
+	            ? entity.right.clone()
+	            : entity?.right
+	                ? new Vec3(entity.right.x, entity.right.y, entity.right.z)
+	                : new Vec3(1, 0, 0);
+	        const upVec = entity?.up && entity.up.clone
+	            ? entity.up.clone()
+	            : entity?.up
+	                ? new Vec3(entity.up.x, entity.up.y, entity.up.z)
+	                : Vec3.UP.clone();
 	        // Target velocity in world space
 	        const target = new Vec3(0, 0, 0);
 	        target.add(fwd.mulScalar(nz * speed));
@@ -104763,7 +104836,9 @@ fn fragmentMain(input: FragmentInput) -> FragmentOutput {
 	        }
 	    };
 	    FlyCamera.prototype._applyConstraints = function () {
-	        if (!this.enableCollision && this.minHeight == null && this.maxHeight == null) {
+	        if (!this.enableCollision &&
+	            this.minHeight == null &&
+	            this.maxHeight == null) {
 	            return;
 	        }
 	        const pos = this.entity.getPosition