@pmndrs/viverse 0.1.20 → 0.2.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;
-}

package/dist/simple-character.js

@@ -1,344 +0,0 @@
-import { VRM, VRMUtils } from '@pixiv/three-vrm';
-import { action, animationFinished, start, timePassed, forever, parallel, graph, } from '@pmndrs/timeline';
-import { AnimationMixer, Euler, Group, LoopOnce, Quaternion, Vector3, } from 'three';
-import { simpleCharacterAnimationNames, getSimpleCharacterModelAnimationOptions as getSimpleCharacterModelAnimationOptions, loadCharacterModelAnimation as loadCharacterModelAnimation, } from './animation/index.js';
-import { SimpleCharacterCameraBehavior } from './camera.js';
-import { InputSystem, LocomotionKeyboardInput, MoveBackwardField, MoveForwardField, MoveLeftField, MoveRightField, PointerCaptureInput, RunField, LastTimeJumpPressedField, ScreenJoystickInput, ScreenJumpButtonInput, } from './input/index.js';
-import { clearCharacterModelCache, loadCharacterModel } from './model/index.js';
-import { BvhCharacterPhysics } from './physics/index.js';
-import { extractProxy } from './utils.js';
-const DefaultCrossFadeDuration = 0.1;
-const DefaultJumDelay = 0.2;
-//constants
-const NegZAxis = new Vector3(0, 0, -1);
-const _2MathPI = 2 * Math.PI;
-//helper objects
-const cameraEuler = new Euler();
-const cameraRotation = new Quaternion();
-const vector = new Vector3();
-const characterTargetEuler = new Euler();
-const goalTargetEuler = new Euler();
-const inputDirection = new Vector3();
-const quaternion = new Quaternion();
-export async function preloadSimpleCharacterAssets(options) {
-    // load model
-    const model = await loadCharacterModel(options.model);
-    if (model == null) {
-        return {};
-    }
-    model.scene.addEventListener('dispose', () => clearCharacterModelCache(options.model));
-    // load animations
-    return {
-        model,
-        animations: (await Promise.all(simpleCharacterAnimationNames.map(async (name) => loadCharacterModelAnimation(model, options.animation?.[name] ?? (await getSimpleCharacterModelAnimationOptions(name)))))).reduce((prev, animation, i) => {
-            prev[simpleCharacterAnimationNames[i]] = animation;
-            return prev;
-        }, {}),
-    };
-}
-async function* SimpleCharacterTimeline(character) {
-    let lastJump = 0;
-    function shouldJump() {
-        let jumpOptions = character.options.movement?.jump;
-        if (jumpOptions === false) {
-            return false;
-        }
-        if (jumpOptions === true) {
-            jumpOptions = {};
-        }
-        if (!character.physics.isGrounded) {
-            return false;
-        }
-        const lastTimePressed = character.inputSystem.get(LastTimeJumpPressedField);
-        if (lastTimePressed == null) {
-            return false;
-        }
-        if (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 < (jumpOptions?.bufferTime ?? 0.1);
-    }
-    function applyJumpForce() {
-        lastJump = performance.now() / 1000;
-        character.physics.applyVelocity(vector.set(0, (typeof character.options.movement?.jump === 'object' ? character.options.movement?.jump.speed : undefined) ??
-            8, 0));
-    }
-    const model = character.model;
-    const actions = character.actions;
-    //run character
-    yield* parallel('all', 
-    // character movement
-    action({
-        update() {
-            cameraEuler.setFromQuaternion(character.getCamera().getWorldQuaternion(cameraRotation), 'YXZ');
-            cameraEuler.x = 0;
-            cameraEuler.z = 0;
-            let inputSpeed = 0;
-            let runOptions = character.options.movement?.run ?? true;
-            if (character.inputSystem.get(RunField) && runOptions !== false) {
-                runOptions = runOptions === true ? {} : runOptions;
-                inputSpeed = runOptions.speed ?? 6;
-            }
-            let walkOptions = character.options.movement?.walk ?? true;
-            if (inputSpeed === 0 && walkOptions !== false) {
-                walkOptions = walkOptions === true ? {} : walkOptions;
-                inputSpeed = walkOptions.speed ?? 3;
-            }
-            character.physics.inputVelocity
-                .set(-character.inputSystem.get(MoveLeftField) + character.inputSystem.get(MoveRightField), 0, -character.inputSystem.get(MoveForwardField) + character.inputSystem.get(MoveBackwardField))
-                .normalize()
-                .applyEuler(cameraEuler)
-                .multiplyScalar(inputSpeed);
-            //run forever
-            return true;
-        },
-    }), 
-    // rotation animations
-    model != null &&
-        action({
-            update(_, clock) {
-                // Character yaw rotation logic
-                const basedOn = character.options.animation?.yawRotationBasdOn ?? 'movement';
-                // compute goalTargetEuler
-                if (basedOn === 'camera') {
-                    goalTargetEuler.setFromQuaternion(character.getCamera().getWorldQuaternion(quaternion), 'YXZ');
-                }
-                else {
-                    //don't rotate if not moving
-                    if (character.physics.inputVelocity.lengthSq() === 0) {
-                        // run forever
-                        return true;
-                    }
-                    inputDirection.copy(character.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;
-                const maxYawRotationSpeed = (typeof character.options.animation === 'object'
-                    ? character.options.animation.maxYawRotationSpeed
-                    : undefined) ?? 10;
-                model.scene.rotation.y += Math.min(maxYawRotationSpeed * clock.delta, absDeltaYaw) * yawRotationDirection;
-                // run forever
-                return true;
-            },
-        }), 
-    // jump and walk animations
-    actions == null
-        ? action({
-            update: () => void (shouldJump() && applyJumpForce()),
-        })
-        : graph('moving', {
-            jumpStart: {
-                timeline: async function* () {
-                    yield* action({
-                        init() {
-                            actions.jumpUp.reset();
-                            actions.jumpUp.play();
-                            actions.jumpUp.paused = true;
-                            actions.jumpUp.fadeIn(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                            actions.jumpForward.reset();
-                            actions.jumpForward.play();
-                            actions.jumpForward.paused = true;
-                            actions.jumpForward.fadeIn(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                        },
-                        update: () => void character.physics.inputVelocity.multiplyScalar(0.3),
-                        until: timePassed((typeof character.options.movement?.jump === 'object'
-                            ? character.options.movement?.jump.delay
-                            : undefined) ?? DefaultJumDelay, 'seconds'),
-                    });
-                    if (character.inputSystem.get(RunField)) {
-                        actions.jumpUp.fadeOut(0.1);
-                        return 'jumpForward';
-                    }
-                    else {
-                        actions.jumpForward.fadeOut(0.1);
-                        return 'jumpUp';
-                    }
-                },
-                transitionTo: {
-                    jumpDown: { when: () => !character.physics.isGrounded },
-                },
-            },
-            jumpForward: {
-                timeline: async function* () {
-                    yield* action({
-                        init: () => {
-                            actions.jumpForward.paused = false;
-                            applyJumpForce();
-                            return () => actions.jumpForward.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                        },
-                        until: animationFinished(actions.jumpForward),
-                    });
-                    if (character.physics.isGrounded) {
-                        return 'moving';
-                    }
-                    return 'jumpLoop';
-                },
-            },
-            jumpUp: {
-                timeline: () => action({
-                    init: () => {
-                        actions.jumpUp.paused = false;
-                        applyJumpForce();
-                        return () => void actions.jumpUp.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                    },
-                    until: animationFinished(actions.jumpUp),
-                }),
-                transitionTo: {
-                    jumpDown: {
-                        when: (_, _clock, actionTime) => actionTime > 0.3 && character.physics.isGrounded,
-                    },
-                    finally: 'jumpLoop',
-                },
-            },
-            jumpLoop: {
-                timeline: () => action({
-                    init: () => {
-                        actions.jumpLoop.reset();
-                        actions.jumpLoop.play();
-                        actions.jumpLoop.fadeIn(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                        return () => actions.jumpLoop.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                    },
-                    until: forever(),
-                }),
-                transitionTo: {
-                    jumpDown: { when: () => character.physics.isGrounded },
-                },
-            },
-            jumpDown: {
-                timeline: () => action({
-                    init: () => {
-                        actions.jumpUp.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                        actions.jumpForward.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                        actions.jumpDown.reset();
-                        actions.jumpDown.play();
-                        actions.jumpDown.fadeIn(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                        return () => actions.jumpDown.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                    },
-                    until: timePassed(150, 'milliseconds'),
-                }),
-                transitionTo: { finally: 'moving' },
-            },
-            moving: {
-                timeline: () => {
-                    let currentAnimation;
-                    return action({
-                        update() {
-                            let nextAnimation;
-                            if (character.physics.inputVelocity.lengthSq() === 0) {
-                                nextAnimation = actions.idle;
-                            }
-                            else if (character.inputSystem.get(RunField) && character.options.movement?.run != false) {
-                                nextAnimation = actions.run;
-                            }
-                            else if (character.options.movement?.walk != false) {
-                                nextAnimation = actions.walk;
-                            }
-                            else {
-                                nextAnimation = actions.idle;
-                            }
-                            if (nextAnimation === currentAnimation) {
-                                return;
-                            }
-                            currentAnimation?.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                            nextAnimation.reset();
-                            nextAnimation.play();
-                            nextAnimation.fadeIn(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration);
-                            currentAnimation = nextAnimation;
-                        },
-                        init: () => () => currentAnimation?.fadeOut(character.options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration),
-                    });
-                },
-                transitionTo: {
-                    jumpStart: { when: () => shouldJump() },
-                    jumpLoop: { when: () => !character.physics.isGrounded },
-                },
-            },
-        }));
-}
-export class SimpleCharacter extends Group {
-    camera;
-    options;
-    cameraBehavior;
-    physics;
-    mixer = new AnimationMixer(this);
-    //can be changed from the outside
-    inputSystem;
-    //loaded asychronously
-    actions;
-    model;
-    updateTimeline;
-    abortController = new AbortController();
-    constructor(camera, world, domElement, options = {}) {
-        super();
-        this.camera = camera;
-        this.options = options;
-        // input system
-        this.inputSystem =
-            options.input instanceof InputSystem
-                ? options.input
-                : new InputSystem(domElement, options.input ?? [ScreenJoystickInput, ScreenJumpButtonInput, PointerCaptureInput, LocomotionKeyboardInput], extractProxy(options, 'inputOptions'));
-        options.physics ??= {};
-        // camera behavior
-        this.cameraBehavior = new SimpleCharacterCameraBehavior(typeof camera === 'function' ? camera : () => camera, this, world.raycast.bind(world));
-        // physics
-        this.physics = new BvhCharacterPhysics(this, world);
-        this.init(options).catch(console.error);
-    }
-    getCamera() {
-        return typeof this.camera === 'function' ? this.camera() : this.camera;
-    }
-    async init(options) {
-        const { model, animations } = await preloadSimpleCharacterAssets(options);
-        this.model = model;
-        if (model != null && animations != null) {
-            this.add(model.scene);
-            this.actions = {};
-            for (const name of simpleCharacterAnimationNames) {
-                this.actions[name] = this.mixer.clipAction(animations[name]);
-            }
-            this.actions.jumpDown.loop = LoopOnce;
-            this.actions.jumpDown.clampWhenFinished = true;
-            this.actions.jumpUp.loop = LoopOnce;
-            this.actions.jumpUp.clampWhenFinished = true;
-            this.actions.jumpForward.loop = LoopOnce;
-            this.actions.jumpForward.clampWhenFinished = true;
-        }
-        this.updateTimeline = start(SimpleCharacterTimeline(this), this.abortController.signal);
-        this.dispatchEvent({ type: 'loaded' });
-    }
-    update(delta) {
-        this.updateTimeline?.(undefined, delta);
-        this.mixer?.update(delta);
-        if (this.model instanceof VRM) {
-            this.model.update(delta);
-        }
-        this.physics.update(delta, this.options.physics);
-        this.cameraBehavior.update(delta, this.options.cameraBehavior);
-    }
-    dispose() {
-        this.abortController.abort();
-        this.parent?.remove(this);
-        this.model?.scene.dispatchEvent({ type: 'dispose' });
-        this.inputSystem.dispose();
-        this.physics.dispose();
-        VRMUtils.deepDispose(this);
-    }
-}