@pmndrs/viverse 0.1.20 → 0.2.0

package/dist/simple-character/state/jump-start.js

@@ -0,0 +1,30 @@
+import { action, timePassed } from '@pmndrs/timeline';
+import { RunField } from '../../input/index.js';
+import { startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration, DefaultJumDelay } from '../defaults.js';
+export async function loadSimpleCharacterJumpStartState(jumpUp, jumpForward, state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation state without existing model`);
+    }
+    return {
+        timeline: () => action({
+            init() {
+                startAnimation(jumpUp, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                    paused: true,
+                });
+                startAnimation(jumpForward, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                    paused: true,
+                });
+            },
+            update: () => void state.physics.inputVelocity.multiplyScalar(0.3),
+            until: timePassed((typeof options.movement?.jump === 'object' ? options.movement?.jump.delay : undefined) ?? DefaultJumDelay, 'seconds'),
+        }),
+        transitionTo: {
+            jumpDown: { whenUpdate: () => !state.physics.isGrounded },
+            finally: () => (state.inputSystem.get(RunField) ? 'jumpForward' : 'jumpUp'),
+        },
+    };
+}

package/dist/simple-character/state/jump-up.d.ts

@@ -0,0 +1,5 @@
+import { GraphTimelineState } from '@pmndrs/timeline';
+import { AnimationAction } from 'three';
+import { SimpleCharacterState, SimpleCharacterOptions } from '../index.js';
+export declare function loadSimpleCharacterJumpUpAction(state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<AnimationAction>;
+export declare function loadSimpleCharacterJumpUpState<T>(jumpUp: AnimationAction, state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<GraphTimelineState<T>>;

package/dist/simple-character/state/jump-up.js

@@ -0,0 +1,38 @@
+import { action, animationFinished } from '@pmndrs/timeline';
+import { LoopOnce, Vector3 } from 'three';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { startAnimation } from '../../utils.js';
+export async function loadSimpleCharacterJumpUpAction(state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation without existing model`);
+    }
+    const jumpUp = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.jumpUp ?? {
+        url: { default: 'jumpUp' },
+    })));
+    jumpUp.loop = LoopOnce;
+    jumpUp.clampWhenFinished = true;
+    return jumpUp;
+}
+export async function loadSimpleCharacterJumpUpState(jumpUp, state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation state without existing model`);
+    }
+    return {
+        timeline: () => action({
+            init: () => {
+                startAnimation(jumpUp, model.currentAnimations, { fadeDuration: 0.1 });
+                state.lastJump = performance.now() / 1000;
+                state.physics.applyVelocity(new Vector3(0, (typeof options.movement?.jump === 'object' ? options.movement?.jump.speed : undefined) ?? 8, 0));
+            },
+            until: animationFinished(jumpUp),
+        }),
+        transitionTo: {
+            jumpDown: {
+                whenUpdate: (_, _clock, actionTime) => actionTime > 0.3 && state.physics.isGrounded,
+            },
+            finally: 'jumpLoop',
+        },
+    };
+}

package/dist/simple-character/state/movement.d.ts

@@ -0,0 +1,3 @@
+import { type GraphTimelineState } from '@pmndrs/timeline';
+import type { SimpleCharacterOptions, SimpleCharacterState } from '../index.js';
+export declare function loadSimpleCharacterMovingState<T>(state: SimpleCharacterState, options: SimpleCharacterOptions): Promise<GraphTimelineState<T>>;

package/dist/simple-character/state/movement.js

@@ -0,0 +1,59 @@
+import { action } from '@pmndrs/timeline';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { RunField } from '../../input/index.js';
+import { shouldJump, startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration } from '../defaults.js';
+export async function loadSimpleCharacterMovingState(state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation without existing model`);
+    }
+    const idle = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.idle ?? {
+        url: { default: 'idle' },
+    })));
+    const run = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
+        url: { default: 'run' },
+        scaleTime: 0.8,
+    })));
+    const walk = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions(options.animation?.walk ?? {
+        scaleTime: 0.5,
+        url: { default: 'walk' },
+    })));
+    return {
+        timeline: () => {
+            let currentAnimation;
+            return action({
+                update: () => {
+                    let nextAnimation;
+                    if (state.physics.inputVelocity.lengthSq() === 0) {
+                        nextAnimation = idle;
+                    }
+                    else if (state.inputSystem.get(RunField) && options.movement?.run != false) {
+                        nextAnimation = run;
+                    }
+                    else if (options.movement?.walk != false) {
+                        nextAnimation = walk;
+                    }
+                    else {
+                        nextAnimation = idle;
+                    }
+                    if (nextAnimation === currentAnimation) {
+                        return;
+                    }
+                    currentAnimation?.fadeOut(options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
+                    startAnimation(nextAnimation, model.currentAnimations, {
+                        fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                    });
+                    currentAnimation = nextAnimation;
+                },
+            });
+        },
+        transitionTo: {
+            jumpStart: {
+                whenUpdate: () => options.movement?.jump !== false &&
+                    shouldJump(state.physics, state.inputSystem, state.lastJump, options.movement?.jump === true ? undefined : options.movement?.jump?.bufferTime),
+            },
+            jumpLoop: { whenUpdate: () => !state.physics.isGrounded },
+        },
+    };
+}

