@pmndrs/viverse 0.1.20 → 0.2.0

package/dist/animation/default.js

@@ -0,0 +1,18 @@
+export async function loadDefaultCharacterAnimationUrl(type) {
+    switch (type) {
+        case 'idle':
+            return (await import('../assets/idle.js')).url;
+        case 'jumpDown':
+            return (await import('../assets/jump-down.js')).url;
+        case 'jumpForward':
+            return (await import('../assets/jump-forward.js')).url;
+        case 'jumpLoop':
+            return (await import('../assets/jump-loop.js')).url;
+        case 'jumpUp':
+            return (await import('../assets/jump-up.js')).url;
+        case 'run':
+            return (await import('../assets/run.js')).url;
+        case 'walk':
+            return (await import('../assets/walk.js')).url;
+    }
+}

package/dist/animation/fbx.d.ts

@@ -1,4 +1,4 @@
 import { AnimationClip } from 'three';
-import { loadCharacterModel } from '../model/index.js';
+import type { CharacterModel } from '../model/index.js';
 import type { VRMHumanBoneName } from '@pixiv/three-vrm';
-export declare function loadVrmModelFbxAnimations(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;
+export declare function loadVrmModelFbxAnimations(model: CharacterModel, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;

package/dist/animation/gltf.d.ts

@@ -1,3 +1,3 @@
 import { AnimationClip } from 'three';
-import { loadCharacterModel, VRMHumanBoneName } from '../model/index.js';
-export declare function loadVrmModelGltfAnimations(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;
+import type { CharacterModel, VRMHumanBoneName } from '../model/index.js';
+export declare function loadVrmModelGltfAnimations(model: CharacterModel, url: string, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): Promise<Array<AnimationClip>>;

package/dist/animation/index.d.ts

@@ -1,14 +1,18 @@
 import { VRMHumanBoneName } from '@pixiv/three-vrm';
 import { AnimationClip, Object3D } from 'three';
-import { loadCharacterModel } from '../model/index.js';
-export declare function fixModelAnimationClip(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, clip: AnimationClip, clipScene: Object3D | undefined, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): void;
+import { loadDefaultCharacterAnimationUrl } from './default.js';
+import type { CharacterModel } from '../model/index.js';
+export declare function fixModelAnimationClip(model: CharacterModel, clip: AnimationClip, clipScene: Object3D | undefined, removeXZMovement: boolean, boneMap?: Record<string, VRMHumanBoneName>): void;
 export * from './gltf.js';
 export * from './fbx.js';
 export * from './vrma.js';
 export * from './utils.js';
-export type ModelAnimationOptions = {
+export type CharacterAnimationMask = (boneName: VRMHumanBoneName) => boolean;
+export type CharacterAnimationOptions = {
+    url: string | {
+        default: Parameters<typeof loadDefaultCharacterAnimationUrl>[0];
+    };
     type?: 'mixamo' | 'gltf' | 'vrma' | 'fbx' | 'bvh';
-    url: string;
     removeXZMovement?: boolean;
     trimTime?: {
         start?: number;
@@ -16,18 +20,12 @@ export type ModelAnimationOptions = {
     };
     boneMap?: Record<string, VRMHumanBoneName>;
     scaleTime?: number;
+    mask?: CharacterAnimationMask;
 };
-export declare function loadCharacterModelAnimation(model: Exclude<Awaited<ReturnType<typeof loadCharacterModel>>, undefined>, options: ModelAnimationOptions): Promise<AnimationClip>;
-declare const simpleCharacterAnimationUrls: {
-    walk: () => Promise<typeof import("../assets/walk.js")>;
-    run: () => Promise<typeof import("../assets/run.js")>;
-    idle: () => Promise<typeof import("../assets/idle.js")>;
-    jumpUp: () => Promise<typeof import("../assets/jump-up.js")>;
-    jumpLoop: () => Promise<typeof import("../assets/jump-loop.js")>;
-    jumpDown: () => Promise<typeof import("../assets/jump-down.js")>;
-    jumpForward: () => Promise<typeof import("../assets/jump-forward.js")>;
-};
-export declare const simpleCharacterAnimationNames: Array<keyof typeof simpleCharacterAnimationUrls>;
-export declare function getSimpleCharacterModelAnimationOptions(animationName: keyof typeof simpleCharacterAnimationUrls): Promise<ModelAnimationOptions>;
+export type Tail<T extends any[]> = T extends [any, ...infer Rest] ? Rest : never;
+export declare function flattenCharacterAnimationOptions(options: Exclude<CharacterAnimationOptions, false>): Tail<Parameters<typeof loadCharacterAnimation>>;
+export declare function loadCharacterAnimation(model: CharacterModel, url: string | {
+    default: Parameters<typeof loadDefaultCharacterAnimationUrl>[0];
+}, type?: CharacterAnimationOptions['type'], removeXZMovement?: boolean, trimStartTime?: number | undefined, trimEndTime?: number | undefined, boneMap?: Record<string, VRMHumanBoneName> | undefined, scaleTime?: number | undefined, mask?: CharacterAnimationMask): Promise<AnimationClip>;
 export declare const mixamoBoneMap: Record<string, VRMHumanBoneName>;
 export declare const bvhBoneMap: Record<string, VRMHumanBoneName>;

package/dist/animation/index.js

@@ -2,12 +2,12 @@ import { VRM } from '@pixiv/three-vrm';
 import { Euler, Quaternion, QuaternionKeyframeTrack, Vector3, VectorKeyframeTrack, } from 'three';
 import _bvhBoneMap from './bvh-bone-map.json';
 import { loadVrmModelBvhAnimations } from './bvh.js';
+import { loadDefaultCharacterAnimationUrl } from './default.js';
 import { loadVrmModelFbxAnimations } from './fbx.js';
 import { loadVrmModelGltfAnimations } from './gltf.js';
 import _mixamoBoneMap from './mixamo-bone-map.json';
 import { scaleAnimationClipTime, trimAnimationClip } from './utils.js';
 import { loadVrmModelVrmaAnimations } from './vrma.js';
-import { cached } from '../utils.js';
 //helper variables for the quaternion retargeting
 const baseThisLocalRestRotation_inverse = new Quaternion();
 const baseThisLocalCurrentRotation = new Quaternion();
@@ -174,7 +174,23 @@ export * from './gltf.js';
 export * from './fbx.js';
 export * from './vrma.js';
 export * from './utils.js';
-async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, trimStartTime, trimEndTime, boneMap, scaleTime) {
+export function flattenCharacterAnimationOptions(options) {
+    return [
+        options.url,
+        options.type,
+        options.removeXZMovement,
+        options.trimTime?.start,
+        options.trimTime?.end,
+        options.boneMap,
+        options.scaleTime,
+        options.mask,
+    ];
+}
+export async function loadCharacterAnimation(model, url, type, removeXZMovement = false, trimStartTime, trimEndTime, boneMap, scaleTime, mask) {
+    if (typeof url === 'object') {
+        url = await loadDefaultCharacterAnimationUrl(url.default);
+        type = 'gltf';
+    }
     let clips;
     if (type == null) {
         const lowerCaseUrl = url.toLocaleLowerCase();
@@ -226,39 +242,5 @@ async function uncachedLoadModelAnimation(model, type, url, removeXZMovement, tr
     }
     return clip;
 }
-export function loadCharacterModelAnimation(model, options) {
-    return cached(uncachedLoadModelAnimation, [
-        model,
-        options.type,
-        options.url,
-        options.removeXZMovement ?? false,
-        options.trimTime?.start,
-        options.trimTime?.end,
-        options.boneMap,
-        options.scaleTime,
-    ]);
-}
-const extraOptions = {
-    walk: { scaleTime: 0.5 },
-    run: { scaleTime: 0.8 },
-    jumpForward: { scaleTime: 0.9 },
-};
-const simpleCharacterAnimationUrls = {
-    walk: () => import('../assets/walk.js'),
-    run: () => import('../assets/run.js'),
-    idle: () => import('../assets/idle.js'),
-    jumpUp: () => import('../assets/jump-up.js'),
-    jumpLoop: () => import('../assets/jump-loop.js'),
-    jumpDown: () => import('../assets/jump-down.js'),
-    jumpForward: () => import('../assets/jump-forward.js'),
-};
-export const simpleCharacterAnimationNames = Object.keys(simpleCharacterAnimationUrls);
-export async function getSimpleCharacterModelAnimationOptions(animationName) {
-    return {
-        type: 'gltf',
-        ...extraOptions[animationName],
-        url: (await simpleCharacterAnimationUrls[animationName]()).url,
-    };
-}
 export const mixamoBoneMap = _mixamoBoneMap;
 export const bvhBoneMap = _bvhBoneMap;

package/dist/animation/mask.d.ts

@@ -0,0 +1,3 @@
+import type { CharacterAnimationMask } from './index.js';
+import type { AnimationClip } from 'three';
+export declare function applyMask(clip: AnimationClip, mask: CharacterAnimationMask): void;

package/dist/animation/mask.js

@@ -0,0 +1,3 @@
+export function applyMask(clip, mask) {
+    clip.tracks = clip.tracks.filter((track) => mask(track.name.split('.')[0]));
+}

package/dist/camera.d.ts

@@ -1,5 +1,5 @@
 import { Object3D, Vector3, Vector3Tuple, Ray } from 'three';
-import { SimpleCharacter } from './simple-character.js';
+import { InputSystem } from './input/index.js';
 export declare const FirstPersonCharacterCameraBehavior: SimpleCharacterCameraBehaviorOptions;
 export type SimpleCharacterCameraBehaviorOptions = {
     /**
@@ -55,16 +55,12 @@ export type SimpleCharacterCameraBehaviorOptions = {
         maxDistance?: number;
     } | boolean;
 } | boolean;
-export declare class SimpleCharacterCameraBehavior {
-    getCamera: () => Object3D;
-    character: SimpleCharacter;
-    private readonly raycast?;
+export declare class CharacterCameraBehavior {
     rotationPitch: number;
     rotationYaw: number;
     zoomDistance: number;
     private collisionFreeZoomDistance;
     private firstUpdate;
-    constructor(getCamera: () => Object3D, character: SimpleCharacter, raycast?: ((ray: Ray, far: number) => number | undefined) | undefined);
     private setRotationFromDelta;
     private setDistanceFromDelta;
     private computeCharacterBaseOffset;
@@ -74,5 +70,5 @@ export declare class SimpleCharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(deltaTime: number, options?: SimpleCharacterCameraBehaviorOptions): void;
+    update(camera: Object3D, target: Object3D, inputSystem: InputSystem, deltaTime: number, raycast?: (ray: Ray, far: number) => number | undefined, options?: SimpleCharacterCameraBehaviorOptions): void;
 }

package/dist/camera.js

@@ -11,25 +11,17 @@ const sphericalOffset = new Vector3();
 const characterWorldPosition = new Vector3();
 const euler = new Euler();
 const rayHelper = new Ray();
-export class SimpleCharacterCameraBehavior {
-    getCamera;
-    character;
-    raycast;
+export class CharacterCameraBehavior {
     rotationPitch = (-20 * Math.PI) / 180;
     rotationYaw = 0;
     zoomDistance = 4; // Changed from zoom to distance for clearer semantics
     //internal state
     collisionFreeZoomDistance = this.zoomDistance;
     firstUpdate = true;
-    constructor(getCamera, character, raycast) {
-        this.getCamera = getCamera;
-        this.character = character;
-        this.raycast = raycast;
-    }
-    setRotationFromDelta(delta, rotationOptions) {
+    setRotationFromDelta(camera, delta, rotationOptions) {
         if (delta.lengthSq() < 0.0001) {
             // use current camera rotation if very close to target
-            euler.setFromQuaternion(this.getCamera().quaternion, 'YXZ');
+            euler.setFromQuaternion(camera.quaternion, 'YXZ');
             this.rotationPitch = euler.x;
             this.rotationYaw = euler.y;
             return;
@@ -63,7 +55,7 @@ export class SimpleCharacterCameraBehavior {
     /**
      * @param delta in seconds
      */
-    update(deltaTime, options = true) {
+    update(camera, target, inputSystem, deltaTime, raycast, options = true) {
         if (options === false) {
             this.firstUpdate = true;
             return;
@@ -74,33 +66,33 @@ export class SimpleCharacterCameraBehavior {
         }
         //compute character->camera delta through offset
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
-        this.character.getWorldPosition(characterWorldPosition);
+        target.getWorldPosition(characterWorldPosition);
         characterWorldPosition.add(chracterBaseOffsetHelper);
-        this.getCamera().getWorldPosition(deltaHelper);
+        camera.getWorldPosition(deltaHelper);
         deltaHelper.sub(characterWorldPosition);
         // apply rotation input to rotationYaw and rotationPitch if not disabled or first update
         let rotationOptions = options.rotation ?? true;
         if (!this.firstUpdate && rotationOptions !== false) {
             rotationOptions = rotationOptions === true ? {} : rotationOptions;
             const rotationSpeed = rotationOptions.speed ?? 1000.0;
-            const deltaYaw = this.character.inputSystem.get(DeltaYawField);
-            const deltaPitch = this.character.inputSystem.get(DeltaPitchField);
+            const deltaYaw = inputSystem.get(DeltaYawField);
+            const deltaPitch = inputSystem.get(DeltaPitchField);
             this.rotationYaw = this.clampYaw(this.rotationYaw + deltaYaw * rotationSpeed * deltaTime, rotationOptions);
             this.rotationPitch = this.clampPitch(this.rotationPitch + deltaPitch * rotationSpeed * deltaTime, rotationOptions);
         }
         else {
-            this.setRotationFromDelta(deltaHelper, typeof rotationOptions === 'boolean' ? {} : rotationOptions);
+            this.setRotationFromDelta(camera, deltaHelper, typeof rotationOptions === 'boolean' ? {} : rotationOptions);
         }
         // apply yaw and pitch to camera rotation
-        this.getCamera().rotation.set(this.rotationPitch, this.rotationYaw, 0, 'YXZ');
-        rayHelper.direction.set(0, 0, 1).applyEuler(this.getCamera().rotation);
+        camera.rotation.set(this.rotationPitch, this.rotationYaw, 0, 'YXZ');
+        rayHelper.direction.set(0, 0, 1).applyEuler(camera.rotation);
         rayHelper.origin.copy(characterWorldPosition);
         // apply zoom input to zoomDistance if not disabled or first update
         let zoomOptions = options.zoom ?? true;
         if (!this.firstUpdate && zoomOptions !== false) {
             zoomOptions = zoomOptions === true ? {} : zoomOptions;
             const zoomSpeed = zoomOptions.speed ?? 1000.0;
-            const deltaZoom = this.character.inputSystem.get(DeltaZoomField);
+            const deltaZoom = inputSystem.get(DeltaZoomField);
             const zoomFactor = 1 + deltaZoom * zoomSpeed * deltaTime;
             if (deltaZoom >= 0) {
                 this.zoomDistance *= zoomFactor;
@@ -119,19 +111,19 @@ export class SimpleCharacterCameraBehavior {
             if (collisionOptions === true) {
                 collisionOptions = {};
             }
-            let distance = this.raycast?.(rayHelper, this.zoomDistance);
+            let distance = raycast?.(rayHelper, this.zoomDistance);
             if (distance != null) {
                 this.collisionFreeZoomDistance = distance - (collisionOptions?.offset ?? 0.2);
             }
         }
         // Calculate camera position using spherical coordinates from euler
         sphericalOffset.set(0, 0, this.collisionFreeZoomDistance);
-        sphericalOffset.applyEuler(this.getCamera().rotation);
+        sphericalOffset.applyEuler(camera.rotation);
         // Get target position with offset (reuse helper vector)
-        this.character.getWorldPosition(characterWorldPosition);
+        target.getWorldPosition(characterWorldPosition);
         this.computeCharacterBaseOffset(chracterBaseOffsetHelper, options.characterBaseOffset);
         characterWorldPosition.add(chracterBaseOffsetHelper);
         // Set camera position relative to target
-        this.getCamera().position.copy(characterWorldPosition).add(sphericalOffset);
+        camera.position.copy(characterWorldPosition).add(sphericalOffset);
     }
 }

package/dist/index.d.ts

@@ -1,8 +1,9 @@
-export { extractProxy, getIsMobileMediaQuery, isMobile } from './utils.js';
+export * from './utils.js';
 export * from './input/index.js';
+export * from './utils.js';
 export * from './camera.js';
 export * from './physics/index.js';
 export * from './animation/index.js';
 export * from './material.js';
-export * from './simple-character.js';
+export * from './simple-character/index.js';
 export * from './model/index.js';

package/dist/index.js

@@ -1,10 +1,11 @@
-export { extractProxy, getIsMobileMediaQuery, isMobile } from './utils.js';
+export * from './utils.js';
 export * from './input/index.js';
+export * from './utils.js';
 export * from './camera.js';
 export * from './physics/index.js';
 export * from './animation/index.js';
 export * from './material.js';
-export * from './simple-character.js';
+export * from './simple-character/index.js';
 export * from './model/index.js';
 (function injectMobileClassStyle() {
     if (typeof document === 'undefined') {

package/dist/input/index.d.ts

@@ -1,8 +1,7 @@
-export declare class InputSystem {
-    private readonly inputs;
-    constructor(domElement: HTMLElement, inputs: ReadonlyArray<Input | {
-        new (element: HTMLElement, options?: {}): Input;
-    }>, options?: {});
+export declare class InputSystem<T extends {} = {}> {
+    options: T;
+    readonly inputs: Array<Input>;
+    constructor(options?: T);
     add(input: Input): void;
     remove(input: Input): void;
     dispose(): void;
@@ -21,8 +20,8 @@ export declare const RunField: InputField<boolean>;
 export declare const DeltaZoomField: InputField<number>;
 export declare const DeltaYawField: InputField<number>;
 export declare const DeltaPitchField: InputField<number>;
-export interface Input {
-    get<T>(field: InputField<T>): T | undefined;
+export interface Input<O = {}> {
+    get<T>(field: InputField<T>, options: O): T | undefined;
     dispose?(): void;
 }
 export * from './pointer-lock.js';

package/dist/input/index.js

@@ -1,7 +1,8 @@
 export class InputSystem {
-    inputs;
-    constructor(domElement, inputs, options) {
-        this.inputs = inputs.map((input) => (typeof input === 'function' ? new input(domElement, options) : input));
+    options;
+    inputs = [];
+    constructor(options = {}) {
+        this.options = options;
     }
     add(input) {
         this.inputs.push(input);
@@ -20,7 +21,7 @@ export class InputSystem {
     get(field) {
         let current;
         for (const input of this.inputs) {
-            const result = input.get(field);
+            const result = input.get(field, this.options);
             if (result == null) {
                 continue;
             }

package/dist/input/keyboard.d.ts

@@ -7,11 +7,10 @@ export type LocomotionKeyboardInputOptions = {
     keyboardRunKeys?: Array<string>;
     keyboardJumpKeys?: Array<string>;
 };
-export declare class LocomotionKeyboardInput implements Input {
-    private readonly options;
+export declare class LocomotionKeyboardInput implements Input<LocomotionKeyboardInputOptions> {
     private readonly abortController;
     private readonly keyState;
-    constructor(domElement: HTMLElement, options?: LocomotionKeyboardInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    constructor(domElement: HTMLElement);
+    get<T>(field: InputField<T>, options: LocomotionKeyboardInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/keyboard.js

@@ -6,11 +6,9 @@ const DefaultMoveRightKeys = ['KeyD'];
 const DefaultRunKeys = ['ShiftRight', 'ShiftLeft'];
 const DefaultJumpKeys = ['Space'];
 export class LocomotionKeyboardInput {
-    options;
     abortController = new AbortController();
     keyState = new Map();
-    constructor(domElement, options = {}) {
-        this.options = options;
+    constructor(domElement) {
         domElement.tabIndex = 0;
         domElement.addEventListener('keydown', (event) => {
             let state = this.keyState.get(event.code);
@@ -41,9 +39,9 @@ export class LocomotionKeyboardInput {
             signal: this.abortController.signal,
         });
     }
-    get(field) {
+    get(field, options) {
         if (field === LastTimeJumpPressedField) {
-            const jumpKeys = this.options.keyboardJumpKeys ?? DefaultJumpKeys;
+            const jumpKeys = options.keyboardJumpKeys ?? DefaultJumpKeys;
             const pressed = jumpKeys
                 .map((key) => this.keyState.get(key)?.pressTime ?? null)
                 .filter((t) => t != null);
@@ -52,19 +50,19 @@ export class LocomotionKeyboardInput {
         let keys;
         switch (field) {
             case MoveForwardField:
-                keys = this.options.keyboardMoveForwardKeys ?? DefaultMoveForwardKeys;
+                keys = options.keyboardMoveForwardKeys ?? DefaultMoveForwardKeys;
                 break;
             case MoveBackwardField:
-                keys = this.options.keyboardMoveBackwardKeys ?? DefaultMoveBackwardKeys;
+                keys = options.keyboardMoveBackwardKeys ?? DefaultMoveBackwardKeys;
                 break;
             case MoveLeftField:
-                keys = this.options.keyboardMoveLeftKeys ?? DefaultMoveLeftKeys;
+                keys = options.keyboardMoveLeftKeys ?? DefaultMoveLeftKeys;
                 break;
             case MoveRightField:
-                keys = this.options.keyboardMoveRightKeys ?? DefaultMoveRightKeys;
+                keys = options.keyboardMoveRightKeys ?? DefaultMoveRightKeys;
                 break;
             case RunField:
-                keys = this.options.keyboardRunKeys ?? DefaultRunKeys;
+                keys = options.keyboardRunKeys ?? DefaultRunKeys;
                 break;
         }
         if (keys == null) {

package/dist/input/pointer-capture.d.ts

@@ -6,7 +6,7 @@ export type PointerCaptureInputOptions = {
 /**
  * @requires to manually execute `domElement.setPointerCapture(pointerId)` on pointerdown
  */
-export declare class PointerCaptureInput implements Input {
+export declare class PointerCaptureInput implements Input<PointerCaptureInputOptions> {
     private readonly domElement;
     private readonly abortController;
     private deltaZoom;
@@ -14,7 +14,7 @@ export declare class PointerCaptureInput implements Input {
     private deltaPitch;
     private activePointers;
     private lastPinchDist;
-    constructor(domElement: HTMLElement, options?: PointerCaptureInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    constructor(domElement: HTMLElement);
+    get<T>(field: InputField<T>, options: PointerCaptureInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/pointer-capture.js

@@ -10,7 +10,7 @@ export class PointerCaptureInput {
     deltaPitch = 0;
     activePointers = new Map();
     lastPinchDist = null;
-    constructor(domElement, options = {}) {
+    constructor(domElement) {
         this.domElement = domElement;
         domElement.addEventListener('pointerdown', (event) => {
             this.domElement.setPointerCapture(event.pointerId);
@@ -31,16 +31,14 @@ export class PointerCaptureInput {
                 const pts = Array.from(this.activePointers.values());
                 if (this.lastPinchDist != null) {
                     const d = Math.hypot(pts[0].x - pts[1].x, pts[0].y - pts[1].y);
-                    const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
-                    this.deltaZoom += (this.lastPinchDist - d) * zoomSpeed;
+                    this.deltaZoom += this.lastPinchDist - d;
                     this.lastPinchDist = d;
                 }
                 event.preventDefault();
                 return;
             }
-            const rotationSpeed = options.pointerCaptureRotationSpeed ?? 0.4;
-            this.deltaYaw -= (rotationSpeed * event.movementX) / window.innerHeight;
-            this.deltaPitch -= (rotationSpeed * event.movementY) / window.innerHeight;
+            this.deltaYaw -= event.movementX / window.innerHeight;
+            this.deltaPitch -= event.movementY / window.innerHeight;
         }, {
             signal: this.abortController.signal,
         });
@@ -64,25 +62,26 @@ export class PointerCaptureInput {
         });
         domElement.addEventListener('wheel', (event) => {
             event.preventDefault();
-            const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
-            this.deltaZoom += event.deltaY * zoomSpeed;
+            this.deltaZoom += event.deltaY;
         }, {
             signal: this.abortController.signal,
         });
     }
-    get(field) {
+    get(field, options) {
+        const rotationSpeed = options.pointerCaptureRotationSpeed ?? 0.4;
+        const zoomSpeed = options.pointerCaptureZoomSpeed ?? 0.0001;
         let result;
         switch (field) {
             case DeltaPitchField:
-                result = this.deltaPitch;
+                result = (this.deltaPitch * rotationSpeed);
                 this.deltaPitch = 0;
                 break;
             case DeltaYawField:
-                result = this.deltaYaw;
+                result = (this.deltaYaw * rotationSpeed);
                 this.deltaYaw = 0;
                 break;
             case DeltaZoomField:
-                result = this.deltaZoom;
+                result = (this.deltaZoom * zoomSpeed);
                 this.deltaZoom = 0;
                 break;
         }

package/dist/input/pointer-lock.d.ts

@@ -6,12 +6,12 @@ export type PointerLockInputOptions = {
 /**
  * @requires to manually execute `domElement.requestPointerLock()`
  */
-export declare class PointerLockInput implements Input {
+export declare class PointerLockInput implements Input<PointerLockInputOptions> {
     private readonly abortController;
     private deltaZoom;
     private deltaYaw;
     private deltaPitch;
-    constructor(domElement: HTMLElement, options?: PointerLockInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    constructor(domElement: HTMLElement);
+    get<T>(field: InputField<T>, options: PointerLockInputOptions): T | undefined;
     dispose(): void;
 }

package/dist/input/pointer-lock.js

@@ -7,16 +7,15 @@ export class PointerLockInput {
     deltaZoom = 0;
     deltaYaw = 0;
     deltaPitch = 0;
-    constructor(domElement, options = {}) {
+    constructor(domElement) {
         domElement.addEventListener('pointermove', (event) => {
             if (document.pointerLockElement != domElement) {
                 return;
             }
-            const rotationSpeed = options.pointerLockRotationSpeed ?? 0.4;
             // Compute based on domElement bounds instead of window.innerHeight
             const rect = domElement.getBoundingClientRect();
-            this.deltaYaw -= (rotationSpeed * event.movementX) / rect.height;
-            this.deltaPitch -= (rotationSpeed * event.movementY) / rect.height;
+            this.deltaYaw -= event.movementX / rect.height;
+            this.deltaPitch -= event.movementY / rect.height;
         }, {
             signal: this.abortController.signal,
         });
@@ -24,26 +23,27 @@ export class PointerLockInput {
             if (document.pointerLockElement != domElement) {
                 return;
             }
-            const zoomSpeed = options.pointerLockZoomSpeed ?? 0.0001;
-            this.deltaZoom += event.deltaY * zoomSpeed;
+            this.deltaZoom += event.deltaY;
             event.preventDefault();
         }, {
             signal: this.abortController.signal,
         });
     }
-    get(field) {
+    get(field, options) {
+        const rotationSpeed = options.pointerLockRotationSpeed ?? 0.4;
+        const zoomSpeed = options.pointerLockZoomSpeed ?? 0.0001;
         let result;
         switch (field) {
             case DeltaPitchField:
-                result = this.deltaPitch;
+                result = (this.deltaPitch * rotationSpeed);
                 this.deltaPitch = 0;
                 break;
             case DeltaYawField:
-                result = this.deltaYaw;
+                result = (this.deltaYaw * rotationSpeed);
                 this.deltaYaw = 0;
                 break;
             case DeltaZoomField:
-                result = this.deltaZoom;
+                result = (this.deltaZoom * zoomSpeed);
                 this.deltaZoom = 0;
                 break;
         }

package/dist/input/screen-joystick.d.ts

@@ -3,19 +3,15 @@ export type ScreenJoystickInputOptions = {
     screenJoystickRunDistancePx?: number;
     screenJoystickDeadZonePx?: number;
 };
-export declare class ScreenJoystickInput implements Input {
-    private readonly options;
+export declare class ScreenJoystickInput implements Input<ScreenJoystickInputOptions> {
     readonly root: HTMLDivElement;
     private readonly handle;
-    private moveX;
-    private moveY;
-    private running;
-    private readonly joystickRadius;
-    private joyCenterX;
-    private joyCenterY;
     private pointerId;
-    constructor(domElement: HTMLElement, options?: ScreenJoystickInputOptions);
-    get<T>(field: InputField<T>): T | undefined;
+    private distanceToCenter;
+    private clampedX;
+    private clampedY;
+    constructor(domElement: HTMLElement);
+    get<T>(field: InputField<T>, options: ScreenJoystickInputOptions): T | undefined;
     dispose(): void;
     private updateHandle;
     private resetHandle;