@pmndrs/viverse 0.1.20 → 0.2.1

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

@@ -0,0 +1,6 @@
+export * from './jump-down.js';
+export * from './jump-loop.js';
+export * from './jump-start.js';
+export * from './jump-forward.js';
+export * from './jump-up.js';
+export * from './movement.js';

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

@@ -0,0 +1,6 @@
+export * from './jump-down.js';
+export * from './jump-loop.js';
+export * from './jump-start.js';
+export * from './jump-forward.js';
+export * from './jump-up.js';
+export * from './movement.js';

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

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

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

@@ -0,0 +1,26 @@
+import { action, timePassed } from '@pmndrs/timeline';
+import { LoopOnce } from 'three';
+import { JumpDownAnimationUrl } from '../../animation/default.js';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration } from '../defaults.js';
+export async function loadSimpleCharacterJumpDownState(state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation without existing model`);
+    }
+    const jumpDown = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({ url: JumpDownAnimationUrl, ...options.animation?.jumpDown })));
+    jumpDown.loop = LoopOnce;
+    jumpDown.clampWhenFinished = true;
+    return {
+        timeline: () => action({
+            init: () => {
+                startAnimation(jumpDown, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                });
+            },
+            until: timePassed(150, 'milliseconds'),
+        }),
+        transitionTo: { finally: 'moving' },
+    };
+}

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

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

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

@@ -0,0 +1,41 @@
+import { action, animationFinished } from '@pmndrs/timeline';
+import { LoopOnce, Vector3 } from 'three';
+import { JumpForwardAnimationUrl } from '../../animation/default.js';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration } from '../defaults.js';
+export async function loadSimpleCharacterJumpForwardAction(state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation without existing model`);
+    }
+    const jumpForward = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
+        url: JumpForwardAnimationUrl,
+        scaleTime: 0.9,
+        ...options.animation?.jumpForward,
+    })));
+    jumpForward.loop = LoopOnce;
+    jumpForward.clampWhenFinished = true;
+    return jumpForward;
+}
+export async function loadSimpleCharacterJumpForwardState(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(jumpForward, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                });
+                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(jumpForward),
+        }),
+        transitionTo: {
+            finally: () => (state.physics.isGrounded ? 'moving' : 'jumpLoop'),
+        },
+    };
+}

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

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

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

@@ -0,0 +1,24 @@
+import { action } from '@pmndrs/timeline';
+import { JumpLoopAnimationUrl } from '../../animation/default.js';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { startAnimation } from '../../utils.js';
+import { DefaultCrossFadeDuration } from '../defaults.js';
+export async function loadSimpleCharacterJumpLoopState(state, options) {
+    const model = state.model;
+    if (model == null) {
+        throw new Error(`Unable to load animation without existing model`);
+    }
+    const jumpLoop = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({ url: JumpLoopAnimationUrl, ...options.animation?.jumpLoop })));
+    return {
+        timeline: () => action({
+            init: () => {
+                startAnimation(jumpLoop, model.currentAnimations, {
+                    fadeDuration: options.animation?.crossFadeDuration ?? DefaultCrossFadeDuration,
+                });
+            },
+        }),
+        transitionTo: {
+            jumpDown: { whenUpdate: () => state.physics.isGrounded },
+        },
+    };
+}

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

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

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