package/dist/simple-character/update-input-velocity.d.ts

@@ -0,0 +1,5 @@
+import { Object3D } from 'three';
+import { InputSystem } from '../input/index.js';
+import type { SimpleCharacterMovementOptions } from './index.js';
+import type { BvhCharacterPhysics } from '../physics/index.js';
+export declare function updateSimpleCharacterInputVelocity(camera: Object3D, inputSystem: InputSystem, physics: BvhCharacterPhysics, options?: SimpleCharacterMovementOptions): void;

package/dist/simple-character/update-input-velocity.js

@@ -0,0 +1,25 @@
+import { Euler, Quaternion } from 'three';
+import { RunField, MoveLeftField, MoveRightField, MoveForwardField, MoveBackwardField, } from '../input/index.js';
+const cameraEuler = new Euler();
+const cameraRotation = new Quaternion();
+export function updateSimpleCharacterInputVelocity(camera, inputSystem, physics, options) {
+    cameraEuler.setFromQuaternion(camera.getWorldQuaternion(cameraRotation), 'YXZ');
+    cameraEuler.x = 0;
+    cameraEuler.z = 0;
+    let inputSpeed = 0;
+    let runOptions = options?.run ?? true;
+    if (inputSystem.get(RunField) && runOptions !== false) {
+        runOptions = runOptions === true ? {} : runOptions;
+        inputSpeed = runOptions.speed ?? 6;
+    }
+    let walkOptions = options?.walk ?? true;
+    if (inputSpeed === 0 && walkOptions !== false) {
+        walkOptions = walkOptions === true ? {} : walkOptions;
+        inputSpeed = walkOptions.speed ?? 3;
+    }
+    physics.inputVelocity
+        .set(-inputSystem.get(MoveLeftField) + inputSystem.get(MoveRightField), 0, -inputSystem.get(MoveForwardField) + inputSystem.get(MoveBackwardField))
+        .normalize()
+        .applyEuler(cameraEuler)
+        .multiplyScalar(inputSpeed);
+}

package/dist/simple-character/update-rotation.d.ts

@@ -0,0 +1,6 @@
+import { Object3D } from 'three';
+import { BvhCharacterPhysics } from '../physics/index.js';
+import type { SimpleCharacterAnimationOptions } from './index.js';
+export declare function updateSimpleCharacterRotation(delta: number, physics: BvhCharacterPhysics, camera: Object3D, model: {
+    scene: Object3D;
+}, options?: SimpleCharacterAnimationOptions): true | undefined;

package/dist/simple-character/update-rotation.js

@@ -0,0 +1,40 @@
+import { Euler, Quaternion, Vector3 } from 'three';
+const NegZAxis = new Vector3(0, 0, -1);
+const _2MathPI = 2 * Math.PI;
+const characterTargetEuler = new Euler();
+const goalTargetEuler = new Euler();
+const inputDirection = new Vector3();
+const quaternion = new Quaternion();
+export function updateSimpleCharacterRotation(delta, physics, camera, model, options) {
+    // Character yaw rotation logic
+    const basedOn = options?.yawRotationBasdOn ?? 'movement';
+    // compute goalTargetEuler
+    if (basedOn === 'camera') {
+        goalTargetEuler.setFromQuaternion(camera.getWorldQuaternion(quaternion), 'YXZ');
+    }
+    else {
+        //don't rotate if not moving
+        if (physics.inputVelocity.lengthSq() === 0) {
+            // run forever
+            return true;
+        }
+        inputDirection.copy(physics.inputVelocity).normalize();
+        quaternion.setFromUnitVectors(NegZAxis, inputDirection);
+        goalTargetEuler.setFromQuaternion(quaternion, 'YXZ');
+    }
+    // compute currentTargetEuler
+    model.scene.getWorldQuaternion(quaternion);
+    characterTargetEuler.setFromQuaternion(quaternion, 'YXZ');
+    // apply delta yaw rotation
+    let deltaYaw = (goalTargetEuler.y - characterTargetEuler.y + _2MathPI) % _2MathPI;
+    if (deltaYaw > Math.PI) {
+        deltaYaw = deltaYaw - _2MathPI;
+    }
+    const absDeltaYaw = Math.abs(deltaYaw);
+    if (absDeltaYaw < 0.001) {
+        // run forever
+        return true;
+    }
+    const yawRotationDirection = deltaYaw / absDeltaYaw;
+    model.scene.rotation.y += Math.min((options?.maxYawRotationSpeed ?? 10) * delta, absDeltaYaw) * yawRotationDirection;
+}

package/dist/utils.d.ts

@@ -1,7 +1,14 @@
-export declare function cached<D extends ReadonlyArray<unknown>, T>(fn: (...deps: D) => Promise<T>, dependencies: D): Promise<T>;
-export declare function clearCache(fn: Function, dependencies: Array<unknown>): void;
-export declare function extractProxy<K extends string, T extends {
-    [key in K]?: {};
-}>(value: T, key: K): Partial<Exclude<T[K], undefined>>;
+import { type InputSystem } from './input/index.js';
+import type { CharacterAnimationMask } from './animation/index.js';
+import type { CharacterModel } from './model/index.js';
+import type { BvhCharacterPhysics } from './physics/index.js';
+import type { AnimationAction } from 'three';
 export declare function getIsMobileMediaQuery(): MediaQueryList | undefined;
 export declare function isMobile(): boolean;
+export type StartAnimationOptions = {
+    fadeDuration?: number;
+    paused?: boolean;
+    mask?: CharacterAnimationMask;
+};
+export declare function startAnimation(animation: AnimationAction, currentAnimations: CharacterModel['currentAnimations'], { fadeDuration, paused, mask }: StartAnimationOptions): void;
+export declare function shouldJump(physics: BvhCharacterPhysics, inputSystem: InputSystem, lastJump: number, bufferTime?: number): boolean;

package/dist/utils.js