@@ -0,0 +1,30 @@
+import { action, timePassed } from '@pmndrs/timeline';
+import { RunAction } 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: () => (RunAction.get() ? '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,40 @@
+import { action, animationFinished } from '@pmndrs/timeline';
+import { LoopOnce, Vector3 } from 'three';
+import { JumpUpAnimationUrl } from '../../animation/default.js';
+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({
+        url: JumpUpAnimationUrl,
+        ...options.animation?.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,63 @@
+import { action } from '@pmndrs/timeline';
+import { IdleAnimationUrl, RunAnimationUrl, WalkAnimationUrl } from '../../animation/default.js';
+import { flattenCharacterAnimationOptions, loadCharacterAnimation } from '../../animation/index.js';
+import { RunAction } 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({
+        url: IdleAnimationUrl,
+        ...options.animation?.idle,
+    })));
+    const run = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
+        url: RunAnimationUrl,
+        scaleTime: 0.8,
+        ...options.animation?.run,
+    })));
+    const walk = model.mixer.clipAction(await loadCharacterAnimation(model, ...flattenCharacterAnimationOptions({
+        scaleTime: 0.5,
+        url: WalkAnimationUrl,
+        ...options.animation?.walk,
+    })));
+    return {
+        timeline: () => {
+            let currentAnimation;
+            return action({
+                update: () => {
+                    let nextAnimation;
+                    if (state.physics.inputVelocity.lengthSq() === 0) {
+                        nextAnimation = idle;
+                    }
+                    else if (RunAction.get() && 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.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,4 @@
+import { Object3D } from 'three';
+import type { SimpleCharacterMovementOptions } from './index.js';
+import type { BvhCharacterPhysics } from '../physics/index.js';
+export declare function updateSimpleCharacterInputVelocity(camera: Object3D, physics: BvhCharacterPhysics, options?: SimpleCharacterMovementOptions): void;

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

@@ -0,0 +1,25 @@
+import { Euler, Quaternion } from 'three';
+import { RunAction, MoveLeftAction, MoveRightAction, MoveForwardAction, MoveBackwardAction } from '../input/index.js';
+const cameraEuler = new Euler();
+const cameraRotation = new Quaternion();
+export function updateSimpleCharacterInputVelocity(camera, physics, options) {
+    cameraEuler.setFromQuaternion(camera.getWorldQuaternion(cameraRotation), 'YXZ');
+    cameraEuler.x = 0;
+    cameraEuler.z = 0;
+    let inputSpeed = 0;
+    let runOptions = options?.run ?? true;
+    if (RunAction.get() && 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(-MoveLeftAction.get() + MoveRightAction.get(), 0, -MoveForwardAction.get() + MoveBackwardAction.get())
+        .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 { 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;
+    sync?: boolean;
+    paused?: boolean;
+    crossFade?: boolean;
+    layer?: string;
+};
+export declare function startAnimation(animation: AnimationAction, currentAnimations: CharacterModel['currentAnimations'], { crossFade, layer, fadeDuration, paused, sync }: StartAnimationOptions): (() => void) | undefined;
+export declare function shouldJump(physics: BvhCharacterPhysics, 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 { JumpAction } from './input/index.js';
 export function getIsMobileMediaQuery() {
     if (typeof window === 'undefined' || typeof window.matchMedia !== 'function') {
         return undefined;
@@ -46,3 +8,39 @@ export function getIsMobileMediaQuery() {
 export function isMobile() {
     return getIsMobileMediaQuery()?.matches ?? false;
 }
+export function startAnimation(animation, currentAnimations, { crossFade = true, layer, fadeDuration = 0.1, paused = false, sync = false }) {
+    animation.reset();
+    animation.play();
+    animation.paused = paused;
+    if (!crossFade) {
+        animation.fadeIn(fadeDuration);
+        return () => {
+            animation.fadeOut(fadeDuration);
+        };
+    }
+    const currentAnimation = currentAnimations.get(layer);
+    if (currentAnimation != null && sync) {
+        animation.syncWith(currentAnimation);
+    }
+    if (currentAnimation != null) {
+        animation.crossFadeFrom(currentAnimation, fadeDuration);
+    }
+    else {
+        animation.fadeIn(fadeDuration);
+    }
+    currentAnimations.set(layer, animation);
+}
+export function shouldJump(physics, lastJump, bufferTime = 0.1) {
+    if (!physics.isGrounded) {
+        return false;
+    }
+    const lastTimePressed = JumpAction.getLatestTime();
+    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.1",
   "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.7",
     "@viverse/sdk": "1.2.10-alpha.0",
     "three-mesh-bvh": "^0.9.1"
   },

package/dist/animation/bvh.d.ts

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

package/dist/animation/bvh.js

@@ -1,8 +0,0 @@
-import { BVHLoader } from 'three/examples/jsm/Addons.js';
-import { bvhBoneMap, fixModelAnimationClip } from './index.js';
-const loader = new BVHLoader();
-export async function loadVrmModelBvhAnimations(model, url, removeXZMovement, boneMap) {
-    const clipScene = await loader.loadAsync(url);
-    fixModelAnimationClip(model, clipScene.clip, undefined, removeXZMovement, boneMap ?? bvhBoneMap);
-    return [clipScene.clip];
-}

package/dist/animation/fbx.d.ts

@@ -1,4 +0,0 @@
-import { AnimationClip } from 'three';
-import { loadCharacterModel } 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>>;

package/dist/animation/fbx.js

@@ -1,8 +0,0 @@
-import { FBXLoader } from 'three/examples/jsm/Addons.js';
-import { fixModelAnimationClip } from './index.js';
-const loader = new FBXLoader();
-export async function loadVrmModelFbxAnimations(model, url, removeXZMovement, boneMap) {
-    const clipScene = await loader.loadAsync(url);
-    clipScene.animations.forEach((clip) => fixModelAnimationClip(model, clip, clipScene, removeXZMovement, boneMap));
-    return clipScene.animations;
-}

package/dist/animation/gltf.d.ts

@@ -1,3 +0,0 @@
-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>>;

package/dist/animation/gltf.js

@@ -1,8 +0,0 @@
-import { GLTFLoader } from 'three/examples/jsm/Addons.js';
-import { fixModelAnimationClip } from './index.js';
-const loader = new GLTFLoader();
-export async function loadVrmModelGltfAnimations(model, url, removeXZMovement, boneMap) {
-    const { animations, scene: clipScene } = await loader.loadAsync(url);
-    animations.forEach((clip) => fixModelAnimationClip(model, clip, clipScene, removeXZMovement, boneMap));
-    return animations;
-}

package/dist/animation/vrma.d.ts

@@ -1,3 +0,0 @@
-import { VRM } from '@pixiv/three-vrm';
-import { AnimationClip } from 'three';
-export declare function loadVrmModelVrmaAnimations(vrm: VRM, url: string, removeXZMovement: boolean): Promise<Array<AnimationClip>>;

package/dist/animation/vrma.js

@@ -1,8 +0,0 @@
-import { createVRMAnimationClip } from '@pixiv/three-vrm-animation';
-import { vrmaLoader } from '../index.js';
-export async function loadVrmModelVrmaAnimations(vrm, url, removeXZMovement) {
-    const animations = await vrmaLoader.loadAsync(url);
-    const vrmAnimations = animations.userData.vrmAnimations;
-    const clips = vrmAnimations.map((vrmAnimation) => createVRMAnimationClip(vrmAnimation, vrm));
-    return clips;
-}