@@ -1,42 +1,4 @@
-function shallowEqual(a, b) {
-    if (a.length !== b.length)
-        return false;
-    for (let i = 0; i < a.length; i++) {
-        if (a[i] !== b[i])
-            return false;
-    }
-    return true;
-}
-const cacheMap = new Map();
-export function cached(fn, dependencies) {
-    let cache = cacheMap.get(fn);
-    if (cache == null) {
-        cacheMap.set(fn, (cache = []));
-    }
-    const entry = cache.find(({ deps }) => shallowEqual(deps, dependencies));
-    if (entry != null) {
-        return entry.result;
-    }
-    const result = fn(...dependencies);
-    cache.push({ deps: dependencies, result });
-    return result;
-}
-export function clearCache(fn, dependencies) {
-    const cache = cacheMap.get(fn);
-    if (cache == null) {
-        return;
-    }
-    const index = cache.findIndex(({ deps }) => shallowEqual(deps, dependencies));
-    if (index === -1) {
-        return;
-    }
-    cache.splice(index, 1);
-}
-export function extractProxy(value, key) {
-    return new Proxy({}, {
-        get: (_, p) => value[key]?.[p],
-    });
-}
+import { LastTimeJumpPressedField } from './input/index.js';
 export function getIsMobileMediaQuery() {
     if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {
         return undefined;
@@ -46,3 +8,30 @@ export function getIsMobileMediaQuery() {
 export function isMobile() {
     return getIsMobileMediaQuery()?.matches ?? false;
 }
+export function startAnimation(animation, currentAnimations, { fadeDuration = 0.1, paused = false, mask }) {
+    animation.reset();
+    animation.play();
+    animation.paused = paused;
+    const currentAnimation = currentAnimations.get(mask);
+    if (currentAnimation != null) {
+        animation.crossFadeFrom(currentAnimation, fadeDuration);
+    }
+    else {
+        animation.fadeIn(fadeDuration);
+    }
+    currentAnimations.set(mask, animation);
+}
+export function shouldJump(physics, inputSystem, lastJump, bufferTime = 0.1) {
+    if (!physics.isGrounded) {
+        return false;
+    }
+    const lastTimePressed = inputSystem.get(LastTimeJumpPressedField);
+    if (lastTimePressed == null || lastJump > lastTimePressed) {
+        return false;
+    }
+    //last jump must be more then 0.3 second ago, if not, we dont jump, this is to give the character time to get off the ground
+    if (lastJump > performance.now() / 1000 - 0.3) {
+        return false;
+    }
+    return performance.now() / 1000 - lastTimePressed < bufferTime;
+}

package/package.json

@@ -21,12 +21,12 @@
   "peerDependencies": {
     "three": "*"
   },
-  "version": "0.1.20",
+  "version": "0.2.0",
   "type": "module",
   "dependencies": {
     "@pixiv/three-vrm": "^3.4.2",
     "@pixiv/three-vrm-animation": "^3.4.2",
-    "@pmndrs/timeline": "^0.2.6",
+    "@pmndrs/timeline": "^0.3.5",
     "@viverse/sdk": "1.2.10-alpha.0",
     "three-mesh-bvh": "^0.9.1"
   },

package/dist/simple-character.d.ts

@@ -1,107 +0,0 @@
-import { VRM } from '@pixiv/three-vrm';
-import { AnimationAction, AnimationClip, AnimationMixer, Group, Object3D, Object3DEventMap, Quaternion } from 'three';
-import { simpleCharacterAnimationNames, ModelAnimationOptions } from './animation/index.js';
-import { SimpleCharacterCameraBehavior, SimpleCharacterCameraBehaviorOptions } from './camera.js';
-import { Input, InputSystem, ScreenJoystickInputOptions, LocomotionKeyboardInputOptions, PointerCaptureInputOptions, PointerLockInputOptions } from './input/index.js';
-import { CharacterModelOptions, loadCharacterModel } from './model/index.js';
-import { BvhCharacterPhysicsOptions, BvhCharacterPhysics, BvhPhysicsWorld } from './physics/index.js';
-export type SimpleCharacterMovementOptions = {
-    /**
-     * @default true
-     */
-    jump?: {
-        /**
-         * @default 0.2
-         */
-        delay?: number;
-        /**
-         * @default 0.1
-         */
-        bufferTime?: number;
-        /**
-         * @default 8
-         */
-        speed?: number;
-    } | boolean;
-    /**
-     * @default true
-     */
-    walk?: {
-        speed?: number;
-    } | boolean;
-    /**
-     * @default true
-     */
-    run?: {
-        speed?: number;
-    } | boolean;
-};
-export type SimpleCharacterAnimationOptions = {
-    readonly walk?: ModelAnimationOptions;
-    readonly run?: ModelAnimationOptions;
-    readonly idle?: ModelAnimationOptions;
-    readonly jumpUp?: ModelAnimationOptions;
-    readonly jumpLoop?: ModelAnimationOptions;
-    readonly jumpDown?: ModelAnimationOptions;
-    readonly jumpForward?: ModelAnimationOptions;
-    /**
-     * @default "movement"
-     */
-    yawRotationBasdOn?: 'camera' | 'movement';
-    /**
-     * @default 10
-     */
-    maxYawRotationSpeed?: number;
-    /**
-     * @default 0.3
-     */
-    crossFadeDuration?: number;
-};
-export type SimpleCharacterInputOptions = ScreenJoystickInputOptions & PointerCaptureInputOptions & PointerLockInputOptions & LocomotionKeyboardInputOptions;
-export type SimpleCharacterOptions = {
-    readonly input?: ReadonlyArray<Input | {
-        new (domElement: HTMLElement): Input;
-    }> | InputSystem;
-    inputOptions?: SimpleCharacterInputOptions;
-    movement?: SimpleCharacterMovementOptions;
-    readonly model?: CharacterModelOptions;
-    physics?: BvhCharacterPhysicsOptions;
-    cameraBehavior?: SimpleCharacterCameraBehaviorOptions;
-    readonly animation?: SimpleCharacterAnimationOptions;
-};
-export declare function preloadSimpleCharacterAssets(options: Pick<SimpleCharacterOptions, 'animation' | 'model'>): Promise<{
-    model?: undefined;
-    animations?: undefined;
-} | {
-    model: ((VRM & {
-        scene: Object3D<Object3DEventMap & {
-            dispose: {};
-        }>;
-    }) | (import("three/examples/jsm/Addons.js").GLTF & {
-        scene: Object3D<Object3DEventMap & {
-            dispose: {};
-        }>;
-    })) & {
-        boneRotationOffset?: Quaternion;
-    };
-    animations: Record<"walk" | "run" | "jumpForward" | "idle" | "jumpUp" | "jumpLoop" | "jumpDown", AnimationClip>;
-}>;
-export declare class SimpleCharacter extends Group<Object3DEventMap & {
-    loaded: {};
-}> {
-    private readonly camera;
-    readonly options: SimpleCharacterOptions;
-    readonly cameraBehavior: SimpleCharacterCameraBehavior;
-    readonly physics: BvhCharacterPhysics;
-    readonly mixer: AnimationMixer;
-    inputSystem: InputSystem;
-    actions?: Record<(typeof simpleCharacterAnimationNames)[number], AnimationAction> | undefined;
-    model?: Awaited<Exclude<ReturnType<typeof loadCharacterModel>, undefined>>;
-    private updateTimeline?;
-    private readonly abortController;
-    constructor(camera: Object3D | (() => Object3D), world: BvhPhysicsWorld, domElement: HTMLElement, options?: SimpleCharacterOptions);
-    getCamera(): Object3D<Object3DEventMap>;
-    private init;
-    update(delta: number): void;
-    dispose(): void;
-}